Changed `MachineCodeForMethod' to `MachineFunction'.

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

diff --git a/include/llvm/CodeGen/MachineBasicBlock.h b/include/llvm/CodeGen/MachineBasicBlock.h
index a95103f35fd8105352aca93c0a705396aee8a344..1a3c7a00f64fdb9d169be092af48c77b114b1a1c 100644 (file)
--- a/include/llvm/CodeGen/MachineBasicBlock.h
+++ b/include/llvm/CodeGen/MachineBasicBlock.h
@@ -1,27 +1,31 @@
-//===-- llvm/CodeGen/MachineCodeForBasicBlock.h -----------------*- C++ -*--=//
+//===-- llvm/CodeGen/MachineBasicBlock.h ------------------------*- C++ -*--=//
 // 
 // Collect the sequence of machine instructions for a basic block.
 //
 //===---------------------------------------------------------------------===//
 
-#ifndef LLVM_CODEGEN_MACHINECODEFORBASICBLOCK_H
-#define LLVM_CODEGEN_MACHINECODEFORBASICBLOCK_H
+#ifndef LLVM_CODEGEN_MACHINEBASICBLOCK_H
+#define LLVM_CODEGEN_MACHINEBASICBLOCK_H
 
 #include "llvm/BasicBlock.h"
 class MachineInstr;
 
 extern AnnotationID MCFBB_AID;
 
-class MachineCodeForBasicBlock : public Annotation {
+// FIXME: this should go away soon
+class MachineBasicBlock;
+typedef MachineBasicBlock MachineCodeForBasicBlock;
+
+class MachineBasicBlock: public Annotation {
   std::vector<MachineInstr*> Insts;
 public:
-  MachineCodeForBasicBlock();
-  ~MachineCodeForBasicBlock() {}
+  MachineBasicBlock();
+  ~MachineBasicBlock() {}
   
-  // Static methods to retrieve or destroy the MachineCodeForBasicBlock
+  // Static methods to retrieve or destroy the MachineBasicBlock
   // object for a given basic block.
-  static MachineCodeForBasicBlock& get(const BasicBlock *bb) {
-    return *(MachineCodeForBasicBlock*)bb->getOrCreateAnnotation(MCFBB_AID);
+  static MachineBasicBlock& get(const BasicBlock *bb) {
+    return *(MachineBasicBlock*)bb->getOrCreateAnnotation(MCFBB_AID);
   }
   
   static void destroy(const BasicBlock *bb) {

diff --git a/include/llvm/CodeGen/MachineCodeForBasicBlock.h b/include/llvm/CodeGen/MachineCodeForBasicBlock.h
index a95103f35fd8105352aca93c0a705396aee8a344..1a3c7a00f64fdb9d169be092af48c77b114b1a1c 100644 (file)
--- a/include/llvm/CodeGen/MachineCodeForBasicBlock.h
+++ b/include/llvm/CodeGen/MachineCodeForBasicBlock.h
@@ -1,27 +1,31 @@
-//===-- llvm/CodeGen/MachineCodeForBasicBlock.h -----------------*- C++ -*--=//
+//===-- llvm/CodeGen/MachineBasicBlock.h ------------------------*- C++ -*--=//
 // 
 // Collect the sequence of machine instructions for a basic block.
 //
 //===---------------------------------------------------------------------===//
 
-#ifndef LLVM_CODEGEN_MACHINECODEFORBASICBLOCK_H
-#define LLVM_CODEGEN_MACHINECODEFORBASICBLOCK_H
+#ifndef LLVM_CODEGEN_MACHINEBASICBLOCK_H
+#define LLVM_CODEGEN_MACHINEBASICBLOCK_H
 
 #include "llvm/BasicBlock.h"
 class MachineInstr;
 
 extern AnnotationID MCFBB_AID;
 
-class MachineCodeForBasicBlock : public Annotation {
+// FIXME: this should go away soon
+class MachineBasicBlock;
+typedef MachineBasicBlock MachineCodeForBasicBlock;
+
+class MachineBasicBlock: public Annotation {
   std::vector<MachineInstr*> Insts;
 public:
-  MachineCodeForBasicBlock();
-  ~MachineCodeForBasicBlock() {}
+  MachineBasicBlock();
+  ~MachineBasicBlock() {}
   
-  // Static methods to retrieve or destroy the MachineCodeForBasicBlock
+  // Static methods to retrieve or destroy the MachineBasicBlock
   // object for a given basic block.
-  static MachineCodeForBasicBlock& get(const BasicBlock *bb) {
-    return *(MachineCodeForBasicBlock*)bb->getOrCreateAnnotation(MCFBB_AID);
+  static MachineBasicBlock& get(const BasicBlock *bb) {
+    return *(MachineBasicBlock*)bb->getOrCreateAnnotation(MCFBB_AID);
   }
   
   static void destroy(const BasicBlock *bb) {

diff --git a/include/llvm/CodeGen/MachineCodeForMethod.h b/include/llvm/CodeGen/MachineCodeForMethod.h
index 742d4b5c0f851727fa9d0440213d42c5188316d8..00f3cdee584144aa239df1bc7ae33d7e329677f7 100644 (file)
--- a/include/llvm/CodeGen/MachineCodeForMethod.h
+++ b/include/llvm/CodeGen/MachineCodeForMethod.h
@@ -1,4 +1,4 @@
-//===-- llvm/CodeGen/MachineCodeForMethod.h ----------------------*- C++ -*--=//
+//===-- llvm/CodeGen/MachineFunction.h ----------------------*- C++ -*--=//
 // 
 // Purpose:
 //   Collect native machine code information for a method.
@@ -6,8 +6,8 @@
 //   to be stored with each method.
 //===----------------------------------------------------------------------===//
 
-#ifndef LLVM_CODEGEN_MACHINECODEFORMETHOD_H
-#define LLVM_CODEGEN_MACHINECODEFORMETHOD_H
+#ifndef LLVM_CODEGEN_MACHINEFUNCTION_H
+#define LLVM_CODEGEN_MACHINEFUNCTION_H
 
 #include "llvm/Annotation.h"
 #include "Support/NonCopyable.h"
@@ -19,8 +19,11 @@ class Constant;
 class Type;
 class TargetMachine;
 
+// FIXME: this should go away soon
+class MachineFunction;
+typedef MachineFunction MachineCodeForMethod;
 
-class MachineCodeForMethod : private Annotation {
+class MachineFunction : private Annotation {
   hash_set<const Constant*> constantsForConstPool;
   hash_map<const Value*, int> offsets;
   const         Function* method;
@@ -36,20 +39,20 @@ class MachineCodeForMethod : private Annotation {
   bool          automaticVarsAreaFrozen;
   
 public:
-  /*ctor*/      MachineCodeForMethod(const Function* function,
+  /*ctor*/      MachineFunction(const Function* function,
                                      const TargetMachine& target);
   
   // The next two methods are used to construct and to retrieve
-  // the MachineCodeForMethod object for the given method.
+  // the MachineFunction object for the given method.
   // construct() -- Allocates and initializes for a given method and target
   // get()       -- Returns a handle to the object.
   //                This should not be called before "construct()"
   //                for a given Method.
   // 
-  static MachineCodeForMethod& construct(const Function *method,
+  static MachineFunction& construct(const Function *method,
                                          const TargetMachine &target);
   static void destruct(const Function *F);
-  static MachineCodeForMethod& get(const Function* function);
+  static MachineFunction& get(const Function* function);
   
   //
   // Accessors for global information about generated code for a method.

diff --git a/include/llvm/CodeGen/MachineFunction.h b/include/llvm/CodeGen/MachineFunction.h
index 742d4b5c0f851727fa9d0440213d42c5188316d8..141838f6003fd144e2b564bdfc3317bb9c140bc6 100644 (file)
--- a/include/llvm/CodeGen/MachineFunction.h
+++ b/include/llvm/CodeGen/MachineFunction.h
@@ -1,13 +1,13 @@
-//===-- llvm/CodeGen/MachineCodeForMethod.h ----------------------*- C++ -*--=//
+//===-- llvm/CodeGen/MachineFunction.h ---------------------------*- C++ -*--=//
 // 
-// Purpose:
-//   Collect native machine code information for a method.
-//   This allows target-specific information about the generated code
-//   to be stored with each method.
+// Collect native machine code information for a method.  This allows
+// target-specific information about the generated code to be stored with each
+// method.
+//   
 //===----------------------------------------------------------------------===//
 
-#ifndef LLVM_CODEGEN_MACHINECODEFORMETHOD_H
-#define LLVM_CODEGEN_MACHINECODEFORMETHOD_H
+#ifndef LLVM_CODEGEN_MACHINEFUNCTION_H
+#define LLVM_CODEGEN_MACHINEFUNCTION_H
 
 #include "llvm/Annotation.h"
 #include "Support/NonCopyable.h"
@@ -20,7 +20,7 @@ class Type;
 class TargetMachine;
 
 
-class MachineCodeForMethod : private Annotation {
+class MachineFunction : private Annotation {
   hash_set<const Constant*> constantsForConstPool;
   hash_map<const Value*, int> offsets;
   const         Function* method;
@@ -36,20 +36,20 @@ class MachineCodeForMethod : private Annotation {
   bool          automaticVarsAreaFrozen;
   
 public:
-  /*ctor*/      MachineCodeForMethod(const Function* function,
-                                     const TargetMachine& target);
+  /*ctor*/      MachineFunction(const Function* function,
+                                const TargetMachine& target);
   
   // The next two methods are used to construct and to retrieve
-  // the MachineCodeForMethod object for the given method.
+  // the MachineFunction object for the given method.
   // construct() -- Allocates and initializes for a given method and target
   // get()       -- Returns a handle to the object.
   //                This should not be called before "construct()"
   //                for a given Method.
   // 
-  static MachineCodeForMethod& construct(const Function *method,
+  static MachineFunction& construct(const Function *method,
                                          const TargetMachine &target);
   static void destruct(const Function *F);
-  static MachineCodeForMethod& get(const Function* function);
+  static MachineFunction& get(const Function* function);
   
   //
   // Accessors for global information about generated code for a method.

diff --git a/include/llvm/Target/MachineInstrInfo.h b/include/llvm/Target/MachineInstrInfo.h
index 6bfe7e5d67fc221c4f45192e2ed36d9ad767a46f..8fe4d3b4f6f9fa4a1534367feea621002eee29cb 100644 (file)
--- a/include/llvm/Target/MachineInstrInfo.h
+++ b/include/llvm/Target/MachineInstrInfo.h
@@ -275,7 +275,7 @@ public:
   // The generated instructions are returned in `mvec'.
   // Any temp. registers (TmpInstruction) created are recorded in mcfi.
   // Symbolic constants or constants that must be accessed from memory
-  // are added to the constant pool via MachineCodeForMethod::get(F).
+  // are added to the constant pool via MachineFunction::get(F).
   // 
   virtual void  CreateCodeToLoadConst(const TargetMachine& target,
                                       Function* F,

diff --git a/include/llvm/Target/TargetFrameInfo.h b/include/llvm/Target/TargetFrameInfo.h
index c6d2a943164206538711900e6ed96d8393f7f563..699966a35e766e0e63c0b45d992426da58b84482 100644 (file)
--- a/include/llvm/Target/TargetFrameInfo.h
+++ b/include/llvm/Target/TargetFrameInfo.h
@@ -10,7 +10,7 @@
 #include "Support/NonCopyable.h"
 #include <vector>
 
-class MachineCodeForMethod;
+class MachineFunction;
 class TargetMachine;
 
 struct MachineFrameInfo : public NonCopyableV {
@@ -41,24 +41,24 @@ public:
   // The first few methods have default machine-independent implementations.
   // The rest must be implemented by the machine-specific subclass.
   // 
-  virtual int getIncomingArgOffset              (MachineCodeForMethod& mcInfo,
+  virtual int getIncomingArgOffset              (MachineFunction& mcInfo,
                                                  unsigned argNum) const;
-  virtual int getOutgoingArgOffset              (MachineCodeForMethod& mcInfo,
+  virtual int getOutgoingArgOffset              (MachineFunction& mcInfo,
                                                  unsigned argNum) const;
   
-  virtual int getFirstIncomingArgOffset         (MachineCodeForMethod& mcInfo,
+  virtual int getFirstIncomingArgOffset         (MachineFunction& mcInfo,
                                                  bool& growUp) const=0;
-  virtual int getFirstOutgoingArgOffset         (MachineCodeForMethod& mcInfo,
+  virtual int getFirstOutgoingArgOffset         (MachineFunction& mcInfo,
                                                  bool& growUp) const=0;
-  virtual int getFirstOptionalOutgoingArgOffset (MachineCodeForMethod&,
+  virtual int getFirstOptionalOutgoingArgOffset (MachineFunction&,
                                                  bool& growUp) const=0;
-  virtual int getFirstAutomaticVarOffset        (MachineCodeForMethod& mcInfo,
+  virtual int getFirstAutomaticVarOffset        (MachineFunction& mcInfo,
                                                  bool& growUp) const=0;
-  virtual int getRegSpillAreaOffset             (MachineCodeForMethod& mcInfo,
+  virtual int getRegSpillAreaOffset             (MachineFunction& mcInfo,
                                                  bool& growUp) const=0;
-  virtual int getTmpAreaOffset                  (MachineCodeForMethod& mcInfo,
+  virtual int getTmpAreaOffset                  (MachineFunction& mcInfo,
                                                  bool& growUp) const=0;
-  virtual int getDynamicAreaOffset              (MachineCodeForMethod& mcInfo,
+  virtual int getDynamicAreaOffset              (MachineFunction& mcInfo,
                                                  bool& growUp) const=0;
 
   //

diff --git a/include/llvm/Target/TargetInstrInfo.h b/include/llvm/Target/TargetInstrInfo.h
index 6bfe7e5d67fc221c4f45192e2ed36d9ad767a46f..8fe4d3b4f6f9fa4a1534367feea621002eee29cb 100644 (file)
--- a/include/llvm/Target/TargetInstrInfo.h
+++ b/include/llvm/Target/TargetInstrInfo.h
@@ -275,7 +275,7 @@ public:
   // The generated instructions are returned in `mvec'.
   // Any temp. registers (TmpInstruction) created are recorded in mcfi.
   // Symbolic constants or constants that must be accessed from memory
-  // are added to the constant pool via MachineCodeForMethod::get(F).
+  // are added to the constant pool via MachineFunction::get(F).
   // 
   virtual void  CreateCodeToLoadConst(const TargetMachine& target,
                                       Function* F,

diff --git a/lib/CodeGen/InstrSched/InstrScheduling.cpp b/lib/CodeGen/InstrSched/InstrScheduling.cpp
index 9818b708381c0da84f9daab7428bb57f5640f511..ea20a3e92a420649431835b7c9147d3cf0237ac4 100644 (file)
--- a/lib/CodeGen/InstrSched/InstrScheduling.cpp
+++ b/lib/CodeGen/InstrSched/InstrScheduling.cpp
@@ -9,7 +9,7 @@
 #include "llvm/CodeGen/MachineInstr.h"
 #include "llvm/CodeGen/MachineCodeForInstruction.h"
 #include "llvm/CodeGen/MachineCodeForBasicBlock.h"
-#include "llvm/CodeGen/MachineCodeForMethod.h"
+#include "llvm/CodeGen/MachineFunction.h"
 #include "llvm/Analysis/LiveVar/FunctionLiveVarInfo.h" // FIXME: Remove when modularized better
 #include "llvm/Target/TargetMachine.h"
 #include "llvm/BasicBlock.h"
@@ -1542,7 +1542,7 @@ bool InstructionSchedulingWithSSA::runOnFunction(Function &F)
   if (SchedDebugLevel >= Sched_PrintMachineCode)
     {
       cerr << "\n*** Machine instructions after INSTRUCTION SCHEDULING\n";
-      MachineCodeForMethod::get(&F).dump();
+      MachineFunction::get(&F).dump();
     }
   
   return false;

diff --git a/lib/CodeGen/InstrSched/SchedGraph.h b/lib/CodeGen/InstrSched/SchedGraph.h
index eac9c1c6d609d90b34583fe354c215a1a5c71118..514e5654774a7818c79354d715c91a66a47b7569 100644 (file)
--- a/lib/CodeGen/InstrSched/SchedGraph.h
+++ b/lib/CodeGen/InstrSched/SchedGraph.h
@@ -31,7 +31,7 @@ class RegToRefVecMap;
 class ValueToDefVecMap;
 class RefVec;
 class MachineInstr;
-class MachineCodeForBasicBlock;
+class MachineBasicBlock;
 
 
 /******************** Exported Data Types and Constants ********************/
@@ -312,7 +312,7 @@ private:
                                      const TargetMachine& target);
   
   void          addCallCCEdges      (const std::vector<SchedGraphNode*>& memNod,
-                                     MachineCodeForBasicBlock& bbMvec,
+                                     MachineBasicBlock& bbMvec,
                                      const TargetMachine& target);
     
   void         addMachineRegEdges      (RegToRefVecMap& regToRefVecMap,

diff --git a/lib/CodeGen/InstrSelection/InstrSelection.cpp b/lib/CodeGen/InstrSelection/InstrSelection.cpp
index a9d1331c94c83e12129cc334a8fb06190430d484..83ce0a7dfe7ea2cf4b1abfa160bdb19cbe9b7390 100644 (file)
--- a/lib/CodeGen/InstrSelection/InstrSelection.cpp
+++ b/lib/CodeGen/InstrSelection/InstrSelection.cpp
@@ -12,7 +12,7 @@
 #include "llvm/CodeGen/InstrForest.h"
 #include "llvm/CodeGen/MachineCodeForInstruction.h"
 #include "llvm/CodeGen/MachineCodeForBasicBlock.h"
-#include "llvm/CodeGen/MachineCodeForMethod.h"
+#include "llvm/CodeGen/MachineFunction.h"
 #include "llvm/Target/MachineRegInfo.h"
 #include "llvm/Target/TargetMachine.h"
 #include "llvm/Function.h"
@@ -155,7 +155,7 @@ bool InstructionSelection::runOnFunction(Function &F)
   if (SelectDebugLevel >= Select_PrintMachineCode)
     {
       cerr << "\n*** Machine instructions after INSTRUCTION SELECTION\n";
-      MachineCodeForMethod::get(&F).dump();
+      MachineFunction::get(&F).dump();
     }
   
   return true;

diff --git a/lib/CodeGen/InstrSelection/InstrSelectionSupport.cpp b/lib/CodeGen/InstrSelection/InstrSelectionSupport.cpp
index 731f3355af1bc655f6656360c2efe1e37b924554..b2f5b22f4c5b715bd443f3d501b772f4d95c08ab 100644 (file)
--- a/lib/CodeGen/InstrSelection/InstrSelectionSupport.cpp
+++ b/lib/CodeGen/InstrSelection/InstrSelectionSupport.cpp
@@ -10,7 +10,7 @@
 #include "llvm/CodeGen/MachineInstr.h"
 #include "llvm/CodeGen/MachineInstrAnnot.h"
 #include "llvm/CodeGen/MachineCodeForInstruction.h"
-#include "llvm/CodeGen/MachineCodeForMethod.h"
+#include "llvm/CodeGen/MachineFunction.h"
 #include "llvm/CodeGen/InstrForest.h"
 #include "llvm/Target/TargetMachine.h"
 #include "llvm/Target/MachineRegInfo.h"

diff --git a/lib/CodeGen/MachineFunction.cpp b/lib/CodeGen/MachineFunction.cpp
index e809e31a62e5b94367802545acc7ff743bcfd09e..b9f1ae28aeedc09356559a588f1629fe6664c378 100644 (file)
--- a/lib/CodeGen/MachineFunction.cpp
+++ b/lib/CodeGen/MachineFunction.cpp
@@ -6,7 +6,7 @@
 //   to be stored with each function.
 //===---------------------------------------------------------------------===//
 
-#include "llvm/CodeGen/MachineCodeForMethod.h"
+#include "llvm/CodeGen/MachineFunction.h"
 #include "llvm/CodeGen/MachineInstr.h"  // For debug output
 #include "llvm/CodeGen/MachineCodeForBasicBlock.h"
 #include "llvm/Target/TargetMachine.h"
@@ -30,27 +30,27 @@ static AnnotationID MCFM_AID(
 //                This should not be called before "construct()"
 //                for a given Function.
 // 
-MachineCodeForMethod&
-MachineCodeForMethod::construct(const Function *M, const TargetMachine &Tar)
+MachineFunction&
+MachineFunction::construct(const Function *M, const TargetMachine &Tar)
 {
   assert(M->getAnnotation(MCFM_AID) == 0 &&
          "Object already exists for this function!");
-  MachineCodeForMethod* mcInfo = new MachineCodeForMethod(M, Tar);
+  MachineFunction* mcInfo = new MachineFunction(M, Tar);
   M->addAnnotation(mcInfo);
   return *mcInfo;
 }
 
 void
-MachineCodeForMethod::destruct(const Function *M)
+MachineFunction::destruct(const Function *M)
 {
   bool Deleted = M->deleteAnnotation(MCFM_AID);
   assert(Deleted && "Machine code did not exist for function!");
 }
 
-MachineCodeForMethod&
-MachineCodeForMethod::get(const Function *F)
+MachineFunction&
+MachineFunction::get(const Function *F)
 {
-  MachineCodeForMethod *mc = (MachineCodeForMethod*)F->getAnnotation(MCFM_AID);
+  MachineFunction *mc = (MachineFunction*)F->getAnnotation(MCFM_AID);
   assert(mc && "Call construct() method first to allocate the object");
   return *mc;
 }
@@ -122,7 +122,7 @@ SizeToAlignment(unsigned int size, const TargetMachine& target)
 
 
 /*ctor*/
-MachineCodeForMethod::MachineCodeForMethod(const Function *F,
+MachineFunction::MachineFunction(const Function *F,
                                            const TargetMachine& target)
   : Annotation(MCFM_AID),
     method(F), staticStackSize(0),
@@ -138,7 +138,7 @@ MachineCodeForMethod::MachineCodeForMethod(const Function *F,
 }
 
 int
-MachineCodeForMethod::computeOffsetforLocalVar(const TargetMachine& target,
+MachineFunction::computeOffsetforLocalVar(const TargetMachine& target,
                                                const Value* val,
                                                unsigned int& getPaddedSize,
                                                unsigned int  sizeToUse)
@@ -160,7 +160,7 @@ MachineCodeForMethod::computeOffsetforLocalVar(const TargetMachine& target,
 }
 
 int
-MachineCodeForMethod::allocateLocalVar(const TargetMachine& target,
+MachineFunction::allocateLocalVar(const TargetMachine& target,
                                        const Value* val,
                                        unsigned int sizeToUse)
 {
@@ -183,7 +183,7 @@ MachineCodeForMethod::allocateLocalVar(const TargetMachine& target,
 }
 
 int
-MachineCodeForMethod::allocateSpilledValue(const TargetMachine& target,
+MachineFunction::allocateSpilledValue(const TargetMachine& target,
                                            const Type* type)
 {
   assert(! spillsAreaFrozen &&
@@ -208,7 +208,7 @@ MachineCodeForMethod::allocateSpilledValue(const TargetMachine& target,
 }
 
 int
-MachineCodeForMethod::pushTempValue(const TargetMachine& target,
+MachineFunction::pushTempValue(const TargetMachine& target,
                                     unsigned int size)
 {
   unsigned int align = SizeToAlignment(size, target);
@@ -228,20 +228,20 @@ MachineCodeForMethod::pushTempValue(const TargetMachine& target,
 }
 
 void
-MachineCodeForMethod::popAllTempValues(const TargetMachine& target)
+MachineFunction::popAllTempValues(const TargetMachine& target)
 {
   resetTmpAreaSize();            // clear tmp area to reuse
 }
 
 int
-MachineCodeForMethod::getOffset(const Value* val) const
+MachineFunction::getOffset(const Value* val) const
 {
   hash_map<const Value*, int>::const_iterator pair = offsets.find(val);
   return (pair == offsets.end())? INVALID_FRAME_OFFSET : pair->second;
 }
 
 void
-MachineCodeForMethod::dump() const
+MachineFunction::dump() const
 {
   std::cerr << "\n" << method->getReturnType()
             << " \"" << method->getName() << "\"\n";

diff --git a/lib/CodeGen/RegAlloc/PhyRegAlloc.cpp b/lib/CodeGen/RegAlloc/PhyRegAlloc.cpp
index 5fc6a4d5c00b33990e1fc233c88fbb96f0d98759..9899dbc71cc070db9eeebd8f22363db31ec8d318 100644 (file)
--- a/lib/CodeGen/RegAlloc/PhyRegAlloc.cpp
+++ b/lib/CodeGen/RegAlloc/PhyRegAlloc.cpp
@@ -10,7 +10,7 @@
 #include "llvm/CodeGen/MachineInstr.h"
 #include "llvm/CodeGen/MachineInstrAnnot.h"
 #include "llvm/CodeGen/MachineCodeForBasicBlock.h"
-#include "llvm/CodeGen/MachineCodeForMethod.h"
+#include "llvm/CodeGen/MachineFunction.h"
 #include "llvm/Analysis/LiveVar/FunctionLiveVarInfo.h"
 #include "llvm/Analysis/LoopInfo.h"
 #include "llvm/Target/TargetMachine.h"
@@ -78,7 +78,7 @@ Pass *getRegisterAllocator(TargetMachine &T) {
 PhyRegAlloc::PhyRegAlloc(Function *F, const TargetMachine& tm, 
                         FunctionLiveVarInfo *Lvi, LoopInfo *LDC) 
                        :  TM(tm), Meth(F),
-                          mcInfo(MachineCodeForMethod::get(F)),
+                          mcInfo(MachineFunction::get(F)),
                           LVI(Lvi), LRI(F, tm, RegClassList), 
                          MRI(tm.getRegInfo()),
                           NumOfRegClasses(MRI.getNumOfRegClasses()),
@@ -1194,7 +1194,7 @@ void PhyRegAlloc::allocateRegisters()
 
   if (DEBUG_RA) {
     cerr << "\n**** Machine Code After Register Allocation:\n\n";
-    MachineCodeForMethod::get(Meth).dump();
+    MachineFunction::get(Meth).dump();
   }
 }
 

diff --git a/lib/CodeGen/RegAlloc/PhyRegAlloc.h b/lib/CodeGen/RegAlloc/PhyRegAlloc.h
index da4d2fd8ecdd859261e5e672630b06889124531e..ca517138b750f43b09baa9951babc0b4df26a174 100644 (file)
--- a/lib/CodeGen/RegAlloc/PhyRegAlloc.h
+++ b/lib/CodeGen/RegAlloc/PhyRegAlloc.h
@@ -35,7 +35,7 @@
 #include <vector>
 #include <map>
 
-class MachineCodeForMethod;
+class MachineFunction;
 class MachineRegInfo;
 class FunctionLiveVarInfo;
 class MachineInstr;
@@ -71,7 +71,7 @@ class PhyRegAlloc: public NonCopyable {
   std::vector<RegClass *> RegClassList; // vector of register classes
   const TargetMachine &TM;              // target machine
   const Function *Meth;                 // name of the function we work on
-  MachineCodeForMethod &mcInfo;         // descriptor for method's native code
+  MachineFunction &mcInfo;              // descriptor for method's native code
   FunctionLiveVarInfo *const LVI;       // LV information for this method 
                                         // (already computed for BBs) 
   LiveRangeInfo LRI;                    // LR info  (will be computed)

diff --git a/lib/Target/MachineFrameInfo.cpp b/lib/Target/MachineFrameInfo.cpp
index 0eeacbc2b0ae7b0718a83a8adfd7ab0785085a21..4d2fab230e53d309fc539cc3ad1ca4ceee642593 100644 (file)
--- a/lib/Target/MachineFrameInfo.cpp
+++ b/lib/Target/MachineFrameInfo.cpp
@@ -7,10 +7,10 @@
 //===----------------------------------------------------------------------===//
 
 #include "llvm/Target/MachineFrameInfo.h"
-#include "llvm/CodeGen/MachineCodeForMethod.h"
+#include "llvm/CodeGen/MachineFunction.h"
 
 int
-MachineFrameInfo::getIncomingArgOffset(MachineCodeForMethod& mcInfo,
+MachineFrameInfo::getIncomingArgOffset(MachineFunction& mcInfo,
                                        unsigned argNum) const
 {
   assert(argsOnStackHaveFixedSize()); 
@@ -25,7 +25,7 @@ MachineFrameInfo::getIncomingArgOffset(MachineCodeForMethod& mcInfo,
 
 
 int
-MachineFrameInfo::getOutgoingArgOffset(MachineCodeForMethod& mcInfo,
+MachineFrameInfo::getOutgoingArgOffset(MachineFunction& mcInfo,
                                        unsigned argNum) const
 {
   assert(argsOnStackHaveFixedSize()); 

diff --git a/lib/Target/SparcV9/InstrSched/InstrScheduling.cpp b/lib/Target/SparcV9/InstrSched/InstrScheduling.cpp
index 9818b708381c0da84f9daab7428bb57f5640f511..ea20a3e92a420649431835b7c9147d3cf0237ac4 100644 (file)
--- a/lib/Target/SparcV9/InstrSched/InstrScheduling.cpp
+++ b/lib/Target/SparcV9/InstrSched/InstrScheduling.cpp
@@ -9,7 +9,7 @@
 #include "llvm/CodeGen/MachineInstr.h"
 #include "llvm/CodeGen/MachineCodeForInstruction.h"
 #include "llvm/CodeGen/MachineCodeForBasicBlock.h"
-#include "llvm/CodeGen/MachineCodeForMethod.h"
+#include "llvm/CodeGen/MachineFunction.h"
 #include "llvm/Analysis/LiveVar/FunctionLiveVarInfo.h" // FIXME: Remove when modularized better
 #include "llvm/Target/TargetMachine.h"
 #include "llvm/BasicBlock.h"
@@ -1542,7 +1542,7 @@ bool InstructionSchedulingWithSSA::runOnFunction(Function &F)
   if (SchedDebugLevel >= Sched_PrintMachineCode)
     {
       cerr << "\n*** Machine instructions after INSTRUCTION SCHEDULING\n";
-      MachineCodeForMethod::get(&F).dump();
+      MachineFunction::get(&F).dump();
     }
   
   return false;

diff --git a/lib/Target/SparcV9/InstrSched/SchedGraph.h b/lib/Target/SparcV9/InstrSched/SchedGraph.h
index eac9c1c6d609d90b34583fe354c215a1a5c71118..514e5654774a7818c79354d715c91a66a47b7569 100644 (file)
--- a/lib/Target/SparcV9/InstrSched/SchedGraph.h
+++ b/lib/Target/SparcV9/InstrSched/SchedGraph.h
@@ -31,7 +31,7 @@ class RegToRefVecMap;
 class ValueToDefVecMap;
 class RefVec;
 class MachineInstr;
-class MachineCodeForBasicBlock;
+class MachineBasicBlock;
 
 
 /******************** Exported Data Types and Constants ********************/
@@ -312,7 +312,7 @@ private:
                                      const TargetMachine& target);
   
   void          addCallCCEdges      (const std::vector<SchedGraphNode*>& memNod,
-                                     MachineCodeForBasicBlock& bbMvec,
+                                     MachineBasicBlock& bbMvec,
                                      const TargetMachine& target);
     
   void         addMachineRegEdges      (RegToRefVecMap& regToRefVecMap,

diff --git a/lib/Target/SparcV9/InstrSelection/InstrSelection.cpp b/lib/Target/SparcV9/InstrSelection/InstrSelection.cpp
index a9d1331c94c83e12129cc334a8fb06190430d484..83ce0a7dfe7ea2cf4b1abfa160bdb19cbe9b7390 100644 (file)
--- a/lib/Target/SparcV9/InstrSelection/InstrSelection.cpp
+++ b/lib/Target/SparcV9/InstrSelection/InstrSelection.cpp
@@ -12,7 +12,7 @@
 #include "llvm/CodeGen/InstrForest.h"
 #include "llvm/CodeGen/MachineCodeForInstruction.h"
 #include "llvm/CodeGen/MachineCodeForBasicBlock.h"
-#include "llvm/CodeGen/MachineCodeForMethod.h"
+#include "llvm/CodeGen/MachineFunction.h"
 #include "llvm/Target/MachineRegInfo.h"
 #include "llvm/Target/TargetMachine.h"
 #include "llvm/Function.h"
@@ -155,7 +155,7 @@ bool InstructionSelection::runOnFunction(Function &F)
   if (SelectDebugLevel >= Select_PrintMachineCode)
     {
       cerr << "\n*** Machine instructions after INSTRUCTION SELECTION\n";
-      MachineCodeForMethod::get(&F).dump();
+      MachineFunction::get(&F).dump();
     }
   
   return true;

diff --git a/lib/Target/SparcV9/InstrSelection/InstrSelectionSupport.cpp b/lib/Target/SparcV9/InstrSelection/InstrSelectionSupport.cpp
index 731f3355af1bc655f6656360c2efe1e37b924554..b2f5b22f4c5b715bd443f3d501b772f4d95c08ab 100644 (file)
--- a/lib/Target/SparcV9/InstrSelection/InstrSelectionSupport.cpp
+++ b/lib/Target/SparcV9/InstrSelection/InstrSelectionSupport.cpp
@@ -10,7 +10,7 @@
 #include "llvm/CodeGen/MachineInstr.h"
 #include "llvm/CodeGen/MachineInstrAnnot.h"
 #include "llvm/CodeGen/MachineCodeForInstruction.h"
-#include "llvm/CodeGen/MachineCodeForMethod.h"
+#include "llvm/CodeGen/MachineFunction.h"
 #include "llvm/CodeGen/InstrForest.h"
 #include "llvm/Target/TargetMachine.h"
 #include "llvm/Target/MachineRegInfo.h"

diff --git a/lib/Target/SparcV9/RegAlloc/PhyRegAlloc.cpp b/lib/Target/SparcV9/RegAlloc/PhyRegAlloc.cpp
index 5fc6a4d5c00b33990e1fc233c88fbb96f0d98759..9899dbc71cc070db9eeebd8f22363db31ec8d318 100644 (file)
--- a/lib/Target/SparcV9/RegAlloc/PhyRegAlloc.cpp
+++ b/lib/Target/SparcV9/RegAlloc/PhyRegAlloc.cpp
@@ -10,7 +10,7 @@
 #include "llvm/CodeGen/MachineInstr.h"
 #include "llvm/CodeGen/MachineInstrAnnot.h"
 #include "llvm/CodeGen/MachineCodeForBasicBlock.h"
-#include "llvm/CodeGen/MachineCodeForMethod.h"
+#include "llvm/CodeGen/MachineFunction.h"
 #include "llvm/Analysis/LiveVar/FunctionLiveVarInfo.h"
 #include "llvm/Analysis/LoopInfo.h"
 #include "llvm/Target/TargetMachine.h"
@@ -78,7 +78,7 @@ Pass *getRegisterAllocator(TargetMachine &T) {
 PhyRegAlloc::PhyRegAlloc(Function *F, const TargetMachine& tm, 
                         FunctionLiveVarInfo *Lvi, LoopInfo *LDC) 
                        :  TM(tm), Meth(F),
-                          mcInfo(MachineCodeForMethod::get(F)),
+                          mcInfo(MachineFunction::get(F)),
                           LVI(Lvi), LRI(F, tm, RegClassList), 
                          MRI(tm.getRegInfo()),
                           NumOfRegClasses(MRI.getNumOfRegClasses()),
@@ -1194,7 +1194,7 @@ void PhyRegAlloc::allocateRegisters()
 
   if (DEBUG_RA) {
     cerr << "\n**** Machine Code After Register Allocation:\n\n";
-    MachineCodeForMethod::get(Meth).dump();
+    MachineFunction::get(Meth).dump();
   }
 }
 

diff --git a/lib/Target/SparcV9/RegAlloc/PhyRegAlloc.h b/lib/Target/SparcV9/RegAlloc/PhyRegAlloc.h
index da4d2fd8ecdd859261e5e672630b06889124531e..ca517138b750f43b09baa9951babc0b4df26a174 100644 (file)
--- a/lib/Target/SparcV9/RegAlloc/PhyRegAlloc.h
+++ b/lib/Target/SparcV9/RegAlloc/PhyRegAlloc.h
@@ -35,7 +35,7 @@
 #include <vector>
 #include <map>
 
-class MachineCodeForMethod;
+class MachineFunction;
 class MachineRegInfo;
 class FunctionLiveVarInfo;
 class MachineInstr;
@@ -71,7 +71,7 @@ class PhyRegAlloc: public NonCopyable {
   std::vector<RegClass *> RegClassList; // vector of register classes
   const TargetMachine &TM;              // target machine
   const Function *Meth;                 // name of the function we work on
-  MachineCodeForMethod &mcInfo;         // descriptor for method's native code
+  MachineFunction &mcInfo;              // descriptor for method's native code
   FunctionLiveVarInfo *const LVI;       // LV information for this method 
                                         // (already computed for BBs) 
   LiveRangeInfo LRI;                    // LR info  (will be computed)

diff --git a/lib/Target/SparcV9/SparcV9AsmPrinter.cpp b/lib/Target/SparcV9/SparcV9AsmPrinter.cpp
index ce81248478a0da3fd1cb3ef1f0719533286d95f8..f414347dea4f97493c005864a5d7459055ae7e11 100644 (file)
--- a/lib/Target/SparcV9/SparcV9AsmPrinter.cpp
+++ b/lib/Target/SparcV9/SparcV9AsmPrinter.cpp
@@ -14,7 +14,7 @@
 #include "SparcInternals.h"
 #include "llvm/CodeGen/MachineInstr.h"
 #include "llvm/CodeGen/MachineCodeForBasicBlock.h"
-#include "llvm/CodeGen/MachineCodeForMethod.h"
+#include "llvm/CodeGen/MachineFunction.h"
 #include "llvm/Constants.h"
 #include "llvm/DerivedTypes.h"
 #include "llvm/Module.h"
@@ -865,7 +865,7 @@ void SparcModuleAsmPrinter::FoldConstants(const Module &M,
   for (Module::const_iterator I = M.begin(), E = M.end(); I != E; ++I)
     if (!I->isExternal()) {
       const hash_set<const Constant*> &pool =
-        MachineCodeForMethod::get(I).getConstantPoolValues();
+        MachineFunction::get(I).getConstantPoolValues();
       MC.insert(pool.begin(), pool.end());
     }
 }

diff --git a/lib/Target/SparcV9/SparcV9InstrInfo.cpp b/lib/Target/SparcV9/SparcV9InstrInfo.cpp
index 662c80a357701d959f2f7ab817eb4eea7f811172..fbabe933166403fd398b74121e04629c2c729d93 100644 (file)
--- a/lib/Target/SparcV9/SparcV9InstrInfo.cpp
+++ b/lib/Target/SparcV9/SparcV9InstrInfo.cpp
@@ -6,7 +6,7 @@
 #include "SparcInstrSelectionSupport.h"
 #include "llvm/CodeGen/InstrSelection.h"
 #include "llvm/CodeGen/InstrSelectionSupport.h"
-#include "llvm/CodeGen/MachineCodeForMethod.h"
+#include "llvm/CodeGen/MachineFunction.h"
 #include "llvm/CodeGen/MachineCodeForInstruction.h"
 #include "llvm/Function.h"
 #include "llvm/Constants.h"
@@ -361,7 +361,7 @@ UltraSparcInstrInfo::ConstantMayNotFitInImmedField(const Constant* CV,
 // GlobalValue, viz., the constant address of a global variable or function.
 // The generated instructions are returned in `mvec'.
 // Any temp. registers (TmpInstruction) created are recorded in mcfi.
-// Any stack space required is allocated via MachineCodeForMethod.
+// Any stack space required is allocated via MachineFunction.
 // 
 void
 UltraSparcInstrInfo::CreateCodeToLoadConst(const TargetMachine& target,
@@ -461,7 +461,7 @@ UltraSparcInstrInfo::CreateCodeToLoadConst(const TargetMachine& target,
       mvec.push_back(MI);
       
       // Make sure constant is emitted to constant pool in assembly code.
-      MachineCodeForMethod::get(F).addToConstantPool(cast<Constant>(val));
+      MachineFunction::get(F).addToConstantPool(cast<Constant>(val));
     }
 }
 
@@ -471,7 +471,7 @@ UltraSparcInstrInfo::CreateCodeToLoadConst(const TargetMachine& target,
 // val must be an integral type.  dest must be a Float or Double.
 // The generated instructions are returned in `mvec'.
 // Any temp. registers (TmpInstruction) created are recorded in mcfi.
-// Any stack space required is allocated via MachineCodeForMethod.
+// Any stack space required is allocated via MachineFunction.
 // 
 void
 UltraSparcInstrInfo::CreateCodeToCopyIntToFloat(const TargetMachine& target,
@@ -487,7 +487,7 @@ UltraSparcInstrInfo::CreateCodeToCopyIntToFloat(const TargetMachine& target,
          && "Dest type must be float/double");
 
   // Get a stack slot to use for the copy
-  int offset = MachineCodeForMethod::get(F).allocateLocalVar(target, val); 
+  int offset = MachineFunction::get(F).allocateLocalVar(target, val); 
 
   // Get the size of the source value being copied. 
   size_t srcSize = target.DataLayout.getTypeSize(val->getType());
@@ -532,7 +532,7 @@ UltraSparcInstrInfo::CreateCodeToCopyIntToFloat(const TargetMachine& target,
 // `val' to an integer register `dest' by copying to memory and back.
 // The generated instructions are returned in `mvec'.
 // Any temp. registers (TmpInstruction) created are recorded in mcfi.
-// Any stack space required is allocated via MachineCodeForMethod.
+// Any stack space required is allocated via MachineFunction.
 // 
 void
 UltraSparcInstrInfo::CreateCodeToCopyFloatToInt(const TargetMachine& target,
@@ -549,7 +549,7 @@ UltraSparcInstrInfo::CreateCodeToCopyFloatToInt(const TargetMachine& target,
   assert((destTy->isIntegral() || isa<PointerType>(destTy))
          && "Dest type must be integer, bool or pointer");
 
-  int offset = MachineCodeForMethod::get(F).allocateLocalVar(target, val); 
+  int offset = MachineFunction::get(F).allocateLocalVar(target, val); 
 
   // Store instruction stores `val' to [%fp+offset].
   // The store opCode is based only the source value being copied.
@@ -579,7 +579,7 @@ UltraSparcInstrInfo::CreateCodeToCopyFloatToInt(const TargetMachine& target,
 // Create instruction(s) to copy src to dest, for arbitrary types
 // The generated instructions are returned in `mvec'.
 // Any temp. registers (TmpInstruction) created are recorded in mcfi.
-// Any stack space required is allocated via MachineCodeForMethod.
+// Any stack space required is allocated via MachineFunction.
 // 
 void
 UltraSparcInstrInfo::CreateCopyInstructionsByType(const TargetMachine& target,
@@ -675,7 +675,7 @@ CreateBitExtensionInstructions(bool signExtend,
 // from an arbitrary-sized integer value (sized in bits, not bytes).
 // The generated instructions are returned in `mvec'.
 // Any temp. registers (TmpInstruction) created are recorded in mcfi.
-// Any stack space required is allocated via MachineCodeForMethod.
+// Any stack space required is allocated via MachineFunction.
 // 
 void
 UltraSparcInstrInfo::CreateSignExtensionInstructions(
@@ -697,7 +697,7 @@ UltraSparcInstrInfo::CreateSignExtensionInstructions(
 // For SPARC v9, we sign-extend the given operand using SLL; SRL.
 // The generated instructions are returned in `mvec'.
 // Any temp. registers (TmpInstruction) created are recorded in mcfi.
-// Any stack space required is allocated via MachineCodeForMethod.
+// Any stack space required is allocated via MachineFunction.
 // 
 void
 UltraSparcInstrInfo::CreateZeroExtensionInstructions(

diff --git a/lib/Target/SparcV9/SparcV9InstrSelection.cpp b/lib/Target/SparcV9/SparcV9InstrSelection.cpp
index 5195f4ac29faef839c3603f35fff817e89f62238..4a55df3407f87ddf2ca52f3f68204fa7ec45b59b 100644 (file)
--- a/lib/Target/SparcV9/SparcV9InstrSelection.cpp
+++ b/lib/Target/SparcV9/SparcV9InstrSelection.cpp
@@ -12,7 +12,7 @@
 #include "llvm/CodeGen/MachineInstrAnnot.h"
 #include "llvm/CodeGen/InstrForest.h"
 #include "llvm/CodeGen/InstrSelection.h"
-#include "llvm/CodeGen/MachineCodeForMethod.h"
+#include "llvm/CodeGen/MachineFunction.h"
 #include "llvm/CodeGen/MachineCodeForInstruction.h"
 #include "llvm/DerivedTypes.h"
 #include "llvm/iTerminators.h"
@@ -843,7 +843,7 @@ CreateCodeForVariableSizeAlloca(const TargetMachine& target,
   // and create a temporary Value to hold it.
   assert(result && result->getParent() && "Result value is not part of a fn?");
   Function *F = result->getParent()->getParent();
-  MachineCodeForMethod& mcInfo = MachineCodeForMethod::get(F);
+  MachineFunction& mcInfo = MachineFunction::get(F);
   bool growUp;
   ConstantSInt* dynamicAreaOffset =
     ConstantSInt::get(Type::IntTy,
@@ -885,7 +885,7 @@ CreateCodeForFixedSizeAlloca(const TargetMachine& target,
   assert(result && result->getParent() &&
          "Result value is not part of a function?");
   Function *F = result->getParent()->getParent();
-  MachineCodeForMethod &mcInfo = MachineCodeForMethod::get(F);
+  MachineFunction &mcInfo = MachineFunction::get(F);
 
   // Check if the offset would small enough to use as an immediate in
   // load/stores (check LDX because all load/stores have the same-size immediate

diff --git a/lib/Target/SparcV9/SparcV9Internals.h b/lib/Target/SparcV9/SparcV9Internals.h
index 2399a1e68b3971c6873eb6e48845c5f9fa90d040..4304518c6937224d4cd7e58de2ae32df3f41591b 100644 (file)
--- a/lib/Target/SparcV9/SparcV9Internals.h
+++ b/lib/Target/SparcV9/SparcV9Internals.h
@@ -560,32 +560,32 @@ public:
   // particular function.  The frame contents are obtained from the
   // MachineCodeInfoForMethod object for the given function.
   // 
-  int getFirstIncomingArgOffset  (MachineCodeForMethod& mcInfo,
+  int getFirstIncomingArgOffset  (MachineFunction& mcInfo,
                                   bool& growUp) const
   {
     growUp = true;                         // arguments area grows upwards
     return FirstIncomingArgOffsetFromFP;
   }
-  int getFirstOutgoingArgOffset  (MachineCodeForMethod& mcInfo,
+  int getFirstOutgoingArgOffset  (MachineFunction& mcInfo,
                                   bool& growUp) const
   {
     growUp = true;                         // arguments area grows upwards
     return FirstOutgoingArgOffsetFromSP;
   }
-  int getFirstOptionalOutgoingArgOffset(MachineCodeForMethod& mcInfo,
+  int getFirstOptionalOutgoingArgOffset(MachineFunction& mcInfo,
                                         bool& growUp)const
   {
     growUp = true;                         // arguments area grows upwards
     return FirstOptionalOutgoingArgOffsetFromSP;
   }
   
-  int getFirstAutomaticVarOffset (MachineCodeForMethod& mcInfo,
+  int getFirstAutomaticVarOffset (MachineFunction& mcInfo,
                                   bool& growUp) const;
-  int getRegSpillAreaOffset      (MachineCodeForMethod& mcInfo,
+  int getRegSpillAreaOffset      (MachineFunction& mcInfo,
                                   bool& growUp) const;
-  int getTmpAreaOffset           (MachineCodeForMethod& mcInfo,
+  int getTmpAreaOffset           (MachineFunction& mcInfo,
                                   bool& growUp) const;
-  int getDynamicAreaOffset       (MachineCodeForMethod& mcInfo,
+  int getDynamicAreaOffset       (MachineFunction& mcInfo,
                                   bool& growUp) const;
 
   //

diff --git a/lib/Target/SparcV9/SparcV9PrologEpilogInserter.cpp b/lib/Target/SparcV9/SparcV9PrologEpilogInserter.cpp
index 75146c072ed94d1598080b0fcd1387b4d575ee77..adb1490b06ba93c8d06492124ee0d7ab5853e5f4 100644 (file)
--- a/lib/Target/SparcV9/SparcV9PrologEpilogInserter.cpp
+++ b/lib/Target/SparcV9/SparcV9PrologEpilogInserter.cpp
@@ -11,7 +11,7 @@
 
 #include "SparcInternals.h"
 #include "SparcRegClassInfo.h"
-#include "llvm/CodeGen/MachineCodeForMethod.h"
+#include "llvm/CodeGen/MachineFunction.h"
 #include "llvm/CodeGen/MachineCodeForBasicBlock.h"
 #include "llvm/CodeGen/MachineCodeForInstruction.h"
 #include "llvm/CodeGen/MachineInstr.h"
@@ -28,7 +28,7 @@ namespace {
     const char *getPassName() const { return "Sparc Prolog/Epilog Inserter"; }
     
     bool runOnFunction(Function &F) {
-      MachineCodeForMethod &mcodeInfo = MachineCodeForMethod::get(&F);
+      MachineFunction &mcodeInfo = MachineFunction::get(&F);
       if (!mcodeInfo.isCompiledAsLeafMethod()) {
         InsertPrologCode(F);
         InsertEpilogCode(F);
@@ -60,7 +60,7 @@ void InsertPrologEpilogCode::InsertPrologCode(Function &F)
   // immediate field, we have to use a free register to hold the size.
   // See the comments below for the choice of this register.
   // 
-  MachineCodeForMethod& mcInfo = MachineCodeForMethod::get(&F);
+  MachineFunction& mcInfo = MachineFunction::get(&F);
   unsigned int staticStackSize = mcInfo.getStaticStackSize();
   
   if (staticStackSize < (unsigned) frameInfo.getMinStackFrameSize())

diff --git a/lib/Target/SparcV9/SparcV9RegInfo.cpp b/lib/Target/SparcV9/SparcV9RegInfo.cpp
index 65539cf87e7bbcab7bb544b226aa6ccbb8c4a927..17c210f74e4bfbf6f16d8b4f0c57c396de16cb07 100644 (file)
--- a/lib/Target/SparcV9/SparcV9RegInfo.cpp
+++ b/lib/Target/SparcV9/SparcV9RegInfo.cpp
@@ -8,7 +8,7 @@
 #include "SparcInternals.h"
 #include "SparcRegClassInfo.h"
 #include "llvm/Target/Sparc.h"
-#include "llvm/CodeGen/MachineCodeForMethod.h"
+#include "llvm/CodeGen/MachineFunction.h"
 #include "llvm/CodeGen/PhyRegAlloc.h"
 #include "llvm/CodeGen/InstrSelection.h"
 #include "llvm/CodeGen/InstrSelectionSupport.h"
@@ -477,7 +477,7 @@ void UltraSparcRegInfo::colorMethodArgs(const Function *Meth,
                  regClassIDOfArgReg == IntRegClassID &&
                  "This should only be an Int register for an FP argument");
           
-         int TmpOff = MachineCodeForMethod::get(Meth).pushTempValue(target,  
+         int TmpOff = MachineFunction::get(Meth).pushTempValue(target,  
                                                 getSpilledRegSize(regType));
          cpReg2MemMI(FirstAI->InstrnsBefore,
                       UniArgReg, getFramePointer(), TmpOff, IntRegType);
@@ -496,7 +496,7 @@ void UltraSparcRegInfo::colorMethodArgs(const Function *Meth,
        //
         const MachineFrameInfo& frameInfo = target.getFrameInfo();
        int offsetFromFP =
-          frameInfo.getIncomingArgOffset(MachineCodeForMethod::get(Meth),
+          frameInfo.getIncomingArgOffset(MachineFunction::get(Meth),
                                          argNo);
         
        cpMem2RegMI(FirstAI->InstrnsBefore,
@@ -544,7 +544,7 @@ void UltraSparcRegInfo::colorMethodArgs(const Function *Meth,
 
         const MachineFrameInfo& frameInfo = target.getFrameInfo();
        int offsetFromFP =
-          frameInfo.getIncomingArgOffset(MachineCodeForMethod::get(Meth),
+          frameInfo.getIncomingArgOffset(MachineFunction::get(Meth),
                                          argNo);
         
        LR->modifySpillOffFromFP( offsetFromFP );

diff --git a/lib/Target/SparcV9/SparcV9StackSlots.cpp b/lib/Target/SparcV9/SparcV9StackSlots.cpp
index c7584d2c94d9913343f6a429cd72524f29c9bf5a..10cccd3c58d9cc574555ff239648a5dec15b1b54 100644 (file)
--- a/lib/Target/SparcV9/SparcV9StackSlots.cpp
+++ b/lib/Target/SparcV9/SparcV9StackSlots.cpp
@@ -13,7 +13,7 @@
 #include "llvm/Function.h"
 #include "llvm/DerivedTypes.h"
 #include "llvm/Pass.h"
-#include "llvm/CodeGen/MachineCodeForMethod.h"
+#include "llvm/CodeGen/MachineFunction.h"
 
 class StackSlots : public FunctionPass {
   const TargetMachine &Target;
@@ -32,7 +32,7 @@ public:
     const Type *PtrInt = PointerType::get(Type::IntTy);
     unsigned Size = Target.DataLayout.getTypeSize(PtrInt);
 
-    MachineCodeForMethod &mcInfo = MachineCodeForMethod::get(&F);
+    MachineFunction &mcInfo = MachineFunction::get(&F);
     Value *V = Constant::getNullValue(Type::IntTy);
     mcInfo.allocateLocalVar(Target, V, 2*Size);
     return true;

diff --git a/lib/Target/SparcV9/SparcV9TargetMachine.cpp b/lib/Target/SparcV9/SparcV9TargetMachine.cpp
index 88eaeb893f70d0e5d2b3dc55d51d45a0ae6ee2c4..2484acebf24616344b2bc7072d43df4c7e61ffae 100644 (file)
--- a/lib/Target/SparcV9/SparcV9TargetMachine.cpp
+++ b/lib/Target/SparcV9/SparcV9TargetMachine.cpp
@@ -8,7 +8,7 @@
 #include "SparcInternals.h"
 #include "llvm/Target/Sparc.h"
 #include "llvm/Function.h"
-#include "llvm/CodeGen/MachineCodeForMethod.h"
+#include "llvm/CodeGen/MachineFunction.h"
 using std::cerr;
 
 // Build the MachineInstruction Description Array...
@@ -39,7 +39,7 @@ TargetMachine *allocateSparcTargetMachine() { return new UltraSparc(); }
 //---------------------------------------------------------------------------
 
 int
-UltraSparcFrameInfo::getFirstAutomaticVarOffset(MachineCodeForMethod& ,
+UltraSparcFrameInfo::getFirstAutomaticVarOffset(MachineFunction& ,
                                                 bool& pos) const
 {
   pos = false;                          // static stack area grows downwards
@@ -47,7 +47,7 @@ UltraSparcFrameInfo::getFirstAutomaticVarOffset(MachineCodeForMethod& ,
 }
 
 int
-UltraSparcFrameInfo::getRegSpillAreaOffset(MachineCodeForMethod& mcInfo,
+UltraSparcFrameInfo::getRegSpillAreaOffset(MachineFunction& mcInfo,
                                            bool& pos) const
 {
   mcInfo.freezeAutomaticVarsArea();     // ensure no more auto vars are added
@@ -58,7 +58,7 @@ UltraSparcFrameInfo::getRegSpillAreaOffset(MachineCodeForMethod& mcInfo,
 }
 
 int
-UltraSparcFrameInfo::getTmpAreaOffset(MachineCodeForMethod& mcInfo,
+UltraSparcFrameInfo::getTmpAreaOffset(MachineFunction& mcInfo,
                                       bool& pos) const
 {
   mcInfo.freezeAutomaticVarsArea();     // ensure no more auto vars are added
@@ -72,7 +72,7 @@ UltraSparcFrameInfo::getTmpAreaOffset(MachineCodeForMethod& mcInfo,
 }
 
 int
-UltraSparcFrameInfo::getDynamicAreaOffset(MachineCodeForMethod& mcInfo,
+UltraSparcFrameInfo::getDynamicAreaOffset(MachineFunction& mcInfo,
                                           bool& pos) const
 {
   // Dynamic stack area grows downwards starting at top of opt-args area.

diff --git a/lib/Target/TargetMachine.cpp b/lib/Target/TargetMachine.cpp
index 5a0acfd4399fff9731671902e85af28d13b5afac..a61a804088e6dacbdf4ae937e62c6396fb90e2d6 100644 (file)
--- a/lib/Target/TargetMachine.cpp
+++ b/lib/Target/TargetMachine.cpp
@@ -14,7 +14,7 @@
 #include "llvm/CodeGen/InstrScheduling.h"
 #include "llvm/CodeGen/RegisterAllocation.h"
 #include "llvm/CodeGen/PeepholeOpts.h"
-#include "llvm/CodeGen/MachineCodeForMethod.h"
+#include "llvm/CodeGen/MachineFunction.h"
 #include "llvm/CodeGen/MachineCodeForInstruction.h"
 #include "llvm/Reoptimizer/Mapping/MappingInfo.h" 
 #include "llvm/Reoptimizer/Mapping/FInfo.h" 
@@ -87,7 +87,7 @@ public:
   }
 
   bool runOnFunction(Function &F) {
-    MachineCodeForMethod::construct(&F, Target);
+    MachineFunction::construct(&F, Target);
     return false;
   }
 };
@@ -117,7 +117,7 @@ struct FreeMachineCodeForFunction : public FunctionPass {
 void
 TargetMachine::addPassesToEmitAssembly(PassManager &PM, std::ostream &Out)
 {
-  // Construct and initialize the MachineCodeForMethod object for this fn.
+  // Construct and initialize the MachineFunction object for this fn.
   PM.add(new ConstructMachineCodeForFunction(*this));
 
   //Insert empty stackslots in the stack frame of each function