• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 ///===- LazyMachineBlockFrequencyInfo.cpp - Lazy Machine Block Frequency --===//
2 ///
3 ///                     The LLVM Compiler Infrastructure
4 ///
5 /// This file is distributed under the University of Illinois Open Source
6 /// License. See LICENSE.TXT for details.
7 ///
8 ///===---------------------------------------------------------------------===//
9 /// \file
10 /// This is an alternative analysis pass to MachineBlockFrequencyInfo.  The
11 /// difference is that with this pass the block frequencies are not computed
12 /// when the analysis pass is executed but rather when the BFI result is
13 /// explicitly requested by the analysis client.
14 ///
15 ///===---------------------------------------------------------------------===//
16 
17 #include "llvm/CodeGen/LazyMachineBlockFrequencyInfo.h"
18 
19 using namespace llvm;
20 
21 #define DEBUG_TYPE "lazy-machine-block-freq"
22 
23 INITIALIZE_PASS_BEGIN(LazyMachineBlockFrequencyInfoPass, DEBUG_TYPE,
24                       "Lazy Machine Block Frequency Analysis", true, true)
25 INITIALIZE_PASS_DEPENDENCY(MachineBranchProbabilityInfo)
26 INITIALIZE_PASS_DEPENDENCY(MachineLoopInfo)
27 INITIALIZE_PASS_END(LazyMachineBlockFrequencyInfoPass, DEBUG_TYPE,
28                     "Lazy Machine Block Frequency Analysis", true, true)
29 
30 char LazyMachineBlockFrequencyInfoPass::ID = 0;
31 
LazyMachineBlockFrequencyInfoPass()32 LazyMachineBlockFrequencyInfoPass::LazyMachineBlockFrequencyInfoPass()
33     : MachineFunctionPass(ID) {
34   initializeLazyMachineBlockFrequencyInfoPassPass(
35       *PassRegistry::getPassRegistry());
36 }
37 
print(raw_ostream & OS,const Module * M) const38 void LazyMachineBlockFrequencyInfoPass::print(raw_ostream &OS,
39                                               const Module *M) const {
40   getBFI().print(OS, M);
41 }
42 
getAnalysisUsage(AnalysisUsage & AU) const43 void LazyMachineBlockFrequencyInfoPass::getAnalysisUsage(
44     AnalysisUsage &AU) const {
45   AU.addRequired<MachineBranchProbabilityInfo>();
46   AU.setPreservesAll();
47   MachineFunctionPass::getAnalysisUsage(AU);
48 }
49 
releaseMemory()50 void LazyMachineBlockFrequencyInfoPass::releaseMemory() {
51   OwnedMBFI.reset();
52   OwnedMLI.reset();
53   OwnedMDT.reset();
54 }
55 
56 MachineBlockFrequencyInfo &
calculateIfNotAvailable() const57 LazyMachineBlockFrequencyInfoPass::calculateIfNotAvailable() const {
58   auto *MBFI = getAnalysisIfAvailable<MachineBlockFrequencyInfo>();
59   if (MBFI) {
60     LLVM_DEBUG(dbgs() << "MachineBlockFrequencyInfo is available\n");
61     return *MBFI;
62   }
63 
64   auto &MBPI = getAnalysis<MachineBranchProbabilityInfo>();
65   auto *MLI = getAnalysisIfAvailable<MachineLoopInfo>();
66   auto *MDT = getAnalysisIfAvailable<MachineDominatorTree>();
67   LLVM_DEBUG(dbgs() << "Building MachineBlockFrequencyInfo on the fly\n");
68   LLVM_DEBUG(if (MLI) dbgs() << "LoopInfo is available\n");
69 
70   if (!MLI) {
71     LLVM_DEBUG(dbgs() << "Building LoopInfo on the fly\n");
72     // First create a dominator tree.
73     LLVM_DEBUG(if (MDT) dbgs() << "DominatorTree is available\n");
74 
75     if (!MDT) {
76       LLVM_DEBUG(dbgs() << "Building DominatorTree on the fly\n");
77       OwnedMDT = make_unique<MachineDominatorTree>();
78       OwnedMDT->getBase().recalculate(*MF);
79       MDT = OwnedMDT.get();
80     }
81 
82     // Generate LoopInfo from it.
83     OwnedMLI = make_unique<MachineLoopInfo>();
84     OwnedMLI->getBase().analyze(MDT->getBase());
85     MLI = OwnedMLI.get();
86   }
87 
88   OwnedMBFI = make_unique<MachineBlockFrequencyInfo>();
89   OwnedMBFI->calculate(*MF, MBPI, *MLI);
90   return *OwnedMBFI.get();
91 }
92 
runOnMachineFunction(MachineFunction & F)93 bool LazyMachineBlockFrequencyInfoPass::runOnMachineFunction(
94     MachineFunction &F) {
95   MF = &F;
96   return false;
97 }
98