LLVM  14.0.0git
LazyBlockFrequencyInfo.cpp
Go to the documentation of this file.
1 //===- LazyBlockFrequencyInfo.cpp - Lazy Block Frequency Analysis ---------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 //
9 // This is an alternative analysis pass to BlockFrequencyInfoWrapperPass. The
10 // difference is that with this pass the block frequencies are not computed when
11 // the analysis pass is executed but rather when the BFI result is explicitly
12 // requested by the analysis client.
13 //
14 //===----------------------------------------------------------------------===//
15 
18 #include "llvm/Analysis/LoopInfo.h"
19 #include "llvm/IR/Dominators.h"
20 #include "llvm/InitializePasses.h"
21 
22 using namespace llvm;
23 
24 #define DEBUG_TYPE "lazy-block-freq"
25 
27  "Lazy Block Frequency Analysis", true, true)
28 INITIALIZE_PASS_DEPENDENCY(LazyBPIPass)
31  "Lazy Block Frequency Analysis", true, true)
32 
34 
37 }
38 
40  LBFI.getCalculated().print(OS);
41 }
42 
45  // We require DT so it's available when LI is available. The LI updating code
46  // asserts that DT is also present so if we don't make sure that we have DT
47  // here, that assert will trigger.
50  AU.setPreservesAll();
51 }
52 
53 void LazyBlockFrequencyInfoPass::releaseMemory() { LBFI.releaseMemory(); }
54 
56  auto &BPIPass = getAnalysis<LazyBranchProbabilityInfoPass>();
57  LoopInfo &LI = getAnalysis<LoopInfoWrapperPass>().getLoopInfo();
58  LBFI.setAnalysis(&F, &BPIPass, &LI);
59  return false;
60 }
61 
66 }
67 
72 }
llvm::initializeLazyBFIPassPass
void initializeLazyBFIPassPass(PassRegistry &Registry)
Helper for client passes to initialize dependent passes for LBFI.
Definition: LazyBlockFrequencyInfo.cpp:68
llvm
---------------------— PointerInfo ------------------------------------—
Definition: AllocatorList.h:23
llvm::LazyBlockFrequencyInfoPass::releaseMemory
void releaseMemory() override
releaseMemory() - This member can be implemented by a pass if it wants to be able to release its memo...
Definition: LazyBlockFrequencyInfo.cpp:53
llvm::LazyBlockFrequencyInfoPass::runOnFunction
bool runOnFunction(Function &F) override
runOnFunction - Virtual method overriden by subclasses to do the per-function processing of the pass.
Definition: LazyBlockFrequencyInfo.cpp:55
llvm::Function
Definition: Function.h:61
INITIALIZE_PASS_BEGIN
INITIALIZE_PASS_BEGIN(LazyBlockFrequencyInfoPass, DEBUG_TYPE, "Lazy Block Frequency Analysis", true, true) INITIALIZE_PASS_END(LazyBlockFrequencyInfoPass
LazyBlockFrequencyInfo.h
llvm::LazyBlockFrequencyInfoPass::getLazyBFIAnalysisUsage
static void getLazyBFIAnalysisUsage(AnalysisUsage &AU)
Helper for client passes to set up the analysis usage on behalf of this pass.
Definition: LazyBlockFrequencyInfo.cpp:62
llvm::LoopInfoWrapperPass
The legacy pass manager's analysis pass to compute loop information.
Definition: LoopInfo.h:1268
true
Lazy Block Frequency true
Definition: LazyBlockFrequencyInfo.cpp:31
F
#define F(x, y, z)
Definition: MD5.cpp:56
llvm::LazyBlockFrequencyInfoPass
This is an alternative analysis pass to BlockFrequencyInfoWrapperPass.
Definition: LazyBlockFrequencyInfo.h:100
llvm::LazyBlockFrequencyInfoPass::print
void print(raw_ostream &OS, const Module *M) const override
print - Print out the internal state of the pass.
Definition: LazyBlockFrequencyInfo.cpp:39
llvm::PassRegistry::getPassRegistry
static PassRegistry * getPassRegistry()
getPassRegistry - Access the global registry object, which is automatically initialized at applicatio...
Definition: PassRegistry.cpp:31
llvm::AnalysisUsage
Represent the analysis usage information of a pass.
Definition: PassAnalysisSupport.h:47
llvm::LazyBranchProbabilityInfoPass::getLazyBPIAnalysisUsage
static void getLazyBPIAnalysisUsage(AnalysisUsage &AU)
Helper for client passes to set up the analysis usage on behalf of this pass.
Definition: LazyBranchProbabilityInfo.cpp:65
llvm::LazyBlockFrequencyInfoPass::getAnalysisUsage
void getAnalysisUsage(AnalysisUsage &AU) const override
getAnalysisUsage - This function should be overriden by passes that need analysis information to do t...
Definition: LazyBlockFrequencyInfo.cpp:43
llvm::DominatorTreeWrapperPass
Legacy analysis pass which computes a DominatorTree.
Definition: Dominators.h:287
llvm::PassRegistry
PassRegistry - This class manages the registration and intitialization of the pass subsystem as appli...
Definition: PassRegistry.h:38
llvm::raw_ostream
This class implements an extremely fast bulk output stream that can only output to a stream.
Definition: raw_ostream.h:53
INITIALIZE_PASS_END
#define INITIALIZE_PASS_END(passName, arg, name, cfg, analysis)
Definition: PassSupport.h:58
LoopInfo.h
DEBUG_TYPE
#define DEBUG_TYPE
Definition: LazyBlockFrequencyInfo.cpp:24
INITIALIZE_PASS_DEPENDENCY
INITIALIZE_PASS_DEPENDENCY(DominatorTreeWrapperPass)
llvm::initializeLazyBPIPassPass
void initializeLazyBPIPassPass(PassRegistry &Registry)
Helper for client passes to initialize dependent passes for LBPI.
Definition: LazyBranchProbabilityInfo.cpp:71
llvm::Module
A Module instance is used to store all the information related to an LLVM module.
Definition: Module.h:67
llvm::LoopInfo
Definition: LoopInfo.h:1083
llvm::AnalysisUsage::setPreservesAll
void setPreservesAll()
Set by analyses that do not transform their input at all.
Definition: PassAnalysisSupport.h:130
llvm::initializeLazyBlockFrequencyInfoPassPass
void initializeLazyBlockFrequencyInfoPassPass(PassRegistry &)
llvm::Registry
A global registry used in conjunction with static constructors to make pluggable components (like tar...
Definition: Registry.h:44
Dominators.h
llvm::AnalysisUsage::addRequiredTransitive
AnalysisUsage & addRequiredTransitive()
Definition: PassAnalysisSupport.h:81
llvm::FunctionPass
FunctionPass class - This class is used to implement most global optimizations.
Definition: Pass.h:298
InitializePasses.h
LazyBranchProbabilityInfo.h
llvm::Intrinsic::ID
unsigned ID
Definition: TargetTransformInfo.h:37