mirror of
https://github.com/RPCS3/llvm-mirror.git
synced 2024-11-24 03:33:20 +01:00
d52db24563
Since LoopInfo is not available in machine passes as universally as in IR passes, using the same approach for OptimizationRemarkEmitter as we did for IR will run LoopInfo and DominatorTree unnecessarily. (LoopInfo is not used lazily by ORE.) To fix this, I am modifying the approach I took in D29836. LazyMachineBFI now uses its client passes including MachineBFI itself that are available or otherwise compute them on the fly. So for example GreedyRegAlloc, since it's already using MBFI, will reuse that instance. On the other hand, AsmPrinter in Justin's patch will generate DT, LI and finally BFI on the fly. (I am of course wondering now if the simplicity of this approach is even preferable in IR. I will do some experiments.) Testing is provided by an updated version of D29837 which requires Justin's patch to bring ORE to the AsmPrinter. Differential Revision: https://reviews.llvm.org/D30128 llvm-svn: 295996
98 lines
3.3 KiB
C++
98 lines
3.3 KiB
C++
///===- LazyMachineBlockFrequencyInfo.cpp - Lazy Machine Block Frequency --===//
|
|
///
|
|
/// The LLVM Compiler Infrastructure
|
|
///
|
|
/// This file is distributed under the University of Illinois Open Source
|
|
/// License. See LICENSE.TXT for details.
|
|
///
|
|
///===---------------------------------------------------------------------===//
|
|
/// \file
|
|
/// This is an alternative analysis pass to MachineBlockFrequencyInfo. The
|
|
/// difference is that with this pass the block frequencies are not computed
|
|
/// when the analysis pass is executed but rather when the BFI result is
|
|
/// explicitly requested by the analysis client.
|
|
///
|
|
///===---------------------------------------------------------------------===//
|
|
|
|
#include "llvm/CodeGen/LazyMachineBlockFrequencyInfo.h"
|
|
|
|
using namespace llvm;
|
|
|
|
#define DEBUG_TYPE "lazy-machine-block-freq"
|
|
|
|
INITIALIZE_PASS_BEGIN(LazyMachineBlockFrequencyInfoPass, DEBUG_TYPE,
|
|
"Lazy Machine Block Frequency Analysis", true, true)
|
|
INITIALIZE_PASS_DEPENDENCY(MachineBranchProbabilityInfo)
|
|
INITIALIZE_PASS_DEPENDENCY(MachineLoopInfo)
|
|
INITIALIZE_PASS_END(LazyMachineBlockFrequencyInfoPass, DEBUG_TYPE,
|
|
"Lazy Machine Block Frequency Analysis", true, true)
|
|
|
|
char LazyMachineBlockFrequencyInfoPass::ID = 0;
|
|
|
|
LazyMachineBlockFrequencyInfoPass::LazyMachineBlockFrequencyInfoPass()
|
|
: MachineFunctionPass(ID) {
|
|
initializeLazyMachineBlockFrequencyInfoPassPass(
|
|
*PassRegistry::getPassRegistry());
|
|
}
|
|
|
|
void LazyMachineBlockFrequencyInfoPass::print(raw_ostream &OS,
|
|
const Module *M) const {
|
|
getBFI().print(OS, M);
|
|
}
|
|
|
|
void LazyMachineBlockFrequencyInfoPass::getAnalysisUsage(
|
|
AnalysisUsage &AU) const {
|
|
AU.addRequired<MachineBranchProbabilityInfo>();
|
|
AU.setPreservesAll();
|
|
MachineFunctionPass::getAnalysisUsage(AU);
|
|
}
|
|
|
|
void LazyMachineBlockFrequencyInfoPass::releaseMemory() {
|
|
OwnedMBFI.reset();
|
|
OwnedMLI.reset();
|
|
OwnedMDT.reset();
|
|
}
|
|
|
|
MachineBlockFrequencyInfo &
|
|
LazyMachineBlockFrequencyInfoPass::calculateIfNotAvailable() const {
|
|
auto *MBFI = getAnalysisIfAvailable<MachineBlockFrequencyInfo>();
|
|
if (MBFI) {
|
|
DEBUG(dbgs() << "MachineBlockFrequencyInfo is available\n");
|
|
return *MBFI;
|
|
}
|
|
|
|
auto &MBPI = getAnalysis<MachineBranchProbabilityInfo>();
|
|
auto *MLI = getAnalysisIfAvailable<MachineLoopInfo>();
|
|
auto *MDT = getAnalysisIfAvailable<MachineDominatorTree>();
|
|
DEBUG(dbgs() << "Building MachineBlockFrequencyInfo on the fly\n");
|
|
DEBUG(if (MLI) dbgs() << "LoopInfo is available\n");
|
|
|
|
if (!MLI) {
|
|
DEBUG(dbgs() << "Building LoopInfo on the fly\n");
|
|
// First create a dominator tree.
|
|
DEBUG(if (MDT) dbgs() << "DominatorTree is available\n");
|
|
|
|
if (!MDT) {
|
|
DEBUG(dbgs() << "Building DominatorTree on the fly\n");
|
|
OwnedMDT = make_unique<MachineDominatorTree>();
|
|
OwnedMDT->getBase().recalculate(*MF);
|
|
MDT = OwnedMDT.get();
|
|
}
|
|
|
|
// Generate LoopInfo from it.
|
|
OwnedMLI = make_unique<MachineLoopInfo>();
|
|
OwnedMLI->getBase().analyze(MDT->getBase());
|
|
MLI = OwnedMLI.get();
|
|
}
|
|
|
|
OwnedMBFI = make_unique<MachineBlockFrequencyInfo>();
|
|
OwnedMBFI->calculate(*MF, MBPI, *MLI);
|
|
return *OwnedMBFI.get();
|
|
}
|
|
|
|
bool LazyMachineBlockFrequencyInfoPass::runOnMachineFunction(
|
|
MachineFunction &F) {
|
|
MF = &F;
|
|
return false;
|
|
}
|