diff --git a/lib/Analysis/AliasAnalysisCounter.cpp b/lib/Analysis/AliasAnalysisCounter.cpp
index 09fd6b9..b17941f 100644
--- a/lib/Analysis/AliasAnalysisCounter.cpp
+++ b/lib/Analysis/AliasAnalysisCounter.cpp
@@ -18,7 +18,7 @@
 using namespace llvm;
 
 namespace {
-  class AliasAnalysisCounter : public Pass, public AliasAnalysis {
+  class AliasAnalysisCounter : public ModulePass, public AliasAnalysis {
     unsigned No, May, Must;
     unsigned NoMR, JustRef, JustMod, MR;
     const char *Name;
@@ -64,7 +64,7 @@
       }
     }
 
-    bool run(Module &M) {
+    bool runOnModule(Module &M) {
       InitializeAliasAnalysis(this);
       Name = dynamic_cast<Pass*>(&getAnalysis<AliasAnalysis>())->getPassName();
       return false;
diff --git a/lib/Analysis/DataStructure/BottomUpClosure.cpp b/lib/Analysis/DataStructure/BottomUpClosure.cpp
index 4bc6faf..bf4b01c 100644
--- a/lib/Analysis/DataStructure/BottomUpClosure.cpp
+++ b/lib/Analysis/DataStructure/BottomUpClosure.cpp
@@ -35,7 +35,7 @@
 // run - Calculate the bottom up data structure graphs for each function in the
 // program.
 //
-bool BUDataStructures::run(Module &M) {
+bool BUDataStructures::runOnModule(Module &M) {
   LocalDataStructures &LocalDSA = getAnalysis<LocalDataStructures>();
   GlobalsGraph = new DSGraph(LocalDSA.getGlobalsGraph());
   GlobalsGraph->setPrintAuxCalls();
diff --git a/lib/Analysis/DataStructure/CompleteBottomUp.cpp b/lib/Analysis/DataStructure/CompleteBottomUp.cpp
index b2a0f4b..ee111e9 100644
--- a/lib/Analysis/DataStructure/CompleteBottomUp.cpp
+++ b/lib/Analysis/DataStructure/CompleteBottomUp.cpp
@@ -32,7 +32,7 @@
 // run - Calculate the bottom up data structure graphs for each function in the
 // program.
 //
-bool CompleteBUDataStructures::run(Module &M) {
+bool CompleteBUDataStructures::runOnModule(Module &M) {
   BUDataStructures &BU = getAnalysis<BUDataStructures>();
   GlobalsGraph = new DSGraph(BU.getGlobalsGraph());
   GlobalsGraph->setPrintAuxCalls();
diff --git a/lib/Analysis/DataStructure/DataStructureAA.cpp b/lib/Analysis/DataStructure/DataStructureAA.cpp
index 3cff795..6444cc8 100644
--- a/lib/Analysis/DataStructure/DataStructureAA.cpp
+++ b/lib/Analysis/DataStructure/DataStructureAA.cpp
@@ -19,7 +19,7 @@
 using namespace llvm;
 
 namespace {
-  class DSAA : public Pass, public AliasAnalysis {
+  class DSAA : public ModulePass, public AliasAnalysis {
     TDDataStructures *TD;
     BUDataStructures *BU;
   public:
@@ -32,7 +32,7 @@
     // run - Build up the result graph, representing the pointer graph for the
     // program.
     //
-    bool run(Module &M) {
+    bool runOnModule(Module &M) {
       InitializeAliasAnalysis(this);
       TD = &getAnalysis<TDDataStructures>();
       BU = &getAnalysis<BUDataStructures>();
diff --git a/lib/Analysis/DataStructure/DataStructureOpt.cpp b/lib/Analysis/DataStructure/DataStructureOpt.cpp
index f7a1ed9..1996aea 100644
--- a/lib/Analysis/DataStructure/DataStructureOpt.cpp
+++ b/lib/Analysis/DataStructure/DataStructureOpt.cpp
@@ -25,10 +25,10 @@
   Statistic<>
   NumGlobalsIsolated("ds-opt", "Number of globals with references dropped");
 
-  class DSOpt : public Pass {
+  class DSOpt : public ModulePass {
     TDDataStructures *TD;
   public:
-    bool run(Module &M) {
+    bool runOnModule(Module &M) {
       TD = &getAnalysis<TDDataStructures>();
       bool Changed = OptimizeGlobals(M);
       return Changed;
diff --git a/lib/Analysis/DataStructure/IPModRef.cpp b/lib/Analysis/DataStructure/IPModRef.cpp
index ccc15f7..6793b0e 100644
--- a/lib/Analysis/DataStructure/IPModRef.cpp
+++ b/lib/Analysis/DataStructure/IPModRef.cpp
@@ -374,7 +374,7 @@
 // NO real interprocedural work because all that has been done the
 // data structure analysis.
 // 
-bool IPModRef::run(Module &theModule)
+bool IPModRef::runOnModule(Module &theModule)
 {
   M = &theModule;
 
diff --git a/lib/Analysis/DataStructure/IPModRef.h b/lib/Analysis/DataStructure/IPModRef.h
index 4a825db..f8ac15c 100644
--- a/lib/Analysis/DataStructure/IPModRef.h
+++ b/lib/Analysis/DataStructure/IPModRef.h
@@ -183,7 +183,7 @@
 /// from an arbitrary callsite, or during an execution of a single call-site
 /// within the function.
 ///
-class IPModRef : public Pass {
+class IPModRef : public ModulePass {
   std::map<const Function*, FunctionModRefInfo*> funcToModRefInfoMap;
   Module* M;
 
@@ -197,7 +197,7 @@
   /// This initializes the module reference, and then computes IPModRef
   /// results immediately if demand-driven analysis was *not* specified.
   /// 
-  virtual bool run(Module &M);
+  virtual bool runOnModule(Module &M);
 
   /// getFunctionModRefInfo - Retrieve the Mod/Ref information for a single
   /// function
diff --git a/lib/Analysis/DataStructure/Local.cpp b/lib/Analysis/DataStructure/Local.cpp
index b21f2f1..070d037 100644
--- a/lib/Analysis/DataStructure/Local.cpp
+++ b/lib/Analysis/DataStructure/Local.cpp
@@ -1023,7 +1023,7 @@
 }
 
 
-bool LocalDataStructures::run(Module &M) {
+bool LocalDataStructures::runOnModule(Module &M) {
   GlobalsGraph = new DSGraph(getAnalysis<TargetData>());
 
   const TargetData &TD = getAnalysis<TargetData>();
diff --git a/lib/Analysis/DataStructure/MemoryDepAnalysis.cpp b/lib/Analysis/DataStructure/MemoryDepAnalysis.cpp
index 49b6425..f6c54fb 100644
--- a/lib/Analysis/DataStructure/MemoryDepAnalysis.cpp
+++ b/lib/Analysis/DataStructure/MemoryDepAnalysis.cpp
@@ -457,7 +457,7 @@
 // Driver function to compute dependence graphs for every function.
 // This is temporary and will go away once this is a FunctionPass.
 // 
-bool MemoryDepAnalysis::run(Module& M)
+bool MemoryDepAnalysis::runOnModule(Module& M)
 {
   for (Module::iterator FI = M.begin(), FE = M.end(); FI != FE; ++FI)
     if (! FI->isExternal())
diff --git a/lib/Analysis/DataStructure/MemoryDepAnalysis.h b/lib/Analysis/DataStructure/MemoryDepAnalysis.h
index 570a03b..ed21e5f 100644
--- a/lib/Analysis/DataStructure/MemoryDepAnalysis.h
+++ b/lib/Analysis/DataStructure/MemoryDepAnalysis.h
@@ -40,7 +40,7 @@
 /// allowed to use a FunctionPass such as this one.
 ///---------------------------------------------------------------------------
 
-class MemoryDepAnalysis : public Pass {
+class MemoryDepAnalysis : public ModulePass {
   /// The following map and depGraph pointer are temporary until this class
   /// becomes a FunctionPass instead of a module Pass.
   hash_map<Function*, DependenceGraph*> funcMap;
@@ -63,7 +63,7 @@
 
   /// Driver function to compute dependence graphs for every function.
   ///
-  bool run(Module &M);
+  bool runOnModule(Module &M);
 
   /// getGraph - Retrieve the dependence graph for a function.
   /// This is temporary and will go away once this is a FunctionPass.
diff --git a/lib/Analysis/DataStructure/Parallelize.cpp b/lib/Analysis/DataStructure/Parallelize.cpp
index 3dcb05e..2bb6c7f 100644
--- a/lib/Analysis/DataStructure/Parallelize.cpp
+++ b/lib/Analysis/DataStructure/Parallelize.cpp
@@ -388,11 +388,11 @@
 //---------------------------------------------------------------------------- 
 
 namespace {
-  class Parallelize: public Pass {
+  class Parallelize : public ModulePass {
   public:
     /// Driver functions to transform a program
     ///
-    bool run(Module& M);
+    bool runOnModule(Module& M);
 
     /// getAnalysisUsage - Modifies extensively so preserve nothing.
     /// Uses the DependenceGraph and the Top-down DS Graph (only to find
@@ -409,7 +409,7 @@
 }
 
 
-bool Parallelize::run(Module& M) {
+bool Parallelize::runOnModule(Module& M) {
   hash_set<Function*> parallelFunctions;
   hash_set<Function*> safeParallelFunctions;
   hash_set<const GlobalValue*> indirectlyCalled;
diff --git a/lib/Analysis/DataStructure/PgmDependenceGraph.h b/lib/Analysis/DataStructure/PgmDependenceGraph.h
index ec6f927..d777494 100644
--- a/lib/Analysis/DataStructure/PgmDependenceGraph.h
+++ b/lib/Analysis/DataStructure/PgmDependenceGraph.h
@@ -200,7 +200,7 @@
 /// allowed to use a FunctionPass such as this one.
 ///---------------------------------------------------------------------------
 
-class PgmDependenceGraph: public Pass {
+class PgmDependenceGraph: public ModulePass {
 
   /// Information about the function being analyzed.
   /// 
@@ -253,7 +253,7 @@
 
   /// Driver function to compute dependence graphs for every function.
   /// 
-  bool run(Module& M) { return true; }
+  bool runOnModule(Module& M) { return true; }
 
   /// getGraph() -- Retrieve the pgm dependence graph for a function.
   /// This is temporary and will go away once this is a FunctionPass.
diff --git a/lib/Analysis/DataStructure/Steensgaard.cpp b/lib/Analysis/DataStructure/Steensgaard.cpp
index deeb8b3..b0718a1 100644
--- a/lib/Analysis/DataStructure/Steensgaard.cpp
+++ b/lib/Analysis/DataStructure/Steensgaard.cpp
@@ -22,7 +22,7 @@
 using namespace llvm;
 
 namespace {
-  class Steens : public Pass, public AliasAnalysis {
+  class Steens : public ModulePass, public AliasAnalysis {
     DSGraph *ResultGraph;
     DSGraph *GlobalsGraph;  // FIXME: Eliminate globals graph stuff from DNE
   public:
@@ -39,7 +39,7 @@
     // run - Build up the result graph, representing the pointer graph for the
     // program.
     //
-    bool run(Module &M);
+    bool runOnModule(Module &M);
 
     virtual void releaseMyMemory() { delete ResultGraph; ResultGraph = 0; }
 
@@ -103,7 +103,7 @@
 /// run - Build up the result graph, representing the pointer graph for the
 /// program.
 ///
-bool Steens::run(Module &M) {
+bool Steens::runOnModule(Module &M) {
   InitializeAliasAnalysis(this);
   assert(ResultGraph == 0 && "Result graph already allocated!");
   LocalDataStructures &LDS = getAnalysis<LocalDataStructures>();
diff --git a/lib/Analysis/DataStructure/TopDownClosure.cpp b/lib/Analysis/DataStructure/TopDownClosure.cpp
index 1d861e8..6271980 100644
--- a/lib/Analysis/DataStructure/TopDownClosure.cpp
+++ b/lib/Analysis/DataStructure/TopDownClosure.cpp
@@ -51,7 +51,7 @@
 // run - Calculate the top down data structure graphs for each function in the
 // program.
 //
-bool TDDataStructures::run(Module &M) {
+bool TDDataStructures::runOnModule(Module &M) {
   BUDataStructures &BU = getAnalysis<BUDataStructures>();
   GlobalsGraph = new DSGraph(BU.getGlobalsGraph());
   GlobalsGraph->setPrintAuxCalls();
diff --git a/lib/Analysis/IPA/Andersens.cpp b/lib/Analysis/IPA/Andersens.cpp
index 7901c91..9ade25e 100644
--- a/lib/Analysis/IPA/Andersens.cpp
+++ b/lib/Analysis/IPA/Andersens.cpp
@@ -75,7 +75,7 @@
   Statistic<>
   NumIndirectCallees("anders-aa", "Number of indirect callees found");
 
-  class Andersens : public Pass, public AliasAnalysis,
+  class Andersens : public ModulePass, public AliasAnalysis,
                     private InstVisitor<Andersens> {
     /// Node class - This class is used to represent a memory object in the
     /// program, and is the primitive used to build the points-to graph.
@@ -193,7 +193,7 @@
     };
     
   public:
-    bool run(Module &M) {
+    bool runOnModule(Module &M) {
       InitializeAliasAnalysis(this);
       IdentifyObjects(M);
       CollectConstraints(M);
diff --git a/lib/Analysis/IPA/CallGraph.cpp b/lib/Analysis/IPA/CallGraph.cpp
index dbf5b9f..a6d2836 100644
--- a/lib/Analysis/IPA/CallGraph.cpp
+++ b/lib/Analysis/IPA/CallGraph.cpp
@@ -100,7 +100,7 @@
     }
 }
 
-bool CallGraph::run(Module &M) {
+bool CallGraph::runOnModule(Module &M) {
   destroy();
 
   Mod = &M;
diff --git a/lib/Analysis/IPA/CallGraphSCCPass.cpp b/lib/Analysis/IPA/CallGraphSCCPass.cpp
index f7d7ab1..8eb1c12 100644
--- a/lib/Analysis/IPA/CallGraphSCCPass.cpp
+++ b/lib/Analysis/IPA/CallGraphSCCPass.cpp
@@ -28,7 +28,7 @@
   AU.addPreserved<CallGraph>();
 }
 
-bool CallGraphSCCPass::run(Module &M) {
+bool CallGraphSCCPass::runOnModule(Module &M) {
   CallGraph &CG = getAnalysis<CallGraph>();
   bool Changed = doInitialization(CG);
   for (scc_iterator<CallGraph*> I = scc_begin(&CG), E = scc_end(&CG);
diff --git a/lib/Analysis/IPA/FindUnsafePointerTypes.cpp b/lib/Analysis/IPA/FindUnsafePointerTypes.cpp
index 23ee99a..c0d0a62 100644
--- a/lib/Analysis/IPA/FindUnsafePointerTypes.cpp
+++ b/lib/Analysis/IPA/FindUnsafePointerTypes.cpp
@@ -58,7 +58,7 @@
 }
 
 
-bool FindUnsafePointerTypes::run(Module &Mod) {
+bool FindUnsafePointerTypes::runOnModule(Module &Mod) {
   for (Module::iterator FI = Mod.begin(), E = Mod.end();
        FI != E; ++FI) {
     const Function *F = FI;  // We don't need/want write access
diff --git a/lib/Analysis/IPA/FindUsedTypes.cpp b/lib/Analysis/IPA/FindUsedTypes.cpp
index 1f127fe..cb6b05c 100644
--- a/lib/Analysis/IPA/FindUsedTypes.cpp
+++ b/lib/Analysis/IPA/FindUsedTypes.cpp
@@ -58,7 +58,7 @@
 
 // run - This incorporates all types used by the specified module
 //
-bool FindUsedTypes::run(Module &m) {
+bool FindUsedTypes::runOnModule(Module &m) {
   UsedTypes.clear();  // reset if run multiple times...
 
   // Loop over global variables, incorporating their types
diff --git a/lib/Analysis/IPA/GlobalsModRef.cpp b/lib/Analysis/IPA/GlobalsModRef.cpp
index c1f15ed..2c4ad4a 100644
--- a/lib/Analysis/IPA/GlobalsModRef.cpp
+++ b/lib/Analysis/IPA/GlobalsModRef.cpp
@@ -67,7 +67,7 @@
   };
 
   /// GlobalsModRef - The actual analysis pass.
-  class GlobalsModRef : public Pass, public AliasAnalysis {
+  class GlobalsModRef : public ModulePass, public AliasAnalysis {
     /// NonAddressTakenGlobals - The globals that do not have their addresses
     /// taken.
     std::set<GlobalValue*> NonAddressTakenGlobals;
@@ -77,7 +77,7 @@
     std::map<Function*, FunctionRecord> FunctionInfo;
 
   public:
-    bool run(Module &M) {
+    bool runOnModule(Module &M) {
       InitializeAliasAnalysis(this);                 // set up super class
       AnalyzeGlobals(M);                          // find non-addr taken globals
       AnalyzeCallGraph(getAnalysis<CallGraph>(), M); // Propagate on CG
diff --git a/lib/Analysis/ProfileInfoLoaderPass.cpp b/lib/Analysis/ProfileInfoLoaderPass.cpp
index cd3f575..333e9e0 100644
--- a/lib/Analysis/ProfileInfoLoaderPass.cpp
+++ b/lib/Analysis/ProfileInfoLoaderPass.cpp
@@ -28,7 +28,7 @@
                       cl::value_desc("filename"),
                       cl::desc("Profile file loaded by -profile-loader"));
 
-  class LoaderPass : public Pass, public ProfileInfo {
+  class LoaderPass : public ModulePass, public ProfileInfo {
     std::string Filename;
   public:
     LoaderPass(const std::string &filename = "")
@@ -45,7 +45,7 @@
     }
 
     /// run - Load the profile information from the specified file.
-    virtual bool run(Module &M);
+    virtual bool runOnModule(Module &M);
   };
  
   RegisterOpt<LoaderPass>
@@ -62,7 +62,7 @@
   return new LoaderPass(Filename);
 }
 
-bool LoaderPass::run(Module &M) {
+bool LoaderPass::runOnModule(Module &M) {
   ProfileInfoLoader PIL("profile-loader", Filename, M);
   EdgeCounts.clear();
   bool PrintedWarning = false;
diff --git a/lib/Target/CBackend/CBackend.cpp b/lib/Target/CBackend/CBackend.cpp
index 45a771f..c26cfee 100644
--- a/lib/Target/CBackend/CBackend.cpp
+++ b/lib/Target/CBackend/CBackend.cpp
@@ -47,7 +47,7 @@
   /// NameAllUsedStructs - This pass inserts names for any unnamed structure
   /// types that are used by the program.
   ///
-  class CBackendNameAllUsedStructs : public Pass {
+  class CBackendNameAllUsedStructs : public ModulePass {
     void getAnalysisUsage(AnalysisUsage &AU) const {
       AU.addRequired<FindUsedTypes>();
     }
@@ -56,7 +56,7 @@
       return "C backend type canonicalizer";
     }
 
-    virtual bool run(Module &M);
+    virtual bool runOnModule(Module &M);
   };
   
   /// CWriter - This class is the main chunk of code that converts an LLVM
@@ -216,7 +216,7 @@
 /// the program, and removes names from structure types that are not used by the
 /// program.
 ///
-bool CBackendNameAllUsedStructs::run(Module &M) {
+bool CBackendNameAllUsedStructs::runOnModule(Module &M) {
   // Get a set of types that are used by the program...
   std::set<const Type *> UT = getAnalysis<FindUsedTypes>().getTypes();
   
diff --git a/lib/Target/CBackend/Writer.cpp b/lib/Target/CBackend/Writer.cpp
index 45a771f..c26cfee 100644
--- a/lib/Target/CBackend/Writer.cpp
+++ b/lib/Target/CBackend/Writer.cpp
@@ -47,7 +47,7 @@
   /// NameAllUsedStructs - This pass inserts names for any unnamed structure
   /// types that are used by the program.
   ///
-  class CBackendNameAllUsedStructs : public Pass {
+  class CBackendNameAllUsedStructs : public ModulePass {
     void getAnalysisUsage(AnalysisUsage &AU) const {
       AU.addRequired<FindUsedTypes>();
     }
@@ -56,7 +56,7 @@
       return "C backend type canonicalizer";
     }
 
-    virtual bool run(Module &M);
+    virtual bool runOnModule(Module &M);
   };
   
   /// CWriter - This class is the main chunk of code that converts an LLVM
@@ -216,7 +216,7 @@
 /// the program, and removes names from structure types that are not used by the
 /// program.
 ///
-bool CBackendNameAllUsedStructs::run(Module &M) {
+bool CBackendNameAllUsedStructs::runOnModule(Module &M) {
   // Get a set of types that are used by the program...
   std::set<const Type *> UT = getAnalysis<FindUsedTypes>().getTypes();
   
diff --git a/lib/Target/SparcV9/EmitBytecodeToAssembly.cpp b/lib/Target/SparcV9/EmitBytecodeToAssembly.cpp
index 0826f76..26332ca 100644
--- a/lib/Target/SparcV9/EmitBytecodeToAssembly.cpp
+++ b/lib/Target/SparcV9/EmitBytecodeToAssembly.cpp
@@ -17,10 +17,7 @@
 #include "llvm/Pass.h"
 #include "llvm/Bytecode/Writer.h"
 #include <iostream>
-
-namespace llvm {
-
-using std::ostream;
+using namespace llvm;
 
 namespace {
 
@@ -87,14 +84,14 @@
   }
 
   // SparcV9BytecodeWriter - Write bytecode out to a stream that is sparc'ified
-  class SparcV9BytecodeWriter : public Pass {
+  class SparcV9BytecodeWriter : public ModulePass {
     std::ostream &Out;
   public:
     SparcV9BytecodeWriter(std::ostream &out) : Out(out) {}
 
     const char *getPassName() const { return "Emit Bytecode to SparcV9 Assembly";}
     
-    virtual bool run(Module &M) {
+    virtual bool runOnModule(Module &M) {
       // Write an object containing the bytecode to the SPARC assembly stream
       writePrologue (Out, "LLVM BYTECODE OUTPUT", "LLVMBytecode");
       osparcasmstream OS(Out);
@@ -112,8 +109,7 @@
   };
 }  // end anonymous namespace
 
-Pass *createBytecodeAsmPrinterPass(std::ostream &Out) {
+ModulePass *llvm::createBytecodeAsmPrinterPass(std::ostream &Out) {
   return new SparcV9BytecodeWriter(Out);
 }
 
-} // End llvm namespace
diff --git a/lib/Target/SparcV9/InternalGlobalMapper.cpp b/lib/Target/SparcV9/InternalGlobalMapper.cpp
index 0cd2faa..ef870b2 100644
--- a/lib/Target/SparcV9/InternalGlobalMapper.cpp
+++ b/lib/Target/SparcV9/InternalGlobalMapper.cpp
@@ -27,13 +27,13 @@
 
 typedef std::vector<Constant *> GVVectorTy;
 
-class InternalGlobalMapper : public Pass {
+class InternalGlobalMapper : public ModulePass {
 public:
-  bool run (Module &M);
+  bool runOnModule(Module &M);
 };
 
-Pass *llvm::createInternalGlobalMapperPass () {
-  return new InternalGlobalMapper ();
+ModulePass *llvm::createInternalGlobalMapperPass() {
+  return new InternalGlobalMapper();
 }
 
 static void maybeAddInternalValueToVector (GVVectorTy &Vector, GlobalValue &GV){
@@ -41,14 +41,14 @@
   // be mangled), then put the GV, casted to sbyte*, in the vector. Otherwise
   // add a null.
   if (GV.hasInternalLinkage () && GV.hasName ())
-    Vector.push_back (ConstantExpr::getCast
-      (&GV, PointerType::get (Type::SByteTy)));
+    Vector.push_back(ConstantExpr::getCast(&GV,
+                                           PointerType::get(Type::SByteTy)));
   else
     Vector.push_back (ConstantPointerNull::get (PointerType::get
                                                 (Type::SByteTy)));
 }
 
-bool InternalGlobalMapper::run (Module &M) {
+bool InternalGlobalMapper::runOnModule(Module &M) {
   GVVectorTy gvvector;
 
   // Populate the vector with internal global values and their names.
diff --git a/lib/Target/SparcV9/MappingInfo.cpp b/lib/Target/SparcV9/MappingInfo.cpp
index 1a7212c..58f1937 100644
--- a/lib/Target/SparcV9/MappingInfo.cpp
+++ b/lib/Target/SparcV9/MappingInfo.cpp
@@ -78,8 +78,8 @@
 /// MappingInfoAsmPrinter Pass object, which uses OUT as its output
 /// stream for assembly output.
 ///
-Pass *getMappingInfoAsmPrinterPass(std::ostream &out){
-  return (new MappingInfoAsmPrinter(out));
+ModulePass *getMappingInfoAsmPrinterPass(std::ostream &out){
+  return new MappingInfoAsmPrinter(out);
 }
 
 /// runOnFunction - Builds up the maps for the given function FI and then
diff --git a/lib/Target/SparcV9/MappingInfo.h b/lib/Target/SparcV9/MappingInfo.h
index 346a5f7..1be2e86 100644
--- a/lib/Target/SparcV9/MappingInfo.h
+++ b/lib/Target/SparcV9/MappingInfo.h
@@ -21,10 +21,10 @@
 
 namespace llvm {
 
-class Pass;
+class ModulePass;
 
-Pass *getMappingInfoAsmPrinterPass(std::ostream &out);
-Pass *createInternalGlobalMapperPass();
+ModulePass *getMappingInfoAsmPrinterPass(std::ostream &out);
+ModulePass *createInternalGlobalMapperPass();
 
 class MappingInfo {
   struct byteVector : public std::vector <unsigned char> {
diff --git a/lib/Target/SparcV9/SparcV9Internals.h b/lib/Target/SparcV9/SparcV9Internals.h
index 187d984..1f65998 100644
--- a/lib/Target/SparcV9/SparcV9Internals.h
+++ b/lib/Target/SparcV9/SparcV9Internals.h
@@ -28,7 +28,7 @@
 
 class LiveRange;
 class SparcV9TargetMachine;
-class Pass;
+class ModulePass;
 
 enum SparcV9InstrSchedClass {
   SPARC_NONE,		/* Instructions with no scheduling restrictions */
@@ -91,7 +91,7 @@
 /// createStackSlotsPass - External interface to stack-slots pass that enters 2
 /// empty slots at the top of each function stack
 ///
-Pass *createStackSlotsPass(const TargetMachine &TM);
+FunctionPass *createStackSlotsPass(const TargetMachine &TM);
 
 /// Specializes LLVM code for a target machine.
 ///
@@ -111,7 +111,7 @@
 
 /// getBytecodeAsmPrinterPass - Emits final LLVM bytecode to assembly file.
 ///
-Pass* createBytecodeAsmPrinterPass(std::ostream &Out);
+ModulePass* createBytecodeAsmPrinterPass(std::ostream &Out);
 
 FunctionPass *createSparcV9MachineCodeDestructionPass();
 
diff --git a/lib/Target/SparcV9/SparcV9StackSlots.cpp b/lib/Target/SparcV9/SparcV9StackSlots.cpp
index 90aca0d..554a476 100644
--- a/lib/Target/SparcV9/SparcV9StackSlots.cpp
+++ b/lib/Target/SparcV9/SparcV9StackSlots.cpp
@@ -46,7 +46,7 @@
   };
 }
 
-Pass *llvm::createStackSlotsPass(const TargetMachine &Target) {
+FunctionPass *llvm::createStackSlotsPass(const TargetMachine &Target) {
   return new StackSlots(Target);
 }
 
diff --git a/lib/Transforms/IPO/ArgumentPromotion.cpp b/lib/Transforms/IPO/ArgumentPromotion.cpp
index 7b5def4..85339bf 100644
--- a/lib/Transforms/IPO/ArgumentPromotion.cpp
+++ b/lib/Transforms/IPO/ArgumentPromotion.cpp
@@ -75,7 +75,7 @@
                               "Promote 'by reference' arguments to scalars");
 }
 
-Pass *llvm::createArgumentPromotionPass() {
+ModulePass *llvm::createArgumentPromotionPass() {
   return new ArgPromotion();
 }
 
diff --git a/lib/Transforms/IPO/ConstantMerge.cpp b/lib/Transforms/IPO/ConstantMerge.cpp
index 9f3c109..27e1955 100644
--- a/lib/Transforms/IPO/ConstantMerge.cpp
+++ b/lib/Transforms/IPO/ConstantMerge.cpp
@@ -26,19 +26,19 @@
 namespace {
   Statistic<> NumMerged("constmerge", "Number of global constants merged");
 
-  struct ConstantMerge : public Pass {
+  struct ConstantMerge : public ModulePass {
     // run - For this pass, process all of the globals in the module,
     // eliminating duplicate constants.
     //
-    bool run(Module &M);
+    bool runOnModule(Module &M);
   };
 
   RegisterOpt<ConstantMerge> X("constmerge","Merge Duplicate Global Constants");
 }
 
-Pass *llvm::createConstantMergePass() { return new ConstantMerge(); }
+ModulePass *llvm::createConstantMergePass() { return new ConstantMerge(); }
 
-bool ConstantMerge::run(Module &M) {
+bool ConstantMerge::runOnModule(Module &M) {
   std::map<Constant*, GlobalVariable*> CMap;
 
   // Replacements - This vector contains a list of replacements to perform.
diff --git a/lib/Transforms/IPO/DeadArgumentElimination.cpp b/lib/Transforms/IPO/DeadArgumentElimination.cpp
index cde186c..e4b7a3e 100644
--- a/lib/Transforms/IPO/DeadArgumentElimination.cpp
+++ b/lib/Transforms/IPO/DeadArgumentElimination.cpp
@@ -38,7 +38,7 @@
 
   /// DAE - The dead argument elimination pass.
   ///
-  class DAE : public Pass {
+  class DAE : public ModulePass {
     /// Liveness enum - During our initial pass over the program, we determine
     /// that things are either definately alive, definately dead, or in need of
     /// interprocedural analysis (MaybeLive).
@@ -75,7 +75,7 @@
     std::multimap<Function*, CallSite> CallSites;
 
   public:
-    bool run(Module &M);
+    bool runOnModule(Module &M);
 
     virtual bool ShouldHackArguments() const { return false; }
 
@@ -106,8 +106,8 @@
 /// createDeadArgEliminationPass - This pass removes arguments from functions
 /// which are not used by the body of the function.
 ///
-Pass *llvm::createDeadArgEliminationPass() { return new DAE(); }
-Pass *llvm::createDeadArgHackingPass() { return new DAH(); }
+ModulePass *llvm::createDeadArgEliminationPass() { return new DAE(); }
+ModulePass *llvm::createDeadArgHackingPass() { return new DAH(); }
 
 static inline bool CallPassesValueThoughVararg(Instruction *Call,
                                                const Value *Arg) {
@@ -484,7 +484,7 @@
   F->getParent()->getFunctionList().erase(F);
 }
 
-bool DAE::run(Module &M) {
+bool DAE::runOnModule(Module &M) {
   // First phase: loop through the module, determining which arguments are live.
   // We assume all arguments are dead unless proven otherwise (allowing us to
   // determine that dead arguments passed into recursive functions are dead).
diff --git a/lib/Transforms/IPO/DeadTypeElimination.cpp b/lib/Transforms/IPO/DeadTypeElimination.cpp
index e2d475d..9b1a919 100644
--- a/lib/Transforms/IPO/DeadTypeElimination.cpp
+++ b/lib/Transforms/IPO/DeadTypeElimination.cpp
@@ -21,14 +21,14 @@
 using namespace llvm;
 
 namespace {
-  struct DTE : public Pass {
+  struct DTE : public ModulePass {
     // doPassInitialization - For this pass, it removes global symbol table
     // entries for primitive types.  These are never used for linking in GCC and
     // they make the output uglier to look at, so we nuke them.
     //
     // Also, initialize instance variables.
     //
-    bool run(Module &M);
+    bool runOnModule(Module &M);
 
     // getAnalysisUsage - This function needs FindUsedTypes to do its job...
     //
@@ -41,7 +41,7 @@
   NumKilled("deadtypeelim", "Number of unused typenames removed from symtab");
 }
 
-Pass *llvm::createDeadTypeEliminationPass() {
+ModulePass *llvm::createDeadTypeEliminationPass() {
   return new DTE();
 }
 
@@ -65,7 +65,7 @@
 // uglier to look at, so we nuke them.  Also eliminate types that are never used
 // in the entire program as indicated by FindUsedTypes.
 //
-bool DTE::run(Module &M) {
+bool DTE::runOnModule(Module &M) {
   bool Changed = false;
 
   SymbolTable &ST = M.getSymbolTable();
diff --git a/lib/Transforms/IPO/ExtractFunction.cpp b/lib/Transforms/IPO/ExtractFunction.cpp
index 41b7960..1b92fd1 100644
--- a/lib/Transforms/IPO/ExtractFunction.cpp
+++ b/lib/Transforms/IPO/ExtractFunction.cpp
@@ -17,7 +17,7 @@
 using namespace llvm;
 
 namespace {
-  class FunctionExtractorPass : public Pass {
+  class FunctionExtractorPass : public ModulePass {
     Function *Named;
     bool deleteFunc;
   public:
@@ -28,7 +28,7 @@
     FunctionExtractorPass(Function *F = 0, bool deleteFn = true) 
       : Named(F), deleteFunc(deleteFn) {}
 
-    bool run(Module &M) {
+    bool runOnModule(Module &M) {
       if (Named == 0) {
         Named = M.getMainFunction();
         if (Named == 0) return false;  // No function to extract
@@ -112,6 +112,6 @@
   RegisterPass<FunctionExtractorPass> X("extract", "Function Extractor");
 }
 
-Pass *llvm::createFunctionExtractionPass(Function *F, bool deleteFn) {
+ModulePass *llvm::createFunctionExtractionPass(Function *F, bool deleteFn) {
   return new FunctionExtractorPass(F, deleteFn);
 }
diff --git a/lib/Transforms/IPO/FunctionResolution.cpp b/lib/Transforms/IPO/FunctionResolution.cpp
index 006d33c..3450662 100644
--- a/lib/Transforms/IPO/FunctionResolution.cpp
+++ b/lib/Transforms/IPO/FunctionResolution.cpp
@@ -35,17 +35,17 @@
   Statistic<>NumResolved("funcresolve", "Number of varargs functions resolved");
   Statistic<> NumGlobals("funcresolve", "Number of global variables resolved");
 
-  struct FunctionResolvingPass : public Pass {
+  struct FunctionResolvingPass : public ModulePass {
     virtual void getAnalysisUsage(AnalysisUsage &AU) const {
       AU.addRequired<TargetData>();
     }
 
-    bool run(Module &M);
+    bool runOnModule(Module &M);
   };
   RegisterOpt<FunctionResolvingPass> X("funcresolve", "Resolve Functions");
 }
 
-Pass *llvm::createFunctionResolvingPass() {
+ModulePass *llvm::createFunctionResolvingPass() {
   return new FunctionResolvingPass();
 }
 
@@ -293,7 +293,7 @@
   return false;
 }
 
-bool FunctionResolvingPass::run(Module &M) {
+bool FunctionResolvingPass::runOnModule(Module &M) {
   std::map<std::string, std::vector<GlobalValue*> > Globals;
 
   // Loop over the globals, adding them to the Globals map.  We use a two pass
diff --git a/lib/Transforms/IPO/GlobalDCE.cpp b/lib/Transforms/IPO/GlobalDCE.cpp
index ea5201c..cdf994a 100644
--- a/lib/Transforms/IPO/GlobalDCE.cpp
+++ b/lib/Transforms/IPO/GlobalDCE.cpp
@@ -27,11 +27,11 @@
   Statistic<> NumFunctions("globaldce","Number of functions removed");
   Statistic<> NumVariables("globaldce","Number of global variables removed");
 
-  struct GlobalDCE : public Pass {
+  struct GlobalDCE : public ModulePass {
     // run - Do the GlobalDCE pass on the specified module, optionally updating
     // the specified callgraph to reflect the changes.
     //
-    bool run(Module &M);
+    bool runOnModule(Module &M);
 
   private:
     std::set<GlobalValue*> AliveGlobals;
@@ -47,9 +47,9 @@
   RegisterOpt<GlobalDCE> X("globaldce", "Dead Global Elimination");
 }
 
-Pass *llvm::createGlobalDCEPass() { return new GlobalDCE(); }
+ModulePass *llvm::createGlobalDCEPass() { return new GlobalDCE(); }
 
-bool GlobalDCE::run(Module &M) {
+bool GlobalDCE::runOnModule(Module &M) {
   bool Changed = false;
   // Loop over the module, adding globals which are obviously necessary.
   for (Module::iterator I = M.begin(), E = M.end(); I != E; ++I) {
diff --git a/lib/Transforms/IPO/GlobalOpt.cpp b/lib/Transforms/IPO/GlobalOpt.cpp
index dd9894c..f37be86 100644
--- a/lib/Transforms/IPO/GlobalOpt.cpp
+++ b/lib/Transforms/IPO/GlobalOpt.cpp
@@ -31,14 +31,14 @@
 namespace {
   Statistic<> NumMarked("constify", "Number of globals marked constant");
 
-  struct Constifier : public Pass {
-    bool run(Module &M);
+  struct Constifier : public ModulePass {
+    bool runOnModule(Module &M);
   };
 
   RegisterOpt<Constifier> X("constify", "Global Constifier");
 }
 
-Pass *llvm::createGlobalConstifierPass() { return new Constifier(); }
+ModulePass *llvm::createGlobalConstifierPass() { return new Constifier(); }
 
 /// A lot of global constants are stored only in trivially dead setter
 /// functions.  Because we don't want to cycle between globaldce and this pass,
@@ -81,7 +81,7 @@
   return false;
 }
 
-bool Constifier::run(Module &M) {
+bool Constifier::runOnModule(Module &M) {
   bool Changed = false;
   std::set<PHINode*> PHIUsers;
   for (Module::giterator GV = M.gbegin(), E = M.gend(); GV != E; ++GV)
diff --git a/lib/Transforms/IPO/IPConstantPropagation.cpp b/lib/Transforms/IPO/IPConstantPropagation.cpp
index 74a0a9b..64d1df8 100644
--- a/lib/Transforms/IPO/IPConstantPropagation.cpp
+++ b/lib/Transforms/IPO/IPConstantPropagation.cpp
@@ -29,17 +29,17 @@
 
   /// IPCP - The interprocedural constant propagation pass
   ///
-  struct IPCP : public Pass {
-    bool run(Module &M);
+  struct IPCP : public ModulePass {
+    bool runOnModule(Module &M);
   private:
     bool processFunction(Function &F);
   };
   RegisterOpt<IPCP> X("ipconstprop", "Interprocedural constant propagation");
 }
 
-Pass *llvm::createIPConstantPropagationPass() { return new IPCP(); }
+ModulePass *llvm::createIPConstantPropagationPass() { return new IPCP(); }
 
-bool IPCP::run(Module &M) {
+bool IPCP::runOnModule(Module &M) {
   bool Changed = false;
   bool LocalChange = true;
 
diff --git a/lib/Transforms/IPO/InlineSimple.cpp b/lib/Transforms/IPO/InlineSimple.cpp
index 1722fe5..6a43143 100644
--- a/lib/Transforms/IPO/InlineSimple.cpp
+++ b/lib/Transforms/IPO/InlineSimple.cpp
@@ -66,7 +66,7 @@
   RegisterOpt<SimpleInliner> X("inline", "Function Integration/Inlining");
 }
 
-Pass *llvm::createFunctionInliningPass() { return new SimpleInliner(); }
+ModulePass *llvm::createFunctionInliningPass() { return new SimpleInliner(); }
 
 // CountCodeReductionForConstant - Figure out an approximation for how many
 // instructions will be constant folded if the specified value is constant.
diff --git a/lib/Transforms/IPO/Internalize.cpp b/lib/Transforms/IPO/Internalize.cpp
index c6b75b1..5e436aa 100644
--- a/lib/Transforms/IPO/Internalize.cpp
+++ b/lib/Transforms/IPO/Internalize.cpp
@@ -39,7 +39,7 @@
           cl::desc("A list of symbol names to preserve"),
           cl::CommaSeparated);
  
-  class InternalizePass : public Pass {
+  class InternalizePass : public ModulePass {
     std::set<std::string> ExternalNames;
   public:
     InternalizePass() {
@@ -65,7 +65,7 @@
       }
     }
 
-    virtual bool run(Module &M) {
+    virtual bool runOnModule(Module &M) {
       // If no list or file of symbols was specified, check to see if there is a
       // "main" symbol defined in the module.  If so, use it, otherwise do not
       // internalize the module, it must be a library or something.
@@ -117,6 +117,6 @@
   RegisterOpt<InternalizePass> X("internalize", "Internalize Global Symbols");
 } // end anonymous namespace
 
-Pass *llvm::createInternalizePass() {
+ModulePass *llvm::createInternalizePass() {
   return new InternalizePass();
 }
diff --git a/lib/Transforms/IPO/LoopExtractor.cpp b/lib/Transforms/IPO/LoopExtractor.cpp
index e1ce290..1bdb5c2 100644
--- a/lib/Transforms/IPO/LoopExtractor.cpp
+++ b/lib/Transforms/IPO/LoopExtractor.cpp
@@ -126,7 +126,7 @@
 // createSingleLoopExtractorPass - This pass extracts one natural loop from the
 // program into a function if it can.  This is used by bugpoint.
 //
-Pass *llvm::createSingleLoopExtractorPass() {
+ModulePass *llvm::createSingleLoopExtractorPass() {
   return new SingleLoopExtractor();
 }
 
@@ -135,13 +135,13 @@
   /// BlockExtractorPass - This pass is used by bugpoint to extract all blocks
   /// from the module into their own functions except for those specified by the
   /// BlocksToNotExtract list.
-  class BlockExtractorPass : public Pass {
+  class BlockExtractorPass : public ModulePass {
     std::vector<BasicBlock*> BlocksToNotExtract;
   public:
     BlockExtractorPass(std::vector<BasicBlock*> &B) : BlocksToNotExtract(B) {}
     BlockExtractorPass() {}
 
-    bool run(Module &M);
+    bool runOnModule(Module &M);
   };
   RegisterOpt<BlockExtractorPass>
   XX("extract-blocks", "Extract Basic Blocks From Module (for bugpoint use)");
@@ -150,11 +150,11 @@
 // createBlockExtractorPass - This pass extracts all blocks (except those
 // specified in the argument list) from the functions in the module.
 //
-Pass *llvm::createBlockExtractorPass(std::vector<BasicBlock*> &BTNE) {
+ModulePass *llvm::createBlockExtractorPass(std::vector<BasicBlock*> &BTNE) {
   return new BlockExtractorPass(BTNE);
 }
 
-bool BlockExtractorPass::run(Module &M) {
+bool BlockExtractorPass::runOnModule(Module &M) {
   std::set<BasicBlock*> TranslatedBlocksToNotExtract;
   for (unsigned i = 0, e = BlocksToNotExtract.size(); i != e; ++i) {
     BasicBlock *BB = BlocksToNotExtract[i];
diff --git a/lib/Transforms/IPO/LowerSetJmp.cpp b/lib/Transforms/IPO/LowerSetJmp.cpp
index ebd0500..4ad89b5 100644
--- a/lib/Transforms/IPO/LowerSetJmp.cpp
+++ b/lib/Transforms/IPO/LowerSetJmp.cpp
@@ -64,7 +64,7 @@
   // class because it works on a module as a whole, not a function at a
   // time.
 
-  class LowerSetJmp : public Pass,
+  class LowerSetJmp : public ModulePass,
                       public InstVisitor<LowerSetJmp> {
     // LLVM library functions...
     Function* InitSJMap;        // __llvm_sjljeh_init_setjmpmap
@@ -119,7 +119,7 @@
     void visitReturnInst(ReturnInst& RI);
     void visitUnwindInst(UnwindInst& UI);
 
-    bool run(Module& M);
+    bool runOnModule(Module& M);
     bool doInitialization(Module& M);
   };
 
@@ -129,8 +129,7 @@
 // run - Run the transformation on the program. We grab the function
 // prototypes for longjmp and setjmp. If they are used in the program,
 // then we can go directly to the places they're at and transform them.
-bool LowerSetJmp::run(Module& M)
-{
+bool LowerSetJmp::runOnModule(Module& M) {
   bool Changed = false;
 
   // These are what the functions are called.
@@ -509,8 +508,7 @@
 
 // visitReturnInst - We want to destroy the setjmp map upon exit from the
 // function.
-void LowerSetJmp::visitReturnInst(ReturnInst& RI)
-{
+void LowerSetJmp::visitReturnInst(ReturnInst &RI) {
   Function* Func = RI.getParent()->getParent();
   new CallInst(DestroySJMap, make_vector<Value*>(GetSetJmpMap(Func), 0),
                "", &RI);
@@ -518,15 +516,13 @@
 
 // visitUnwindInst - We want to destroy the setjmp map upon exit from the
 // function.
-void LowerSetJmp::visitUnwindInst(UnwindInst& UI)
-{
+void LowerSetJmp::visitUnwindInst(UnwindInst &UI) {
   Function* Func = UI.getParent()->getParent();
   new CallInst(DestroySJMap, make_vector<Value*>(GetSetJmpMap(Func), 0),
                "", &UI);
 }
 
-Pass* llvm::createLowerSetJmpPass()
-{
+ModulePass *llvm::createLowerSetJmpPass() {
   return new LowerSetJmp();
 }
 
diff --git a/lib/Transforms/IPO/PruneEH.cpp b/lib/Transforms/IPO/PruneEH.cpp
index 43b9acf..36423c8 100644
--- a/lib/Transforms/IPO/PruneEH.cpp
+++ b/lib/Transforms/IPO/PruneEH.cpp
@@ -38,7 +38,7 @@
   RegisterOpt<PruneEH> X("prune-eh", "Remove unused exception handling info");
 }
 
-Pass *llvm::createPruneEHPass() { return new PruneEH(); }
+ModulePass *llvm::createPruneEHPass() { return new PruneEH(); }
 
 
 bool PruneEH::runOnSCC(const std::vector<CallGraphNode *> &SCC) {
diff --git a/lib/Transforms/IPO/RaiseAllocations.cpp b/lib/Transforms/IPO/RaiseAllocations.cpp
index 42edb7e..d91d23f 100644
--- a/lib/Transforms/IPO/RaiseAllocations.cpp
+++ b/lib/Transforms/IPO/RaiseAllocations.cpp
@@ -28,7 +28,7 @@
   // RaiseAllocations - Turn %malloc and %free calls into the appropriate
   // instruction.
   //
-  class RaiseAllocations : public Pass {
+  class RaiseAllocations : public ModulePass {
     Function *MallocFunc;   // Functions in the module we are processing
     Function *FreeFunc;     // Initialized by doPassInitializationVirt
   public:
@@ -41,7 +41,7 @@
     
     // run - This method does the actual work of converting instructions over.
     //
-    bool run(Module &M);
+    bool runOnModule(Module &M);
   };
   
   RegisterOpt<RaiseAllocations>
@@ -50,7 +50,7 @@
 
 
 // createRaiseAllocationsPass - The interface to this file...
-Pass *llvm::createRaiseAllocationsPass() {
+ModulePass *llvm::createRaiseAllocationsPass() {
   return new RaiseAllocations();
 }
 
@@ -114,7 +114,7 @@
 
 // run - Transform calls into instructions...
 //
-bool RaiseAllocations::run(Module &M) {
+bool RaiseAllocations::runOnModule(Module &M) {
   // Find the malloc/free prototypes...
   doInitialization(M);
 
diff --git a/lib/Transforms/Instrumentation/BlockProfiling.cpp b/lib/Transforms/Instrumentation/BlockProfiling.cpp
index e357e84..f22f81f 100644
--- a/lib/Transforms/Instrumentation/BlockProfiling.cpp
+++ b/lib/Transforms/Instrumentation/BlockProfiling.cpp
@@ -29,15 +29,15 @@
 using namespace llvm;
 
 namespace {
-  class FunctionProfiler : public Pass {
-    bool run(Module &M);
+  class FunctionProfiler : public ModulePass {
+    bool runOnModule(Module &M);
   };
 
   RegisterOpt<FunctionProfiler> X("insert-function-profiling",
                                "Insert instrumentation for function profiling");
 }
 
-bool FunctionProfiler::run(Module &M) {
+bool FunctionProfiler::runOnModule(Module &M) {
   Function *Main = M.getMainFunction();
   if (Main == 0) {
     std::cerr << "WARNING: cannot insert function profiling into a module"
@@ -69,15 +69,15 @@
 
 
 namespace {
-  class BlockProfiler : public Pass {
-    bool run(Module &M);
+  class BlockProfiler : public ModulePass {
+    bool runOnModule(Module &M);
   };
 
   RegisterOpt<BlockProfiler> Y("insert-block-profiling",
                                "Insert instrumentation for block profiling");
 }
 
-bool BlockProfiler::run(Module &M) {
+bool BlockProfiler::runOnModule(Module &M) {
   Function *Main = M.getMainFunction();
   if (Main == 0) {
     std::cerr << "WARNING: cannot insert block profiling into a module"
diff --git a/lib/Transforms/Instrumentation/EdgeProfiling.cpp b/lib/Transforms/Instrumentation/EdgeProfiling.cpp
index c584ca5..89c540c 100644
--- a/lib/Transforms/Instrumentation/EdgeProfiling.cpp
+++ b/lib/Transforms/Instrumentation/EdgeProfiling.cpp
@@ -28,15 +28,15 @@
 using namespace llvm;
 
 namespace {
-  class EdgeProfiler : public Pass {
-    bool run(Module &M);
+  class EdgeProfiler : public ModulePass {
+    bool runOnModule(Module &M);
   };
 
   RegisterOpt<EdgeProfiler> X("insert-edge-profiling",
                               "Insert instrumentation for edge profiling");
 }
 
-bool EdgeProfiler::run(Module &M) {
+bool EdgeProfiler::runOnModule(Module &M) {
   Function *Main = M.getMainFunction();
   if (Main == 0) {
     std::cerr << "WARNING: cannot insert edge profiling into a module"
diff --git a/lib/Transforms/Instrumentation/EmitFunctions.cpp b/lib/Transforms/Instrumentation/EmitFunctions.cpp
index a1c23da..92abffb 100644
--- a/lib/Transforms/Instrumentation/EmitFunctions.cpp
+++ b/lib/Transforms/Instrumentation/EmitFunctions.cpp
@@ -27,8 +27,8 @@
     BLACK
   };
   
-  struct EmitFunctionTable : public Pass {
-    bool run(Module &M);
+  struct EmitFunctionTable : public ModulePass {
+    bool runOnModule(Module &M);
   };
   
   RegisterOpt<EmitFunctionTable>
@@ -64,7 +64,7 @@
 }
 
 // Per Module pass for inserting function table
-bool EmitFunctionTable::run(Module &M){
+bool EmitFunctionTable::runOnModule(Module &M){
   std::vector<const Type*> vType;
  
   std::vector<Constant *> vConsts;
diff --git a/lib/Transforms/Instrumentation/TraceBasicBlocks.cpp b/lib/Transforms/Instrumentation/TraceBasicBlocks.cpp
index 60426c4..746e822 100644
--- a/lib/Transforms/Instrumentation/TraceBasicBlocks.cpp
+++ b/lib/Transforms/Instrumentation/TraceBasicBlocks.cpp
@@ -25,8 +25,8 @@
 using namespace llvm;
 
 namespace {
-  class TraceBasicBlocks : public Pass {
-    bool run(Module &M);
+  class TraceBasicBlocks : public ModulePass {
+    bool runOnModule(Module &M);
   };
 
   RegisterOpt<TraceBasicBlocks> X("trace-basic-blocks",
@@ -52,7 +52,7 @@
   Instruction *InstrCall = new CallInst (InstrFn, Args, "", InsertPos);
 }
 
-bool TraceBasicBlocks::run(Module &M) {
+bool TraceBasicBlocks::runOnModule(Module &M) {
   Function *Main = M.getMainFunction();
   if (Main == 0) {
     std::cerr << "WARNING: cannot insert basic-block trace instrumentation"
diff --git a/lib/VMCore/PassManagerT.h b/lib/VMCore/PassManagerT.h
index 95e0f56..1d8267f 100644
--- a/lib/VMCore/PassManagerT.h
+++ b/lib/VMCore/PassManagerT.h
@@ -726,9 +726,9 @@
 //
 // This is the top level PassManager implementation that holds generic passes.
 //
-template<> struct PassManagerTraits<Module> : public Pass {
+template<> struct PassManagerTraits<Module> : public ModulePass {
   // PassClass - The type of passes tracked by this PassManager
-  typedef Pass PassClass;
+  typedef ModulePass PassClass;
 
   // SubPassClass - The types of classes that should be collated together
   typedef FunctionPass SubPassClass;
@@ -740,15 +740,15 @@
   typedef AnalysisResolver ParentClass;
 
   // runPass - Specify how the pass should be run on the UnitType
-  static bool runPass(PassClass *P, Module *M) { return P->run(*M); }
+  static bool runPass(PassClass *P, Module *M) { return P->runOnModule(*M); }
 
   // getPMName() - Return the name of the unit the PassManager operates on for
   // debugging.
   const char *getPMName() const { return "Module"; }
   virtual const char *getPassName() const { return "Module Pass Manager"; }
 
-  // run - Implement the PassManager interface...
-  bool run(Module &M) {
+  // runOnModule - Implement the PassManager interface.
+  bool runOnModule(Module &M) {
     return ((PassManagerT<Module>*)this)->runOnUnit(&M);
   }
 };