Change references to the Method class to be references to the Function

class.  The Method class is obsolete (renamed) and all references to it
are being converted over to Function.

llvm-svn: 2144

2 files changed, 24 insertions, 27 deletions

diff --git a/llvm/lib/Transforms/Utils/PromoteMemoryToRegister.cpp b/llvm/lib/Transforms/Utils/PromoteMemoryToRegister.cpp
index f94632e3df9..79c03864d86 100644
--- a/llvm/lib/Transforms/Utils/PromoteMemoryToRegister.cpp
+++ b/llvm/lib/Transforms/Utils/PromoteMemoryToRegister.cpp
@@ -21,7 +21,7 @@
 #include "llvm/Analysis/Dominators.h"
 #include "llvm/iMemory.h"
 #include "llvm/Pass.h"
-#include "llvm/Method.h"
+#include "llvm/Function.h"
 #include "llvm/BasicBlock.h"
 #include "llvm/Assembly/Writer.h"  // For debugging
 #include "llvm/iPHINode.h"
@@ -34,8 +34,8 @@ using cfg::DominanceFrontier;
 
 namespace {
 
-//instance of the promoter -- to keep all the local method data.
-// gets re-created for each method processed
+//instance of the promoter -- to keep all the local function data.
+// gets re-created for each function processed
 class PromoteInstance
 {
 	protected:
@@ -54,15 +54,15 @@ class PromoteInstance
 
 
 	void traverse(BasicBlock *f, BasicBlock * predecessor);
-	bool PromoteMethod(Method *M, DominanceFrontier & DF);
+	bool PromoteFunction(Function *F, DominanceFrontier &DF);
 	bool queuePhiNode(BasicBlock *bb, int alloca_index);
-	void findSafeAllocas(Method *M);
+	void findSafeAllocas(Function *M);
 	bool didchange;
 	public:
 	// I do this so that I can force the deconstruction of the local variables
-	PromoteInstance(Method *M, DominanceFrontier & DF)
+	PromoteInstance(Function *F, DominanceFrontier &DF)
 	{
-		didchange=PromoteMethod(M, DF);
+		didchange=PromoteFunction(F, DF);
 	}
 	//This returns whether the pass changes anything
 	operator bool () { return didchange; }
@@ -72,9 +72,9 @@ class PromoteInstance
 
 // findSafeAllocas - Find allocas that are safe to promote
 //
-void PromoteInstance::findSafeAllocas(Method *M)  
+void PromoteInstance::findSafeAllocas(Function *F)  
 {
-  BasicBlock *BB = M->front();  // Get the entry node for the method
+  BasicBlock *BB = F->getEntryNode();  // Get the entry node for the function
 
   // Look at all instructions in the entry node
   for (BasicBlock::iterator I = BB->begin(), E = BB->end(); I != E; ++I)
@@ -107,9 +107,9 @@ void PromoteInstance::findSafeAllocas(Method *M)
 
 
 
-bool PromoteInstance::PromoteMethod(Method *M, DominanceFrontier & DF) {
+bool PromoteInstance::PromoteFunction(Function *F, DominanceFrontier & DF) {
 	// Calculate the set of safe allocas
-	findSafeAllocas(M);
+	findSafeAllocas(F);
 
 	// Add each alloca to the killlist
 	// note: killlist is destroyed MOST recently added to least recently.
@@ -158,10 +158,10 @@ bool PromoteInstance::PromoteMethod(Method *M, DominanceFrontier & DF) {
 		}
 	}
 
-	// Walks all basic blocks in the method
+	// Walks all basic blocks in the function
 	// performing the SSA rename algorithm
 	// and inserting the phi nodes we marked as necessary
-	BasicBlock * f = M->front(); //get root basic-block
+	BasicBlock * f = F->front(); //get root basic-block
 
 	CurrentValue.push_back(vector<Value *>(Allocas.size()));
 
@@ -309,16 +309,13 @@ bool PromoteInstance::queuePhiNode(BasicBlock *bb, int i /*the alloca*/)
 
 
 namespace {
-  class PromotePass : public MethodPass {
-  public:
+  struct PromotePass : public MethodPass {
 
     // runOnMethod - To run this pass, first we calculate the alloca
     // instructions that are safe for promotion, then we promote each one.
     //
-    virtual bool runOnMethod(Method *M)
-    {
-      PromoteInstance inst(M, getAnalysis<DominanceFrontier>());
-      return (bool)inst;
+    virtual bool runOnMethod(Function *F) {
+      return (bool)PromoteInstance(F, getAnalysis<DominanceFrontier>());
     }
     
 
diff --git a/llvm/lib/Transforms/Utils/UnifyFunctionExitNodes.cpp b/llvm/lib/Transforms/Utils/UnifyFunctionExitNodes.cpp
index da7b1f609ae..9a3b52c49cf 100644
--- a/llvm/lib/Transforms/Utils/UnifyFunctionExitNodes.cpp
+++ b/llvm/lib/Transforms/Utils/UnifyFunctionExitNodes.cpp
@@ -1,4 +1,4 @@
-//===- SimplifyCFG.cpp - CFG Simplification Routines -------------*- C++ -*--=//
+//===- UnifyFunctionExitNodes.cpp - Make all functions have a single exit -===//
 //
 // This file provides several routines that are useful for simplifying CFGs in
 // various ways...
@@ -7,7 +7,7 @@
 
 #include "llvm/Transforms/UnifyMethodExitNodes.h"
 #include "llvm/BasicBlock.h"
-#include "llvm/Method.h"
+#include "llvm/Function.h"
 #include "llvm/iTerminators.h"
 #include "llvm/iPHINode.h"
 #include "llvm/Type.h"
@@ -20,14 +20,14 @@ AnalysisID UnifyMethodExitNodes::ID(AnalysisID::create<UnifyMethodExitNodes>());
 // BasicBlock, and converting all returns to unconditional branches to this
 // new basic block.  The singular exit node is returned.
 //
-// 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.
 //
-bool UnifyMethodExitNodes::doit(Method *M, BasicBlock *&ExitNode) {
-  // Loop over all of the blocks in a method, tracking all of the blocks that
+bool UnifyMethodExitNodes::doit(Function *M, BasicBlock *&ExitNode) {
+  // Loop over all of the blocks in a function, tracking all of the blocks that
   // return.
   //
   vector<BasicBlock*> ReturningBlocks;
-  for(Method::iterator I = M->begin(), E = M->end(); I != E; ++I)
+  for(Function::iterator I = M->begin(), E = M->end(); I != E; ++I)
     if (isa<ReturnInst>((*I)->getTerminator()))
       ReturningBlocks.push_back(*I);
 
@@ -39,14 +39,14 @@ bool UnifyMethodExitNodes::doit(Method *M, BasicBlock *&ExitNode) {
     return false;
   }
 
-  // Otherwise, we need to insert a new basic block into the method, add a PHI
+  // Otherwise, we need to insert a new basic block into the function, add a PHI
   // node (if the function returns a value), and convert all of the return 
   // instructions into unconditional branches.
   //
   BasicBlock *NewRetBlock = new BasicBlock("UnifiedExitNode", M);
 
   if (M->getReturnType() != Type::VoidTy) {
-    // If the method doesn't return void... add a PHI node to the block...
+    // If the function doesn't return void... add a PHI node to the block...
     PHINode *PN = new PHINode(M->getReturnType());
     NewRetBlock->getInstList().push_back(PN);