* Rename MethodPass class to FunctionPass

  - Rename runOnMethod to runOnFunction
* Transform getAnalysisUsageInfo into getAnalysisUsage
  - Method is now const
  - It now takes one AnalysisUsage object to fill in instead of 3 vectors
    to fill in
  - Pass's now specify which other passes they _preserve_ not which ones
    they modify (be conservative!)
  - A pass can specify that it preserves all analyses (because it never
    modifies the underlying program)
* s/Method/Function/g in other random places as well


git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@2333 91177308-0d34-0410-b5e6-96231b3b80d8

62 files changed, 609 insertions, 650 deletions

diff --git a/include/llvm/Analysis/CallGraph.h b/include/llvm/Analysis/CallGraph.h
index 3c8b2c4107..61693876c4 100644
--- a/include/llvm/Analysis/CallGraph.h
+++ b/include/llvm/Analysis/CallGraph.h
@@ -118,11 +118,10 @@ public:
   // run - Compute the call graph for the specified module.
   virtual bool run(Module *TheModule);
 
-  // getAnalysisUsageInfo - This obviously provides a call graph
-  virtual void getAnalysisUsageInfo(AnalysisSet &Required,
-                                    AnalysisSet &Destroyed,
-                                    AnalysisSet &Provided) {
-    Provided.push_back(ID);
+  // getAnalysisUsage - This obviously provides a call graph
+  virtual void getAnalysisUsage(AnalysisUsage &AU) const {
+    AU.setPreservesAll();
+    AU.addProvided(ID);
   }
 
   // releaseMemory - Data structures can be large, so free memory agressively.
diff --git a/include/llvm/Analysis/DataStructure.h b/include/llvm/Analysis/DataStructure.h
index 2d21545aeb..90a4b5df23 100644
--- a/include/llvm/Analysis/DataStructure.h
+++ b/include/llvm/Analysis/DataStructure.h
@@ -485,11 +485,10 @@ public:
   // If the pass pipeline is done with this pass, we can release our memory...
   virtual void releaseMemory();
 
-  // getAnalysisUsageInfo - This obviously provides a call graph
-  virtual void getAnalysisUsageInfo(AnalysisSet &Required,
-                                    AnalysisSet &Destroyed,
-                                    AnalysisSet &Provided) {
-    Provided.push_back(ID);
+  // getAnalysisUsage - This obviously provides a call graph
+  virtual void getAnalysisUsage(AnalysisUsage &AU) const {
+    AU.setPreservesAll();
+    AU.addProvided(ID);
   }
 };
 
diff --git a/include/llvm/Analysis/DataStructure/DataStructure.h b/include/llvm/Analysis/DataStructure/DataStructure.h
index 2d21545aeb..90a4b5df23 100644
--- a/include/llvm/Analysis/DataStructure/DataStructure.h
+++ b/include/llvm/Analysis/DataStructure/DataStructure.h
@@ -485,11 +485,10 @@ public:
   // If the pass pipeline is done with this pass, we can release our memory...
   virtual void releaseMemory();
 
-  // getAnalysisUsageInfo - This obviously provides a call graph
-  virtual void getAnalysisUsageInfo(AnalysisSet &Required,
-                                    AnalysisSet &Destroyed,
-                                    AnalysisSet &Provided) {
-    Provided.push_back(ID);
+  // getAnalysisUsage - This obviously provides a call graph
+  virtual void getAnalysisUsage(AnalysisUsage &AU) const {
+    AU.setPreservesAll();
+    AU.addProvided(ID);
   }
 };
 
diff --git a/include/llvm/Analysis/Dominators.h b/include/llvm/Analysis/Dominators.h
index d860ec5504..1f35331b92 100644
--- a/include/llvm/Analysis/Dominators.h
+++ b/include/llvm/Analysis/Dominators.h
@@ -1,13 +1,13 @@
 //===- llvm/Analysis/Dominators.h - Dominator Info Calculation ---*- C++ -*--=//
 //
 // This file defines the following classes:
-//  1. DominatorSet: Calculates the [reverse] dominator set for a method
+//  1. DominatorSet: Calculates the [reverse] dominator set for a function
 //  2. ImmediateDominators: Calculates and holds a mapping between BasicBlocks
 //     and their immediate dominator.
 //  3. DominatorTree: Represent the ImmediateDominator as an explicit tree
 //     structure.
 //  4. DominanceFrontier: Calculate and hold the dominance frontier for a 
-//     method.
+//     function.
 //
 //  These data structures are listed in increasing order of complexity.  It
 //  takes longer to calculate the dominator frontier, for example, than the 
@@ -28,7 +28,7 @@ namespace cfg {
 // DominatorBase - Base class that other, more interesting dominator analyses
 // inherit from.
 //
-class DominatorBase : public MethodPass {
+class DominatorBase : public FunctionPass {
 protected:
   BasicBlock *Root;
   const bool IsPostDominators;
@@ -45,7 +45,7 @@ public:
 //===----------------------------------------------------------------------===//
 //
 // DominatorSet - Maintain a set<const BasicBlock*> for every basic block in a
-// method, that represents the blocks that dominate the block.
+// function, that represents the blocks that dominate the block.
 //
 class DominatorSet : public DominatorBase {
 public:
@@ -59,14 +59,14 @@ private:
   void calcPostDominatorSet(Function *F);
 public:
   // DominatorSet ctor - Build either the dominator set or the post-dominator
-  // set for a method... 
+  // set for a function... 
   //
   static AnalysisID ID;            // Build dominator set
   static AnalysisID PostDomID;     // Build postdominator set
 
   DominatorSet(AnalysisID id) : DominatorBase(id == PostDomID) {}
 
-  virtual bool runOnMethod(Function *F);
+  virtual bool runOnFunction(Function *F);
 
   // Accessor interface:
   typedef DomSetMapType::const_iterator const_iterator;
@@ -83,7 +83,7 @@ public:
   //
   inline const DomSetType &getDominators(const BasicBlock *BB) const {
     const_iterator I = find(BB);
-    assert(I != end() && "BB not in method!");
+    assert(I != end() && "BB not in function!");
     return I->second;
   }
 
@@ -93,19 +93,17 @@ public:
     return getDominators(B).count(A) != 0;
   }
 
-  // getAnalysisUsageInfo - This obviously provides a dominator set, but it also
-  // uses the UnifyMethodExitNode pass if building post-dominators
+  // getAnalysisUsage - This obviously provides a dominator set, but it also
+  // uses the UnifyFunctionExitNode pass if building post-dominators
   //
-  virtual void getAnalysisUsageInfo(Pass::AnalysisSet &Requires,
-                                    Pass::AnalysisSet &Destroyed,
-                                    Pass::AnalysisSet &Provided);
+  virtual void getAnalysisUsage(AnalysisUsage &AU) const;
 };
 
 
 //===----------------------------------------------------------------------===//
 //
 // ImmediateDominators - Calculate the immediate dominator for each node in a
-// method.
+// function.
 //
 class ImmediateDominators : public DominatorBase {
   std::map<const BasicBlock*, const BasicBlock*> IDoms;
@@ -113,14 +111,14 @@ class ImmediateDominators : public DominatorBase {
 public:
 
   // ImmediateDominators ctor - Calculate the idom or post-idom mapping,
-  // for a method...
+  // for a function...
   //
   static AnalysisID ID;         // Build immediate dominators
   static AnalysisID PostDomID;  // Build immediate postdominators
 
   ImmediateDominators(AnalysisID id) : DominatorBase(id == PostDomID) {}
 
-  virtual bool runOnMethod(Function *F) {
+  virtual bool runOnFunction(Function *F) {
     IDoms.clear();     // Reset from the last time we were run...
     DominatorSet *DS;
     if (isPostDominator())
@@ -149,18 +147,17 @@ public:
     return I != IDoms.end() ? I->second : 0;
   }
 
-  // getAnalysisUsageInfo - This obviously provides a dominator tree, but it
+  // getAnalysisUsage - This obviously provides a dominator tree, but it
   // can only do so with the input of dominator sets
   //
-  virtual void getAnalysisUsageInfo(Pass::AnalysisSet &Requires,
-                                    Pass::AnalysisSet &Destroyed,
-                                    Pass::AnalysisSet &Provided) {
+  virtual void getAnalysisUsage(AnalysisUsage &AU) const {
+    AU.setPreservesAll();
     if (isPostDominator()) {
-      Requires.push_back(DominatorSet::PostDomID);
-      Provided.push_back(PostDomID);
+      AU.addRequired(DominatorSet::PostDomID);
+      AU.addProvided(PostDomID);
     } else {
-      Requires.push_back(DominatorSet::ID);
-      Provided.push_back(ID);
+      AU.addRequired(DominatorSet::ID);
+      AU.addProvided(ID);
     }
   }
 };
@@ -168,7 +165,7 @@ public:
 
 //===----------------------------------------------------------------------===//
 //
-// DominatorTree - Calculate the immediate dominator tree for a method.
+// DominatorTree - Calculate the immediate dominator tree for a function.
 //
 class DominatorTree : public DominatorBase {
   class Node2;
@@ -213,7 +210,7 @@ public:
   DominatorTree(AnalysisID id) : DominatorBase(id == PostDomID) {}
   ~DominatorTree() { reset(); }
 
-  virtual bool runOnMethod(Function *F) {
+  virtual bool runOnFunction(Function *F) {
     reset();
     DominatorSet *DS;
     if (isPostDominator())
@@ -230,18 +227,17 @@ public:
     return (i != Nodes.end()) ? i->second : 0;
   }
 
-  // getAnalysisUsageInfo - This obviously provides a dominator tree, but it
+  // getAnalysisUsage - This obviously provides a dominator tree, but it
   // uses dominator sets
   //
-  virtual void getAnalysisUsageInfo(Pass::AnalysisSet &Requires,
-                                    Pass::AnalysisSet &Destroyed,
-                                    Pass::AnalysisSet &Provided) {
+  virtual void getAnalysisUsage(AnalysisUsage &AU) const {
+    AU.setPreservesAll();
     if (isPostDominator()) {
-      Requires.push_back(DominatorSet::PostDomID);
-      Provided.push_back(PostDomID);
+      AU.addRequired(DominatorSet::PostDomID);
+      AU.addProvided(PostDomID);
     } else {
-      Requires.push_back(DominatorSet::ID);
-      Provided.push_back(ID);
+      AU.addRequired(DominatorSet::ID);
+      AU.addProvided(ID);
     }
   }
 };
@@ -249,7 +245,7 @@ public:
 
 //===----------------------------------------------------------------------===//
 //
-// DominanceFrontier - Calculate the dominance frontiers for a method.
+// DominanceFrontier - Calculate the dominance frontiers for a function.
 //
 class DominanceFrontier : public DominatorBase {
 public:
@@ -263,14 +259,14 @@ private:
 					const DominatorTree::Node *Node);
 public:
 
-  // DominatorFrontier ctor - Compute dominator frontiers for a method
+  // DominatorFrontier ctor - Compute dominator frontiers for a function
   //
   static AnalysisID ID;         // Build dominator frontier
   static AnalysisID PostDomID;  // Build postdominator frontier
 
   DominanceFrontier(AnalysisID id) : DominatorBase(id == PostDomID) {}
 
-  virtual bool runOnMethod(Function *) {
+  virtual bool runOnFunction(Function *) {
     Frontiers.clear();
     DominatorTree *DT;
     if (isPostDominator())
@@ -292,18 +288,17 @@ public:
   inline const_iterator end()   const { return Frontiers.end(); }
   inline const_iterator find(const BasicBlock* B) const { return Frontiers.find(B); }
 
-  // getAnalysisUsageInfo - This obviously provides a dominator tree, but it
+  // getAnalysisUsage - This obviously provides the dominance frontier, but it
   // uses dominator sets
   //
-  virtual void getAnalysisUsageInfo(Pass::AnalysisSet &Requires,
-                                    Pass::AnalysisSet &Destroyed,
-                                    Pass::AnalysisSet &Provided) {
+  virtual void getAnalysisUsage(AnalysisUsage &AU) const {
+    AU.setPreservesAll();
     if (isPostDominator()) {
-      Requires.push_back(DominatorTree::PostDomID);
-      Provided.push_back(PostDomID);
+      AU.addRequired(DominatorTree::PostDomID);
+      AU.addProvided(PostDomID);
     } else {
-      Requires.push_back(DominatorTree::ID);
-      Provided.push_back(ID);
+      AU.addRequired(DominatorTree::ID);
+      AU.addProvided(ID);
     }
   }
 };
diff --git a/include/llvm/Analysis/FindUnsafePointerTypes.h b/include/llvm/Analysis/FindUnsafePointerTypes.h
index cd34676727..82cc28a06f 100644
--- a/include/llvm/Analysis/FindUnsafePointerTypes.h
+++ b/include/llvm/Analysis/FindUnsafePointerTypes.h
@@ -1,4 +1,4 @@
-//===- llvm/Analysis/SafePointerAccess.h - Check pointer safety ---*- C++ -*-=//
+//===- llvm/Analysis/FindUnsafePointerTypes.h - Unsafe pointers ---*- C++ -*-=//
 //
 // This file defines a pass that can be used to determine, interprocedurally, 
 // which pointer types are accessed unsafely in a program.  If there is an
@@ -10,12 +10,12 @@
 //
 // Additionally, this analysis exports a hidden command line argument that (when
 // enabled) prints out the reasons a type was determined to be unsafe.  Just add
-// -unsafeptrinst to the command line of the tool you want to get it.
+// -printunsafeptrinst to the command line of the tool you want to get it.
 // 
 //===----------------------------------------------------------------------===//
 
-#ifndef LLVM_ANALYSIS_SAFEPOINTERACCESS_H
-#define LLVM_ANALYSIS_SAFEPOINTERACCESS_H
+#ifndef LLVM_ANALYSIS_UNSAFEPOINTERTYPES_H
+#define LLVM_ANALYSIS_UNSAFEPOINTERTYPES_H
 
 #include "llvm/Pass.h"
 #include <set>
@@ -46,11 +46,12 @@ public:
   //
   void printResults(const Module *Mod, std::ostream &o) const;
 
-  // getAnalysisUsageInfo - This function needs FindUsedTypes to do its job...
+  // getAnalysisUsage - Of course, we provide ourself...
   //
-  virtual void getAnalysisUsageInfo(Pass::AnalysisSet &Required,
-                                    Pass::AnalysisSet &Destroyed,
-                                    Pass::AnalysisSet &Provided);
+  virtual void getAnalysisUsage(AnalysisUsage &AU) const {
+    AU.setPreservesAll();
+    AU.addProvided(ID);
+  }
 };
 
 #endif
diff --git a/include/llvm/Analysis/FindUsedTypes.h b/include/llvm/Analysis/FindUsedTypes.h
index bbaf8dff6b..5c02b2cc5f 100644
--- a/include/llvm/Analysis/FindUsedTypes.h
+++ b/include/llvm/Analysis/FindUsedTypes.h
@@ -52,11 +52,12 @@ public:
   //
   bool run(Module *M);
 
-  // getAnalysisUsageInfo - This function needs FindUsedTypes to do its job...
+  // getAnalysisUsage - Of course, we provide ourself...
   //
-  virtual void getAnalysisUsageInfo(Pass::AnalysisSet &Required,
-                                    Pass::AnalysisSet &Destroyed,
-                                    Pass::AnalysisSet &Provided);
+  virtual void getAnalysisUsage(AnalysisUsage &AU) const {
+    AU.setPreservesAll();
+    AU.addProvided(ID);
+  }
 };
 
 #endif
diff --git a/include/llvm/Analysis/IntervalPartition.h b/include/llvm/Analysis/IntervalPartition.h
index 10f53173bc..d31b5fd750 100644
--- a/include/llvm/Analysis/IntervalPartition.h
+++ b/include/llvm/Analysis/IntervalPartition.h
@@ -1,7 +1,7 @@
 //===- IntervalPartition.h - Interval partition Calculation ------*- C++ -*--=//
 //
 // This file contains the declaration of the cfg::IntervalPartition class, which
-// calculates and represents the interval partition of a method, or a
+// calculates and represents the interval partition of a function, or a
 // preexisting interval partition.
 //
 // In this way, the interval partition may be used to reduce a flow graph down
@@ -24,12 +24,12 @@ namespace cfg {
 //===----------------------------------------------------------------------===//
 //
 // IntervalPartition - This class builds and holds an "interval partition" for
-// a method.  This partition divides the control flow graph into a set of
+// a function.  This partition divides the control flow graph into a set of
 // maximal intervals, as defined with the properties above.  Intuitively, a
 // BasicBlock is a (possibly nonexistent) loop with a "tail" of non looping
 // nodes following it.
 //
-class IntervalPartition : public MethodPass, public std::vector<Interval*> {
+class IntervalPartition : public FunctionPass, public std::vector<Interval*> {
   typedef std::map<BasicBlock*, Interval*> IntervalMapTy;
   IntervalMapTy IntervalMap;
 
@@ -41,8 +41,8 @@ public:
 
   IntervalPartition(AnalysisID AID) : RootInterval(0) { assert(AID == ID); }
 
-  // run - Calculate the interval partition for this method
-  virtual bool runOnMethod(Function *F);
+  // run - Calculate the interval partition for this function
+  virtual bool runOnFunction(Function *F);
 
   // IntervalPartition ctor - Build a reduced interval partition from an
   // existing interval graph.  This takes an additional boolean parameter to
@@ -54,7 +54,7 @@ public:
   ~IntervalPartition() { destroy(); }
 
   // getRootInterval() - Return the root interval that contains the starting
-  // block of the method.
+  // block of the function.
   inline Interval *getRootInterval() { return RootInterval; }
 
   // isDegeneratePartition() - Returns true if the interval partition contains
@@ -69,15 +69,14 @@ public:
     return I != IntervalMap.end() ? I->second : 0;
   }
 
-  // getAnalysisUsageInfo - Implement the Pass API
-  virtual void getAnalysisUsageInfo(AnalysisSet &Required,
-                                    AnalysisSet &Destroyed,
-                                    AnalysisSet &Provided) {
-    Provided.push_back(ID);
+  // getAnalysisUsage - Implement the Pass API
+  virtual void getAnalysisUsage(AnalysisUsage &AU) const {
+    AU.setPreservesAll();
+    AU.addProvided(ID);
   }
 
 private:
-  // destroy - Reset state back to before method was analyzed
+  // destroy - Reset state back to before function was analyzed
   void destroy();
 
   // addIntervalToPartition - Add an interval to the internal list of intervals,
diff --git a/include/llvm/Analysis/LiveVar/FunctionLiveVarInfo.h b/include/llvm/Analysis/LiveVar/FunctionLiveVarInfo.h
index 435f177045..eabae4bddc 100644
--- a/include/llvm/Analysis/LiveVar/FunctionLiveVarInfo.h
+++ b/include/llvm/Analysis/LiveVar/FunctionLiveVarInfo.h
@@ -1,15 +1,15 @@
-/* Title:   MethodLiveVarInfo.h             -*- C++ -*-
+/* Title:   FunctionLiveVarInfo.h             -*- C++ -*-
    Author:  Ruchira Sasanka
    Date:    Jun 30, 01
    Purpose: 
 
-   This is the interface for live variable info of a method that is required 
+   This is the interface for live variable info of a function that is required 
    by any other part of the compiler
 
    It must be called like:
 
-       MethodLiveVarInfo MLVI(Function *);  // initializes data structures
-       MLVI.analyze();                     // do the actural live variable anal
+       FunctionLiveVarInfo FLVI(Function *);  // initializes data structures
+       FLVI.analyze();                     // do the actural live variable anal
 
  After the analysis, getInSetOfBB or getOutSetofBB can be called to get 
  live var info of a BB.
@@ -79,7 +79,7 @@ enum LiveVarDebugLevel_t {
 extern cl::Enum<LiveVarDebugLevel_t> DEBUG_LV;
 
 
-class MethodLiveVarInfo : public MethodPass {
+class MethodLiveVarInfo : public FunctionPass {
   // Machine Instr to LiveVarSet Map for providing LVset BEFORE each inst
   std::map<const MachineInstr *, const ValueSet *> MInst2LVSetBI; 
 
@@ -105,19 +105,18 @@ public:
 
   MethodLiveVarInfo(AnalysisID id = ID) { assert(id == ID); }
 
-  // --------- Implement the MethodPass interface ----------------------
+  // --------- Implement the FunctionPass interface ----------------------
 
-  // runOnMethod - Perform analysis, update internal data structures.
-  virtual bool runOnMethod(Function *F);
+  // runOnFunction - Perform analysis, update internal data structures.
+  virtual bool runOnFunction(Function *F);
 
   // releaseMemory - After LiveVariable analysis has been used, forget!
   virtual void releaseMemory();
 
-  // getAnalysisUsageInfo - Provide self!
-  virtual void getAnalysisUsageInfo(AnalysisSet &Required,
-                                    AnalysisSet &Destroyed,
-                                    AnalysisSet &Provided) {
-    Provided.push_back(ID);
+  // getAnalysisUsage - Provide self!
+  virtual void getAnalysisUsage(AnalysisUsage &AU) const {
+    AU.setPreservesAll();
+    AU.addProvided(ID);
   }
 
   // --------- Functions to access analysis results -------------------
diff --git a/include/llvm/Analysis/LoopInfo.h b/include/llvm/Analysis/LoopInfo.h
index 5b6000d450..6c9468c7d3 100644
--- a/include/llvm/Analysis/LoopInfo.h
+++ b/include/llvm/Analysis/LoopInfo.h
@@ -62,9 +62,9 @@ private:
 
 //===----------------------------------------------------------------------===//
 // LoopInfo - This class builds and contains all of the top level loop
-// structures in the specified method.
+// structures in the specified function.
 //
-class LoopInfo : public MethodPass {
+class LoopInfo : public FunctionPass {
   // BBMap - Mapping of basic blocks to the inner most loop they occur in
   std::map<const BasicBlock *, Loop*> BBMap;
   std::vector<Loop*> TopLevelLoops;
@@ -105,16 +105,15 @@ public:
   bool isLoopExit(const BasicBlock *BB) const;
 #endif
 
-  // runOnMethod - Pass framework implementation
-  virtual bool runOnMethod(Function *F);
+  // runOnFunction - Pass framework implementation
+  virtual bool runOnFunction(Function *F);
 
   virtual void releaseMemory();
 
-  // getAnalysisUsageInfo - Provide loop info, require dominator set
+  // getAnalysisUsage - Provide loop info, require dominator set
   //
-  virtual void getAnalysisUsageInfo(Pass::AnalysisSet &Requires,
-                                    Pass::AnalysisSet &Destroyed,
-                                    Pass::AnalysisSet &Provided);
+  virtual void getAnalysisUsage(AnalysisUsage &AU) const;
+
 private:
   void Calculate(const DominatorSet &DS);
   Loop *ConsiderForLoop(const BasicBlock *BB, const DominatorSet &DS);
diff --git a/include/llvm/Assembly/PrintModulePass.h b/include/llvm/Assembly/PrintModulePass.h
index eceaf3a888..fbab4e4a45 100644
--- a/include/llvm/Assembly/PrintModulePass.h
+++ b/include/llvm/Assembly/PrintModulePass.h
@@ -1,9 +1,10 @@
 //===- llvm/Assembly/PrintModulePass.h - Printing Pass -----------*- C++ -*--=//
 //
-// This file defines two passes to print out a module.  The PrintModulePass
-// pass simply prints out the entire module when it is executed.  The
-// PrintMethodPass class is designed to be pipelined with other MethodPass's,
-// and prints out the methods of the class as they are processed.
+// This file defines two passes to print out a module.  The PrintModulePass pass
+// simply prints out the entire module when it is executed.  The
+// PrintFunctionPass class is designed to be pipelined with other
+// FunctionPass's, and prints out the functions of the class as they are
+// processed.
 //
 //===----------------------------------------------------------------------===//
 
@@ -32,8 +33,8 @@ public:
   }
 };
 
-class PrintFunctionPass : public MethodPass {
-  std::string Banner;     // String to print before each method
+class PrintFunctionPass : public FunctionPass {
+  std::string Banner;     // String to print before each function
   std::ostream *Out;      // ostream to print on
   bool DeleteStream;      // Delete the ostream in our dtor?
 public:
@@ -46,10 +47,10 @@ public:
     if (DeleteStream) delete Out;
   }
   
-  // runOnMethod - This pass just prints a banner followed by the method as
+  // runOnFunction - This pass just prints a banner followed by the function as
   // it's processed.
   //
-  bool runOnMethod(Function *F) {
+  bool runOnFunction(Function *F) {
     (*Out) << Banner << (Value*)F;
     return false;
   }
diff --git a/include/llvm/CodeGen/FunctionLiveVarInfo.h b/include/llvm/CodeGen/FunctionLiveVarInfo.h
index 435f177045..eabae4bddc 100644
--- a/include/llvm/CodeGen/FunctionLiveVarInfo.h
+++ b/include/llvm/CodeGen/FunctionLiveVarInfo.h
@@ -1,15 +1,15 @@
-/* Title:   MethodLiveVarInfo.h             -*- C++ -*-
+/* Title:   FunctionLiveVarInfo.h             -*- C++ -*-
    Author:  Ruchira Sasanka
    Date:    Jun 30, 01
    Purpose: 
 
-   This is the interface for live variable info of a method that is required 
+   This is the interface for live variable info of a function that is required 
    by any other part of the compiler
 
    It must be called like:
 
-       MethodLiveVarInfo MLVI(Function *);  // initializes data structures
-       MLVI.analyze();                     // do the actural live variable anal
+       FunctionLiveVarInfo FLVI(Function *);  // initializes data structures
+       FLVI.analyze();                     // do the actural live variable anal
 
  After the analysis, getInSetOfBB or getOutSetofBB can be called to get 
  live var info of a BB.
@@ -79,7 +79,7 @@ enum LiveVarDebugLevel_t {
 extern cl::Enum<LiveVarDebugLevel_t> DEBUG_LV;
 
 
-class MethodLiveVarInfo : public MethodPass {
+class MethodLiveVarInfo : public FunctionPass {
   // Machine Instr to LiveVarSet Map for providing LVset BEFORE each inst
   std::map<const MachineInstr *, const ValueSet *> MInst2LVSetBI; 
 
@@ -105,19 +105,18 @@ public:
 
   MethodLiveVarInfo(AnalysisID id = ID) { assert(id == ID); }
 
-  // --------- Implement the MethodPass interface ----------------------
+  // --------- Implement the FunctionPass interface ----------------------
 
-  // runOnMethod - Perform analysis, update internal data structures.
-  virtual bool runOnMethod(Function *F);
+  // runOnFunction - Perform analysis, update internal data structures.
+  virtual bool runOnFunction(Function *F);
 
   // releaseMemory - After LiveVariable analysis has been used, forget!
   virtual void releaseMemory();
 
-  // getAnalysisUsageInfo - Provide self!
-  virtual void getAnalysisUsageInfo(AnalysisSet &Required,
-                                    AnalysisSet &Destroyed,
-                                    AnalysisSet &Provided) {
-    Provided.push_back(ID);
+  // getAnalysisUsage - Provide self!
+  virtual void getAnalysisUsage(AnalysisUsage &AU) const {
+    AU.setPreservesAll();
+    AU.addProvided(ID);
   }
 
   // --------- Functions to access analysis results -------------------
diff --git a/include/llvm/CodeGen/InstrScheduling.h b/include/llvm/CodeGen/InstrScheduling.h
index 4ca4086b60..d740f1892b 100644
--- a/include/llvm/CodeGen/InstrScheduling.h
+++ b/include/llvm/CodeGen/InstrScheduling.h
@@ -8,7 +8,7 @@
 #ifndef LLVM_CODEGEN_INSTR_SCHEDULING_H
 #define LLVM_CODEGEN_INSTR_SCHEDULING_H
 
-class MethodPass;
+class Pass;
 class TargetMachine;
 
 //---------------------------------------------------------------------------
@@ -21,7 +21,7 @@ class TargetMachine;
 //   are still in SSA form.
 //---------------------------------------------------------------------------
 
-MethodPass *createInstructionSchedulingWithSSAPass(const TargetMachine &Target);
+Pass *createInstructionSchedulingWithSSAPass(const TargetMachine &Target);
 
 
 //---------------------------------------------------------------------------
diff --git a/include/llvm/CodeGen/RegisterAllocation.h b/include/llvm/CodeGen/RegisterAllocation.h
index e552fbe887..2227f8eaab 100644
--- a/include/llvm/CodeGen/RegisterAllocation.h
+++ b/include/llvm/CodeGen/RegisterAllocation.h
@@ -9,12 +9,11 @@
 
 #include "llvm/Pass.h"
 class TargetMachine;
-class MethodPass;
 
 //----------------------------------------------------------------------------
 // Entry point for register allocation for a module
 //----------------------------------------------------------------------------
 
-MethodPass *getRegisterAllocator(TargetMachine &T);
+Pass *getRegisterAllocator(TargetMachine &T);
 
 #endif
diff --git a/include/llvm/Pass.h b/include/llvm/Pass.h
index af68d42eb7..0fcf6b33ec 100644
--- a/include/llvm/Pass.h
+++ b/include/llvm/Pass.h
@@ -10,8 +10,8 @@
 //
 // Passes should extend one of the classes below, depending on the guarantees
 // that it can make about what will be modified as it is run.  For example, most
-// global optimizations should derive from MethodPass, because they do not add
-// or delete methods, they operate on the internals of the method.
+// global optimizations should derive from FunctionPass, because they do not add
+// or delete functionss, they operate on the internals of the function.
 //
 //===----------------------------------------------------------------------===//
 
@@ -24,6 +24,7 @@ class Value;
 class BasicBlock;
 class Function;
 class Module;
+class AnalysisUsage;
 class AnalysisID;
 class Pass;
 template<class UnitType> class PassManagerT;
@@ -33,7 +34,6 @@ struct AnalysisResolver;
 // Implemented in PassManager.h
 typedef PassManagerT<Module> PassManager;
 
-
 //===----------------------------------------------------------------------===//
 // Pass interface - Implemented by all 'passes'.  Subclass this if you are an
 // interprocedural optimization or you do not fit into any of the more
@@ -43,8 +43,6 @@ class Pass {
   friend class AnalysisResolver;
   AnalysisResolver *Resolver;  // AnalysisResolver this pass is owned by...
 public:
-  typedef std::vector<AnalysisID> AnalysisSet;
-
   inline Pass(AnalysisResolver *AR = 0) : Resolver(AR) {}
   inline virtual ~Pass() {} // Destructor is virtual so we can be subclassed
 
@@ -54,24 +52,13 @@ public:
   //
   virtual bool run(Module *M) = 0;
 
-  // getAnalysisUsageInfo - This function should be overriden by passes that
-  // need analysis information to do their job.  If a pass specifies that it
-  // uses a particular analysis result to this function, it can then use the
+  // getAnalysisUsage - This function should be overriden by passes that need
+  // analysis information to do their job.  If a pass specifies that it uses a
+  // particular analysis result to this function, it can then use the
   // getAnalysis<AnalysisType>() function, below.
   //
-  // The Destroyed vector is used to communicate what analyses are invalidated
-  // by this pass.  This is critical to specify so that the PassManager knows
-  // which analysis must be rerun after this pass has proceeded.  Analysis are
-  // only invalidated if run() returns true.
-  //
-  // The Provided vector is used for passes that provide analysis information,
-  // these are the analysis passes themselves.  All analysis passes should
-  // override this method to return themselves in the provided set.
-  //
-  virtual void getAnalysisUsageInfo(AnalysisSet &Required,
-                                    AnalysisSet &Destroyed,
-                                    AnalysisSet &Provided) {
-    // By default, no analysis results are used or destroyed.
+  virtual void getAnalysisUsage(AnalysisUsage &Info) const {
+    // By default, no analysis results are used, all are invalidated.
   }
 
   // releaseMemory() - This member can be implemented by a pass if it wants to
@@ -93,7 +80,7 @@ public:
 protected:
   // getAnalysis<AnalysisType>() - This function is used by subclasses to get to
   // the analysis information that they claim to use by overriding the
-  // getAnalysisUsageInfo function.
+  // getAnalysisUsage function.
   //
   template<typename AnalysisType>
   AnalysisType &getAnalysis(AnalysisID AID = AnalysisType::ID) {
@@ -118,52 +105,50 @@ private:
   friend class PassManagerT<Module>;
   friend class PassManagerT<Function>;
   friend class PassManagerT<BasicBlock>;
-  virtual void addToPassManager(PassManagerT<Module> *PM, AnalysisSet &Req,
-                                AnalysisSet &Destroyed, AnalysisSet &Provided);
+  virtual void addToPassManager(PassManagerT<Module> *PM, AnalysisUsage &AU);
 };
 
 
 //===----------------------------------------------------------------------===//
-// MethodPass class - This class is used to implement most global optimizations.
-// Optimizations should subclass this class if they meet the following
-// constraints:
-//  1. Optimizations are organized globally, ie a method at a time
-//  2. Optimizing a method does not cause the addition or removal of any methods
-//     in the module
+// FunctionPass class - This class is used to implement most global
+// optimizations.  Optimizations should subclass this class if they meet the
+// following constraints:
+//
+//  1. Optimizations are organized globally, ie a function at a time
+//  2. Optimizing a function does not cause the addition or removal of any
+//     functions in the module
 //
-struct MethodPass : public Pass {
+struct FunctionPass : public Pass {
   // doInitialization - Virtual method overridden by subclasses to do
   // any neccesary per-module initialization.
   //
   virtual bool doInitialization(Module *M) { return false; }
 
-  // runOnMethod - Virtual method overriden by subclasses to do the per-method
-  // processing of the pass.
+  // runOnFunction - Virtual method overriden by subclasses to do the
+  // per-function processing of the pass.
   //
-  virtual bool runOnMethod(Function *M) = 0;
+  virtual bool runOnFunction(Function *F) = 0;
 
   // doFinalization - Virtual method overriden by subclasses to do any post
   // processing needed after all passes have run.
   //
   virtual bool doFinalization(Module *M) { return false; }
 
-  // run - On a module, we run this pass by initializing, ronOnMethod'ing once
-  // for every method in the module, then by finalizing.
+  // run - On a module, we run this pass by initializing, ronOnFunction'ing once
+  // for every function in the module, then by finalizing.
   //
   virtual bool run(Module *M);
 
-  // run - On a method, we simply initialize, run the method, then finalize.
+  // run - On a function, we simply initialize, run the function, then finalize.
   //
-  bool run(Function *M);
+  bool run(Function *F);
 
 private:
   friend class PassManagerT<Module>;
   friend class PassManagerT<Function>;
   friend class PassManagerT<BasicBlock>;
-  virtual void addToPassManager(PassManagerT<Module> *PM, AnalysisSet &Req,
-                                AnalysisSet &Dest, AnalysisSet &Prov);
-  virtual void addToPassManager(PassManagerT<Function> *PM,AnalysisSet &Req,
-                                AnalysisSet &Dest, AnalysisSet &Prov);
+  virtual void addToPassManager(PassManagerT<Module> *PM, AnalysisUsage &AU);
+  virtual void addToPassManager(PassManagerT<Function> *PM, AnalysisUsage &AU);
 };
 
 
@@ -174,20 +159,20 @@ private:
 // meet the following constraints:
 //   1. Optimizations are local, operating on either a basic block or
 //      instruction at a time.
-//   2. Optimizations do not modify the CFG of the contained method, or any
-//      other basic block in the method.
-//   3. Optimizations conform to all of the contstraints of MethodPass's.
+//   2. Optimizations do not modify the CFG of the contained function, or any
+//      other basic block in the function.
+//   3. Optimizations conform to all of the contstraints of FunctionPass's.
 //
-struct BasicBlockPass : public MethodPass {
+struct BasicBlockPass : public FunctionPass {
   // runOnBasicBlock - Virtual method overriden by subclasses to do the
   // per-basicblock processing of the pass.
   //
   virtual bool runOnBasicBlock(BasicBlock *M) = 0;
 
-  // To run this pass on a method, we simply call runOnBasicBlock once for each
-  // method.
+  // To run this pass on a function, we simply call runOnBasicBlock once for
+  // each function.
   //
-  virtual bool runOnMethod(Function *F);
+  virtual bool runOnFunction(Function *F);
 
   // To run directly on the basic block, we initialize, runOnBasicBlock, then
   // finalize.
@@ -197,10 +182,8 @@ struct BasicBlockPass : public MethodPass {
 private:
   friend class PassManagerT<Function>;
   friend class PassManagerT<BasicBlock>;
-  virtual void addToPassManager(PassManagerT<Function> *PM, AnalysisSet &,
-                                AnalysisSet &, AnalysisSet &);
-  virtual void addToPassManager(PassManagerT<BasicBlock> *PM, AnalysisSet &,
-                                AnalysisSet &, AnalysisSet &);
+  virtual void addToPassManager(PassManagerT<Function> *PM, AnalysisUsage &AU);
+  virtual void addToPassManager(PassManagerT<BasicBlock> *PM,AnalysisUsage &AU);
 };
 
 
@@ -249,6 +232,50 @@ public:
   }
 };
 
+//===----------------------------------------------------------------------===//
+// AnalysisUsage - Represent the analysis usage information of a pass.  This
+// tracks analyses that the pass REQUIRES (must available when the pass runs),
+// and analyses that the pass PRESERVES (the pass does not invalidate the
+// results of these analyses).  This information is provided by a pass to the
+// Pass infrastructure through the getAnalysisUsage virtual function.
+//
+class AnalysisUsage {
+  // Sets of analyses required and preserved by a pass
+  std::vector<AnalysisID> Required, Preserved, Provided;
+  bool PreservesAll;
+public:
+  AnalysisUsage() : PreservesAll(false) {}
+  
+  // addRequires - Add the specified ID to the required set of the usage info
+  // for a pass.
+  //
+  AnalysisUsage &addRequired(AnalysisID ID) {
+    Required.push_back(ID);
+    return *this;
+  }
+
+  // addPreserves - Add the specified ID to the set of analyses preserved by
+  // this pass
+  //
+  AnalysisUsage &addPreserved(AnalysisID ID) {
+    Preserved.push_back(ID);
+    return *this;
+  }
+
+  void addProvided(AnalysisID ID) {
+    Provided.push_back(ID);
+  }
+
+  // PreservesAll - Set by analyses that do not transform their input at all
+  void setPreservesAll() { PreservesAll = true; }
+  bool preservesAll() const { return PreservesAll; }
+
+  const std::vector<AnalysisID> &getRequiredSet() const { return Required; }
+  const std::vector<AnalysisID> &getPreservedSet() const { return Preserved; }
+  const std::vector<AnalysisID> &getProvidedSet() const { return Provided; }
+};
+
+
 
 //===----------------------------------------------------------------------===//
 // AnalysisResolver - Simple interface implemented by PassManagers objects that
diff --git a/include/llvm/Transforms/FunctionInlining.h b/include/llvm/Transforms/FunctionInlining.h
index e321df52f7..08fe9d93a6 100644
--- a/include/llvm/Transforms/FunctionInlining.h
+++ b/include/llvm/Transforms/FunctionInlining.h
@@ -1,19 +1,19 @@
-//===-- MethodInlining.h - Functions that perform Inlining -------*- C++ -*--=//
+//===-- FunctionInlining.h - Functions that perform Inlining -----*- C++ -*--=//
 //
-// This family of functions is useful for performing method inlining.
+// This family of functions is useful for performing function inlining.
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef LLVM_TRANSFORMS_METHOD_INLINING_H
-#define LLVM_TRANSFORMS_METHOD_INLINING_H
+#ifndef LLVM_TRANSFORMS_FUNCTION_INLINING_H
+#define LLVM_TRANSFORMS_FUNCTION_INLINING_H
 
 #include "llvm/BasicBlock.h"
 class CallInst;
 class Pass;
 
-Pass *createMethodInliningPass();
+Pass *createFunctionInliningPass();
 
-// InlineMethod - This function forcibly inlines the called method into the
+// InlineFunction - This function forcibly inlines the called function into the
 // basic block of the caller.  This returns true if it is not possible to inline
 // this call.  The program is still in a well defined state if this occurs 
 // though.
@@ -21,9 +21,9 @@ Pass *createMethodInliningPass();
 // Note that this only does one level of inlining.  For example, if the 
 // instruction 'call B' is inlined, and 'B' calls 'C', then the call to 'C' now 
 // exists in the instruction stream.  Similiarly this will inline a recursive
-// method by one level.
+// function by one level.
 //
-bool InlineMethod(CallInst *C);
-bool InlineMethod(BasicBlock::iterator CI);  // *CI must be CallInst
+bool InlineFunction(CallInst *C);
+bool InlineFunction(BasicBlock::iterator CI);  // *CI must be CallInst
 
 #endif
diff --git a/include/llvm/Transforms/Instrumentation/TraceValues.h b/include/llvm/Transforms/Instrumentation/TraceValues.h
index 0519e1d67c..8afed48e29 100644
--- a/include/llvm/Transforms/Instrumentation/TraceValues.h
+++ b/include/llvm/Transforms/Instrumentation/TraceValues.h
@@ -1,6 +1,6 @@
 //===- llvm/Transforms/Instrumentation/TraceValues.h - Tracing ---*- C++ -*--=//
 //
-// Support for inserting LLVM code to print values at basic block and method
+// Support for inserting LLVM code to print values at basic block and function
 // exits.
 //
 //===----------------------------------------------------------------------===//
@@ -9,7 +9,7 @@
 #define LLVM_TRANSFORMS_INSTRUMENTATION_TRACEVALUES_H
 
 class Pass;
-Pass *createTraceValuesPassForMethod();       // Just trace methods
+Pass *createTraceValuesPassForFunction();     // Just trace function entry/exit
 Pass *createTraceValuesPassForBasicBlocks();  // Trace BB's and methods
 
 #endif
diff --git a/include/llvm/Transforms/MutateStructTypes.h b/include/llvm/Transforms/MutateStructTypes.h
index 947606d1f5..e1fbeda2d4 100644
--- a/include/llvm/Transforms/MutateStructTypes.h
+++ b/include/llvm/Transforms/MutateStructTypes.h
@@ -41,7 +41,7 @@ class MutateStructTypes : public Pass {
   // Mapping from global value of old type, to a global value of the new type...
   std::map<const GlobalValue*, GlobalValue*> GlobalMap;
 
-  // Mapping from intra method value to intra method value
+  // Mapping from intra function value to intra function value
   std::map<const Value*, Value*> LocalValueMap;
 
 public:
@@ -60,13 +60,6 @@ public:
   // run - do the transformation
   virtual bool run(Module *M);
 
-  // getAnalysisUsageInfo - This function needs the results of the
-  // FindUsedTypes and FindUnsafePointerTypes analysis passes...
-  //
-  virtual void getAnalysisUsageInfo(Pass::AnalysisSet &Required,
-                                    Pass::AnalysisSet &Destroyed,
-                                    Pass::AnalysisSet &Provided);
-
 protected:
 
   // Alternatively, it is valid to subclass this class and provide transforms
@@ -80,17 +73,17 @@ private:
 
   // processGlobals - This loops over global constants defined in the
   // module, converting them to their new type.  Also this creates placeholder
-  // methods for methods than need to be copied because they have a new
+  // functions for functions than need to be copied because they have a new
   // signature type.
   //
   void processGlobals(Module *M);
 
-  // transformMethod - This transforms the instructions of the method to use the
-  // new types.
+  // transformFunction - This transforms the instructions of the function to use
+  // the new types.
   //
-  void transformMethod(Function *F);
+  void transformFunction(Function *F);
 
-  // removeDeadGlobals - This removes the old versions of methods that are no
+  // removeDeadGlobals - This removes the old versions of functions that are no
   // longer needed.
   //
   void removeDeadGlobals(Module *M);
diff --git a/include/llvm/Transforms/Scalar/InductionVars.h b/include/llvm/Transforms/Scalar/InductionVars.h
index b40f8f3c93..b8d951bb2b 100644
--- a/include/llvm/Transforms/Scalar/InductionVars.h
+++ b/include/llvm/Transforms/Scalar/InductionVars.h
@@ -11,17 +11,15 @@
 #include "llvm/Pass.h"
 namespace cfg { class IntervalPartition; }
 
-struct InductionVariableCannonicalize : public MethodPass {
+struct InductionVariableCannonicalize : public FunctionPass {
   // doInductionVariableCannonicalize - Simplify induction variables in loops
   //
-  static bool doIt(Function *M, cfg::IntervalPartition &IP);
+  static bool doIt(Function *F, cfg::IntervalPartition &IP);
 
-  virtual bool runOnMethod(Function *M);
+  virtual bool runOnFunction(Function *F);
 
-  // getAnalysisUsageInfo - Declare that we need IntervalPartitions
-  void getAnalysisUsageInfo(Pass::AnalysisSet &Required,
-                            Pass::AnalysisSet &Destroyed,
-                            Pass::AnalysisSet &Provided);
+  // getAnalysisUsage - Declare that we need IntervalPartitions
+  void getAnalysisUsage(AnalysisUsage &AU) const;
 };
 
 #endif
diff --git a/include/llvm/Transforms/Utils/UnifyFunctionExitNodes.h b/include/llvm/Transforms/Utils/UnifyFunctionExitNodes.h
index 86784ed1cf..af82f6b3f2 100644
--- a/include/llvm/Transforms/Utils/UnifyFunctionExitNodes.h
+++ b/include/llvm/Transforms/Utils/UnifyFunctionExitNodes.h
@@ -1,17 +1,17 @@
-//===-- UnifyMethodExitNodes.h - Ensure methods have one return --*- C++ -*--=//
+//===-- UnifyFunctionExitNodes.h - Ensure fn's have one return ---*- C++ -*--=//
 //
-// This pass is used to ensure that methods have at most one return instruction
-// in them.  It also holds onto the return instruction of the last unified
-// method.
+// This pass is used to ensure that functions have at most one return
+// instruction in them.  It also holds onto the return instruction of the last
+// unified function.
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef LLVM_XFORMS_UNIFY_METHOD_EXIT_NODES_H
-#define LLVM_XFORMS_UNIFY_METHOD_EXIT_NODES_H
+#ifndef LLVM_XFORMS_UNIFY_FUNCTION_EXIT_NODES_H
+#define LLVM_XFORMS_UNIFY_FUNCTION_EXIT_NODES_H
 
 #include "llvm/Pass.h"
 
-struct UnifyMethodExitNodes : public MethodPass {
+struct UnifyMethodExitNodes : public FunctionPass {
   BasicBlock *ExitNode;
 public:
   static AnalysisID ID;            // Pass ID
@@ -21,22 +21,19 @@ public:
   // BasicBlock, and converting all returns to unconditional branches to this
   // new basic block.  The singular exit node is returned in ExitNode.
   //
-  // If there are no return stmts in the Method, a null pointer is returned.
+  // If there are no return stmts in the function, a null pointer is returned.
   //
   static bool doit(Function *F, BasicBlock *&ExitNode);
 
 
-  virtual bool runOnMethod(Function *F) {
+  virtual bool runOnFunction(Function *F) {
     return doit(F, ExitNode);
   }
 
   BasicBlock *getExitNode() const { return ExitNode; }
 
-  virtual void getAnalysisUsageInfo(Pass::AnalysisSet &Required,
-                                    Pass::AnalysisSet &Destroyed,
-                                    Pass::AnalysisSet &Provided) {
-    // FIXME: Should invalidate CFG
-    Provided.push_back(ID);  // Provide self!
+  virtual void getAnalysisUsage(AnalysisUsage &AU) const {
+    AU.addProvided(ID);  // Provide self!
   }
 };
 
diff --git a/lib/Analysis/IPA/FindUnsafePointerTypes.cpp b/lib/Analysis/IPA/FindUnsafePointerTypes.cpp
index d689d93cd4..9f908c6c71 100644
--- a/lib/Analysis/IPA/FindUnsafePointerTypes.cpp
+++ b/lib/Analysis/IPA/FindUnsafePointerTypes.cpp
@@ -95,11 +95,3 @@ void FindUnsafePointerTypes::printResults(const Module *M,
     CW << " #" << Counter << ". " << (Value*)*I << "\n";
   }
 }
-
-// getAnalysisUsageInfo - Of course, we provide ourself...
-//
-void FindUnsafePointerTypes::getAnalysisUsageInfo(Pass::AnalysisSet &Required,
-                                                  Pass::AnalysisSet &Destroyed,
-                                                  Pass::AnalysisSet &Provided) {
-  Provided.push_back(FindUnsafePointerTypes::ID);
-}
diff --git a/lib/Analysis/IPA/FindUsedTypes.cpp b/lib/Analysis/IPA/FindUsedTypes.cpp
index 5c961d2beb..86061d8610 100644
--- a/lib/Analysis/IPA/FindUsedTypes.cpp
+++ b/lib/Analysis/IPA/FindUsedTypes.cpp
@@ -93,11 +93,3 @@ void FindUsedTypes::printTypes(std::ostream &o, const Module *M = 0) const {
            E = UsedTypes.end(); I != E; ++I)
       o << "  " << *I << "\n";
 }
-
-// getAnalysisUsageInfo - Of course, we provide ourself...
-//
-void FindUsedTypes::getAnalysisUsageInfo(Pass::AnalysisSet &Required,
-                                         Pass::AnalysisSet &Destroyed,
-                                         Pass::AnalysisSet &Provided) {
-  Provided.push_back(FindUsedTypes::ID);
-}
diff --git a/lib/Analysis/IntervalPartition.cpp b/lib/Analysis/IntervalPartition.cpp
index 197bed26d7..bb0f582108 100644
--- a/lib/Analysis/IntervalPartition.cpp
+++ b/lib/Analysis/IntervalPartition.cpp
@@ -52,19 +52,19 @@ void IntervalPartition::updatePredecessors(cfg::Interval *Int) {
 // IntervalPartition ctor - Build the first level interval partition for the
 // specified function...
 //
-bool IntervalPartition::runOnMethod(Function *M) {
-  assert(M->front() && "Cannot operate on prototypes!");
+bool IntervalPartition::runOnFunction(Function *F) {
+  assert(F->front() && "Cannot operate on prototypes!");
 
   // Pass false to intervals_begin because we take ownership of it's memory
-  function_interval_iterator I = intervals_begin(M, false);
-  assert(I != intervals_end(M) && "No intervals in function!?!?!");
+  function_interval_iterator I = intervals_begin(F, false);
+  assert(I != intervals_end(F) && "No intervals in function!?!?!");
 
   addIntervalToPartition(RootInterval = *I);
 
   ++I;  // After the first one...
 
   // Add the rest of the intervals to the partition...
-  for_each(I, intervals_end(M),
+  for_each(I, intervals_end(F),
 	   bind_obj(this, &IntervalPartition::addIntervalToPartition));
 
   // Now that we know all of the successor information, propogate this to the
diff --git a/lib/Analysis/LiveVar/FunctionLiveVarInfo.cpp b/lib/Analysis/LiveVar/FunctionLiveVarInfo.cpp
index e9e4245cca..0518aef3b8 100644
--- a/lib/Analysis/LiveVar/FunctionLiveVarInfo.cpp
+++ b/lib/Analysis/LiveVar/FunctionLiveVarInfo.cpp
@@ -1,6 +1,6 @@
-//===-- MethodLiveVarInfo.cpp - Live Variable Analysis for a Function -----===//
+//===-- FunctionLiveVarInfo.cpp - Live Variable Analysis for a Function ---===//
 //
-// This is the interface to method level live variable information that is
+// This is the interface to function level live variable information that is
 // provided by live variable analysis.
 //
 //===----------------------------------------------------------------------===//
@@ -39,10 +39,10 @@ const ValueSet &MethodLiveVarInfo::getInSetOfBB(const BasicBlock *BB) const {
 
 
 //-----------------------------------------------------------------------------
-// Performs live var analysis for a method
+// Performs live var analysis for a function
 //-----------------------------------------------------------------------------
 
-bool MethodLiveVarInfo::runOnMethod(Function *Meth) {
+bool MethodLiveVarInfo::runOnFunction(Function *Meth) {
   M = Meth;
   if (DEBUG_LV) std::cerr << "Analysing live variables ...\n";
 
@@ -149,12 +149,12 @@ void MethodLiveVarInfo::releaseMemory() {
 
 //-----------------------------------------------------------------------------
 // Following functions will give the LiveVar info for any machine instr in
-// a method. It should be called after a call to analyze().
+// a function. It should be called after a call to analyze().
 //
 // Thsese functions calucluates live var info for all the machine instrs in a 
 // BB when LVInfo for one inst is requested. Hence, this function is useful 
 // when live var info is required for many (or all) instructions in a basic 
-// block. Also, the arguments to this method does not require specific 
+// block. Also, the arguments to this function does not require specific 
 // iterators.
 //-----------------------------------------------------------------------------
 
diff --git a/lib/Analysis/LoopInfo.cpp b/lib/Analysis/LoopInfo.cpp
index ef47936bba..c34aef7b9c 100644
--- a/lib/Analysis/LoopInfo.cpp
+++ b/lib/Analysis/LoopInfo.cpp
@@ -35,7 +35,7 @@ void cfg::LoopInfo::releaseMemory() {
 //===----------------------------------------------------------------------===//
 // cfg::LoopInfo implementation
 //
-bool cfg::LoopInfo::runOnMethod(Function *F) {
+bool cfg::LoopInfo::runOnFunction(Function *F) {
   releaseMemory();
   Calculate(getAnalysis<DominatorSet>());    // Update
   return false;
@@ -53,11 +53,10 @@ void cfg::LoopInfo::Calculate(const DominatorSet &DS) {
     TopLevelLoops[i]->setLoopDepth(1);
 }
 
-void cfg::LoopInfo::getAnalysisUsageInfo(Pass::AnalysisSet &Required,
-                                         Pass::AnalysisSet &Destroyed,
-                                         Pass::AnalysisSet &Provided) {
-  Required.push_back(DominatorSet::ID);
-  Provided.push_back(ID);
+void cfg::LoopInfo::getAnalysisUsage(AnalysisUsage &AU) const {
+  AU.setPreservesAll();
+  AU.addRequired(DominatorSet::ID);
+  AU.addProvided(ID);
 }
 
 
diff --git a/lib/Analysis/PostDominators.cpp b/lib/Analysis/PostDominators.cpp
index 71ee3d74cf..387b673f60 100644
--- a/lib/Analysis/PostDominators.cpp
+++ b/lib/Analysis/PostDominators.cpp
@@ -22,7 +22,7 @@ using std::set;
 AnalysisID cfg::DominatorSet::ID(AnalysisID::create<cfg::DominatorSet>());
 AnalysisID cfg::DominatorSet::PostDomID(AnalysisID::create<cfg::DominatorSet>());
 
-bool cfg::DominatorSet::runOnMethod(Function *F) {
+bool cfg::DominatorSet::runOnFunction(Function *F) {
   Doms.clear();   // Reset from the last time we were run...
 
   if (isPostDominator())
@@ -129,17 +129,16 @@ void cfg::DominatorSet::calcPostDominatorSet(Function *M) {
   } while (Changed);
 }
 
-// getAnalysisUsageInfo - This obviously provides a dominator set, but it also
-// uses the UnifyMethodExitNodes pass if building post-dominators
+// getAnalysisUsage - This obviously provides a dominator set, but it also
+// uses the UnifyFunctionExitNodes pass if building post-dominators
 //
-void cfg::DominatorSet::getAnalysisUsageInfo(Pass::AnalysisSet &Requires,
-                                             Pass::AnalysisSet &Destroyed,
-                                             Pass::AnalysisSet &Provided) {
+void cfg::DominatorSet::getAnalysisUsage(AnalysisUsage &AU) const {
+  AU.setPreservesAll();
   if (isPostDominator()) {
-    Provided.push_back(PostDomID);
-    Requires.push_back(UnifyMethodExitNodes::ID);
+    AU.addProvided(PostDomID);
+    AU.addRequired(UnifyMethodExitNodes::ID);
   } else {
-    Provided.push_back(ID);
+    AU.addProvided(ID);
   }
 }
 
diff --git a/lib/CodeGen/InstrSched/InstrScheduling.cpp b/lib/CodeGen/InstrSched/InstrScheduling.cpp
index f10bf3c412..adc8903541 100644
--- a/lib/CodeGen/InstrSched/InstrScheduling.cpp
+++ b/lib/CodeGen/InstrSched/InstrScheduling.cpp
@@ -1480,26 +1480,23 @@ instrIsFeasible(const SchedulingManager& S,
 //---------------------------------------------------------------------------
 
 namespace {
-  class InstructionSchedulingWithSSA : public MethodPass {
+  class InstructionSchedulingWithSSA : public FunctionPass {
     const TargetMachine &target;
   public:
     inline InstructionSchedulingWithSSA(const TargetMachine &T) : target(T) {}
   
-    // getAnalysisUsageInfo - We use LiveVarInfo...
-    virtual void getAnalysisUsageInfo(Pass::AnalysisSet &Requires,
-                                      Pass::AnalysisSet &Destroyed,
-                                      Pass::AnalysisSet &Provided) {
-      Requires.push_back(MethodLiveVarInfo::ID);
-      Destroyed.push_back(MethodLiveVarInfo::ID);
+    // getAnalysisUsage - We use LiveVarInfo...
+    virtual void getAnalysisUsage(AnalysisUsage &AU) const {
+      AU.addRequired(MethodLiveVarInfo::ID);
     }
     
-    bool runOnMethod(Function *F);
+    bool runOnFunction(Function *F);
   };
 } // end anonymous namespace
 
 
 bool
-InstructionSchedulingWithSSA::runOnMethod(Function *M)
+InstructionSchedulingWithSSA::runOnFunction(Function *M)
 {
   if (SchedDebugLevel == Sched_Disable)
     return false;
@@ -1544,8 +1541,6 @@ InstructionSchedulingWithSSA::runOnMethod(Function *M)
 }
 
 
-MethodPass*
-createInstructionSchedulingWithSSAPass(const TargetMachine &tgt)
-{
+Pass *createInstructionSchedulingWithSSAPass(const TargetMachine &tgt) {
   return new InstructionSchedulingWithSSA(tgt);
 }
diff --git a/lib/CodeGen/RegAlloc/PhyRegAlloc.cpp b/lib/CodeGen/RegAlloc/PhyRegAlloc.cpp
index 0b680ab9e4..c22ede96b3 100644
--- a/lib/CodeGen/RegAlloc/PhyRegAlloc.cpp
+++ b/lib/CodeGen/RegAlloc/PhyRegAlloc.cpp
@@ -40,14 +40,14 @@ cl::Enum<RegAllocDebugLevel_t> DEBUG_RA("dregalloc", cl::NoFlags,
 // RegisterAllocation pass front end...
 //----------------------------------------------------------------------------
 namespace {
-  class RegisterAllocator : public MethodPass {
+  class RegisterAllocator : public FunctionPass {
     TargetMachine &Target;
   public:
     inline RegisterAllocator(TargetMachine &T) : Target(T) {}
     
-    bool runOnMethod(Function *F) {
+    bool runOnFunction(Function *F) {
       if (DEBUG_RA)
-        cerr << "\n******************** Method "<< F->getName()
+        cerr << "\n******************** Function "<< F->getName()
              << " ********************\n";
       
       PhyRegAlloc PRA(F, Target, &getAnalysis<MethodLiveVarInfo>(),
@@ -58,17 +58,14 @@ namespace {
       return false;
     }
 
-    virtual void getAnalysisUsageInfo(Pass::AnalysisSet &Requires,
-                                      Pass::AnalysisSet &Destroyed,
-                                      Pass::AnalysisSet &Provided) {
-      Requires.push_back(cfg::LoopInfo::ID);
-      Requires.push_back(MethodLiveVarInfo::ID);
-      Destroyed.push_back(MethodLiveVarInfo::ID);
+    virtual void getAnalysisUsage(AnalysisUsage &AU) const {
+      AU.addRequired(cfg::LoopInfo::ID);
+      AU.addRequired(MethodLiveVarInfo::ID);
     }
   };
 }
 
-MethodPass *getRegisterAllocator(TargetMachine &T) {
+Pass *getRegisterAllocator(TargetMachine &T) {
   return new RegisterAllocator(T);
 }
 
diff --git a/lib/Target/SparcV9/InstrSched/InstrScheduling.cpp b/lib/Target/SparcV9/InstrSched/InstrScheduling.cpp
index f10bf3c412..adc8903541 100644
--- a/lib/Target/SparcV9/InstrSched/InstrScheduling.cpp
+++ b/lib/Target/SparcV9/InstrSched/InstrScheduling.cpp
@@ -1480,26 +1480,23 @@ instrIsFeasible(const SchedulingManager& S,
 //---------------------------------------------------------------------------
 
 namespace {
-  class InstructionSchedulingWithSSA : public MethodPass {
+  class InstructionSchedulingWithSSA : public FunctionPass {
     const TargetMachine &target;
   public:
     inline InstructionSchedulingWithSSA(const TargetMachine &T) : target(T) {}
   
-    // getAnalysisUsageInfo - We use LiveVarInfo...
-    virtual void getAnalysisUsageInfo(Pass::AnalysisSet &Requires,
-                                      Pass::AnalysisSet &Destroyed,
-                                      Pass::AnalysisSet &Provided) {
-      Requires.push_back(MethodLiveVarInfo::ID);
-      Destroyed.push_back(MethodLiveVarInfo::ID);
+    // getAnalysisUsage - We use LiveVarInfo...
+    virtual void getAnalysisUsage(AnalysisUsage &AU) const {
+      AU.addRequired(MethodLiveVarInfo::ID);
     }
     
-    bool runOnMethod(Function *F);
+    bool runOnFunction(Function *F);
   };
 } // end anonymous namespace
 
 
 bool
-InstructionSchedulingWithSSA::runOnMethod(Function *M)
+InstructionSchedulingWithSSA::runOnFunction(Function *M)
 {
   if (SchedDebugLevel == Sched_Disable)
     return false;
@@ -1544,8 +1541,6 @@ InstructionSchedulingWithSSA::runOnMethod(Function *M)
 }
 
 
-MethodPass*
-createInstructionSchedulingWithSSAPass(const TargetMachine &tgt)
-{
+Pass *createInstructionSchedulingWithSSAPass(const TargetMachine &tgt) {
   return new InstructionSchedulingWithSSA(tgt);
 }
diff --git a/lib/Target/SparcV9/LiveVar/FunctionLiveVarInfo.cpp b/lib/Target/SparcV9/LiveVar/FunctionLiveVarInfo.cpp
index e9e4245cca..0518aef3b8 100644
--- a/lib/Target/SparcV9/LiveVar/FunctionLiveVarInfo.cpp
+++ b/lib/Target/SparcV9/LiveVar/FunctionLiveVarInfo.cpp
@@ -1,6 +1,6 @@
-//===-- MethodLiveVarInfo.cpp - Live Variable Analysis for a Function -----===//
+//===-- FunctionLiveVarInfo.cpp - Live Variable Analysis for a Function ---===//
 //
-// This is the interface to method level live variable information that is
+// This is the interface to function level live variable information that is
 // provided by live variable analysis.
 //
 //===----------------------------------------------------------------------===//
@@ -39,10 +39,10 @@ const ValueSet &MethodLiveVarInfo::getInSetOfBB(const BasicBlock *BB) const {
 
 
 //-----------------------------------------------------------------------------
-// Performs live var analysis for a method
+// Performs live var analysis for a function
 //-----------------------------------------------------------------------------
 
-bool MethodLiveVarInfo::runOnMethod(Function *Meth) {
+bool MethodLiveVarInfo::runOnFunction(Function *Meth) {
   M = Meth;
   if (DEBUG_LV) std::cerr << "Analysing live variables ...\n";
 
@@ -149,12 +149,12 @@ void MethodLiveVarInfo::releaseMemory() {
 
 //-----------------------------------------------------------------------------
 // Following functions will give the LiveVar info for any machine instr in
-// a method. It should be called after a call to analyze().
+// a function. It should be called after a call to analyze().
 //
 // Thsese functions calucluates live var info for all the machine instrs in a 
 // BB when LVInfo for one inst is requested. Hence, this function is useful 
 // when live var info is required for many (or all) instructions in a basic 
-// block. Also, the arguments to this method does not require specific 
+// block. Also, the arguments to this function does not require specific 
 // iterators.
 //-----------------------------------------------------------------------------
 
diff --git a/lib/Target/SparcV9/RegAlloc/PhyRegAlloc.cpp b/lib/Target/SparcV9/RegAlloc/PhyRegAlloc.cpp
index 0b680ab9e4..c22ede96b3 100644
--- a/lib/Target/SparcV9/RegAlloc/PhyRegAlloc.cpp
+++ b/lib/Target/SparcV9/RegAlloc/PhyRegAlloc.cpp
@@ -40,14 +40,14 @@ cl::Enum<RegAllocDebugLevel_t> DEBUG_RA("dregalloc", cl::NoFlags,
 // RegisterAllocation pass front end...
 //----------------------------------------------------------------------------
 namespace {
-  class RegisterAllocator : public MethodPass {
+  class RegisterAllocator : public FunctionPass {
     TargetMachine &Target;
   public:
     inline RegisterAllocator(TargetMachine &T) : Target(T) {}
     
-    bool runOnMethod(Function *F) {
+    bool runOnFunction(Function *F) {
       if (DEBUG_RA)
-        cerr << "\n******************** Method "<< F->getName()
+        cerr << "\n******************** Function "<< F->getName()
              << " ********************\n";
       
       PhyRegAlloc PRA(F, Target, &getAnalysis<MethodLiveVarInfo>(),
@@ -58,17 +58,14 @@ namespace {
       return false;
     }
 
-    virtual void getAnalysisUsageInfo(Pass::AnalysisSet &Requires,
-                                      Pass::AnalysisSet &Destroyed,
-                                      Pass::AnalysisSet &Provided) {
-      Requires.push_back(cfg::LoopInfo::ID);
-      Requires.push_back(MethodLiveVarInfo::ID);
-      Destroyed.push_back(MethodLiveVarInfo::ID);
+    virtual void getAnalysisUsage(AnalysisUsage &AU) const {
+      AU.addRequired(cfg::LoopInfo::ID);
+      AU.addRequired(MethodLiveVarInfo::ID);
     }
   };
 }
 
-MethodPass *getRegisterAllocator(TargetMachine &T) {
+Pass *getRegisterAllocator(TargetMachine &T) {
   return new RegisterAllocator(T);
 }
 
diff --git a/lib/Target/SparcV9/SparcV9AsmPrinter.cpp b/lib/Target/SparcV9/SparcV9AsmPrinter.cpp
index a46f2ef729..83e5487165 100644
--- a/lib/Target/SparcV9/SparcV9AsmPrinter.cpp
+++ b/lib/Target/SparcV9/SparcV9AsmPrinter.cpp
@@ -4,10 +4,10 @@
 // LLVM.  The code in this file assumes that the specified module has already
 // been compiled into the internal data structures of the Module.
 //
-// This code largely consists of two LLVM Pass's: a MethodPass and a Pass.  The
-// MethodPass is pipelined together with all of the rest of the code generation
-// stages, and the Pass runs at the end to emit code for global variables and
-// such.
+// This code largely consists of two LLVM Pass's: a FunctionPass and a Pass.
+// The FunctionPass is pipelined together with all of the rest of the code
+// generation stages, and the Pass runs at the end to emit code for global
+// variables and such.
 //
 //===----------------------------------------------------------------------===//
 
@@ -197,7 +197,7 @@ public:
 //   SparcFunctionAsmPrinter Code
 //===----------------------------------------------------------------------===//
 
-struct SparcFunctionAsmPrinter : public MethodPass, public AsmPrinter {
+struct SparcFunctionAsmPrinter : public FunctionPass, public AsmPrinter {
   inline SparcFunctionAsmPrinter(std::ostream &os, const TargetMachine &t)
     : AsmPrinter(os, t) {}
 
@@ -206,7 +206,7 @@ struct SparcFunctionAsmPrinter : public MethodPass, public AsmPrinter {
     return false;
   }
 
-  virtual bool runOnMethod(Function *F) {
+  virtual bool runOnFunction(Function *F) {
     startFunction(F);
     emitFunction(F);
     endFunction(F);
@@ -410,7 +410,7 @@ SparcFunctionAsmPrinter::emitFunction(const Function *M)
 
 }  // End anonymous namespace
 
-Pass *UltraSparc::getMethodAsmPrinterPass(PassManager &PM, std::ostream &Out) {
+Pass *UltraSparc::getFunctionAsmPrinterPass(PassManager &PM, std::ostream &Out){
   return new SparcFunctionAsmPrinter(Out, *this);
 }
 
diff --git a/lib/Target/SparcV9/SparcV9Internals.h b/lib/Target/SparcV9/SparcV9Internals.h
index 12c86b8b8d..0e80179f4e 100644
--- a/lib/Target/SparcV9/SparcV9Internals.h
+++ b/lib/Target/SparcV9/SparcV9Internals.h
@@ -128,7 +128,7 @@ public:
   // returned in `minstrVec'.  Any temporary registers (TmpInstruction)
   // created are returned in `tempVec'.
   // 
-  virtual void  CreateCodeToLoadConst(Function* method,
+  virtual void  CreateCodeToLoadConst(Function *F,
                                       Value* val,
                                       Instruction* dest,
                                       std::vector<MachineInstr*>& minstrVec,
@@ -141,7 +141,7 @@ public:
   // The generated instructions are returned in `minstrVec'.
   // Any temp. registers (TmpInstruction) created are returned in `tempVec'.
   // 
-  virtual void  CreateCodeToCopyIntToFloat(Function* method,
+  virtual void  CreateCodeToCopyIntToFloat(Function* F,
                                            Value* val,
                                            Instruction* dest,
                                            std::vector<MachineInstr*>& minstr,
@@ -152,7 +152,7 @@ public:
   // `val' to an integer value `dest' by copying to memory and back.
   // See the previous function for information about return values.
   // 
-  virtual void  CreateCodeToCopyFloatToInt(Function* method,
+  virtual void  CreateCodeToCopyFloatToInt(Function* F,
                                            Value* val,
                                            Instruction* dest,
                                            std::vector<MachineInstr*>& minstr,
@@ -161,7 +161,7 @@ public:
 
  // create copy instruction(s)
   virtual void CreateCopyInstructionsByType(const TargetMachine& target,
-                                            Function* method,
+                                            Function* F,
                                             Value* src,
                                             Instruction* dest,
                                             std::vector<MachineInstr*>& minstr) const;
@@ -224,7 +224,7 @@ class UltraSparcRegInfo : public MachineRegInfo {
   // ========================  Private Methods =============================
 
   // The following methods are used to color special live ranges (e.g.
-  // method args and return values etc.) with specific hardware registers
+  // function args and return values etc.) with specific hardware registers
   // as required. See SparcRegInfo.cpp for the implementation.
   //
   void setCallOrRetArgCol(LiveRange *LR, unsigned RegNo,
@@ -251,7 +251,7 @@ class UltraSparcRegInfo : public MachineRegInfo {
   unsigned getCallInstNumArgs(const MachineInstr *CallMI) const;
 
 
-  // The following 3  methods are used to find the RegType (see enum above)
+  // The following 3 methods are used to find the RegType (see enum above)
   // of a LiveRange, Value and using the unified RegClassID
   int getRegType(const LiveRange *LR) const;
   int getRegType(const Value *Val) const;
@@ -272,7 +272,7 @@ class UltraSparcRegInfo : public MachineRegInfo {
 
 
   // The following 2 methods are used to order the instructions addeed by
-  // the register allocator in association with method calling. See
+  // the register allocator in association with function calling. See
   // SparcRegInfo.cpp for more details
   //
   void moveInst2OrdVec(std::vector<MachineInstr *> &OrdVec,
@@ -344,7 +344,7 @@ public:
   virtual int getZeroRegNum() const;
 
   // getCallAddressReg - returns the reg used for pushing the address when a
-  // method is called. This can be used for other purposes between calls
+  // function is called. This can be used for other purposes between calls
   //
   unsigned getCallAddressReg() const;
 
@@ -357,7 +357,7 @@ public:
 
 
   // The following methods are used to color special live ranges (e.g.
-  // method args and return values etc.) with specific hardware registers
+  // function args and return values etc.) with specific hardware registers
   // as required. See SparcRegInfo.cpp for the implementation for Sparc.
   //
   void suggestRegs4MethodArgs(const Function *Meth, 
@@ -499,16 +499,16 @@ public:
   UltraSparcFrameInfo(const TargetMachine &tgt) : MachineFrameInfo(tgt) {}
   
 public:
-  int  getStackFrameSizeAlignment   () const { return StackFrameSizeAlignment;}
-  int  getMinStackFrameSize         () const { return MinStackFrameSize; }
-  int  getNumFixedOutgoingArgs      () const { return NumFixedOutgoingArgs; }
-  int  getSizeOfEachArgOnStack      () const { return SizeOfEachArgOnStack; }
-  bool argsOnStackHaveFixedSize     () const { return true; }
+  int  getStackFrameSizeAlignment() const { return StackFrameSizeAlignment;}
+  int  getMinStackFrameSize()       const { return MinStackFrameSize; }
+  int  getNumFixedOutgoingArgs()    const { return NumFixedOutgoingArgs; }
+  int  getSizeOfEachArgOnStack()    const { return SizeOfEachArgOnStack; }
+  bool argsOnStackHaveFixedSize()   const { return true; }
 
   //
   // These methods compute offsets using the frame contents for a
-  // particular method.  The frame contents are obtained from the
-  // MachineCodeInfoForMethod object for the given method.
+  // particular function.  The frame contents are obtained from the
+  // MachineCodeInfoForMethod object for the given function.
   // 
   int getFirstIncomingArgOffset  (MachineCodeForMethod& mcInfo,
                                   bool& growUp) const
@@ -623,7 +623,7 @@ public:
   virtual void addPassesToEmitAssembly(PassManager &PM, std::ostream &Out);
 
 private:
-  Pass *getMethodAsmPrinterPass(PassManager &PM, std::ostream &Out);
+  Pass *getFunctionAsmPrinterPass(PassManager &PM, std::ostream &Out);
   Pass *getModuleAsmPrinterPass(PassManager &PM, std::ostream &Out);
   Pass *getEmitBytecodeToAsmPass(std::ostream &Out);
 };
diff --git a/lib/Target/SparcV9/SparcV9PrologEpilogInserter.cpp b/lib/Target/SparcV9/SparcV9PrologEpilogInserter.cpp
index 2dad572020..17cd73bfc3 100644
--- a/lib/Target/SparcV9/SparcV9PrologEpilogInserter.cpp
+++ b/lib/Target/SparcV9/SparcV9PrologEpilogInserter.cpp
@@ -21,11 +21,11 @@
 
 namespace {
 
-class InsertPrologEpilogCode : public MethodPass {
+class InsertPrologEpilogCode : public FunctionPass {
   TargetMachine &Target;
 public:
   InsertPrologEpilogCode(TargetMachine &T) : Target(T) {}
-  bool runOnMethod(Function *F) {
+  bool runOnFunction(Function *F) {
     MachineCodeForMethod &mcodeInfo = MachineCodeForMethod::get(F);
     if (!mcodeInfo.isCompiledAsLeafMethod()) {
       InsertPrologCode(F);
diff --git a/lib/Target/SparcV9/SparcV9TargetMachine.cpp b/lib/Target/SparcV9/SparcV9TargetMachine.cpp
index de778e2562..306b85a227 100644
--- a/lib/Target/SparcV9/SparcV9TargetMachine.cpp
+++ b/lib/Target/SparcV9/SparcV9TargetMachine.cpp
@@ -126,21 +126,21 @@ UltraSparc::UltraSparc()
 // Native code generation for a specified target.
 //===---------------------------------------------------------------------===//
 
-class ConstructMachineCodeForFunction : public MethodPass {
+class ConstructMachineCodeForFunction : public FunctionPass {
   TargetMachine &Target;
 public:
   inline ConstructMachineCodeForFunction(TargetMachine &T) : Target(T) {}
-  bool runOnMethod(Function *F) {
+  bool runOnFunction(Function *F) {
     MachineCodeForMethod::construct(F, Target);
     return false;
   }
 };
 
-class InstructionSelection : public MethodPass {
+class InstructionSelection : public FunctionPass {
   TargetMachine &Target;
 public:
   inline InstructionSelection(TargetMachine &T) : Target(T) {}
-  bool runOnMethod(Function *F) {
+  bool runOnFunction(Function *F) {
     if (SelectInstructionsForMethod(F, Target)) {
       cerr << "Instr selection failed for function " << F->getName() << "\n";
       abort();
@@ -149,12 +149,12 @@ public:
   }
 };
 
-struct FreeMachineCodeForFunction : public MethodPass {
+struct FreeMachineCodeForFunction : public FunctionPass {
   static void freeMachineCode(Instruction *I) {
     MachineCodeForInstruction::destroy(I);
   }
   
-  bool runOnMethod(Function *F) {
+  bool runOnFunction(Function *F) {
     for (Function::iterator FI = F->begin(), FE = F->end(); FI != FE; ++FI)
       for (BasicBlock::iterator I = (*FI)->begin(), E = (*FI)->end();
            I != E; ++I)
@@ -197,7 +197,7 @@ void UltraSparc::addPassesToEmitAssembly(PassManager &PM, std::ostream &Out) {
   // allowing machine code representations for functions to be free'd after the
   // function has been emitted.
   //
-  PM.add(getMethodAsmPrinterPass(PM, Out));
+  PM.add(getFunctionAsmPrinterPass(PM, Out));
   PM.add(new FreeMachineCodeForFunction());  // Free stuff no longer needed
 
   // Emit Module level assembly after all of the functions have been processed.
diff --git a/lib/Transforms/HoistPHIConstants.cpp b/lib/Transforms/HoistPHIConstants.cpp
index 26cf5ca04f..f6e6109ea5 100644
--- a/lib/Transforms/HoistPHIConstants.cpp
+++ b/lib/Transforms/HoistPHIConstants.cpp
@@ -74,8 +74,8 @@ static bool doHoistPHIConstants(Function *M) {
 }
 
 namespace {
-  struct HoistPHIConstants : public MethodPass {
-    virtual bool runOnMethod(Function *F) { return doHoistPHIConstants(F); }
+  struct HoistPHIConstants : public FunctionPass {
+    virtual bool runOnFunction(Function *F) { return doHoistPHIConstants(F); }
   };
 }
 
diff --git a/lib/Transforms/IPO/ConstantMerge.cpp b/lib/Transforms/IPO/ConstantMerge.cpp
index ef51105a47..ee28b13a2c 100644
--- a/lib/Transforms/IPO/ConstantMerge.cpp
+++ b/lib/Transforms/IPO/ConstantMerge.cpp
@@ -58,8 +58,8 @@ bool mergeDuplicateConstants(Module *M, unsigned &ConstantNo,
 }
 
 namespace {
-  // FIXME: ConstantMerge should not be a methodPass!!!
-  class ConstantMerge : public MethodPass {
+  // FIXME: ConstantMerge should not be a FunctionPass!!!
+  class ConstantMerge : public FunctionPass {
   protected:
     std::map<Constant*, GlobalVariable*> Constants;
     unsigned LastConstantSeen;
@@ -73,7 +73,7 @@ namespace {
       return ::mergeDuplicateConstants(M, LastConstantSeen, Constants);
     }
     
-    bool runOnMethod(Function *) { return false; }
+    bool runOnFunction(Function *) { return false; }
     
     // doFinalization - Clean up internal state for this module
     //
@@ -85,10 +85,10 @@ namespace {
   };
   
   struct DynamicConstantMerge : public ConstantMerge {
-    // runOnMethod - Check to see if any globals have been added to the 
+    // runOnFunction - Check to see if any globals have been added to the 
     // global list for the module.  If so, eliminate them.
     //
-    bool runOnMethod(Function *F) {
+    bool runOnFunction(Function *F) {
       return ::mergeDuplicateConstants(F->getParent(), LastConstantSeen,
                                        Constants);
     }
diff --git a/lib/Transforms/IPO/DeadTypeElimination.cpp b/lib/Transforms/IPO/DeadTypeElimination.cpp
index 4f2e24d462..3ba6057fad 100644
--- a/lib/Transforms/IPO/DeadTypeElimination.cpp
+++ b/lib/Transforms/IPO/DeadTypeElimination.cpp
@@ -35,7 +35,7 @@ using std::cerr;
 static const Type *PtrSByte = 0;    // 'sbyte*' type
 
 namespace {
-  struct CleanupGCCOutput : public MethodPass {
+  struct CleanupGCCOutput : public FunctionPass {
     // 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.
@@ -46,18 +46,15 @@ namespace {
     
     // runOnFunction - This method simplifies the specified function hopefully.
     //
-    bool runOnMethod(Function *F);
+    bool runOnFunction(Function *F);
     
     // doPassFinalization - Strip out type names that are unused by the program
     bool doFinalization(Module *M);
     
-    // getAnalysisUsageInfo - This function needs FindUsedTypes to do its job...
+    // getAnalysisUsage - This function needs FindUsedTypes to do its job...
     //
-    virtual void getAnalysisUsageInfo(Pass::AnalysisSet &Required,
-                                      Pass::AnalysisSet &Destroyed,
-                                      Pass::AnalysisSet &Provided) {
-      // FIXME: Invalidates the CFG
-      Required.push_back(FindUsedTypes::ID);
+    virtual void getAnalysisUsage(AnalysisUsage &AU) const {
+      AU.addRequired(FindUsedTypes::ID);
     }
   };
 }
@@ -246,7 +243,7 @@ static inline void RefactorPredecessor(BasicBlock *BB, BasicBlock *Pred) {
 }
 
 
-// runOnMethod - Loop through the function and fix problems with the PHI nodes
+// runOnFunction - Loop through the function and fix problems with the PHI nodes
 // in the current function.  The problem is that PHI nodes might exist with
 // multiple entries for the same predecessor.  GCC sometimes generates code that
 // looks like this:
@@ -262,7 +259,7 @@ static inline void RefactorPredecessor(BasicBlock *BB, BasicBlock *Pred) {
 //  bb8: %reg119 = phi uint [ 0, %bbX ], [ 1, %bb7 ]
 //
 //
-bool CleanupGCCOutput::runOnMethod(Function *M) {
+bool CleanupGCCOutput::runOnFunction(Function *M) {
   bool Changed = false;
   // Don't use iterators because invalidation gets messy...
   for (unsigned MI = 0; MI < M->size(); ++MI) {
diff --git a/lib/Transforms/IPO/GlobalDCE.cpp b/lib/Transforms/IPO/GlobalDCE.cpp
index ae9bd39270..cd9c35f058 100644
--- a/lib/Transforms/IPO/GlobalDCE.cpp
+++ b/lib/Transforms/IPO/GlobalDCE.cpp
@@ -1,6 +1,7 @@
 //===-- GlobalDCE.cpp - DCE unreachable internal functions ----------------===//
 //
 // This transform is designed to eliminate unreachable internal globals
+// FIXME: GlobalDCE should update the callgraph, not destroy it!
 //
 //===----------------------------------------------------------------------===//
 
@@ -55,16 +56,12 @@ namespace {
       return RemoveUnreachableFunctions(M, getAnalysis<CallGraph>());
     }
 
-    // getAnalysisUsageInfo - This function works on the call graph of a module.
+    // getAnalysisUsage - This function works on the call graph of a module.
     // It is capable of updating the call graph to reflect the new state of the
     // module.
     //
-    virtual void getAnalysisUsageInfo(Pass::AnalysisSet &Required,
-                                      Pass::AnalysisSet &Destroyed,
-                                      Pass::AnalysisSet &Provided) {
-      Required.push_back(CallGraph::ID);
-      // FIXME: This should update the callgraph, not destroy it!
-      Destroyed.push_back(CallGraph::ID);
+    virtual void getAnalysisUsage(AnalysisUsage &AU) const {
+      AU.addRequired(CallGraph::ID);
     }
   };
 }
diff --git a/lib/Transforms/IPO/InlineSimple.cpp b/lib/Transforms/IPO/InlineSimple.cpp
index 7f96278265..fcb1e4fa40 100644
--- a/lib/Transforms/IPO/InlineSimple.cpp
+++ b/lib/Transforms/IPO/InlineSimple.cpp
@@ -53,7 +53,7 @@ static inline void RemapInstruction(Instruction *I,
   }
 }
 
-// InlineMethod - This function forcibly inlines the called function into the
+// InlineFunction - This function forcibly inlines the called function into the
 // basic block of the caller.  This returns false if it is not possible to
 // inline this call.  The program is still in a well defined state if this 
 // occurs though.
@@ -63,8 +63,8 @@ static inline void RemapInstruction(Instruction *I,
 // exists in the instruction stream.  Similiarly this will inline a recursive
 // function by one level.
 //
-bool InlineMethod(BasicBlock::iterator CIIt) {
-  assert(isa<CallInst>(*CIIt) && "InlineMethod only works on CallInst nodes!");
+bool InlineFunction(BasicBlock::iterator CIIt) {
+  assert(isa<CallInst>(*CIIt) && "InlineFunction only works on CallInst nodes");
   assert((*CIIt)->getParent() && "Instruction not embedded in basic block!");
   assert((*CIIt)->getParent()->getParent() && "Instruction not in function!");
 
@@ -209,7 +209,7 @@ bool InlineMethod(BasicBlock::iterator CIIt) {
   return true;
 }
 
-bool InlineMethod(CallInst *CI) {
+bool InlineFunction(CallInst *CI) {
   assert(CI->getParent() && "CallInst not embeded in BasicBlock!");
   BasicBlock *PBB = CI->getParent();
 
@@ -217,12 +217,12 @@ bool InlineMethod(CallInst *CI) {
 
   assert(CallIt != PBB->end() && 
 	 "CallInst has parent that doesn't contain CallInst?!?");
-  return InlineMethod(CallIt);
+  return InlineFunction(CallIt);
 }
 
 static inline bool ShouldInlineFunction(const CallInst *CI, const Function *F) {
   assert(CI->getParent() && CI->getParent()->getParent() && 
-	 "Call not embedded into a method!");
+	 "Call not embedded into a function!");
 
   // Don't inline a recursive call.
   if (CI->getParent()->getParent() == F) return false;
@@ -244,7 +244,7 @@ static inline bool DoFunctionInlining(BasicBlock *BB) {
       // Check to see if we should inline this function
       Function *F = CI->getCalledFunction();
       if (F && ShouldInlineFunction(CI, F))
-	return InlineMethod(I);
+	return InlineFunction(I);
     }
   }
   return false;
@@ -270,11 +270,11 @@ static bool doFunctionInlining(Function *F) {
 }
 
 namespace {
-  struct FunctionInlining : public MethodPass {
-    virtual bool runOnMethod(Function *F) {
+  struct FunctionInlining : public FunctionPass {
+    virtual bool runOnFunction(Function *F) {
       return doFunctionInlining(F);
     }
   };
 }
 
-Pass *createMethodInliningPass() { return new FunctionInlining(); }
+Pass *createFunctionInliningPass() { return new FunctionInlining(); }
diff --git a/lib/Transforms/IPO/MutateStructTypes.cpp b/lib/Transforms/IPO/MutateStructTypes.cpp
index b5dd937f7e..2a6d18460d 100644
--- a/lib/Transforms/IPO/MutateStructTypes.cpp
+++ b/lib/Transforms/IPO/MutateStructTypes.cpp
@@ -28,12 +28,6 @@
 using std::map;
 using std::vector;
 
-//FIXME: These headers are only included because the analyses are killed!!!
-#include "llvm/Analysis/CallGraph.h"
-#include "llvm/Analysis/FindUsedTypes.h"
-#include "llvm/Analysis/FindUnsafePointerTypes.h"
-//FIXME end
-
 // To enable debugging, uncomment this...
 //#define DEBUG_MST(x) x
 
@@ -273,7 +267,7 @@ void MutateStructTypes::processGlobals(Module *M) {
       if (Meth->hasName())
         Meth->setName("OLD."+Meth->getName());
 
-      // Insert the new function into the method list... to be filled in later..
+      // Insert the new function into the function list... to be filled in later
       M->getFunctionList().push_back(NewMeth);
       
       // Keep track of the association...
@@ -325,10 +319,10 @@ void MutateStructTypes::removeDeadGlobals(Module *M) {
 
 
 
-// transformMethod - This transforms the instructions of the function to use the
-// new types.
+// transformFunction - This transforms the instructions of the function to use
+// the new types.
 //
-void MutateStructTypes::transformMethod(Function *m) {
+void MutateStructTypes::transformFunction(Function *m) {
   const Function *M = m;
   map<const GlobalValue*, GlobalValue*>::iterator GMI = GlobalMap.find(M);
   if (GMI == GlobalMap.end())
@@ -518,19 +512,9 @@ bool MutateStructTypes::run(Module *M) {
   processGlobals(M);
 
   for_each(M->begin(), M->end(),
-           bind_obj(this, &MutateStructTypes::transformMethod));
+           bind_obj(this, &MutateStructTypes::transformFunction));
 
   removeDeadGlobals(M);
   return true;
 }
 
-// getAnalysisUsageInfo - This function needs the results of the
-// FindUsedTypes and FindUnsafePointerTypes analysis passes...
-//
-void MutateStructTypes::getAnalysisUsageInfo(Pass::AnalysisSet &Required,
-                                             Pass::AnalysisSet &Destroyed,
-                                             Pass::AnalysisSet &Provided) {
-  Destroyed.push_back(FindUsedTypes::ID);
-  Destroyed.push_back(FindUnsafePointerTypes::ID);
-  Destroyed.push_back(CallGraph::ID);
-}
diff --git a/lib/Transforms/IPO/OldPoolAllocate.cpp b/lib/Transforms/IPO/OldPoolAllocate.cpp
index 43683e4c35..bd67fe1cc9 100644
--- a/lib/Transforms/IPO/OldPoolAllocate.cpp
+++ b/lib/Transforms/IPO/OldPoolAllocate.cpp
@@ -234,12 +234,11 @@ namespace {
 
     bool run(Module *M);
 
-    // getAnalysisUsageInfo - This function requires data structure information
+    // getAnalysisUsage - This function requires data structure information
     // to be able to see what is pool allocatable.
     //
-    virtual void getAnalysisUsageInfo(Pass::AnalysisSet &Required,
-                                      Pass::AnalysisSet &,Pass::AnalysisSet &) {
-      Required.push_back(DataStructure::ID);
+    virtual void getAnalysisUsage(AnalysisUsage &AU) const {
+      AU.addRequired(DataStructure::ID);
     }
 
   public:
diff --git a/lib/Transforms/IPO/SimpleStructMutation.cpp b/lib/Transforms/IPO/SimpleStructMutation.cpp
index 5c64aa3537..33e0289504 100644
--- a/lib/Transforms/IPO/SimpleStructMutation.cpp
+++ b/lib/Transforms/IPO/SimpleStructMutation.cpp
@@ -1,4 +1,4 @@
-//===- SimpleStructMutation.cpp - Swap structure elements around ---*- C++ -*--=//
+//===- SimpleStructMutation.cpp - Swap structure elements around -*- C++ -*--=//
 //
 // This pass does a simple transformation that swaps all of the elements of the
 // struct types in the program around.
@@ -31,15 +31,13 @@ namespace {
       return Changed;
     }
     
-    // getAnalysisUsageInfo - This function needs the results of the
+    // getAnalysisUsage - This function needs the results of the
     // FindUsedTypes and FindUnsafePointerTypes analysis passes...
     //
-    virtual void getAnalysisUsageInfo(Pass::AnalysisSet &Required,
-                                      Pass::AnalysisSet &Destroyed,
-                                      Pass::AnalysisSet &Provided) {
-      Required.push_back(FindUsedTypes::ID);
-      Required.push_back(FindUnsafePointerTypes::ID);
-      MutateStructTypes::getAnalysisUsageInfo(Required, Destroyed, Provided);
+    virtual void getAnalysisUsage(AnalysisUsage &AU) const {
+      AU.addRequired(FindUsedTypes::ID);
+      AU.addRequired(FindUnsafePointerTypes::ID);
+      MutateStructTypes::getAnalysisUsage(AU);
     }
     
   private:
diff --git a/lib/Transforms/Instrumentation/ProfilePaths/ProfilePaths.cpp b/lib/Transforms/Instrumentation/ProfilePaths/ProfilePaths.cpp
index aa2cfdd218..860119e206 100644
--- a/lib/Transforms/Instrumentation/ProfilePaths/ProfilePaths.cpp
+++ b/lib/Transforms/Instrumentation/ProfilePaths/ProfilePaths.cpp
@@ -37,17 +37,15 @@
 
 using std::vector;
 
-class ProfilePaths: public MethodPass {
+class ProfilePaths: public FunctionPass {
  public:
-  bool runOnMethod(Function *M);
+  bool runOnFunction(Function *F);
 
   // Before this pass, make sure that there is only one 
   // entry and only one exit node for the function in the CFG of the function
   //
-  void ProfilePaths::getAnalysisUsageInfo(Pass::AnalysisSet &Requires,
-					  Pass::AnalysisSet &Destroyed,
-					  Pass::AnalysisSet &Provided) {
-    Requires.push_back(UnifyMethodExitNodes::ID);
+  void ProfilePaths::getAnalysisUsage(AnalysisUsage &AU) const {
+    AU.addRequired(UnifyMethodExitNodes::ID);
   }
 };
 
@@ -68,7 +66,7 @@ static Node *findBB(std::set<Node *> &st, BasicBlock *BB){
 }
 
 //Per function pass for inserting counters and trigger code
-bool ProfilePaths::runOnMethod(Function *M){
+bool ProfilePaths::runOnFunction(Function *M){
   //Transform the cfg s.t. we have just one exit node
   BasicBlock *ExitNode = 
     getAnalysis<UnifyMethodExitNodes>().getExitNode();  
diff --git a/lib/Transforms/Instrumentation/TraceValues.cpp b/lib/Transforms/Instrumentation/TraceValues.cpp
index 12fc84b347..d05d33dc72 100644
--- a/lib/Transforms/Instrumentation/TraceValues.cpp
+++ b/lib/Transforms/Instrumentation/TraceValues.cpp
@@ -23,7 +23,7 @@ using std::vector;
 using std::string;
 
 namespace {
-  class InsertTraceCode : public MethodPass {
+  class InsertTraceCode : public FunctionPass {
     bool TraceBasicBlockExits, TraceFunctionExits;
     Function *PrintfFunc;
   public:
@@ -46,14 +46,14 @@ namespace {
     
     // runOnFunction - This method does the work.
     //
-    bool runOnMethod(Function *F) {
+    bool runOnFunction(Function *F) {
       return doit(F, TraceBasicBlockExits, TraceFunctionExits, PrintfFunc);
     }
   };
 } // end anonymous namespace
 
 
-Pass *createTraceValuesPassForMethod() {       // Just trace functions
+Pass *createTraceValuesPassForFunction() {     // Just trace functions
   return new InsertTraceCode(false, true);
 }
 
diff --git a/lib/Transforms/LevelRaise.cpp b/lib/Transforms/LevelRaise.cpp
index 51d863d10d..f556cedcd8 100644
--- a/lib/Transforms/LevelRaise.cpp
+++ b/lib/Transforms/LevelRaise.cpp
@@ -440,7 +440,7 @@ static bool DoRaisePass(Function *F) {
 }
 
 
-// RaisePointerReferences::doit - Raise a method representation to a higher
+// RaisePointerReferences::doit - Raise a function representation to a higher
 // level.
 //
 static bool doRPR(Function *F) {
@@ -458,7 +458,7 @@ static bool doRPR(Function *F) {
     cerr << "Looping: \n" << F;
 #endif
 
-    // Iterate over the method, refining it, until it converges on a stable
+    // Iterate over the function, refining it, until it converges on a stable
     // state
     LocalChange = false;
     while (DoRaisePass(F)) LocalChange = true;
@@ -470,8 +470,8 @@ static bool doRPR(Function *F) {
 }
 
 namespace {
-  struct RaisePointerReferences : public MethodPass {
-    virtual bool runOnMethod(Function *F) { return doRPR(F); }
+  struct RaisePointerReferences : public FunctionPass {
+    virtual bool runOnFunction(Function *F) { return doRPR(F); }
   };
 }
 
diff --git a/lib/Transforms/Scalar/ADCE.cpp b/lib/Transforms/Scalar/ADCE.cpp
index c129b5c5a8..71069c617c 100644
--- a/lib/Transforms/Scalar/ADCE.cpp
+++ b/lib/Transforms/Scalar/ADCE.cpp
@@ -29,7 +29,7 @@ using std::cerr;
 // It's public interface consists of a constructor and a doADCE() method.
 //
 class ADCE {
-  Function *M;                          // The method that we are working on...
+  Function *M;                          // The function that we are working on
   std::vector<Instruction*> WorkList;   // Instructions that just became live
   std::set<Instruction*>    LiveSet;    // The set of live instructions
   bool MadeChanges;
@@ -38,11 +38,11 @@ class ADCE {
   // The public interface for this class
   //
 public:
-  // ADCE Ctor - Save the method to operate on...
-  inline ADCE(Function *m) : M(m), MadeChanges(false) {}
+  // ADCE Ctor - Save the function to operate on...
+  inline ADCE(Function *f) : M(f), MadeChanges(false) {}
 
   // doADCE() - Run the Agressive Dead Code Elimination algorithm, returning
-  // true if the method was modified.
+  // true if the function was modified.
   bool doADCE(cfg::DominanceFrontier &CDG);
 
   //===--------------------------------------------------------------------===//
@@ -75,14 +75,14 @@ private:
 
 
 // doADCE() - Run the Agressive Dead Code Elimination algorithm, returning
-// true if the method was modified.
+// true if the function was modified.
 //
 bool ADCE::doADCE(cfg::DominanceFrontier &CDG) {
 #ifdef DEBUG_ADCE
   cerr << "Function: " << M;
 #endif
 
-  // Iterate over all of the instructions in the method, eliminating trivially
+  // Iterate over all of the instructions in the function, eliminating trivially
   // dead instructions, and marking instructions live that are known to be 
   // needed.  Perform the walk in depth first order so that we avoid marking any
   // instructions live in basic blocks that are unreachable.  These blocks will
@@ -173,7 +173,7 @@ bool ADCE::doADCE(cfg::DominanceFrontier &CDG) {
   if (EntryBlock && EntryBlock != M->front()) {
     if (isa<PHINode>(EntryBlock->front())) {
       // Cannot make the first block be a block with a PHI node in it! Instead,
-      // strip the first basic block of the method to contain no instructions,
+      // strip the first basic block of the function to contain no instructions,
       // then add a simple branch to the "real" entry node...
       //
       BasicBlock *E = M->front();
@@ -191,9 +191,9 @@ bool ADCE::doADCE(cfg::DominanceFrontier &CDG) {
 
 
     } else {
-      // We need to move the new entry block to be the first bb of the method.
+      // We need to move the new entry block to be the first bb of the function
       Function::iterator EBI = find(M->begin(), M->end(), EntryBlock);
-      std::swap(*EBI, *M->begin());// Exchange old location with start of method
+      std::swap(*EBI, *M->begin());  // Exchange old location with start of fn
       MadeChanges = true;
     }
   }
@@ -289,19 +289,17 @@ BasicBlock *ADCE::fixupCFG(BasicBlock *BB, std::set<BasicBlock*> &VisitedBlocks,
 }
 
 namespace {
-  struct AgressiveDCE : public MethodPass {
+  struct AgressiveDCE : public FunctionPass {
     // doADCE - Execute the Agressive Dead Code Elimination Algorithm
     //
-    virtual bool runOnMethod(Function *M) {
-      return ADCE(M).doADCE(
+    virtual bool runOnFunction(Function *F) {
+      return ADCE(F).doADCE(
    getAnalysis<cfg::DominanceFrontier>(cfg::DominanceFrontier::PostDomID));
     }
-    // getAnalysisUsageInfo - We require post dominance frontiers (aka Control
+    // getAnalysisUsage - We require post dominance frontiers (aka Control
     // Dependence Graph)
-    virtual void getAnalysisUsageInfo(Pass::AnalysisSet &Requires,
-                                      Pass::AnalysisSet &Destroyed,
-                                      Pass::AnalysisSet &Provided) {
-      Requires.push_back(cfg::DominanceFrontier::PostDomID);
+    virtual void getAnalysisUsage(AnalysisUsage &AU) const {
+      AU.addRequired(cfg::DominanceFrontier::PostDomID);
     }
   };
 }
diff --git a/lib/Transforms/Scalar/ConstantProp.cpp b/lib/Transforms/Scalar/ConstantProp.cpp
index 26d5c7d43e..a8cd02fed0 100644
--- a/lib/Transforms/Scalar/ConstantProp.cpp
+++ b/lib/Transforms/Scalar/ConstantProp.cpp
@@ -211,8 +211,8 @@ static bool DoConstPropPass(Function *F) {
 }
 
 namespace {
-  struct ConstantPropogation : public MethodPass {
-    inline bool runOnMethod(Function *F) {
+  struct ConstantPropogation : public FunctionPass {
+    inline bool runOnFunction(Function *F) {
       bool Modified = false;
 
       // Fold constants until we make no progress...
diff --git a/lib/Transforms/Scalar/DCE.cpp b/lib/Transforms/Scalar/DCE.cpp
index 6169730ce8..0d6f293cd0 100644
--- a/lib/Transforms/Scalar/DCE.cpp
+++ b/lib/Transforms/Scalar/DCE.cpp
@@ -9,7 +9,7 @@
 //     predecessor only has one successor.
 //   * Eliminates PHI nodes for basic blocks with a single predecessor
 //   * Eliminates a basic block that only contains an unconditional branch
-//   * Eliminates method prototypes that are not referenced
+//   * Eliminates function prototypes that are not referenced
 //
 // TODO: This should REALLY be worklist driven instead of iterative.  Right now,
 // we scan linearly through values, removing unused ones as we go.  The problem
@@ -163,13 +163,13 @@ static bool PropogatePredecessorsForPHIs(BasicBlock *BB, BasicBlock *Succ) {
 // iterator that designates the first element remaining after the block that
 // was deleted.
 //
-// WARNING:  The entry node of a method may not be simplified.
+// WARNING:  The entry node of a function may not be simplified.
 //
 bool SimplifyCFG(Function::iterator &BBIt) {
   BasicBlock *BB = *BBIt;
   Function *M = BB->getParent();
 
-  assert(BB && BB->getParent() && "Block not embedded in method!");
+  assert(BB && BB->getParent() && "Block not embedded in function!");
   assert(BB->getTerminator() && "Degenerate basic block encountered!");
   assert(BB->getParent()->front() != BB && "Can't Simplify entry block!");
 
@@ -258,7 +258,7 @@ bool SimplifyCFG(Function::iterator &BBIt) {
 	Pred->getInstList().push_back(Def);              // Add to end...
       }
       
-      // Remove basic block from the method... and advance iterator to the
+      // Remove basic block from the function... and advance iterator to the
       // next valid block...
       BB = M->getBasicBlocks().remove(BBIt);
 
@@ -303,7 +303,7 @@ static bool DoDCEPass(Function *F) {
 }
 
 // Remove unused global values - This removes unused global values of no
-// possible value.  This currently includes unused method prototypes and
+// possible value.  This currently includes unused function prototypes and
 // unitialized global variables.
 //
 static bool RemoveUnusedGlobalValues(Module *Mod) {
@@ -313,7 +313,7 @@ static bool RemoveUnusedGlobalValues(Module *Mod) {
     Function *Meth = *MI;
     if (Meth->isExternal() && Meth->use_size() == 0) {
       // No references to prototype?
-      //cerr << "Removing method proto: " << Meth->getName() << endl;
+      //cerr << "Removing function proto: " << Meth->getName() << endl;
       delete Mod->getFunctionList().remove(MI);  // Remove prototype
       // Remove moves iterator to point to the next one automatically
       Changed = true;
@@ -339,7 +339,7 @@ static bool RemoveUnusedGlobalValues(Module *Mod) {
 }
 
 namespace {
-  struct DeadCodeElimination : public MethodPass {
+  struct DeadCodeElimination : public FunctionPass {
 
     // Pass Interface...
     virtual bool doInitialization(Module *M) {
@@ -349,7 +349,7 @@ namespace {
     // It is possible that we may require multiple passes over the code to fully
     // eliminate dead code.  Iterate until we are done.
     //
-    virtual bool runOnMethod(Function *F) {
+    virtual bool runOnFunction(Function *F) {
       bool Changed = false;
       while (DoDCEPass(F)) Changed = true;
       return Changed;
diff --git a/lib/Transforms/Scalar/DecomposeMultiDimRefs.cpp b/lib/Transforms/Scalar/DecomposeMultiDimRefs.cpp
index 390cd953ef..0ec72c65e0 100644
--- a/lib/Transforms/Scalar/DecomposeMultiDimRefs.cpp
+++ b/lib/Transforms/Scalar/DecomposeMultiDimRefs.cpp
@@ -1,4 +1,4 @@
-//===- llvm/Transforms/DecomposeMultiDimRefs.cpp - Lower array refs to 1D -----=//
+//===- llvm/Transforms/DecomposeMultiDimRefs.cpp - Lower array refs to 1D ---=//
 //
 // DecomposeMultiDimRefs - 
 // Convert multi-dimensional references consisting of any combination
@@ -7,7 +7,7 @@
 // has at most one index (except structure references,
 // which need an extra leading index of [0]).
 //
-//===---------------------------------------------------------------------===//
+//===----------------------------------------------------------------------===//
 
 #include "llvm/Transforms/Scalar/DecomposeMultiDimRefs.h"
 #include "llvm/ConstantVals.h"
@@ -171,9 +171,13 @@ doDecomposeMultiDimRefs(Function *F)
 
 
 namespace {
-  struct DecomposeMultiDimRefsPass : public MethodPass {
-    virtual bool runOnMethod(Function *F) { return doDecomposeMultiDimRefs(F); }
+  struct DecomposeMultiDimRefsPass : public FunctionPass {
+    virtual bool runOnFunction(Function *F) {
+      return doDecomposeMultiDimRefs(F);
+    }
   };
 }
 
-Pass *createDecomposeMultiDimRefsPass() { return new DecomposeMultiDimRefsPass(); }
+Pass *createDecomposeMultiDimRefsPass() {
+  return new DecomposeMultiDimRefsPass();
+}
diff --git a/lib/Transforms/Scalar/IndVarSimplify.cpp b/lib/Transforms/Scalar/IndVarSimplify.cpp
index a388025531..40ee5c7f83 100644
--- a/lib/Transforms/Scalar/IndVarSimplify.cpp
+++ b/lib/Transforms/Scalar/IndVarSimplify.cpp
@@ -188,7 +188,7 @@ static bool TransformLoop(cfg::LoopInfo *Loops, cfg::Loop *Loop) {
 }
 
 static bool doit(Function *M, cfg::LoopInfo &Loops) {
-  // Induction Variables live in the header nodes of the loops of the method...
+  // Induction Variables live in the header nodes of the loops of the function
   return reduce_apply_bool(Loops.getTopLevelLoops().begin(),
                            Loops.getTopLevelLoops().end(),
                            std::bind1st(std::ptr_fun(TransformLoop), &Loops));
@@ -196,15 +196,13 @@ static bool doit(Function *M, cfg::LoopInfo &Loops) {
 
 
 namespace {
-  struct InductionVariableSimplify : public MethodPass {
-    virtual bool runOnMethod(Function *F) {
+  struct InductionVariableSimplify : public FunctionPass {
+    virtual bool runOnFunction(Function *F) {
       return doit(F, getAnalysis<cfg::LoopInfo>());
     }
     
-    virtual void getAnalysisUsageInfo(Pass::AnalysisSet &Required,
-                                      Pass::AnalysisSet &Destroyed,
-                                      Pass::AnalysisSet &Provided) {
-      Required.push_back(cfg::LoopInfo::ID);
+    virtual void getAnalysisUsage(AnalysisUsage &AU) const {
+      AU.addRequired(cfg::LoopInfo::ID);
     }
   };
 }
diff --git a/lib/Transforms/Scalar/InductionVars.cpp b/lib/Transforms/Scalar/InductionVars.cpp
index 9931a6b5d7..8e559a3d6c 100644
--- a/lib/Transforms/Scalar/InductionVars.cpp
+++ b/lib/Transforms/Scalar/InductionVars.cpp
@@ -183,7 +183,7 @@ static PHINode *InjectSimpleInductionVariable(cfg::Interval *Int) {
   Function *M = Header->getParent();
 
   if (M->hasSymbolTable()) {
-    // Only name the induction variable if the method isn't stripped.
+    // Only name the induction variable if the function isn't stripped.
     PHIName = "ind_var";
     AddName = "ind_var_next";
   }
@@ -353,7 +353,7 @@ static bool ProcessInterval(cfg::Interval *Int) {
 //
 static bool ProcessIntervalPartition(cfg::IntervalPartition &IP) {
   // This currently just prints out information about the interval structure
-  // of the method...
+  // of the function...
 #if 0
   static unsigned N = 0;
   cerr << "\n***********Interval Partition #" << (++N) << "************\n\n";
@@ -398,17 +398,14 @@ bool InductionVariableCannonicalize::doIt(Function *M,
 }
 
 
-bool InductionVariableCannonicalize::runOnMethod(Function *F) {
+bool InductionVariableCannonicalize::runOnFunction(Function *F) {
   return doIt(F, getAnalysis<cfg::IntervalPartition>());
 }
 
-// getAnalysisUsageInfo - This function works on the call graph of a module.
+// getAnalysisUsage - This function works on the call graph of a module.
 // It is capable of updating the call graph to reflect the new state of the
 // module.
 //
-void InductionVariableCannonicalize::getAnalysisUsageInfo(
-                                           Pass::AnalysisSet &Required,
-                                           Pass::AnalysisSet &Destroyed,
-                                           Pass::AnalysisSet &Provided) {
-  Required.push_back(cfg::IntervalPartition::ID);
+void InductionVariableCannonicalize::getAnalysisUsage(AnalysisUsage &AU) const {
+  AU.addRequired(cfg::IntervalPartition::ID);
 }
diff --git a/lib/Transforms/Scalar/InstructionCombining.cpp b/lib/Transforms/Scalar/InstructionCombining.cpp
index c2fa84c21f..dea024442d 100644
--- a/lib/Transforms/Scalar/InstructionCombining.cpp
+++ b/lib/Transforms/Scalar/InstructionCombining.cpp
@@ -27,7 +27,7 @@
 
 
 namespace {
-  class InstCombiner : public MethodPass,
+  class InstCombiner : public FunctionPass,
                        public InstVisitor<InstCombiner, Instruction*> {
     // Worklist of all of the instructions that need to be simplified.
     std::vector<Instruction*> WorkList;
@@ -44,7 +44,7 @@ namespace {
   public:
 
 
-    virtual bool runOnMethod(Function *F);
+    virtual bool runOnFunction(Function *F);
 
     // Visitation implementation - Implement instruction combining for different
     // instruction types.  The semantics are as follows:
@@ -205,7 +205,7 @@ Instruction *InstCombiner::visitMemAccessInst(MemAccessInst *MAI) {
 }
 
 
-bool InstCombiner::runOnMethod(Function *F) {
+bool InstCombiner::runOnFunction(Function *F) {
   bool Changed = false;
 
   WorkList.insert(WorkList.end(), inst_begin(F), inst_end(F));
diff --git a/lib/Transforms/Scalar/SCCP.cpp b/lib/Transforms/Scalar/SCCP.cpp
index 51a827d14b..e723fc833b 100644
--- a/lib/Transforms/Scalar/SCCP.cpp
+++ b/lib/Transforms/Scalar/SCCP.cpp
@@ -34,9 +34,7 @@
 using std::cerr;
 
 // InstVal class - This class represents the different lattice values that an 
-// instruction may occupy.  It is a simple class with value semantics.  The
-// potential constant value that is pointed to is owned by the constant pool
-// for the method being optimized.
+// instruction may occupy.  It is a simple class with value semantics.
 //
 class InstVal {
   enum { 
@@ -83,7 +81,7 @@ public:
 // SCCP Class
 //
 // This class does all of the work of Sparse Conditional Constant Propogation.
-// It's public interface consists of a constructor and a doSCCP() method.
+// It's public interface consists of a constructor and a doSCCP() function.
 //
 class SCCP : public InstVisitor<SCCP> {
   Function *M;                           // The function that we are working on
@@ -99,11 +97,11 @@ class SCCP : public InstVisitor<SCCP> {
   //
 public:
 
-  // SCCP Ctor - Save the method to operate on...
+  // SCCP Ctor - Save the function to operate on...
   inline SCCP(Function *f) : M(f) {}
 
   // doSCCP() - Run the Sparse Conditional Constant Propogation algorithm, and 
-  // return true if the method was modified.
+  // return true if the function was modified.
   bool doSCCP();
 
   //===--------------------------------------------------------------------===//
@@ -212,10 +210,10 @@ private:
 
 
 // doSCCP() - Run the Sparse Conditional Constant Propogation algorithm, and 
-// return true if the method was modified.
+// return true if the function was modified.
 //
 bool SCCP::doSCCP() {
-  // Mark the first block of the method as being executable...
+  // Mark the first block of the function as being executable...
   markExecutable(M->front());
 
   // Process the work lists until their are empty!
@@ -264,7 +262,7 @@ bool SCCP::doSCCP() {
 #endif
 
 
-  // Iterate over all of the instructions in a method, replacing them with
+  // Iterate over all of the instructions in a function, replacing them with
   // constants if we have found them to be of constant values.
   //
   bool MadeChanges = false;
@@ -467,8 +465,8 @@ namespace {
   // SCCPPass - Use Sparse Conditional Constant Propogation
   // to prove whether a value is constant and whether blocks are used.
   //
-  struct SCCPPass : public MethodPass {
-    inline bool runOnMethod(Function *F) {
+  struct SCCPPass : public FunctionPass {
+    inline bool runOnFunction(Function *F) {
       SCCP S(F);
       return S.doSCCP();
     }
diff --git a/lib/Transforms/Scalar/SymbolStripping.cpp b/lib/Transforms/Scalar/SymbolStripping.cpp
index a026fd673a..36b465ebb6 100644
--- a/lib/Transforms/Scalar/SymbolStripping.cpp
+++ b/lib/Transforms/Scalar/SymbolStripping.cpp
@@ -60,8 +60,8 @@ static bool doStripGlobalSymbols(Module *M) {
 }
 
 namespace {
-  struct SymbolStripping : public MethodPass {
-    virtual bool runOnMethod(Function *F) {
+  struct SymbolStripping : public FunctionPass {
+    virtual bool runOnFunction(Function *F) {
       return doSymbolStripping(F);
     }
   };
diff --git a/lib/Transforms/Utils/PromoteMemoryToRegister.cpp b/lib/Transforms/Utils/PromoteMemoryToRegister.cpp
index 6f220f8604..8726ed43e3 100644
--- a/lib/Transforms/Utils/PromoteMemoryToRegister.cpp
+++ b/lib/Transforms/Utils/PromoteMemoryToRegister.cpp
@@ -309,22 +309,20 @@ bool PromoteInstance::queuePhiNode(BasicBlock *bb, int i /*the alloca*/)
 
 
 namespace {
-  struct PromotePass : public MethodPass {
+  struct PromotePass : public FunctionPass {
 
-    // runOnMethod - To run this pass, first we calculate the alloca
+    // runOnFunction - To run this pass, first we calculate the alloca
     // instructions that are safe for promotion, then we promote each one.
     //
-    virtual bool runOnMethod(Function *F) {
+    virtual bool runOnFunction(Function *F) {
       return (bool)PromoteInstance(F, getAnalysis<DominanceFrontier>());
     }
     
 
-    // getAnalysisUsageInfo - We need dominance frontiers
+    // getAnalysisUsage - We need dominance frontiers
     //
-    virtual void getAnalysisUsageInfo(Pass::AnalysisSet &Requires,
-				      Pass::AnalysisSet &Destroyed,
-				      Pass::AnalysisSet &Provided) {
-      Requires.push_back(DominanceFrontier::ID);
+    virtual void getAnalysisUsage(AnalysisUsage &AU) const {
+      AU.addRequired(DominanceFrontier::ID);
     }
   };
 }
diff --git a/lib/VMCore/Dominators.cpp b/lib/VMCore/Dominators.cpp
index 71ee3d74cf..387b673f60 100644
--- a/lib/VMCore/Dominators.cpp
+++ b/lib/VMCore/Dominators.cpp
@@ -22,7 +22,7 @@ using std::set;
 AnalysisID cfg::DominatorSet::ID(AnalysisID::create<cfg::DominatorSet>());
 AnalysisID cfg::DominatorSet::PostDomID(AnalysisID::create<cfg::DominatorSet>());
 
-bool cfg::DominatorSet::runOnMethod(Function *F) {
+bool cfg::DominatorSet::runOnFunction(Function *F) {
   Doms.clear();   // Reset from the last time we were run...
 
   if (isPostDominator())
@@ -129,17 +129,16 @@ void cfg::DominatorSet::calcPostDominatorSet(Function *M) {
   } while (Changed);
 }
 
-// getAnalysisUsageInfo - This obviously provides a dominator set, but it also
-// uses the UnifyMethodExitNodes pass if building post-dominators
+// getAnalysisUsage - This obviously provides a dominator set, but it also
+// uses the UnifyFunctionExitNodes pass if building post-dominators
 //
-void cfg::DominatorSet::getAnalysisUsageInfo(Pass::AnalysisSet &Requires,
-                                             Pass::AnalysisSet &Destroyed,
-                                             Pass::AnalysisSet &Provided) {
+void cfg::DominatorSet::getAnalysisUsage(AnalysisUsage &AU) const {
+  AU.setPreservesAll();
   if (isPostDominator()) {
-    Provided.push_back(PostDomID);
-    Requires.push_back(UnifyMethodExitNodes::ID);
+    AU.addProvided(PostDomID);
+    AU.addRequired(UnifyMethodExitNodes::ID);
   } else {
-    Provided.push_back(ID);
+    AU.addProvided(ID);
   }
 }
 
diff --git a/lib/VMCore/Pass.cpp b/lib/VMCore/Pass.cpp
index 9596f5234e..14ebd50dd1 100644
--- a/lib/VMCore/Pass.cpp
+++ b/lib/VMCore/Pass.cpp
@@ -71,10 +71,10 @@ void PMDebug::PrintPassInformation(unsigned Depth, const char *Action,
 }
 
 void PMDebug::PrintAnalysisSetInfo(unsigned Depth, const char *Msg,
-                                   Pass *P, const Pass::AnalysisSet &Set) {
+                                   Pass *P, const std::vector<AnalysisID> &Set){
   if (PassDebugging >= PassDetails && !Set.empty()) {
     std::cerr << (void*)P << std::string(Depth*2+3, ' ') << Msg << " Analyses:";
-    for (unsigned i = 0; i < Set.size(); ++i) {
+    for (unsigned i = 0; i != Set.size(); ++i) {
       Pass *P = Set[i].createPass();   // Good thing this is just debug code...
       std::cerr << "  " << typeid(*P).name();
       delete P;
@@ -93,57 +93,54 @@ void Pass::dumpPassStructure(unsigned Offset = 0) {
 // Pass Implementation
 //
 
-void Pass::addToPassManager(PassManagerT<Module> *PM, AnalysisSet &Required,
-                            AnalysisSet &Destroyed, AnalysisSet &Provided) {
-  PM->addPass(this, Required, Destroyed, Provided);
+void Pass::addToPassManager(PassManagerT<Module> *PM, AnalysisUsage &AU) {
+  PM->addPass(this, AU);
 }
 
 //===----------------------------------------------------------------------===//
-// MethodPass Implementation
+// FunctionPass Implementation
 //
 
-// run - On a module, we run this pass by initializing, ronOnMethod'ing once
-// for every method in the module, then by finalizing.
+// run - On a module, we run this pass by initializing, runOnFunction'ing once
+// for every function in the module, then by finalizing.
 //
-bool MethodPass::run(Module *M) {
+bool FunctionPass::run(Module *M) {
   bool Changed = doInitialization(M);
   
   for (Module::iterator I = M->begin(), E = M->end(); I != E; ++I)
-    if (!(*I)->isExternal())      // Passes are not run on external methods!
-    Changed |= runOnMethod(*I);
+    if (!(*I)->isExternal())      // Passes are not run on external functions!
+    Changed |= runOnFunction(*I);
   
   return Changed | doFinalization(M);
 }
 
-// run - On a method, we simply initialize, run the method, then finalize.
+// run - On a function, we simply initialize, run the function, then finalize.
 //
-bool MethodPass::run(Function *F) {
-  if (F->isExternal()) return false;  // Passes are not run on external methods!
+bool FunctionPass::run(Function *F) {
+  if (F->isExternal()) return false;// Passes are not run on external functions!
 
-  return doInitialization(F->getParent()) | runOnMethod(F)
+  return doInitialization(F->getParent()) | runOnFunction(F)
        | doFinalization(F->getParent());
 }
 
-void MethodPass::addToPassManager(PassManagerT<Module> *PM,
-                                  AnalysisSet &Required, AnalysisSet &Destroyed,
-                                  AnalysisSet &Provided) {
-  PM->addPass(this, Required, Destroyed, Provided);
+void FunctionPass::addToPassManager(PassManagerT<Module> *PM,
+                                    AnalysisUsage &AU) {
+  PM->addPass(this, AU);
 }
 
-void MethodPass::addToPassManager(PassManagerT<Function> *PM,
-                                  AnalysisSet &Required, AnalysisSet &Destroyed,
-                                  AnalysisSet &Provided) {
-  PM->addPass(this, Required, Destroyed, Provided);
+void FunctionPass::addToPassManager(PassManagerT<Function> *PM,
+                                    AnalysisUsage &AU) {
+  PM->addPass(this, AU);
 }
 
 //===----------------------------------------------------------------------===//
 // BasicBlockPass Implementation
 //
 
-// To run this pass on a method, we simply call runOnBasicBlock once for each
-// method.
+// To run this pass on a function, we simply call runOnBasicBlock once for each
+// function.
 //
-bool BasicBlockPass::runOnMethod(Function *F) {
+bool BasicBlockPass::runOnFunction(Function *F) {
   bool Changed = false;
   for (Function::iterator I = F->begin(), E = F->end(); I != E; ++I)
     Changed |= runOnBasicBlock(*I);
@@ -159,16 +156,12 @@ bool BasicBlockPass::run(BasicBlock *BB) {
 }
 
 void BasicBlockPass::addToPassManager(PassManagerT<Function> *PM,
-                                      AnalysisSet &Required,
-                                      AnalysisSet &Destroyed,
-                                      AnalysisSet &Provided) {
-  PM->addPass(this, Required, Destroyed, Provided);
+                                      AnalysisUsage &AU) {
+  PM->addPass(this, AU);
 }
 
 void BasicBlockPass::addToPassManager(PassManagerT<BasicBlock> *PM,
-                                      AnalysisSet &Required,
-                                      AnalysisSet &Destroyed,
-                                      AnalysisSet &Provided) {
-  PM->addPass(this, Required, Destroyed, Provided);
+                                      AnalysisUsage &AU) {
+  PM->addPass(this, AU);
 }
 
diff --git a/lib/VMCore/PassManagerT.h b/lib/VMCore/PassManagerT.h
index 4c521f1a26..a8c8d579be 100644
--- a/lib/VMCore/PassManagerT.h
+++ b/lib/VMCore/PassManagerT.h
@@ -14,6 +14,7 @@
 
 #include "llvm/Pass.h"
 #include <string>
+#include <algorithm>
 
 //===----------------------------------------------------------------------===//
 // PMDebug class - a set of debugging functions, that are not to be
@@ -26,7 +27,7 @@ struct PMDebug {
   static void PrintPassStructure(Pass *P);
   static void PrintPassInformation(unsigned,const char*,Pass *, Value *);
   static void PrintAnalysisSetInfo(unsigned,const char*,Pass *P,
-                                   const Pass::AnalysisSet&);
+                                   const std::vector<AnalysisID> &);
 };
 
 
@@ -107,15 +108,16 @@ public:
       PMDebug::PrintPassInformation(getDepth(), "Executing Pass", P, (Value*)M);
 
       // Get information about what analyses the pass uses...
-      std::vector<AnalysisID> Required, Destroyed, Provided;
-      P->getAnalysisUsageInfo(Required, Destroyed, Provided);
-      
-      PMDebug::PrintAnalysisSetInfo(getDepth(), "Required", P, Required);
+      AnalysisUsage AnUsage;
+      P->getAnalysisUsage(AnUsage);
+      PMDebug::PrintAnalysisSetInfo(getDepth(), "Required", P,
+                                    AnUsage.getRequiredSet());
 
 #ifndef NDEBUG
       // All Required analyses should be available to the pass as it runs!
-      for (Pass::AnalysisSet::iterator I = Required.begin(), 
-                                       E = Required.end(); I != E; ++I) {
+      for (vector<AnalysisID>::const_iterator
+             I = AnUsage.getRequiredSet().begin(), 
+             E = AnUsage.getRequiredSet().end(); I != E; ++I) {
         assert(getAnalysisOrNullUp(*I) && "Analysis used but not available!");
       }
 #endif
@@ -127,17 +129,35 @@ public:
       if (Changed)
         PMDebug::PrintPassInformation(getDepth()+1, "Made Modification", P,
                                       (Value*)M);
-      PMDebug::PrintAnalysisSetInfo(getDepth(), "Destroyed", P, Destroyed);
-      PMDebug::PrintAnalysisSetInfo(getDepth(), "Provided", P, Provided);
+      PMDebug::PrintAnalysisSetInfo(getDepth(), "Preserved", P,
+                                    AnUsage.getPreservedSet());
+      PMDebug::PrintAnalysisSetInfo(getDepth(), "Provided", P,
+                                    AnUsage.getProvidedSet());
+
+
+      // Erase all analyses not in the preserved set...
+      if (!AnUsage.preservesAll()) {
+        const std::vector<AnalysisID> &PreservedSet = AnUsage.getPreservedSet();
+        for (std::map<AnalysisID, Pass*>::iterator I = CurrentAnalyses.begin(),
+               E = CurrentAnalyses.end(); I != E; )
+          if (std::find(PreservedSet.begin(), PreservedSet.end(), I->first) !=
+              PreservedSet.end())
+            ++I; // This analysis is preserved, leave it in the available set...
+          else {
+#if MAP_DOESNT_HAVE_BROKEN_ERASE_MEMBER
+            I = CurrentAnalyses.erase(I);   // Analysis not preserved!
+#else
+            // GCC 2.95.3 STL doesn't have correct erase member!
+            CurrentAnalyses.erase(I);
+            I = CurrentAnalyses.begin();
+#endif
+          }
+      }
 
-      // Erase all analyses in the destroyed set...
-      for (Pass::AnalysisSet::iterator I = Destroyed.begin(), 
-             E = Destroyed.end(); I != E; ++I)
-        CurrentAnalyses.erase(*I);
-      
       // Add all analyses in the provided set...
-      for (Pass::AnalysisSet::iterator I = Provided.begin(),
-             E = Provided.end(); I != E; ++I)
+      for (std::vector<AnalysisID>::const_iterator
+             I = AnUsage.getProvidedSet().begin(),
+             E = AnUsage.getProvidedSet().end(); I != E; ++I)
         CurrentAnalyses[*I] = P;
 
       // Free memory for any passes that we are the last use of...
@@ -226,12 +246,13 @@ public:
   //
   void add(PassClass *P) {
     // Get information about what analyses the pass uses...
-    std::vector<AnalysisID> Required, Destroyed, Provided;
-    P->getAnalysisUsageInfo(Required, Destroyed, Provided);
+    AnalysisUsage AnUsage;
+    P->getAnalysisUsage(AnUsage);
+    const std::vector<AnalysisID> &Required = AnUsage.getRequiredSet();
 
     // Loop over all of the analyses used by this pass,
-    for (std::vector<AnalysisID>::iterator I = Required.begin(),
-                                           E = Required.end(); I != E; ++I) {
+    for (std::vector<AnalysisID>::const_iterator I = Required.begin(),
+           E = Required.end(); I != E; ++I) {
       if (getAnalysisOrNullDown(*I) == 0)
         add((PassClass*)I->createPass());
     }
@@ -240,7 +261,7 @@ public:
     // depends on the class of the pass, and is critical to laying out passes in
     // an optimal order..
     //
-    P->addToPassManager(this, Required, Destroyed, Provided);
+    P->addToPassManager(this, AnUsage);
   }
 
 private:
@@ -253,15 +274,17 @@ private:
   //
   // For generic Pass subclasses (which are interprocedural passes), we simply
   // add the pass to the end of the pass list and terminate any accumulation of
-  // MethodPasses that are present.
+  // FunctionPass's that are present.
   //
-  void addPass(PassClass *P, Pass::AnalysisSet &Required,
-               Pass::AnalysisSet &Destroyed, Pass::AnalysisSet &Provided) {
+  void addPass(PassClass *P, AnalysisUsage &AnUsage) {
+    const std::vector<AnalysisID> &RequiredSet = AnUsage.getRequiredSet();
+    const std::vector<AnalysisID> &ProvidedSet = AnUsage.getProvidedSet();
+
     // Providers are analysis classes which are forbidden to modify the module
     // they are operating on, so they are allowed to be reordered to before the
     // batcher...
     //
-    if (Batcher && Provided.empty())
+    if (Batcher && ProvidedSet.empty())
       closeBatcher();                     // This pass cannot be batched!
     
     // Set the Resolver instance variable in the Pass so that it knows where to 
@@ -274,34 +297,46 @@ private:
     // being used by this pass.  This is used to make sure that analyses are not
     // free'd before we have to use them...
     //
-    for (std::vector<AnalysisID>::iterator I = Required.begin(), 
-           E = Required.end(); I != E; ++I)
+    for (std::vector<AnalysisID>::const_iterator I = RequiredSet.begin(),
+           E = RequiredSet.end(); I != E; ++I)
       markPassUsed(*I, P);     // Mark *I as used by P
 
-    // Erase all analyses in the destroyed set...
-    for (std::vector<AnalysisID>::iterator I = Destroyed.begin(), 
-           E = Destroyed.end(); I != E; ++I)
-      CurrentAnalyses.erase(*I);
+    // Erase all analyses not in the preserved set...
+    if (!AnUsage.preservesAll()) {
+      const std::vector<AnalysisID> &PreservedSet = AnUsage.getPreservedSet();
+      for (std::map<AnalysisID, Pass*>::iterator I = CurrentAnalyses.begin(),
+             E = CurrentAnalyses.end(); I != E; )
+        if (std::find(PreservedSet.begin(), PreservedSet.end(), I->first) !=
+            PreservedSet.end())
+          ++I;  // This analysis is preserved, leave it in the available set...
+        else {
+#if MAP_DOESNT_HAVE_BROKEN_ERASE_MEMBER
+          I = CurrentAnalyses.erase(I);   // Analysis not preserved!
+#else
+          CurrentAnalyses.erase(I);// GCC 2.95.3 STL doesn't have correct erase!
+          I = CurrentAnalyses.begin();
+#endif
+        }
+    }
 
     // Add all analyses in the provided set...
-    for (std::vector<AnalysisID>::iterator I = Provided.begin(),
-           E = Provided.end(); I != E; ++I)
+    for (std::vector<AnalysisID>::const_iterator I = ProvidedSet.begin(),
+           E = ProvidedSet.end(); I != E; ++I)
       CurrentAnalyses[*I] = P;
 
     // For now assume that our results are never used...
     LastUseOf[P] = P;
   }
   
-  // For MethodPass subclasses, we must be sure to batch the MethodPasses
-  // together in a MethodPassBatcher object so that all of the analyses are run
-  // together a method at a time.
+  // For FunctionPass subclasses, we must be sure to batch the FunctionPass's
+  // together in a BatcherClass object so that all of the analyses are run
+  // together a function at a time.
   //
-  void addPass(SubPassClass *MP, Pass::AnalysisSet &Required,
-               Pass::AnalysisSet &Destroyed, Pass::AnalysisSet &Provided) {
+  void addPass(SubPassClass *MP, AnalysisUsage &AnUsage) {
     if (Batcher == 0) // If we don't have a batcher yet, make one now.
       Batcher = new BatcherClass(this);
     // The Batcher will queue them passes up
-    MP->addToPassManager(Batcher, Required, Destroyed, Provided);
+    MP->addToPassManager(Batcher, AnUsage);
   }
 
   // closeBatcher - Terminate the batcher that is being worked on.
@@ -364,12 +399,12 @@ template<> struct PassManagerTraits<BasicBlock> : public BasicBlockPass {
 //===----------------------------------------------------------------------===//
 // PassManagerTraits<Function> Specialization
 //
-// This pass manager is used to group together all of the MethodPass's
+// This pass manager is used to group together all of the FunctionPass's
 // into a single unit.
 //
-template<> struct PassManagerTraits<Function> : public MethodPass {
+template<> struct PassManagerTraits<Function> : public FunctionPass {
   // PassClass - The type of passes tracked by this PassManager
-  typedef MethodPass PassClass;
+  typedef FunctionPass PassClass;
 
   // SubPassClass - The types of classes that should be collated together
   typedef BasicBlockPass SubPassClass;
@@ -384,17 +419,17 @@ template<> struct PassManagerTraits<Function> : public MethodPass {
   typedef PassManagerT<Function> PMType;
 
   // runPass - Specify how the pass should be run on the UnitType
-  static bool runPass(PassClass *P, Function *M) {
-    return P->runOnMethod(M);
+  static bool runPass(PassClass *P, Function *F) {
+    return P->runOnFunction(F);
   }
 
   // getPMName() - Return the name of the unit the PassManager operates on for
   // debugging.
   const char *getPMName() const { return "Function"; }
 
-  // Implement the MethodPass interface...
+  // Implement the FunctionPass interface...
   virtual bool doInitialization(Module *M);
-  virtual bool runOnMethod(Function *M);
+  virtual bool runOnFunction(Function *F);
   virtual bool doFinalization(Module *M);
 };
 
@@ -410,7 +445,7 @@ template<> struct PassManagerTraits<Module> : public Pass {
   typedef Pass PassClass;
 
   // SubPassClass - The types of classes that should be collated together
-  typedef MethodPass SubPassClass;
+  typedef FunctionPass SubPassClass;
 
   // BatcherClass - The type to use for collation of subtypes...
   typedef PassManagerT<Function> BatcherClass;
@@ -467,8 +502,8 @@ inline bool PassManagerTraits<Function>::doInitialization(Module *M) {
   return Changed;
 }
 
-inline bool PassManagerTraits<Function>::runOnMethod(Function *M) {
-  return ((PMType*)this)->runOnUnit(M);
+inline bool PassManagerTraits<Function>::runOnFunction(Function *F) {
+  return ((PMType*)this)->runOnUnit(F);
 }
 
 inline bool PassManagerTraits<Function>::doFinalization(Module *M) {
diff --git a/lib/VMCore/Verifier.cpp b/lib/VMCore/Verifier.cpp
index 5c7f98b05b..691f1182c3 100644
--- a/lib/VMCore/Verifier.cpp
+++ b/lib/VMCore/Verifier.cpp
@@ -53,7 +53,7 @@
 
 namespace {  // Anonymous namespace for class
 
-  struct Verifier : public MethodPass, InstVisitor<Verifier> {
+  struct Verifier : public FunctionPass, InstVisitor<Verifier> {
     bool Broken;
 
     Verifier() : Broken(false) {}
@@ -63,7 +63,7 @@ namespace {  // Anonymous namespace for class
       return false;
     }
 
-    bool runOnMethod(Function *F) {
+    bool runOnFunction(Function *F) {
       visit(F);
       return false;
     }
diff --git a/tools/analyze/analyze.cpp b/tools/analyze/analyze.cpp
index a83ede3a05..141f0dfe69 100644
--- a/tools/analyze/analyze.cpp
+++ b/tools/analyze/analyze.cpp
@@ -90,30 +90,26 @@ public:
     return false;
   }
 
-  virtual void getAnalysisUsageInfo(Pass::AnalysisSet &Required,
-                                    Pass::AnalysisSet &Destroyed,
-                                    Pass::AnalysisSet &Provided) {
-    Required.push_back(ID);
+  virtual void getAnalysisUsage(AnalysisUsage &AU) const {
+    AU.addRequired(ID);
   }
 };
 
 template <class PassName>
-class PassPrinter<MethodPass, PassName> : public MethodPass {
+class PassPrinter<FunctionPass, PassName> : public FunctionPass {
   const string Message;
   const AnalysisID ID;
 public:
   PassPrinter(const string &M, AnalysisID id) : Message(M), ID(id) {}
   
-  virtual bool runOnMethod(Function *F) {
-    std::cout << Message << " on method '" << F->getName() << "'\n";
+  virtual bool runOnFunction(Function *F) {
+    std::cout << Message << " on function '" << F->getName() << "'\n";
     printPass(getAnalysis<PassName>(ID), std::cout, F);
     return false;
   }
 
-  virtual void getAnalysisUsageInfo(Pass::AnalysisSet &Required,
-                                    Pass::AnalysisSet &Destroyed,
-                                    Pass::AnalysisSet &Provided) {
-    Required.push_back(ID);
+  virtual void getAnalysisUsage(AnalysisUsage &AU) const {
+    AU.addRequired(ID);
   }
 };
 
@@ -137,13 +133,13 @@ Pass *NewPrintModule(const string &Message) {
   return new PrintModulePass(&std::cout);
 }
 
-struct InstForest : public MethodPass {
+struct InstForest : public FunctionPass {
   void doit(Function *F) {
     std::cout << analysis::InstForest<char>(F);
   }
 };
 
-struct IndVars : public MethodPass {
+struct IndVars : public FunctionPass {
   void doit(Function *F) {
     cfg::LoopInfo &LI = getAnalysis<cfg::LoopInfo>();
     for (inst_iterator I = inst_begin(F), E = inst_end(F); I != E; ++I)
@@ -154,13 +150,12 @@ struct IndVars : public MethodPass {
       }
   }
 
-  void getAnalysisUsageInfo(Pass::AnalysisSet &Req,
-                            Pass::AnalysisSet &, Pass::AnalysisSet &) {
-    Req.push_back(cfg::LoopInfo::ID);
+  void getAnalysisUsage(AnalysisUsage &AU) const {
+    AU.addRequired(cfg::LoopInfo::ID);
   }
 };
 
-struct Exprs : public MethodPass {
+struct Exprs : public FunctionPass {
   static void doit(Function *F) {
     std::cout << "Classified expressions for: " << F->getName() << "\n";
     for (inst_iterator I = inst_begin(F), E = inst_end(F); I != E; ++I) {
@@ -197,8 +192,8 @@ class PrinterPass : public TraitClass {
 public:
   PrinterPass(const string &M) : Message(M) {}
   
-  virtual bool runOnMethod(Function *F) {
-    std::cout << Message << " on method '" << F->getName() << "'\n";
+  virtual bool runOnFunction(Function *F) {
+    std::cout << Message << " on function '" << F->getName() << "'\n";
 
     TraitClass::doit(F);
     return false;
@@ -259,8 +254,8 @@ struct {
 } AnTable[] = {
   // Global analyses
   { print             , NewPrintFunction                        },
-  { intervals         , New<MethodPass, cfg::IntervalPartition> },
-  { loops             , New<MethodPass, cfg::LoopInfo>          },
+  { intervals         , New<FunctionPass, cfg::IntervalPartition> },
+  { loops             , New<FunctionPass, cfg::LoopInfo>        },
   { instforest        , Create<PrinterPass<InstForest> >        },
   { indvars           , Create<PrinterPass<IndVars> >           },
   { exprs             , Create<PrinterPass<Exprs> >             },
@@ -273,15 +268,15 @@ struct {
   { unsafepointertypes, New<Pass, FindUnsafePointerTypes> },
 
   // Dominator analyses
-  { domset            , New<MethodPass, cfg::DominatorSet>        },
-  { idom              , New<MethodPass, cfg::ImmediateDominators> },
-  { domtree           , New<MethodPass, cfg::DominatorTree>       },
-  { domfrontier       , New<MethodPass, cfg::DominanceFrontier>   },
-
-  { postdomset        , New<MethodPass, cfg::DominatorSet, cfg::DominatorSet::PostDomID> },
-  { postidom          , New<MethodPass, cfg::ImmediateDominators, cfg::ImmediateDominators::PostDomID> },
-  { postdomtree       , New<MethodPass, cfg::DominatorTree, cfg::DominatorTree::PostDomID> },
-  { postdomfrontier   , New<MethodPass, cfg::DominanceFrontier, cfg::DominanceFrontier::PostDomID> },
+  { domset            , New<FunctionPass, cfg::DominatorSet>        },
+  { idom              , New<FunctionPass, cfg::ImmediateDominators> },
+  { domtree           , New<FunctionPass, cfg::DominatorTree>       },
+  { domfrontier       , New<FunctionPass, cfg::DominanceFrontier>   },
+
+  { postdomset        , New<FunctionPass, cfg::DominatorSet, cfg::DominatorSet::PostDomID> },
+  { postidom          , New<FunctionPass, cfg::ImmediateDominators, cfg::ImmediateDominators::PostDomID> },
+  { postdomtree       , New<FunctionPass, cfg::DominatorTree, cfg::DominatorTree::PostDomID> },
+  { postdomfrontier   , New<FunctionPass, cfg::DominanceFrontier, cfg::DominanceFrontier::PostDomID> },
 };
 
 int main(int argc, char **argv) {
diff --git a/tools/llc/llc.cpp b/tools/llc/llc.cpp
index b365c3900d..802fd03729 100644
--- a/tools/llc/llc.cpp
+++ b/tools/llc/llc.cpp
@@ -88,7 +88,7 @@ int main(int argc, char **argv) {
     if (TraceValues == TraceBasicBlocks)
       Passes.add(createTraceValuesPassForBasicBlocks());
     else if (TraceValues == TraceFunctions)
-      Passes.add(createTraceValuesPassForMethod());
+      Passes.add(createTraceValuesPassForFunction());
     else
       assert(0 && "Bad value for TraceValues!");
 
diff --git a/tools/opt/opt.cpp b/tools/opt/opt.cpp
index f08567a6b8..f9ef9edd3c 100644
--- a/tools/opt/opt.cpp
+++ b/tools/opt/opt.cpp
@@ -70,35 +70,35 @@ struct {
   enum Opts OptID;
   Pass * (*PassCtor)();
 } OptTable[] = {
-  { dce        , createDeadCodeEliminationPass },
-  { die        , createDeadInstEliminationPass },
-  { constprop  , createConstantPropogationPass }, 
-  { inlining   , createMethodInliningPass },
-  { constmerge , createConstantMergePass },
-  { strip      , createSymbolStrippingPass },
-  { mstrip     , createFullSymbolStrippingPass },
+  { dce        , createDeadCodeEliminationPass  },
+  { die        , createDeadInstEliminationPass  },
+  { constprop  , createConstantPropogationPass  }, 
+  { inlining   , createFunctionInliningPass     },
+  { constmerge , createConstantMergePass        },
+  { strip      , createSymbolStrippingPass      },
+  { mstrip     , createFullSymbolStrippingPass  },
   { mergereturn, createUnifyMethodExitNodesPass },
 
-  { indvars    , createIndVarSimplifyPass },
-  { instcombine, createInstructionCombiningPass },
-  { sccp       , createSCCPPass },
-  { adce       , createAgressiveDCEPass },
+  { indvars    , createIndVarSimplifyPass         },
+  { instcombine, createInstructionCombiningPass   },
+  { sccp       , createSCCPPass                   },
+  { adce       , createAgressiveDCEPass           },
   { raise      , createRaisePointerReferencesPass },
-  { mem2reg    , createPromoteMemoryToRegister },
-  { lowerrefs,   createDecomposeMultiDimRefsPass },
+  { mem2reg    , createPromoteMemoryToRegister    },
+  { lowerrefs,   createDecomposeMultiDimRefsPass  },
 
   { trace      , createTraceValuesPassForBasicBlocks },
-  { tracem     , createTraceValuesPassForMethod },
-  { paths      , createProfilePathsPass },
+  { tracem     , createTraceValuesPassForFunction    },
+  { paths      , createProfilePathsPass  },
 
   { print      , createPrintFunctionPass },
-  { printm     , createPrintModulePass },
-  { verify     , createVerifierPass },
+  { printm     , createPrintModulePass   },
+  { verify     , createVerifierPass      },
 
-  { raiseallocs, createRaiseAllocationsPass },
-  { cleangcc   , createCleanupGCCOutputPass },
+  { raiseallocs, createRaiseAllocationsPass  },
+  { cleangcc   , createCleanupGCCOutputPass  },
   { funcresolve, createFunctionResolvingPass },
-  { globaldce  , createGlobalDCEPass },
+  { globaldce  , createGlobalDCEPass    },
   { swapstructs, createSwapElementsPass },
   { sortstructs, createSortElementsPass },
   { poolalloc  , createPoolAllocatePass },