summary | shortlog | log | commit | commitdiff | tree
raw | patch | inline | side by side (parent: 0e99219)
raw | patch | inline | side by side (parent: 0e99219)
author | Owen Anderson <resistor@mac.com> | |
Thu, 7 Oct 2010 22:25:06 +0000 (22:25 +0000) | ||
committer | Owen Anderson <resistor@mac.com> | |
Thu, 7 Oct 2010 22:25:06 +0000 (22:25 +0000) |
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@115996 91177308-0d34-0410-b5e6-96231b3b80d8
132 files changed:
index 4c630105bbae718e755f7280d0571009e53dd7b6..37010ed0a66791a71efc20edd6cd07b40fdd9c02 100644 (file)
PassInfo::NormalCtor_t(callDefaultCtor< passName >), cfg, analysis); \
Registry.registerPass(*PI); \
} \
- static RegisterPass<passName> passName ## _info(arg, name, cfg, analysis)
+ static RegisterPass<passName> passName ## _info(arg, name, cfg, analysis);
template<typename PassName>
PassInfo *AI = new PassInfo(name, & agName :: ID); \
Registry.registerAnalysisGroup(& agName ::ID, 0, *AI, false); \
} \
- static RegisterAnalysisGroup<agName> agName##_info (name)
+ static RegisterAnalysisGroup<agName> agName##_info (name);
#define INITIALIZE_AG_PASS(passName, agName, arg, name, cfg, analysis, def) \
void llvm::initialize##passName##Pass(PassRegistry &Registry) { \
Registry.registerAnalysisGroup(& agName ::ID, & passName ::ID, *AI, def); \
} \
static RegisterPass<passName> passName ## _info(arg, name, cfg, analysis); \
- static RegisterAnalysisGroup<agName, def> passName ## _ag(passName ## _info)
+ static RegisterAnalysisGroup<agName, def> passName ## _ag(passName ## _info);
//===---------------------------------------------------------------------------
/// PassRegistrationListener class - This class is meant to be derived from by
index 79ccabe88e1d08525ffbbaa1aaa1e05e8fe9f1a5..c189a1d61beb4ca6b70887ac75982b332626d9ae 100644 (file)
using namespace llvm;
// Register the AliasAnalysis interface, providing a nice name to refer to.
-INITIALIZE_ANALYSIS_GROUP(AliasAnalysis, "Alias Analysis");
+INITIALIZE_ANALYSIS_GROUP(AliasAnalysis, "Alias Analysis")
char AliasAnalysis::ID = 0;
//===----------------------------------------------------------------------===//
index 48f7a9f223fe5278b4c1039f84b9c6a32d89121d..8de19f7b62f6d369f2918bd356ec155382fb3a6f 100644 (file)
char AliasAnalysisCounter::ID = 0;
INITIALIZE_AG_PASS(AliasAnalysisCounter, AliasAnalysis, "count-aa",
- "Count Alias Analysis Query Responses", false, true, false);
+ "Count Alias Analysis Query Responses", false, true, false)
ModulePass *llvm::createAliasAnalysisCounterPass() {
return new AliasAnalysisCounter();
index ce363cbc7bbd6140f41d669b434a6476c05d4695..77709ab9f965e893cb7dc7aa7219baaa81d6c14d 100644 (file)
char AAEval::ID = 0;
INITIALIZE_PASS(AAEval, "aa-eval",
- "Exhaustive Alias Analysis Precision Evaluator", false, true);
+ "Exhaustive Alias Analysis Precision Evaluator", false, true)
FunctionPass *llvm::createAAEvalPass() { return new AAEval(); }
index 82e705dd1cc2f13caed7b160a33356d404bd208d..7f49c0510678b536df349dfa4599572e11fe59d0 100644 (file)
char AliasDebugger::ID = 0;
INITIALIZE_AG_PASS(AliasDebugger, AliasAnalysis, "debug-aa",
- "AA use debugger", false, true, false);
+ "AA use debugger", false, true, false)
Pass *llvm::createAliasDebugger() { return new AliasDebugger(); }
index e74543bb508aafca3d8168cf02c08e12db699f92..d3391faf82f7fbe228f283330c70d0fb93ce5917 100644 (file)
char AliasSetPrinter::ID = 0;
INITIALIZE_PASS(AliasSetPrinter, "print-alias-sets",
- "Alias Set Printer", false, true);
+ "Alias Set Printer", false, true)
index 32a17264d50accf72cfc93d44ed8a44f49674fb0..0b54e75be67d4ef47f6e026a1d35f1a14ef00b92 100644 (file)
char NoAA::ID = 0;
INITIALIZE_AG_PASS(NoAA, AliasAnalysis, "no-aa",
"No Alias Analysis (always returns 'may' alias)",
- true, true, false);
+ true, true, false)
ImmutablePass *llvm::createNoAAPass() { return new NoAA(); }
char BasicAliasAnalysis::ID = 0;
INITIALIZE_AG_PASS(BasicAliasAnalysis, AliasAnalysis, "basicaa",
"Basic Alias Analysis (default AA impl)",
- false, true, true);
+ false, true, true)
ImmutablePass *llvm::createBasicAliasAnalysisPass() {
return new BasicAliasAnalysis();
index 705bb806c095f57f362d300cd260b63f31a877ff..4bc465134fd2ece969ebd6d0d8f6d7e817810cbe 100644 (file)
}
char CFGViewer::ID = 0;
-INITIALIZE_PASS(CFGViewer, "view-cfg", "View CFG of function", false, true);
+INITIALIZE_PASS(CFGViewer, "view-cfg", "View CFG of function", false, true)
namespace {
struct CFGOnlyViewer : public FunctionPass {
char CFGOnlyViewer::ID = 0;
INITIALIZE_PASS(CFGOnlyViewer, "view-cfg-only",
- "View CFG of function (with no function bodies)", false, true);
+ "View CFG of function (with no function bodies)", false, true)
namespace {
struct CFGPrinter : public FunctionPass {
char CFGPrinter::ID = 0;
INITIALIZE_PASS(CFGPrinter, "dot-cfg", "Print CFG of function to 'dot' file",
- false, true);
+ false, true)
namespace {
struct CFGOnlyPrinter : public FunctionPass {
char CFGOnlyPrinter::ID = 0;
INITIALIZE_PASS(CFGOnlyPrinter, "dot-cfg-only",
"Print CFG of function to 'dot' file (with no function bodies)",
- false, true);
+ false, true)
/// viewCFG - This function is meant for use from the debugger. You can just
/// say 'call F->viewCFG()' and a ghostview window should pop up from the
index ba41361c6254659065bbc970223c8d45c248dfff..71431c2700e2075315071b6438bc05c90564befe 100644 (file)
}
INITIALIZE_PASS(PrintDbgInfo, "print-dbginfo",
- "Print debug info in human readable form", false, false);
+ "Print debug info in human readable form", false, false)
FunctionPass *llvm::createDbgInfoPrinterPass() { return new PrintDbgInfo(); }
index 9f340942f2ccb6926938210728ee41d4c453c013..af120d1b9427e2cbcb5746f35711c65d8a1f388d 100644 (file)
char DomViewer::ID = 0;
INITIALIZE_PASS(DomViewer, "view-dom",
- "View dominance tree of function", false, false);
+ "View dominance tree of function", false, false)
char DomOnlyViewer::ID = 0;
INITIALIZE_PASS(DomOnlyViewer, "view-dom-only",
"View dominance tree of function (with no function bodies)",
- false, false);
+ false, false)
char PostDomViewer::ID = 0;
INITIALIZE_PASS(PostDomViewer, "view-postdom",
- "View postdominance tree of function", false, false);
+ "View postdominance tree of function", false, false)
char PostDomOnlyViewer::ID = 0;
INITIALIZE_PASS(PostDomOnlyViewer, "view-postdom-only",
"View postdominance tree of function "
"(with no function bodies)",
- false, false);
+ false, false)
namespace {
struct DomPrinter
char DomPrinter::ID = 0;
INITIALIZE_PASS(DomPrinter, "dot-dom",
"Print dominance tree of function to 'dot' file",
- false, false);
+ false, false)
char DomOnlyPrinter::ID = 0;
INITIALIZE_PASS(DomOnlyPrinter, "dot-dom-only",
"Print dominance tree of function to 'dot' file "
"(with no function bodies)",
- false, false);
+ false, false)
char PostDomPrinter::ID = 0;
INITIALIZE_PASS(PostDomPrinter, "dot-postdom",
"Print postdominance tree of function to 'dot' file",
- false, false);
+ false, false)
char PostDomOnlyPrinter::ID = 0;
INITIALIZE_PASS(PostDomOnlyPrinter, "dot-postdom-only",
"Print postdominance tree of function to 'dot' file "
"(with no function bodies)",
- false, false);
+ false, false)
// Create methods available outside of this file, to use them
// "include/llvm/LinkAllPasses.h". Otherwise the pass would be deleted by
index d3d3af3fdf983d57ee775545f9d1b0af9b37fdbc..a555222799179357b7ed3e42bc457e56d5ae18ec 100644 (file)
} //End anonymous namespace
-INITIALIZE_ANALYSIS_GROUP(CallGraph, "Call Graph");
+INITIALIZE_ANALYSIS_GROUP(CallGraph, "Call Graph")
INITIALIZE_AG_PASS(BasicCallGraph, CallGraph, "basiccg",
- "Basic CallGraph Construction", false, true, true);
+ "Basic CallGraph Construction", false, true, true)
char CallGraph::ID = 0;
char BasicCallGraph::ID = 0;
index 8eed9d6f68bc59908a547cb1f15b2b2621c1571e..06ae34cfd98918b2df8dfee4ac9172bd03730103 100644 (file)
char FindUsedTypes::ID = 0;
INITIALIZE_PASS(FindUsedTypes, "print-used-types",
- "Find Used Types", false, true);
+ "Find Used Types", false, true)
// IncorporateType - Incorporate one type and all of its subtypes into the
// collection of used types.
index 8622c1137caa2eda5c3edb7a1dabdfe6c33328ca..fc2f3dfe4fe79bc8d00833daacb3ec0b0d0ff2cd 100644 (file)
char GlobalsModRef::ID = 0;
INITIALIZE_AG_PASS(GlobalsModRef, AliasAnalysis,
"globalsmodref-aa", "Simple mod/ref analysis for globals",
- false, true, false);
+ false, true, false)
Pass *llvm::createGlobalsModRefPass() { return new GlobalsModRef(); }
index cdf667ad6eed901324372484b8ce2f4305b1c4f6..e922ea2a1c13c64908b2e4b9b326d2452cba72a3 100644 (file)
--- a/lib/Analysis/IVUsers.cpp
+++ b/lib/Analysis/IVUsers.cpp
using namespace llvm;
char IVUsers::ID = 0;
-INITIALIZE_PASS(IVUsers, "iv-users", "Induction Variable Users", false, true);
+INITIALIZE_PASS(IVUsers, "iv-users", "Induction Variable Users", false, true)
Pass *llvm::createIVUsersPass() {
return new IVUsers();
index dcbcac005a2fc1c1a0bdbc214cd1993ac082725d..db6f95bc44b15c16588047133c0c7132af0eb262 100644 (file)
char InstCount::ID = 0;
INITIALIZE_PASS(InstCount, "instcount",
- "Counts the various types of Instructions", false, true);
+ "Counts the various types of Instructions", false, true)
FunctionPass *llvm::createInstCountPass() { return new InstCount(); }
index 1c9e14884316b14a5622054a11913726801e2660..2e259b147b8b0efa46b29050fdd8ee0a6d345d5c 100644 (file)
char IntervalPartition::ID = 0;
INITIALIZE_PASS(IntervalPartition, "intervals",
- "Interval Partition Construction", true, true);
+ "Interval Partition Construction", true, true)
//===----------------------------------------------------------------------===//
// IntervalPartition Implementation
index 0e024042f17b1fcb22fc8022a6027f41950de3d4..88e18fa17918d21f17acd4556438dea3e052c950 100644 (file)
char LazyValueInfo::ID = 0;
INITIALIZE_PASS(LazyValueInfo, "lazy-value-info",
- "Lazy Value Information Analysis", false, true);
+ "Lazy Value Information Analysis", false, true)
namespace llvm {
FunctionPass *createLazyValueInfoPass() { return new LazyValueInfo(); }
index 62b9f463cbf266b770a2b07d60b0c9611c6671b5..efb722bb97c46dfc417d395562f7faae2242af15 100644 (file)
// Register this pass...
char LibCallAliasAnalysis::ID = 0;
INITIALIZE_AG_PASS(LibCallAliasAnalysis, AliasAnalysis, "libcall-aa",
- "LibCall Alias Analysis", false, true, false);
+ "LibCall Alias Analysis", false, true, false)
FunctionPass *llvm::createLibCallAliasAnalysisPass(LibCallInfo *LCI) {
return new LibCallAliasAnalysis(LCI);
diff --git a/lib/Analysis/Lint.cpp b/lib/Analysis/Lint.cpp
index 2310e530e6b0204ef7e7c973827d3e31d77d454b..918a0a9c902275d57bed997d411d4cb9ea7a67c0 100644 (file)
--- a/lib/Analysis/Lint.cpp
+++ b/lib/Analysis/Lint.cpp
}
char Lint::ID = 0;
-INITIALIZE_PASS(Lint, "lint", "Statically lint-checks LLVM IR", false, true);
+INITIALIZE_PASS(Lint, "lint", "Statically lint-checks LLVM IR", false, true)
// Assert - We know that cond should be true, if not print an error message.
#define Assert(C, M) \
index 0225f4fa254867b218e8b81d1d7d2f5ca7fa7c4e..3feaf64bdffdd753d2a5ce04666f9714568a27a6 100644 (file)
char LiveValues::ID = 0;
INITIALIZE_PASS(LiveValues, "live-values",
- "Value Liveness Analysis", false, true);
+ "Value Liveness Analysis", false, true)
LiveValues::LiveValues() : FunctionPass(ID) {}
index 82c02dcd13425f632e78c8607bb8168be69bab74..aacdd29a83899fe4f45c6e1db960b0cbefce6b8f 100644 (file)
}
INITIALIZE_PASS(LoopDependenceAnalysis, "lda",
- "Loop Dependence Analysis", false, true);
+ "Loop Dependence Analysis", false, true)
char LoopDependenceAnalysis::ID = 0;
//===----------------------------------------------------------------------===//
index c928df3e72c062d3012ba12e1820442cde414b69..8398c95c727cef183af4a695b46736aecbe1d991 100644 (file)
cl::desc("Verify loop info (time consuming)"));
char LoopInfo::ID = 0;
-INITIALIZE_PASS(LoopInfo, "loops", "Natural Loop Information", true, true);
+INITIALIZE_PASS(LoopInfo, "loops", "Natural Loop Information", true, true)
//===----------------------------------------------------------------------===//
// Loop implementation
index 420ef65e410c9b90cf78b6019c8d2b32ffae78e9..1f5a2d1ef3b2c3816e6d7520d7d0831f9182ca48 100644 (file)
}
char MemDepPrinter::ID = 0;
-INITIALIZE_PASS(MemDepPrinter, "print-memdeps", "Print MemDeps of function", false, true);
+INITIALIZE_PASS(MemDepPrinter, "print-memdeps", "Print MemDeps of function",
+ false, true)
FunctionPass *llvm::createMemDepPrinter() {
return new MemDepPrinter();
index 8ae5e4ce163efd8e2398682acd19f4e84706658a..1708fe85ba3814b556804df3f8ad7ded305df5ad 100644 (file)
// Register this pass...
INITIALIZE_PASS(MemoryDependenceAnalysis, "memdep",
- "Memory Dependence Analysis", false, true);
+ "Memory Dependence Analysis", false, true)
MemoryDependenceAnalysis::MemoryDependenceAnalysis()
: FunctionPass(ID), PredCache(0) {
index 2cc1c2aa005ca9e0af89e44147a9338bcd36da96..5f8f6eeeac7eabd84d8eed4dab12869f530134f2 100644 (file)
char ModuleDebugInfoPrinter::ID = 0;
INITIALIZE_PASS(ModuleDebugInfoPrinter, "module-debuginfo",
- "Decodes module-level debug info", false, true);
+ "Decodes module-level debug info", false, true)
ModulePass *llvm::createModuleDebugInfoPrinterPass() {
return new ModuleDebugInfoPrinter();
index cbe8d1867e4f1d3e91a4401e00aadda75b23128f..c745791c8d63d3b44d5c1c73458d07b4827567eb 100644 (file)
char PostDominatorTree::ID = 0;
char PostDominanceFrontier::ID = 0;
INITIALIZE_PASS(PostDominatorTree, "postdomtree",
- "Post-Dominator Tree Construction", true, true);
+ "Post-Dominator Tree Construction", true, true)
bool PostDominatorTree::runOnFunction(Function &F) {
DT->recalculate(F);
//===----------------------------------------------------------------------===//
INITIALIZE_PASS(PostDominanceFrontier, "postdomfrontier",
- "Post-Dominance Frontier Construction", true, true);
+ "Post-Dominance Frontier Construction", true, true)
const DominanceFrontier::DomSetType &
PostDominanceFrontier::calculate(const PostDominatorTree &DT,
index ecc0a1845307a8998fd01bf6c48616dd11674351..06e2af470eda85e1104ad752bc5991cbc689142c 100644 (file)
char ProfileEstimatorPass::ID = 0;
INITIALIZE_AG_PASS(ProfileEstimatorPass, ProfileInfo, "profile-estimator",
- "Estimate profiling information", false, true, false);
+ "Estimate profiling information", false, true, false)
namespace llvm {
char &ProfileEstimatorPassID = ProfileEstimatorPass::ID;
index cc28d436dfefc88c413e6fac9b57bcca7992331e..29d933e547ba3387caa825529f0e20873627c925 100644 (file)
}
// Register the ProfileInfo interface, providing a nice name to refer to.
-INITIALIZE_ANALYSIS_GROUP(ProfileInfo, "Profile Information");
+INITIALIZE_ANALYSIS_GROUP(ProfileInfo, "Profile Information")
namespace llvm {
char NoProfileInfo::ID = 0;
// Register this pass...
INITIALIZE_AG_PASS(NoProfileInfo, ProfileInfo, "no-profile",
- "No Profile Information", false, true, true);
+ "No Profile Information", false, true, true)
ImmutablePass *llvm::createNoProfileInfoPass() { return new NoProfileInfo(); }
index d325b574e8482aa4eb728c42520b4ecde41a85a5..52a84c9fc56267e75daa8db484e9864506e468ed 100644 (file)
char LoaderPass::ID = 0;
INITIALIZE_AG_PASS(LoaderPass, ProfileInfo, "profile-loader",
- "Load profile information from llvmprof.out", false, true, false);
+ "Load profile information from llvmprof.out", false, true, false)
char &llvm::ProfileLoaderPassID = LoaderPass::ID;
index 3f01b2d592bc4205604d1d6402f3c66df5d2d6b3..41fdb276776da05c38d66cb636346b21540c6002 100644 (file)
}
INITIALIZE_PASS(ProfileVerifierPass, "profile-verifier",
- "Verify profiling information", false, true);
+ "Verify profiling information", false, true)
namespace llvm {
FunctionPass *createProfileVerifierPass() {
index abc057a773a9fba3263ee44cd844c26dc853f79c..a2643e098542c19b838c97e4cbcc8d995328f01e 100644 (file)
char RegionInfo::ID = 0;
INITIALIZE_PASS(RegionInfo, "regions",
- "Detect single entry single exit regions", true, true);
+ "Detect single entry single exit regions", true, true)
// Create methods available outside of this file, to use them
// "include/llvm/LinkAllPasses.h". Otherwise the pass would be deleted by
index f39a08c57326925fd92d78c713ec90ae682605d3..7739a9d41d44cd3b8e9ea34e2f9bf49759a6c1c8 100644 (file)
} //end anonymous namespace
INITIALIZE_PASS(RegionPrinter, "dot-regions",
- "Print regions of function to 'dot' file", true, true);
+ "Print regions of function to 'dot' file", true, true)
INITIALIZE_PASS(RegionViewer, "view-regions", "View regions of function",
- true, true);
+ true, true)
INITIALIZE_PASS(RegionOnlyViewer, "view-regions-only",
"View regions of function (with no function bodies)",
- true, true);
+ true, true)
namespace {
INITIALIZE_PASS(RegionOnlyPrinter, "dot-regions-only",
"Print regions of function to 'dot' file "
"(with no function bodies)",
- true, true);
+ true, true)
FunctionPass* llvm::createRegionViewerPass() {
return new RegionViewer();
index 61c99778fe3ed2663c14d8619a6ed97c770edf34..8bd4da651105f17ec9f7e8abe421d10e978e43bc 100644 (file)
cl::init(100));
INITIALIZE_PASS(ScalarEvolution, "scalar-evolution",
- "Scalar Evolution Analysis", false, true);
+ "Scalar Evolution Analysis", false, true)
char ScalarEvolution::ID = 0;
//===----------------------------------------------------------------------===//
diff --git a/lib/Analysis/ScalarEvolutionAliasAnalysis.cpp b/lib/Analysis/ScalarEvolutionAliasAnalysis.cpp
index d7ecdde3e6c74628f6cb67476dfbb9c1e68278f6..dcfe284984144ae7ccf83f407b767da88e571df9 100644 (file)
// Register this pass...
char ScalarEvolutionAliasAnalysis::ID = 0;
INITIALIZE_AG_PASS(ScalarEvolutionAliasAnalysis, AliasAnalysis, "scev-aa",
- "ScalarEvolution-based Alias Analysis", false, true, false);
+ "ScalarEvolution-based Alias Analysis", false, true, false)
FunctionPass *llvm::createScalarEvolutionAliasAnalysisPass() {
return new ScalarEvolutionAliasAnalysis();
index 7069a178cb08d35d73af8a9bcd68b378e019f84b..491a003435bede16910945ddd12e4baf832b8727 100644 (file)
// Register this pass...
char TypeBasedAliasAnalysis::ID = 0;
INITIALIZE_AG_PASS(TypeBasedAliasAnalysis, AliasAnalysis, "tbaa",
- "Type-Based Alias Analysis", false, true, false);
+ "Type-Based Alias Analysis", false, true, false)
ImmutablePass *llvm::createTypeBasedAliasAnalysisPass() {
return new TypeBasedAliasAnalysis();
index 1b7e08a8b6bb801ab55d9c36ad3bb933deb28320..efe65071e03c2f1370783dc0394f540adbda0fbf 100644 (file)
char CalculateSpillWeights::ID = 0;
INITIALIZE_PASS(CalculateSpillWeights, "calcspillweights",
- "Calculate spill weights", false, false);
+ "Calculate spill weights", false, false)
void CalculateSpillWeights::getAnalysisUsage(AnalysisUsage &au) const {
au.addRequired<LiveIntervals>();
diff --git a/lib/CodeGen/DeadMachineInstructionElim.cpp b/lib/CodeGen/DeadMachineInstructionElim.cpp
index 318d922adebf1069915eb48a327110feb736d9dc..b4f784d87e7be94da921862f2b7a9e1294e72405 100644 (file)
char DeadMachineInstructionElim::ID = 0;
INITIALIZE_PASS(DeadMachineInstructionElim, "dead-mi-elimination",
- "Remove dead machine instructions", false, false);
+ "Remove dead machine instructions", false, false)
FunctionPass *llvm::createDeadMachineInstructionElimPass() {
return new DeadMachineInstructionElim();
index 94026439fefa913e78381b3579f8ebe05d5e92c6..98aced983fa643cdfbbf6ca67dd60d3ce9889694 100644 (file)
}
INITIALIZE_PASS(GCModuleInfo, "collector-metadata",
- "Create Garbage Collector Module Metadata", false, false);
+ "Create Garbage Collector Module Metadata", false, false)
// -----------------------------------------------------------------------------
index bf4175cdcc955e152f1d920c9db912870f0f2db3..ff68e064e12e850b87ca77b44fbfc7955d64c4ec 100644 (file)
char IfConverter::ID = 0;
}
-INITIALIZE_PASS(IfConverter, "if-converter", "If Converter", false, false);
+INITIALIZE_PASS(IfConverter, "if-converter", "If Converter", false, false)
FunctionPass *llvm::createIfConverterPass() { return new IfConverter(); }
index c1e8ce560a351392f16fa4db5bfed98245b8ebc4..31c52132c473b9541f53884e1821068566bf9c09 100644 (file)
char LiveIntervals::ID = 0;
INITIALIZE_PASS(LiveIntervals, "liveintervals",
- "Live Interval Analysis", false, false);
+ "Live Interval Analysis", false, false)
void LiveIntervals::getAnalysisUsage(AnalysisUsage &AU) const {
AU.setPreservesCFG();
index b5c385f7723941b07359268ca89680fee42ab309..92aec6a8e3a043c139eeb40d32ed030d4b8b37d6 100644 (file)
char LiveStacks::ID = 0;
INITIALIZE_PASS(LiveStacks, "livestacks",
- "Live Stack Slot Analysis", false, false);
+ "Live Stack Slot Analysis", false, false)
void LiveStacks::getAnalysisUsage(AnalysisUsage &AU) const {
AU.setPreservesAll();
index 375307b973a9795477a3b3936ba665bee47d534b..fce7a6407f2d56633c401f4963942faed922dac5 100644 (file)
char LiveVariables::ID = 0;
INITIALIZE_PASS(LiveVariables, "livevars",
- "Live Variable Analysis", false, false);
+ "Live Variable Analysis", false, false)
void LiveVariables::getAnalysisUsage(AnalysisUsage &AU) const {
index 9d09f608ee910e588943761777d39f5aebcf3d8e..2cd56ac2214b68c56cc45f7131b81345a75cb2f5 100644 (file)
char MachineCSE::ID = 0;
INITIALIZE_PASS(MachineCSE, "machine-cse",
- "Machine Common Subexpression Elimination", false, false);
+ "Machine Common Subexpression Elimination", false, false)
FunctionPass *llvm::createMachineCSEPass() { return new MachineCSE(); }
index 3c674789244a2dbe71ba3d4b66118e1a98d87fc4..b90607aae23854bc47cb638376581f6b75c7c121 100644 (file)
char MachineDominatorTree::ID = 0;
INITIALIZE_PASS(MachineDominatorTree, "machinedomtree",
- "MachineDominator Tree Construction", true, true);
+ "MachineDominator Tree Construction", true, true)
char &llvm::MachineDominatorsID = MachineDominatorTree::ID;
index 1a74b747e9f2a45e1d137649aa8d4ee12f0a4e54..32b7e00ce660ac50b6629189722c56601e171ddb 100644 (file)
char MachineLICM::ID = 0;
INITIALIZE_PASS(MachineLICM, "machinelicm",
- "Machine Loop Invariant Code Motion", false, false);
+ "Machine Loop Invariant Code Motion", false, false)
FunctionPass *llvm::createMachineLICMPass(bool PreRegAlloc) {
return new MachineLICM(PreRegAlloc);
index bca4b0c28985fad4672e0182db9597b666e8191a..095b2b8d4e3b6bdf8b776fa4555acc90ae149ac7 100644 (file)
char MachineLoopInfo::ID = 0;
INITIALIZE_PASS(MachineLoopInfo, "machine-loops",
- "Machine Natural Loop Construction", true, true);
+ "Machine Natural Loop Construction", true, true)
char &llvm::MachineLoopInfoID = MachineLoopInfo::ID;
index 3482dde1acc147f3862432f93e3f8aff189395e0..f6f9dfacf9d90d97ef6133911c7dd11606fa783b 100644 (file)
// Handle the Pass registration stuff necessary to use TargetData's.
INITIALIZE_PASS(MachineModuleInfo, "machinemoduleinfo",
- "Machine Module Information", false, false);
+ "Machine Module Information", false, false)
char MachineModuleInfo::ID = 0;
// Out of line virtual method.
index b9c1eb4b684fe9d7493c35ce244fb614ae0f7497..5a584f93007f4027d09620ebbf975abff47add93 100644 (file)
char MachineSinking::ID = 0;
INITIALIZE_PASS(MachineSinking, "machine-sink",
- "Machine code sinking", false, false);
+ "Machine code sinking", false, false)
FunctionPass *llvm::createMachineSinkingPass() { return new MachineSinking(); }
index 644e3c06da17ed45a900abc99c97555454c9792c..d7d38e2e55cf921ebcc4cf10124532ebe8dfc033 100644 (file)
char MachineVerifierPass::ID = 0;
INITIALIZE_PASS(MachineVerifierPass, "machineverifier",
- "Verify generated machine code", false, false);
+ "Verify generated machine code", false, false)
FunctionPass *llvm::createMachineVerifierPass() {
return new MachineVerifierPass();
index edb4eea71b8a72032f1d1a3ec5ddb06ce36de287..cfdf46d05956e09fffabfb888ddaf0e591a87831 100644 (file)
char OptimizePHIs::ID = 0;
INITIALIZE_PASS(OptimizePHIs, "opt-phis",
- "Optimize machine instruction PHIs", false, false);
+ "Optimize machine instruction PHIs", false, false)
FunctionPass *llvm::createOptimizePHIsPass() { return new OptimizePHIs(); }
index d4df4c548711e9ae64cced6dfc2bb700bfd0914a..03673b82418a9197b3317d4e8472a8b5ca8d7a1d 100644 (file)
char PHIElimination::ID = 0;
INITIALIZE_PASS(PHIElimination, "phi-node-elimination",
- "Eliminate PHI nodes for register allocation", false, false);
+ "Eliminate PHI nodes for register allocation", false, false)
char &llvm::PHIEliminationID = PHIElimination::ID;
index 5fa63a92ba6569b5719f0eda3633ae981b1dba3e..548e94ac717f5c08f2f23e8dc6865f2b0acee755 100644 (file)
char PeepholeOptimizer::ID = 0;
INITIALIZE_PASS(PeepholeOptimizer, "peephole-opts",
- "Peephole Optimizations", false, false);
+ "Peephole Optimizations", false, false)
FunctionPass *llvm::createPeepholeOptimizerPass() {
return new PeepholeOptimizer();
index 68d28e4f9717da4d629b804b399ac287c0c75e13..c43b2b2c9e3d90307c97ecf0e0b2983520f666af 100644 (file)
INITIALIZE_PASS(PreAllocSplitting, "pre-alloc-splitting",
"Pre-Register Allocation Live Interval Splitting",
- false, false);
+ false, false)
char &llvm::PreAllocSplittingID = PreAllocSplitting::ID;
index b8831db1d118a327db748b1d38678ee4d207d681..b1637293b29d13bf5dec1ec669e993c8fe11bece 100644 (file)
char ProcessImplicitDefs::ID = 0;
INITIALIZE_PASS(ProcessImplicitDefs, "processimpdefs",
- "Process Implicit Definitions.", false, false);
+ "Process Implicit Definitions.", false, false)
void ProcessImplicitDefs::getAnalysisUsage(AnalysisUsage &AU) const {
AU.setPreservesCFG();
index e2802c1fdf4a7ad6d5104a2363610386cabc59ac..254b94bd8cbda63977f09f26c24b4c3e1f8bc2e9 100644 (file)
char PEI::ID = 0;
INITIALIZE_PASS(PEI, "prologepilog",
- "Prologue/Epilogue Insertion", false, false);
+ "Prologue/Epilogue Insertion", false, false)
STATISTIC(NumVirtualFrameRegs, "Number of virtual frame regs encountered");
STATISTIC(NumScavengedRegs, "Number of frame index regs scavenged");
index a4fdcfaa3be62cce6ee1a06961cbfb6dfee1f350..0581eac2abe043ce9786e395c1d439eae113745c 100644 (file)
}
INITIALIZE_PASS(RALinScan, "linearscan-regalloc",
- "Linear Scan Register Allocator", false, false);
+ "Linear Scan Register Allocator", false, false)
void RALinScan::ComputeRelatedRegClasses() {
// First pass, add all reg classes to the union, and determine at least one
index b97a3a09414096bde651167a10a847580cde0e43..657134a9ab757fe4c52d9d10a4b5d0ceb2d00b21 100644 (file)
using namespace llvm;
// Register the RegisterCoalescer interface, providing a nice name to refer to.
-INITIALIZE_ANALYSIS_GROUP(RegisterCoalescer, "Register Coalescer");
+INITIALIZE_ANALYSIS_GROUP(RegisterCoalescer, "Register Coalescer")
char RegisterCoalescer::ID = 0;
// RegisterCoalescer destructor: DO NOT move this to the header file
index 93426eecbbc1e5e9e80e7b3df453a27a9d69baa4..7124e49ea64b2986f9dd347078853fe85634911c 100644 (file)
char RenderMachineFunction::ID = 0;
INITIALIZE_PASS(RenderMachineFunction, "rendermf",
"Render machine functions (and related info) to HTML pages",
- false, false);
+ false, false)
static cl::opt<std::string>
outputFileSuffix("rmf-file-suffix",
index 733b065c9689c1c11da5ed442d24065960fd6108..835365f6f3239c50f838e337bed61ac4af2c7b3c 100644 (file)
INITIALIZE_AG_PASS(SimpleRegisterCoalescing, RegisterCoalescer,
"simple-register-coalescing", "Simple Register Coalescing",
- false, false, true);
+ false, false, true)
char &llvm::SimpleRegisterCoalescingID = SimpleRegisterCoalescing::ID;
index b106d3aa2fe4a77a84cc47eb394e3c903020d388..adab9ff3a5aaec11abb44cddd6e701b012e8996b 100644 (file)
char SlotIndexes::ID = 0;
INITIALIZE_PASS(SlotIndexes, "slotindexes",
- "Slot index numbering", false, false);
+ "Slot index numbering", false, false)
IndexListEntry* IndexListEntry::getEmptyKeyEntry() {
return &*IndexListEntryEmptyKey;
index 825782d69a25ef0c34f50044a282dc553f47b3be..f52eaea10160ce3d76092fc05688af10efae0693 100644 (file)
--- a/lib/CodeGen/Splitter.cpp
+++ b/lib/CodeGen/Splitter.cpp
char LoopSplitter::ID = 0;
INITIALIZE_PASS(LoopSplitter, "loop-splitting",
- "Split virtual regists across loop boundaries.", false, false);
+ "Split virtual regists across loop boundaries.", false, false)
namespace llvm {
index 9f51778da756241d7e43b761edfa97de37fee038..eb21e156be88ef3d5567c5cf8f15f7670fecd513 100644 (file)
char StackProtector::ID = 0;
INITIALIZE_PASS(StackProtector, "stack-protector",
- "Insert stack protectors", false, false);
+ "Insert stack protectors", false, false)
FunctionPass *llvm::createStackProtectorPass(const TargetLowering *tli) {
return new StackProtector(tli);
index 8d57ae95dde2a106fa2e3eedba1139e3dd2e2d3c..d565922639e65bec60c3e660a10be7b3e261cab3 100644 (file)
char StackSlotColoring::ID = 0;
INITIALIZE_PASS(StackSlotColoring, "stack-slot-coloring",
- "Stack Slot Coloring", false, false);
+ "Stack Slot Coloring", false, false)
FunctionPass *llvm::createStackSlotColoringPass(bool RegColor) {
return new StackSlotColoring(RegColor);
index 894dbfa28bac7a8f0c4836ea009b428adbc68213..55b2897bab135ce63fe5d8bfeb2b17f40010d7c9 100644 (file)
char StrongPHIElimination::ID = 0;
INITIALIZE_PASS(StrongPHIElimination, "strong-phi-node-elimination",
- "Eliminate PHI nodes for register allocation, intelligently", false, false);
+ "Eliminate PHI nodes for register allocation, intelligently", false, false)
char &llvm::StrongPHIEliminationID = StrongPHIElimination::ID;
index 78989c567e42feb9c964b306b682404c52b19059..bef78cc260f8d76333ed5b5b24271976bfa8524f 100644 (file)
char TwoAddressInstructionPass::ID = 0;
INITIALIZE_PASS(TwoAddressInstructionPass, "twoaddressinstruction",
- "Two-Address instruction pass", false, false);
+ "Two-Address instruction pass", false, false)
char &llvm::TwoAddressInstructionPassID = TwoAddressInstructionPass::ID;
index ebf1129d55abd5f253e02944569bffdee6b99adc..0e8a8a7e08f7af9af14de70d0cdc47d787eb821d 100644 (file)
}
char UnreachableBlockElim::ID = 0;
INITIALIZE_PASS(UnreachableBlockElim, "unreachableblockelim",
- "Remove unreachable blocks from the CFG", false, false);
+ "Remove unreachable blocks from the CFG", false, false)
FunctionPass *llvm::createUnreachableBlockEliminationPass() {
return new UnreachableBlockElim();
char UnreachableMachineBlockElim::ID = 0;
INITIALIZE_PASS(UnreachableMachineBlockElim, "unreachable-mbb-elimination",
- "Remove unreachable machine basic blocks", false, false);
+ "Remove unreachable machine basic blocks", false, false)
char &llvm::UnreachableMachineBlockElimID = UnreachableMachineBlockElim::ID;
index 20ffcffa70d35da9b2f15d99a9903a9fbb1a29d2..6ed0b64f5fc063d90b3c13d9f8d07ad02c1d7681 100644 (file)
char VirtRegMap::ID = 0;
-INITIALIZE_PASS(VirtRegMap, "virtregmap", "Virtual Register Map", false, false);
+INITIALIZE_PASS(VirtRegMap, "virtregmap", "Virtual Register Map", false, false)
bool VirtRegMap::runOnMachineFunction(MachineFunction &mf) {
MRI = &mf.getRegInfo();
index 0a282c38c0316c2e8692f8eb961d45b7aa3d69df..eaaaad9eab1192ede3c15ae9b51f7aa90feb2f3b 100644 (file)
// Handle the Pass registration stuff necessary to use TargetData's.
// Register the default SparcV9 implementation...
-INITIALIZE_PASS(TargetData, "targetdata", "Target Data Layout", false, true);
+INITIALIZE_PASS(TargetData, "targetdata", "Target Data Layout", false, true)
char TargetData::ID = 0;
//===----------------------------------------------------------------------===//
index 0c77e1fd8cff4f7dfdcc155515d62cd41201a13d..8b6de188642a5404604c2913e38cf01750227515 100644 (file)
char ArgPromotion::ID = 0;
INITIALIZE_PASS(ArgPromotion, "argpromotion",
- "Promote 'by reference' arguments to scalars", false, false);
+ "Promote 'by reference' arguments to scalars", false, false)
Pass *llvm::createArgumentPromotionPass(unsigned maxElements) {
return new ArgPromotion(maxElements);
index 64e8d792dc3ad5caae9a67d94345f6877a993bfd..706c3eefd33e8743f2e8f487093229925177f004 100644 (file)
char ConstantMerge::ID = 0;
INITIALIZE_PASS(ConstantMerge, "constmerge",
- "Merge Duplicate Global Constants", false, false);
+ "Merge Duplicate Global Constants", false, false)
ModulePass *llvm::createConstantMergePass() { return new ConstantMerge(); }
diff --git a/lib/Transforms/IPO/DeadArgumentElimination.cpp b/lib/Transforms/IPO/DeadArgumentElimination.cpp
index e8b168e4575b8cd6b50d5092a492129a8a3664e3..5a838b8ccc1d7746399b1d44e65c340d802965c0 100644 (file)
char DAE::ID = 0;
-INITIALIZE_PASS(DAE, "deadargelim", "Dead Argument Elimination", false, false);
+INITIALIZE_PASS(DAE, "deadargelim", "Dead Argument Elimination", false, false)
namespace {
/// DAH - DeadArgumentHacking pass - Same as dead argument elimination, but
char DAH::ID = 0;
INITIALIZE_PASS(DAH, "deadarghaX0r",
"Dead Argument Hacking (BUGPOINT USE ONLY; DO NOT USE)",
- false, false);
+ false, false)
/// createDeadArgEliminationPass - This pass removes arguments from functions
/// which are not used by the body of the function.
diff --git a/lib/Transforms/IPO/DeadTypeElimination.cpp b/lib/Transforms/IPO/DeadTypeElimination.cpp
index 5dc50c5bef32fe0ad67ed4d3de1d80de54e73c92..c93e2431eefe8ee72720d1b080d8c558024eabb0 100644 (file)
}
char DTE::ID = 0;
-INITIALIZE_PASS(DTE, "deadtypeelim", "Dead Type Elimination", false, false);
+INITIALIZE_PASS(DTE, "deadtypeelim", "Dead Type Elimination", false, false)
ModulePass *llvm::createDeadTypeEliminationPass() {
return new DTE();
index 6165ba023f7377b757a618200fa347675dc1c485..0c0ca84462b9c139adec51f210065d9f9626aeb6 100644 (file)
char FunctionAttrs::ID = 0;
INITIALIZE_PASS(FunctionAttrs, "functionattrs",
- "Deduce function attributes", false, false);
+ "Deduce function attributes", false, false)
Pass *llvm::createFunctionAttrsPass() { return new FunctionAttrs(); }
index aa18601b9aecaf8a2cb17315df28332257426b1f..95b0af41b513add72eb96ccee1e94b5e1b9c220e 100644 (file)
char GlobalDCE::ID = 0;
INITIALIZE_PASS(GlobalDCE, "globaldce",
- "Dead Global Elimination", false, false);
+ "Dead Global Elimination", false, false)
ModulePass *llvm::createGlobalDCEPass() { return new GlobalDCE(); }
index a77af549caa131579abb709f240966e921926781..a00474460aaf597c5abe93cd100e760aa0e03b46 100644 (file)
char GlobalOpt::ID = 0;
INITIALIZE_PASS(GlobalOpt, "globalopt",
- "Global Variable Optimizer", false, false);
+ "Global Variable Optimizer", false, false)
ModulePass *llvm::createGlobalOptimizerPass() { return new GlobalOpt(); }
diff --git a/lib/Transforms/IPO/IPConstantPropagation.cpp b/lib/Transforms/IPO/IPConstantPropagation.cpp
index 1b3cf7810cc68f6db9332d941f49f652cf2485eb..6f6632a4b4f7645c65e2dc0d86f515a522915b97 100644 (file)
char IPCP::ID = 0;
INITIALIZE_PASS(IPCP, "ipconstprop",
- "Interprocedural constant propagation", false, false);
+ "Interprocedural constant propagation", false, false)
ModulePass *llvm::createIPConstantPropagationPass() { return new IPCP(); }
index ecc60ad069325917b045542bba4ea9fe0613dcab..769abed6ce30ecc9e5b5eb08d68030efd0292ef1 100644 (file)
char AlwaysInliner::ID = 0;
INITIALIZE_PASS(AlwaysInliner, "always-inline",
- "Inliner for always_inline functions", false, false);
+ "Inliner for always_inline functions", false, false)
Pass *llvm::createAlwaysInlinerPass() { return new AlwaysInliner(); }
index 9c6637dfe5ad6bc5de2b58e80750746d35116acf..57682ad130f45b77c59336cd1eef9f3b57a506b0 100644 (file)
char SimpleInliner::ID = 0;
INITIALIZE_PASS(SimpleInliner, "inline",
- "Function Integration/Inlining", false, false);
+ "Function Integration/Inlining", false, false)
Pass *llvm::createFunctionInliningPass() { return new SimpleInliner(); }
index a1d919fd8a042050525b4b4a7f42249c66f8b5d7..45f13eaadcd2b03d4f7990a45524aa321a135b03 100644 (file)
char InternalizePass::ID = 0;
INITIALIZE_PASS(InternalizePass, "internalize",
- "Internalize Global Symbols", false, false);
+ "Internalize Global Symbols", false, false)
InternalizePass::InternalizePass(bool AllButMain)
: ModulePass(ID), AllButMain(AllButMain){
index f88dff67d7c9831851ef207cec04b5970cf34c6f..09f80a93c3fa4cd082c52a6103ebdf6e78bff0a8 100644 (file)
char LoopExtractor::ID = 0;
INITIALIZE_PASS(LoopExtractor, "loop-extract",
- "Extract loops into new functions", false, false);
+ "Extract loops into new functions", false, false)
namespace {
/// SingleLoopExtractor - For bugpoint.
char SingleLoopExtractor::ID = 0;
INITIALIZE_PASS(SingleLoopExtractor, "loop-extract-single",
- "Extract at most one loop into a new function", false, false);
+ "Extract at most one loop into a new function", false, false)
// createLoopExtractorPass - This pass extracts all natural loops from the
// program into a function if it can.
char BlockExtractorPass::ID = 0;
INITIALIZE_PASS(BlockExtractorPass, "extract-blocks",
"Extract Basic Blocks From Module (for bugpoint use)",
- false, false);
+ false, false)
// createBlockExtractorPass - This pass extracts all blocks (except those
// specified in the argument list) from the functions in the module.
index 6c715de04b76365784f302451e0c20132b10e9bc..230847bae824a8b6f14febd9c1871559c1cc65e1 100644 (file)
} // end anonymous namespace
char LowerSetJmp::ID = 0;
-INITIALIZE_PASS(LowerSetJmp, "lowersetjmp", "Lower Set Jump", false, false);
+INITIALIZE_PASS(LowerSetJmp, "lowersetjmp", "Lower Set Jump", false, false)
// run - Run the transformation on the program. We grab the function
// prototypes for longjmp and setjmp. If they are used in the program,
index 9308b3058e9e8688d494e63e5f75211fef677ffe..ab55db9d9d763f1237aa284733d8c6767e3fb88a 100644 (file)
} // end anonymous namespace
char MergeFunctions::ID = 0;
-INITIALIZE_PASS(MergeFunctions, "mergefunc", "Merge Functions", false, false);
+INITIALIZE_PASS(MergeFunctions, "mergefunc", "Merge Functions", false, false)
ModulePass *llvm::createMergeFunctionsPass() {
return new MergeFunctions();
index 432f7c53a67d106454907cd1ef88f2030ef54aab..c0c252fe508a777baa2743a40a140710aaf0836e 100644 (file)
char PartialInliner::ID = 0;
INITIALIZE_PASS(PartialInliner, "partial-inliner",
- "Partial Inliner", false, false);
+ "Partial Inliner", false, false)
ModulePass* llvm::createPartialInliningPass() { return new PartialInliner(); }
diff --git a/lib/Transforms/IPO/PartialSpecialization.cpp b/lib/Transforms/IPO/PartialSpecialization.cpp
index 4a99a411ab338c57d7b498beb69437c57881fe18..756c9b3ed405b7f644ddd7b1b344e1aac452f1e9 100644 (file)
char PartSpec::ID = 0;
INITIALIZE_PASS(PartSpec, "partialspecialization",
- "Partial Specialization", false, false);
+ "Partial Specialization", false, false)
// Specialize F by replacing the arguments (keys) in replacements with the
// constants (values). Replace all calls to F with those constants with
index 09ac76f979649efb1169f46cbdaee4d89f7b26c4..e71344b215877e33621d5b82a30ef0a4e4371485 100644 (file)
char PruneEH::ID = 0;
INITIALIZE_PASS(PruneEH, "prune-eh",
- "Remove unused exception handling info", false, false);
+ "Remove unused exception handling info", false, false)
Pass *llvm::createPruneEHPass() { return new PruneEH(); }
diff --git a/lib/Transforms/IPO/StripDeadPrototypes.cpp b/lib/Transforms/IPO/StripDeadPrototypes.cpp
index ee10ad0b8ba265196e516f23df5d4a59aeaddfc0..d44642f950d60ea35ceaaf70f465704ad4517514 100644 (file)
char StripDeadPrototypesPass::ID = 0;
INITIALIZE_PASS(StripDeadPrototypesPass, "strip-dead-prototypes",
- "Strip Unused Function Prototypes", false, false);
+ "Strip Unused Function Prototypes", false, false)
bool StripDeadPrototypesPass::runOnModule(Module &M) {
bool MadeChange = false;
index 20b7b8f2b8509228343546069d509a192d37f683..549015524c4df70f91f77fdcadd4dfa316a13dfb 100644 (file)
char StripSymbols::ID = 0;
INITIALIZE_PASS(StripSymbols, "strip",
- "Strip all symbols from a module", false, false);
+ "Strip all symbols from a module", false, false)
ModulePass *llvm::createStripSymbolsPass(bool OnlyDebugInfo) {
return new StripSymbols(OnlyDebugInfo);
char StripNonDebugSymbols::ID = 0;
INITIALIZE_PASS(StripNonDebugSymbols, "strip-nondebug",
"Strip all symbols, except dbg symbols, from a module",
- false, false);
+ false, false)
ModulePass *llvm::createStripNonDebugSymbolsPass() {
return new StripNonDebugSymbols();
char StripDebugDeclare::ID = 0;
INITIALIZE_PASS(StripDebugDeclare, "strip-debug-declare",
- "Strip all llvm.dbg.declare intrinsics", false, false);
+ "Strip all llvm.dbg.declare intrinsics", false, false)
ModulePass *llvm::createStripDebugDeclarePass() {
return new StripDebugDeclare();
char StripDeadDebugInfo::ID = 0;
INITIALIZE_PASS(StripDeadDebugInfo, "strip-dead-debug-info",
- "Strip debug info for unused symbols", false, false);
+ "Strip debug info for unused symbols", false, false)
ModulePass *llvm::createStripDeadDebugInfoPass() {
return new StripDeadDebugInfo();
index b82b03f7d9e7d198ddc159b680ba43871da8a4b6..f3565f6b76941f75c0805587c42f5b6816e8bd50 100644 (file)
char SRETPromotion::ID = 0;
INITIALIZE_PASS(SRETPromotion, "sretpromotion",
- "Promote sret arguments to multiple ret values", false, false);
+ "Promote sret arguments to multiple ret values", false, false)
Pass *llvm::createStructRetPromotionPass() {
return new SRETPromotion();
diff --git a/lib/Transforms/InstCombine/InstructionCombining.cpp b/lib/Transforms/InstCombine/InstructionCombining.cpp
index 5ac5bd4f7928238e0d5e10a009e3e00d8c2dca8f..47519fbaef93c81246faa7797aeef3750a7424e4 100644 (file)
char InstCombiner::ID = 0;
INITIALIZE_PASS(InstCombiner, "instcombine",
- "Combine redundant instructions", false, false);
+ "Combine redundant instructions", false, false)
void InstCombiner::getAnalysisUsage(AnalysisUsage &AU) const {
AU.addPreservedID(LCSSAID);
diff --git a/lib/Transforms/Instrumentation/EdgeProfiling.cpp b/lib/Transforms/Instrumentation/EdgeProfiling.cpp
index a77d70cd1c1bc45ea0d86c68c937bb560ca902c4..a1173006b1f8998f6c52b8110c4f9542e5450521 100644 (file)
char EdgeProfiler::ID = 0;
INITIALIZE_PASS(EdgeProfiler, "insert-edge-profiling",
- "Insert instrumentation for edge profiling", false, false);
+ "Insert instrumentation for edge profiling", false, false)
ModulePass *llvm::createEdgeProfilerPass() { return new EdgeProfiler(); }
diff --git a/lib/Transforms/Instrumentation/OptimalEdgeProfiling.cpp b/lib/Transforms/Instrumentation/OptimalEdgeProfiling.cpp
index 8eec9872812dc7a6478f1d7b7790960083b44de0..b70309edd467b6b73e2f809ca0f018c78ab75be2 100644 (file)
char OptimalEdgeProfiler::ID = 0;
INITIALIZE_PASS(OptimalEdgeProfiler, "insert-optimal-edge-profiling",
"Insert optimal instrumentation for edge profiling",
- false, false);
+ false, false)
ModulePass *llvm::createOptimalEdgeProfilerPass() {
return new OptimalEdgeProfiler();
index ada086e9db766404980eca3732d9fb027cb95984..ac6fa8ea2e7f5646fba378631b9841e307fc519a 100644 (file)
}
char ADCE::ID = 0;
-INITIALIZE_PASS(ADCE, "adce", "Aggressive Dead Code Elimination", false, false);
+INITIALIZE_PASS(ADCE, "adce", "Aggressive Dead Code Elimination", false, false)
bool ADCE::runOnFunction(Function& F) {
SmallPtrSet<Instruction*, 128> alive;
diff --git a/lib/Transforms/Scalar/BasicBlockPlacement.cpp b/lib/Transforms/Scalar/BasicBlockPlacement.cpp
index b144678c6a0eda03a7b9324329787f1e5f043ace..69d1a7e15d0f189cc502627aba947978bb31c035 100644 (file)
char BlockPlacement::ID = 0;
INITIALIZE_PASS(BlockPlacement, "block-placement",
- "Profile Guided Basic Block Placement", false, false);
+ "Profile Guided Basic Block Placement", false, false)
FunctionPass *llvm::createBlockPlacementPass() { return new BlockPlacement(); }
index 880a4e5eb890551e6144e146937f52a329c6afd5..980e8f8f0fb51b933391f226231ec22da10a3375 100644 (file)
char CodeGenPrepare::ID = 0;
INITIALIZE_PASS(CodeGenPrepare, "codegenprepare",
- "Optimize for code generation", false, false);
+ "Optimize for code generation", false, false)
FunctionPass *llvm::createCodeGenPreparePass(const TargetLowering *TLI) {
return new CodeGenPrepare(TLI);
index a0ea369d0cadd06cfab1cb132d12365485ceb7c1..efc0551b7eb7723ea9ccf343ea8d5b57d38a8c64 100644 (file)
char ConstantPropagation::ID = 0;
INITIALIZE_PASS(ConstantPropagation, "constprop",
- "Simple constant propagation", false, false);
+ "Simple constant propagation", false, false)
FunctionPass *llvm::createConstantPropagationPass() {
return new ConstantPropagation();
diff --git a/lib/Transforms/Scalar/CorrelatedValuePropagation.cpp b/lib/Transforms/Scalar/CorrelatedValuePropagation.cpp
index e8b8e946170b0f59e356669271cc5d337a06bb6e..bb92096400973441fd90a036dc4f984f259de22b 100644 (file)
char CorrelatedValuePropagation::ID = 0;
INITIALIZE_PASS(CorrelatedValuePropagation, "correlated-propagation",
- "Value Propagation", false, false);
+ "Value Propagation", false, false)
// Public interface to the Value Propagation pass
Pass *llvm::createCorrelatedValuePropagationPass() {
index 87ea8038356ae6b3b207bd30f57d27515307859a..978769f23b8a865dd0a9084ca4d544d04c42e9a0 100644 (file)
char DeadInstElimination::ID = 0;
INITIALIZE_PASS(DeadInstElimination, "die",
- "Dead Instruction Elimination", false, false);
+ "Dead Instruction Elimination", false, false)
Pass *llvm::createDeadInstEliminationPass() {
return new DeadInstElimination();
}
char DCE::ID = 0;
-INITIALIZE_PASS(DCE, "dce", "Dead Code Elimination", false, false);
+INITIALIZE_PASS(DCE, "dce", "Dead Code Elimination", false, false)
bool DCE::runOnFunction(Function &F) {
// Start out with all of the instructions in the worklist...
diff --git a/lib/Transforms/Scalar/DeadStoreElimination.cpp b/lib/Transforms/Scalar/DeadStoreElimination.cpp
index c8fd9d9fa5561b487f0b0f95cd9c7f4f5f539e25..4ac81f4a5a18a9db7f64d6111317a1b906fbe16e 100644 (file)
}
char DSE::ID = 0;
-INITIALIZE_PASS(DSE, "dse", "Dead Store Elimination", false, false);
+INITIALIZE_PASS(DSE, "dse", "Dead Store Elimination", false, false)
FunctionPass *llvm::createDeadStoreEliminationPass() { return new DSE(); }
index 53dd06d24bb5b01cb34e30fb0f70a0043fa06982..4ae9bb104d247beef0e7143ca3e59257a0468694 100644 (file)
char GEPSplitter::ID = 0;
INITIALIZE_PASS(GEPSplitter, "split-geps",
- "split complex GEPs into simple GEPs", false, false);
+ "split complex GEPs into simple GEPs", false, false)
FunctionPass *llvm::createGEPSplitterPass() {
return new GEPSplitter();
index dc75342b4050302d98e463da3df5c5e3691cd30b..9dc82cebe75b30154e93d1e8ced61b0ef990c4e5 100644 (file)
return new GVN(NoLoads);
}
-INITIALIZE_PASS(GVN, "gvn", "Global Value Numbering", false, false);
+INITIALIZE_PASS(GVN, "gvn", "Global Value Numbering", false, false)
void GVN::dump(DenseMap<uint32_t, Value*>& d) {
errs() << "{\n";
index dfdd8b7c89f05bd6f5befba8ca1850d66e4ded5a..8825a13f6f288616a9dc03b75cba2c172be550a8 100644 (file)
char IndVarSimplify::ID = 0;
INITIALIZE_PASS(IndVarSimplify, "indvars",
- "Canonicalize Induction Variables", false, false);
+ "Canonicalize Induction Variables", false, false)
Pass *llvm::createIndVarSimplifyPass() {
return new IndVarSimplify();
index 43460beb3bd96de79caec77e2a029fb1ae500be3..df2b9bd2bbefa01cda8bccadf1c3057a1f8896d2 100644 (file)
char JumpThreading::ID = 0;
INITIALIZE_PASS(JumpThreading, "jump-threading",
- "Jump Threading", false, false);
+ "Jump Threading", false, false)
// Public interface to the Jump Threading pass
FunctionPass *llvm::createJumpThreadingPass() { return new JumpThreading(); }
index af9a7eefb6a661228b7023bfc9267cd016e6a2bb..1071f4b07da2163589b0656b7bb6cc5c5a789cee 100644 (file)
}
char LICM::ID = 0;
-INITIALIZE_PASS(LICM, "licm", "Loop Invariant Code Motion", false, false);
+INITIALIZE_PASS(LICM, "licm", "Loop Invariant Code Motion", false, false)
Pass *llvm::createLICMPass() { return new LICM(); }
index 543dfc1cba0960402cac3c1794f60198b5591443..d5dae53cb4e0dcfa9fd7e1eecee2b6c94c89372e 100644 (file)
char LoopDeletion::ID = 0;
INITIALIZE_PASS(LoopDeletion, "loop-deletion",
- "Delete dead loops", false, false);
+ "Delete dead loops", false, false)
Pass* llvm::createLoopDeletionPass() {
return new LoopDeletion();
index fbb57804c40166bb3e005738491b9e0d88089e79..f091a94bddafc9022ac3dba35bfd37562f49097b 100644 (file)
char LoopIndexSplit::ID = 0;
INITIALIZE_PASS(LoopIndexSplit, "loop-index-split",
- "Index Split Loops", false, false);
+ "Index Split Loops", false, false)
Pass *llvm::createLoopIndexSplitPass() {
return new LoopIndexSplit();
index a0d07726fe884408c0614fccef13421cf00ed7be..bdc8f4ab7b4f2d186863c3f7adf82c9299ccbf24 100644 (file)
}
char LoopRotate::ID = 0;
-INITIALIZE_PASS(LoopRotate, "loop-rotate", "Rotate Loops", false, false);
+INITIALIZE_PASS(LoopRotate, "loop-rotate", "Rotate Loops", false, false)
Pass *llvm::createLoopRotatePass() { return new LoopRotate(); }
diff --git a/lib/Transforms/Scalar/LoopStrengthReduce.cpp b/lib/Transforms/Scalar/LoopStrengthReduce.cpp
index a3cef7a82807ad677af121c8f92e9eb3bcb0898b..90af6c9ee5a784517f7fff8fdde085278b72382b 100644 (file)
char LoopStrengthReduce::ID = 0;
INITIALIZE_PASS(LoopStrengthReduce, "loop-reduce",
- "Loop Strength Reduction", false, false);
+ "Loop Strength Reduction", false, false)
Pass *llvm::createLoopStrengthReducePass(const TargetLowering *TLI) {
return new LoopStrengthReduce(TLI);
index 7da2b52da544a64bfc94e5588022a98b48beef02..288ed621660753d8d81d2ccbe0a1f52c42f633f8 100644 (file)
}
char LoopUnroll::ID = 0;
-INITIALIZE_PASS(LoopUnroll, "loop-unroll", "Unroll loops", false, false);
+INITIALIZE_PASS(LoopUnroll, "loop-unroll", "Unroll loops", false, false)
Pass *llvm::createLoopUnrollPass() { return new LoopUnroll(); }
index 9afe428ba5691ae4a3d5a7e0d62d91d563ae8df4..b0c3ba27bf8270e318972126d04a1bc8f3e13256 100644 (file)
};
}
char LoopUnswitch::ID = 0;
-INITIALIZE_PASS(LoopUnswitch, "loop-unswitch", "Unswitch loops", false, false);
+INITIALIZE_PASS(LoopUnswitch, "loop-unswitch", "Unswitch loops", false, false)
Pass *llvm::createLoopUnswitchPass(bool Os) {
return new LoopUnswitch(Os);
index 55e0b94e294f19f25da4f1c6ac9ee725695e6704..b41f25479a9c2629dbe7aa43ed653e885c0c0378 100644 (file)
char LowerAtomic::ID = 0;
INITIALIZE_PASS(LowerAtomic, "loweratomic",
"Lower atomic intrinsics to non-atomic form",
- false, false);
+ false, false)
Pass *llvm::createLowerAtomicPass() { return new LowerAtomic(); }
index 4172b345c6111e95b9a4647f6fe3dd5cd255588e..72d478b6de9d668b6e90dc4b17094ec0581eeb72 100644 (file)
// createMemCpyOptPass - The public interface to this file...
FunctionPass *llvm::createMemCpyOptPass() { return new MemCpyOpt(); }
-INITIALIZE_PASS(MemCpyOpt, "memcpyopt", "MemCpy Optimization", false, false);
+INITIALIZE_PASS(MemCpyOpt, "memcpyopt", "MemCpy Optimization", false, false)
index b8afcc12d927d165e3e6aa82763932cdf73b96cc..0d51b832af85b5e70ad433ebbd86ea69b29c5b01 100644 (file)
char Reassociate::ID = 0;
INITIALIZE_PASS(Reassociate, "reassociate",
- "Reassociate expressions", false, false);
+ "Reassociate expressions", false, false)
// Public interface to the Reassociate pass
FunctionPass *llvm::createReassociatePass() { return new Reassociate(); }
index 506b72ac34e0d6f86182b7a8ae26d792d5d8225c..14f6f4b919265fbb9801160877b62987f055f283 100644 (file)
char RegToMem::ID = 0;
INITIALIZE_PASS(RegToMem, "reg2mem", "Demote all values to stack slots",
- false, false);
+ false, false)
bool RegToMem::runOnFunction(Function &F) {
index 6115c05c20ac4ed55a3445b1a78097d283e33e13..f6778f366fa3ccf1f01f01589a84067de634e0b0 100644 (file)
char SCCP::ID = 0;
INITIALIZE_PASS(SCCP, "sccp",
- "Sparse Conditional Constant Propagation", false, false);
+ "Sparse Conditional Constant Propagation", false, false)
// createSCCPPass - This is the public interface to this file.
FunctionPass *llvm::createSCCPPass() {
char IPSCCP::ID = 0;
INITIALIZE_PASS(IPSCCP, "ipsccp",
"Interprocedural Sparse Conditional Constant Propagation",
- false, false);
+ false, false)
// createIPSCCPPass - This is the public interface to this file.
ModulePass *llvm::createIPSCCPPass() {
diff --git a/lib/Transforms/Scalar/ScalarReplAggregates.cpp b/lib/Transforms/Scalar/ScalarReplAggregates.cpp
index 33ecb5bf9bdf7d2ad73726edf0d9cf3bbd65ac52..168b56d0c4ad2747d3af3026f301ede741ade9be 100644 (file)
char SROA::ID = 0;
INITIALIZE_PASS(SROA, "scalarrepl",
- "Scalar Replacement of Aggregates", false, false);
+ "Scalar Replacement of Aggregates", false, false)
// Public interface to the ScalarReplAggregates pass
FunctionPass *llvm::createScalarReplAggregatesPass(signed int Threshold) {
index 360749caf1116a2a8fcfb08bc15603967eaab7cd..692e26ecabe19766ec0434e95343627217905073 100644 (file)
char CFGSimplifyPass::ID = 0;
INITIALIZE_PASS(CFGSimplifyPass, "simplifycfg",
- "Simplify the CFG", false, false);
+ "Simplify the CFG", false, false)
// Public interface to the CFGSimplification pass
FunctionPass *llvm::createCFGSimplificationPass() {
diff --git a/lib/Transforms/Scalar/SimplifyHalfPowrLibCalls.cpp b/lib/Transforms/Scalar/SimplifyHalfPowrLibCalls.cpp
index 3ec70ec2e024f44ed49cc6cfc010a26d54cce349..885a7ed958e61b80caf8f5b1127e91ca00ae1cfc 100644 (file)
} // end anonymous namespace.
INITIALIZE_PASS(SimplifyHalfPowrLibCalls, "simplify-libcalls-halfpowr",
- "Simplify half_powr library calls", false, false);
+ "Simplify half_powr library calls", false, false)
// Public interface to the Simplify HalfPowr LibCalls pass.
FunctionPass *llvm::createSimplifyHalfPowrLibCallsPass() {
diff --git a/lib/Transforms/Scalar/SimplifyLibCalls.cpp b/lib/Transforms/Scalar/SimplifyLibCalls.cpp
index 28aa9e87cd514ed29446868375798183728f62e4..68299525d89fded3d85ff88fed0722a8d4c591fc 100644 (file)
} // end anonymous namespace.
INITIALIZE_PASS(SimplifyLibCalls, "simplify-libcalls",
- "Simplify well-known library calls", false, false);
+ "Simplify well-known library calls", false, false)
// Public interface to the Simplify LibCalls pass.
FunctionPass *llvm::createSimplifyLibCallsPass() {
index 95d3dedfb62dbeece1b669f79499c7b9ae2befa5..6dc52a6f8e7172b36172074f8d4e3907824440f4 100644 (file)
} // end anonymous namespace
char Sinking::ID = 0;
-INITIALIZE_PASS(Sinking, "sink", "Code sinking", false, false);
+INITIALIZE_PASS(Sinking, "sink", "Code sinking", false, false)
FunctionPass *llvm::createSinkingPass() { return new Sinking(); }
index 2e437ac778c8c32b0a4f9d291f45b4e3a3158b4a..ea1d722adda7deec2d59cf692b2e89294da7d715 100644 (file)
}
char TailDup::ID = 0;
-INITIALIZE_PASS(TailDup, "tailduplicate", "Tail Duplication", false, false);
+INITIALIZE_PASS(TailDup, "tailduplicate", "Tail Duplication", false, false)
// Public interface to the Tail Duplication pass
FunctionPass *llvm::createTailDuplicationPass() { return new TailDup(); }
diff --git a/lib/Transforms/Scalar/TailRecursionElimination.cpp b/lib/Transforms/Scalar/TailRecursionElimination.cpp
index 371725467a24e0803223de17f7776c2425e1b254..b85c2d1b615ae9942b5237586ec30ea972643143 100644 (file)
char TailCallElim::ID = 0;
INITIALIZE_PASS(TailCallElim, "tailcallelim",
- "Tail Call Elimination", false, false);
+ "Tail Call Elimination", false, false)
// Public interface to the TailCallElimination pass
FunctionPass *llvm::createTailCallEliminationPass() {
diff --git a/lib/Transforms/Utils/BreakCriticalEdges.cpp b/lib/Transforms/Utils/BreakCriticalEdges.cpp
index f75ffe6105fa633a740cc51485bb19a388b7284d..e4f6631b31f97885108869dae6e668dc45ad93f4 100644 (file)
char BreakCriticalEdges::ID = 0;
INITIALIZE_PASS(BreakCriticalEdges, "break-crit-edges",
- "Break critical edges in CFG", false, false);
+ "Break critical edges in CFG", false, false)
// Publically exposed interface to pass...
char &llvm::BreakCriticalEdgesID = BreakCriticalEdges::ID;
index 522439c04be2aac78467773a86b2dcd7d1628ab8..d8d01c9a4bada4ad291f92baec9e3b77d89a910a 100644 (file)
}
INITIALIZE_PASS(InstNamer, "instnamer",
- "Assign names to anonymous instructions", false, false);
+ "Assign names to anonymous instructions", false, false)
char &llvm::InstructionNamerID = InstNamer::ID;
//===----------------------------------------------------------------------===//
//
index 275b26508f99180b722e1890d8864cdf579b0662..777e87619c00962c0509d72089897e104f93872c 100644 (file)
}
char LCSSA::ID = 0;
-INITIALIZE_PASS(LCSSA, "lcssa", "Loop-Closed SSA Form Pass", false, false);
+INITIALIZE_PASS(LCSSA, "lcssa", "Loop-Closed SSA Form Pass", false, false)
Pass *llvm::createLCSSAPass() { return new LCSSA(); }
char &llvm::LCSSAID = LCSSA::ID;
index b3c4801a4f15bd2af05aa0b34eb86dcc54c9993e..60b70f6f92800063f9de8d81c5ffb35bc828233a 100644 (file)
char LoopSimplify::ID = 0;
INITIALIZE_PASS(LoopSimplify, "loopsimplify",
- "Canonicalize natural loops", true, false);
+ "Canonicalize natural loops", true, false)
// Publically exposed interface to pass...
char &llvm::LoopSimplifyID = LoopSimplify::ID;
index 5c65610e5ec732314faaeed6bf122eb561923d29..e8a11e3d0cce783a6d581a088bda55343cb1e4c1 100644 (file)
char LowerInvoke::ID = 0;
INITIALIZE_PASS(LowerInvoke, "lowerinvoke",
"Lower invoke and unwind, for unwindless code generators",
- false, false);
+ false, false)
char &llvm::LowerInvokePassID = LowerInvoke::ID;
index 5530b4700aac60ec65faa1b8f62eee0721b41e10..dce57f517bcbc343f9461f8e32b806d0360df112 100644 (file)
char LowerSwitch::ID = 0;
INITIALIZE_PASS(LowerSwitch, "lowerswitch",
- "Lower SwitchInst's to branches", false, false);
+ "Lower SwitchInst's to branches", false, false)
// Publically exposed interface to pass...
char &llvm::LowerSwitchID = LowerSwitch::ID;
index 101645bd92b777badb81a87526a8856d0cf28edd..c61ffef6d27549e1accb6f6ffaf7d590c4208ce1 100644 (file)
char PromotePass::ID = 0;
INITIALIZE_PASS(PromotePass, "mem2reg", "Promote Memory to Register",
- false, false);
+ false, false)
bool PromotePass::runOnFunction(Function &F) {
std::vector<AllocaInst*> Allocas;
diff --git a/lib/Transforms/Utils/UnifyFunctionExitNodes.cpp b/lib/Transforms/Utils/UnifyFunctionExitNodes.cpp
index a51f1e1a47f653e288bd63036a867450a3dd6b5c..ccb8287d796980518ae1874d28b9748a6f89f720 100644 (file)
char UnifyFunctionExitNodes::ID = 0;
INITIALIZE_PASS(UnifyFunctionExitNodes, "mergereturn",
- "Unify function exit nodes", false, false);
+ "Unify function exit nodes", false, false)
Pass *llvm::createUnifyFunctionExitNodesPass() {
return new UnifyFunctionExitNodes();
index f3dad824461dd9e7ded770765fd37899a386cb80..dc22dd450494265e5f45598a922b5115f48799e0 100644 (file)
char DominatorTree::ID = 0;
INITIALIZE_PASS(DominatorTree, "domtree",
- "Dominator Tree Construction", true, true);
+ "Dominator Tree Construction", true, true)
bool DominatorTree::runOnFunction(Function &F) {
DT->recalculate(F);
@@ -107,7 +107,7 @@ bool DominatorTree::dominates(const Instruction *A, const Instruction *B) const{
char DominanceFrontier::ID = 0;
INITIALIZE_PASS(DominanceFrontier, "domfrontier",
- "Dominance Frontier Construction", true, true);
+ "Dominance Frontier Construction", true, true)
void DominanceFrontier::verifyAnalysis() const {
if (!VerifyDomInfo) return;
index 2ee49d235963c26eb9575a28ecf6c77da2aefbfa..1f1fbc91bc31a4eeb388792335ed4c7f35fb947e 100644 (file)
char PrintModulePass::ID = 0;
INITIALIZE_PASS(PrintModulePass, "print-module",
- "Print module to stderr", false, false);
+ "Print module to stderr", false, false)
char PrintFunctionPass::ID = 0;
INITIALIZE_PASS(PrintFunctionPass, "print-function",
- "Print function to stderr", false, false);
+ "Print function to stderr", false, false)
/// createPrintModulePass - Create and return a pass that writes the
/// module to the specified raw_ostream.
index 384acb748b19bc627446c03d34e3cf98c1e05290..5d369fa0360941bba4de02ff06dadc58cc43906a 100644 (file)
--- a/lib/VMCore/Verifier.cpp
+++ b/lib/VMCore/Verifier.cpp
char PreVerifier::ID = 0;
INITIALIZE_PASS(PreVerifier, "preverify", "Preliminary module verification",
- false, false);
+ false, false)
char &PreVerifyID = PreVerifier::ID;
namespace {
} // End anonymous namespace
char Verifier::ID = 0;
-INITIALIZE_PASS(Verifier, "verify", "Module Verifier", false, false);
+INITIALIZE_PASS(Verifier, "verify", "Module Verifier", false, false)
// Assert - We know that cond should be true, if not print an error message.
#define Assert(C, M) \