-
@@ -95,8 +104,6 @@
- Future extensions planned @@ -126,6 +133,7 @@ from Pass. Depending on how your pass works, you should inherit from the ModulePass, CallGraphSCCPass, FunctionPass, or LoopPass, or BasicBlockPass classes, which gives the system more information about what your pass does, and how it can be combined with other passes. One of the main features of the LLVM Pass Framework is that it @@ -255,6 +263,14 @@ href="#passtype">later, but for now, know that FunctionPass's operate a function at a time. +
- ... not allowed to modify any Functions that are not in the current SCC. -
- ... allowed to inspect any Function's other than those in the +
- ... not allowed to inspect any Function's other than those in the current SCC and the direct callees of the SCC.
- ... required to preserve the current CallGraph object, updating it @@ -687,6 +729,85 @@ program being compiled.
+ static char ID;
+ Hello() : FunctionPass(&ID) {}
++ +
This declares pass identifier used by LLVM to identify pass. This allows LLVM to +avoid using expensive C++ runtime information.
+
virtual bool runOnFunction(Function &F) {
llvm::cerr << "Hello: " << F.getName() << "\n";
@@ -270,13 +286,26 @@ to do our thing, so we just print out our message with the name of each
function.
- RegisterPass<Hello> X("hello", "Hello World Pass");
+ char Hello::ID = 0;
+
+
+ We initialize pass ID here. LLVM uses ID's address to identify pass so
+initialization value is not important.
+
+
+ RegisterPass<Hello> X("hello", "Hello World Pass",
+ false /* Only looks at CFG */,
+ false /* Analysis Pass */);
} // end of anonymous namespace
Lastly, we register our class Hello,
giving it a command line
-argument "hello", and a name "Hello World Pass".
+argument "hello", and a name "Hello World Pass".
+Last two RegisterPass arguments are optional. Their default value is false.
+If a pass walks CFG without modifying it then third argument is set to true.
+If a pass is an analysis pass, for example dominator tree pass, then true
+is supplied as fourth argument.
As a whole, the .cpp file looks like:
@@ -288,12 +317,17 @@ argument "hello", and a name "Hello World Pass".
namespace {
struct Hello : public FunctionPass {
+
+ static char ID;
+ Hello() : FunctionPass(&ID) {}
+
virtual bool runOnFunction(Function &F) {
llvm::cerr << "Hello: " << F.getName() << "\n";
return false;
}
};
+ char Hello::ID = 0;
RegisterPass<Hello> X("hello", "Hello World Pass");
}
To test it, follow the example at the end of the Getting Started Guide to compile "Hello World" to -LLVM. We can now run the bytecode file (hello.bc) for the program -through our transformation like this (or course, any bytecode file will +LLVM. We can now run the bitcode file (hello.bc) for the program +through our transformation like this (or course, any bitcode file will work):
@@ -346,7 +380,7 @@ interesting way, we just throw away the result of opt (sending it to
$ opt -load ../../../Debug/lib/Hello.so --help
OVERVIEW: llvm .bc -> .bc modular optimizer
-USAGE: opt [options] <input bytecode>
+USAGE: opt [options] <input bitcode>
OPTIONS:
Optimizations available:
@@ -381,7 +415,7 @@ Hello: main
Total Execution Time: 0.02 seconds (0.0479059 wall clock)
---User Time--- --System Time-- --User+System-- ---Wall Time--- --- Pass Name ---
- 0.0100 (100.0%) 0.0000 ( 0.0%) 0.0100 ( 50.0%) 0.0402 ( 84.0%) Bytecode Writer
+ 0.0100 (100.0%) 0.0000 ( 0.0%) 0.0100 ( 50.0%) 0.0402 ( 84.0%) Bitcode Writer
0.0000 ( 0.0%) 0.0100 (100.0%) 0.0100 ( 50.0%) 0.0031 ( 6.4%) Dominator Set Construction
0.0000 ( 0.0%) 0.0000 ( 0.0%) 0.0000 ( 0.0%) 0.0013 ( 2.7%) Module Verifier
0.0000 ( 0.0%) 0.0000 ( 0.0%) 0.0000 ( 0.0%) 0.0033 ( 6.9%) Hello World Pass
@@ -459,6 +493,14 @@ refering to function bodies in no predictable order, or adding and removing
functions. Because nothing is known about the behavior of ModulePass
subclasses, no optimization can be done for their execution.
+A module pass can use function level passes (e.g. dominators) using
+the getAnalysis interface
+getAnalysis<DominatorTree>(llvm::Function *) to provide the
+function to retrieve analysis result for, if the function pass does not require
+any module or immutable passes. Note that this can only be done for functions for which the
+analysis ran, e.g. in the case of dominators you should only ask for the
+DominatorTree for function definitions, not declarations.
+
To write a correct ModulePass subclass, derive from
ModulePass and overload the runOnModule method with the
following signature:
@@ -509,7 +551,7 @@ href="#BasicBlockPass">BasicBlockPass, you should derive from
All LoopPass execute on each loop in the function independent of +all of the other loops in the function. LoopPass processes loops in +loop nest order such that outer most loop is processed last.
+ +LoopPass subclasses are allowed to update loop nest using +LPPassManager interface. Implementing a loop pass is usually +straightforward. Looppass's may overload three virtual methods to +do their work. All these methods should return true if they modified the +program, or false if they didn't.
++ virtual bool doInitialization(Loop *, LPPassManager &LPM); +
The doInitialization method is designed to do simple initialization +type of stuff that does not depend on the functions being processed. The +doInitialization method call is not scheduled to overlap with any +other pass executions (thus it should be very fast). LPPassManager +interface should be used to access Function or Module level analysis +information.
+ ++ virtual bool runOnLoop(Loop *, LPPassManager &LPM) = 0; +
+ +
The runOnLoop method must be implemented by your subclass to do +the transformation or analysis work of your pass. As usual, a true value should +be returned if the function is modified. LPPassManager interface +should be used to update loop nest.
+ ++ virtual bool doFinalization(); +
The doFinalization method is an infrequently used method that is +called when the pass framework has finished calling runOnLoop for every loop in the +program being compiled.
+ +- virtual void print(llvm::OStream &O, const Module *M) const; + virtual void print(std::ostream &O, const Module *M) const;
The print method must be implemented by "analyses" in order to print @@ -888,7 +1009,7 @@ depended on.
One of the main responsibilities of the PassManager is the make sure +
One of the main responsibilities of the PassManager is to make sure that passes interact with each other correctly. Because PassManager tries to optimize the execution of passes it must know how the passes interact with each other and what dependencies exist between @@ -1016,7 +1137,8 @@ the fact that it hacks on the CFG.
+ bool ModuleLevelPass::runOnModule(Module &M) {
+ ...
+ DominatorTree &DT = getAnalysis<DominatorTree>(Func);
+ ...
+ }
+In above example, runOnFunction for DominatorTree is called by pass manager +before returning a reference to the desired pass.
If your pass is capable of updating analyses if they exist (e.g., BreakCriticalEdges, as described above), you can use the -getAnalysisToUpdate method, which returns a pointer to the analysis if -it is active. For example:
+getAnalysisIfAvailable method, which returns a pointer to the analysis +if it is active. For example:
...
- if (DominatorSet *DS = getAnalysisToUpdate<DominatorSet>()) {
+ if (DominatorSet *DS = getAnalysisIfAvailable<DominatorSet>()) {
// A DominatorSet is active. This code will update it.
}
...
@@ -1065,7 +1201,7 @@ it is active. For example:
-Now that we understand the basics of how passes are defined, how the are
+
Now that we understand the basics of how passes are defined, how they are
used, and how they are required from other passes, it's time to get a little bit
fancier. All of the pass relationships that we have seen so far are very
simple: one pass depends on one other specific pass to be run before it can run.
@@ -1187,8 +1323,9 @@ no problem.
Here we show how the default implementation is specified (using the extra
argument to the RegisterAnalysisGroup template). There must be exactly
one default implementation available at all times for an Analysis Group to be
-used. Here we declare that the BasicAliasAnalysis
+used. Only default implementation can derive from ImmutablePass.
+Here we declare that the
+ BasicAliasAnalysis
pass is the default implementation for the interface.
@@ -1253,7 +1390,8 @@ the LLVM program representation for a single function at a time, instead of
traversing the entire program. It reduces the memory consumption of compiler,
because, for example, only one DominatorSet
-needs to be calculated at a time. This also makes it possible some interesting enhancements in the future.
@@ -1291,8 +1429,8 @@ Module Pass Manager
Module Verifier
-- Dominator Set Construction
-- Module Verifier
- Bytecode Writer
---Bytecode Writer
+ Bitcode Writer
+--Bitcode Writer
This output shows us when passes are constructed and when the analysis @@ -1332,8 +1470,8 @@ Module Pass Manager Module Verifier -- Dominator Set Construction -- Module Verifier - Bytecode Writer ---Bytecode Writer + Bitcode Writer +--Bitcode Writer Hello: __main Hello: puts Hello: main @@ -1372,8 +1510,8 @@ Module Pass Manager Module Verifier -- Dominator Set Construction -- Module Verifier - Bytecode Writer ---Bytecode Writer + Bitcode Writer +--Bitcode Writer Hello: __main Hello: puts Hello: main @@ -1404,7 +1542,7 @@ need some way to free analysis results when they are no longer useful. The
If you are writing an analysis or any other pass that retains a significant amount of state (for use by another pass which "requires" your pass and uses the getAnalysis method) you should implement -releaseMEmory to, well, release the memory allocated to maintain this +releaseMemory to, well, release the memory allocated to maintain this internal state. This method is called after the run* method for the class, before the next call of run* in your pass.
@@ -1532,7 +1670,7 @@ MachinePassRegistry RegisterMyPasses::Registry;
cl::opt<RegisterMyPasses::FunctionPassCtor, false,
- RegisterPassParser<RegisterMyPasses> >
+ RegisterPassParser<RegisterMyPasses> >
MyPassOpt("mypass",
cl::init(&createDefaultMyPass),
cl::desc("my pass option help"));
@@ -1678,36 +1816,13 @@ Despite that, we have kept the LLVM passes SMP ready, and you should too.
Currently it is illegal for a ModulePass -to require a FunctionPass. This is because -there is only one instance of the FunctionPass object ever created, thus nowhere -to store information for all of the functions in the program at the same time. -Although this has come up a couple of times before, this has always been worked -around by factoring one big complicated pass into a global and an -interprocedural part, both of which are distinct. In the future, it would be -nice to have this though.
- -Note that it is no problem for a FunctionPass to require the results of a ModulePass, only the other way around.
- -
+ src="http://jigsaw.w3.org/css-validator/images/vcss-blue" alt="Valid CSS">
The LLVM Compiler Infrastructure