RegisterOpt<ADCE> X("adce", "Aggressive Dead Code Elimination");
} // End of anonymous namespace
-Pass *llvm::createAggressiveDCEPass() { return new ADCE(); }
+FunctionPass *llvm::createAggressiveDCEPass() { return new ADCE(); }
void ADCE::markBlockAlive(BasicBlock *BB) {
// Mark the basic block as being newly ALIVE... and mark all branches that
RegisterOpt<ConstantPropagation> X("constprop","Simple constant propagation");
}
-Pass *llvm::createConstantPropagationPass() {
+FunctionPass *llvm::createConstantPropagationPass() {
return new ConstantPropagation();
}
RegisterOpt<CEE> X("cee", "Correlated Expression Elimination");
}
-Pass *llvm::createCorrelatedExpressionEliminationPass() { return new CEE(); }
+FunctionPass *llvm::createCorrelatedExpressionEliminationPass() {
+ return new CEE();
+}
bool CEE::runOnFunction(Function &F) {
RegisterOpt<DeadInstElimination> X("die", "Dead Instruction Elimination");
}
-Pass *llvm::createDeadInstEliminationPass() {
+FunctionPass *llvm::createDeadInstEliminationPass() {
return new DeadInstElimination();
}
RegisterOpt<DSE> X("dse", "Dead Store Elimination");
}
-Pass *llvm::createDeadStoreEliminationPass() { return new DSE(); }
+FunctionPass *llvm::createDeadStoreEliminationPass() { return new DSE(); }
bool DSE::runOnBasicBlock(BasicBlock &BB) {
TargetData &TD = getAnalysis<TargetData>();
RegisterOpt<IndVarSimplify> X("indvars", "Canonicalize Induction Variables");
}
-Pass *llvm::createIndVarSimplifyPass() {
+FunctionPass *llvm::createIndVarSimplifyPass() {
return new IndVarSimplify();
}
// createSCCPPass - This is the public interface to this file...
-Pass *llvm::createSCCPPass() {
+FunctionPass *llvm::createSCCPPass() {
return new SCCP();
}
}
// Public interface to the ScalarReplAggregates pass
-Pass *llvm::createScalarReplAggregatesPass() { return new SROA(); }
+FunctionPass *llvm::createScalarReplAggregatesPass() { return new SROA(); }
bool SROA::runOnFunction(Function &F) {
"Strip symbols from module and functions");
}
-Pass *llvm::createSymbolStrippingPass() {
+FunctionPass *llvm::createSymbolStrippingPass() {
return new SymbolStripping();
}
-Pass *llvm::createFullSymbolStrippingPass() {
+FunctionPass *llvm::createFullSymbolStrippingPass() {
return new FullSymbolStripping();
}
}
// Public interface to the Tail Duplication pass
-Pass *llvm::createTailDuplicationPass() { return new TailDup(); }
+FunctionPass *llvm::createTailDuplicationPass() { return new TailDup(); }
/// runOnFunction - Top level algorithm - Loop over each unconditional branch in
/// the function, eliminating it if it looks attractive enough.
// Publically exposed interface to pass...
const PassInfo *llvm::LoopSimplifyID = X.getPassInfo();
-Pass *llvm::createLoopSimplifyPass() { return new LoopSimplify(); }
+FunctionPass *llvm::createLoopSimplifyPass() { return new LoopSimplify(); }
/// runOnFunction - Run down all loops in the CFG (recursively, but we could do
/// it in any convenient order) inserting preheaders...
// createPromoteMemoryToRegister - Provide an entry point to create this pass.
//
-Pass *llvm::createPromoteMemoryToRegister() {
+FunctionPass *llvm::createPromoteMemoryToRegister() {
return new PromotePass();
}