Removal of the redundant CompileContext wrapper

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

diff --git a/include/llvm/CodeGen/InstrSelection.h b/include/llvm/CodeGen/InstrSelection.h
index e5a93b4727dff56dafc1cd7dad08cfce733f4ec3..a175f823891e136e71bbe439d7d9bd4d3861ad0b 100644 (file)
--- a/include/llvm/CodeGen/InstrSelection.h
+++ b/include/llvm/CodeGen/InstrSelection.h
@@ -14,13 +14,13 @@
 
 #include "llvm/Instruction.h"
 #include <vector>
-class CompileContext;
 class Method;
 class InstrForest;
 class MachineInstr;
 class InstructionNode;
 class TmpInstruction;
 class ConstPoolVal;
+class TargetMachine;
 
 //---------------------------------------------------------------------------
 // GLOBAL data and an external function that must be implemented
@@ -32,7 +32,7 @@ const unsigned MAX_INSTR_PER_VMINSTR = 8;
 extern unsigned        GetInstructionsByRule   (InstructionNode* subtreeRoot,
                                         int ruleForNode,
                                         short* nts,
-                                        CompileContext& ccontext,
+                                        TargetMachine &Target,
                                         MachineInstr** minstrVec);
 
 extern bool    ThisIsAChainRule        (int eruleno);
@@ -51,7 +51,7 @@ extern bool   ThisIsAChainRule        (int eruleno);
 //---------------------------------------------------------------------------
 
 bool           SelectInstructionsForMethod     (Method* method,
-                                                CompileContext& ccontext);
+                                                TargetMachine &Target);
 
 
 // Debugging function to print the generated instructions

diff --git a/include/llvm/LLC/CompileContext.h b/include/llvm/LLC/CompileContext.h
deleted file mode 100644 (file)
index 29e1577..0000000
--- a/include/llvm/LLC/CompileContext.h
+++ /dev/null
@@ -1,35 +0,0 @@
-// $Id$ -*-c++-*-
-//***************************************************************************
-// class CompileContext
-// 
-// Purpose:
-//     Holds the common option and target information for a compilation run.
-// 
-// History:
-//     07/15/01 - vadve - Created
-//
-//**************************************************************************/
-
-#ifndef LLVM_LLC_COMPILECONTEXT_H
-#define LLVM_LLC_COMPILECONTEXT_H
-
-#include "llvm/Support/Unique.h"
-class TargetMachine;
-
-//---------------------------------------------------------------------------
-// class CompileContext
-//---------------------------------------------------------------------------
-
-class CompileContext: public Unique {
-private:
-  TargetMachine*       targetMachine;
-  
-public:
-  CompileContext(TargetMachine *Target) : targetMachine(Target) {}
-  ~CompileContext();
-  
-  const TargetMachine& getTarget       () const { return *targetMachine; }
-  TargetMachine&       getTarget       ()       { return *targetMachine; }
-};
-
-#endif

diff --git a/lib/CodeGen/InstrSelection/InstrSelection.cpp b/lib/CodeGen/InstrSelection/InstrSelection.cpp
index 0ad1dbdb5478aab7aca48c4404d2bf572eb62559..c8efb3bf34c9a36c388b043323b9953d17a58f6a 100644 (file)
--- a/lib/CodeGen/InstrSelection/InstrSelection.cpp
+++ b/lib/CodeGen/InstrSelection/InstrSelection.cpp
@@ -16,7 +16,6 @@
 #include "llvm/Type.h"
 #include "llvm/iMemory.h"
 #include "llvm/Instruction.h"
-#include "llvm/LLC/CompileContext.h"
 #include "llvm/CodeGen/MachineInstr.h"
 #include "llvm/Tools/CommandLine.h"
 
@@ -36,7 +35,7 @@ cl::Enum<enum DebugLev> DebugLevel("debug_select", cl::NoFlags, // cl::Hidden
 //************************* Forward Declarations ***************************/
 
 static bool SelectInstructionsForTree(BasicTreeNode* treeRoot, int goalnt,
-                                     CompileContext& ccontext);
+                                     TargetMachine &Target);
 
 
 //******************* Externally Visible Functions *************************/
@@ -47,7 +46,7 @@ static bool SelectInstructionsForTree(BasicTreeNode* treeRoot, int goalnt,
 // Returns true if instruction selection failed, false otherwise.
 //---------------------------------------------------------------------------
 
-bool SelectInstructionsForMethod(Method* method, CompileContext& ccontext) {
+bool SelectInstructionsForMethod(Method* method, TargetMachine &Target) {
   bool failed = false;
   
   InstrForest instrForest;
@@ -77,7 +76,7 @@ bool SelectInstructionsForMethod(Method* method, CompileContext& ccontext) {
        }
       
       // Then recursively walk the tree to select instructions
-      if (SelectInstructionsForTree(basicNode, /*goalnt*/1, ccontext))
+      if (SelectInstructionsForTree(basicNode, /*goalnt*/1, Target))
        {
          failed = true;
          break;
@@ -191,7 +190,7 @@ void PrintMachineInstructions(Method* method) {
 bool
 SelectInstructionsForTree(BasicTreeNode* treeRoot,
                          int goalnt,
-                         CompileContext& ccontext)
+                         TargetMachine &Target)
 {
   // Use a static vector to avoid allocating a new one per VM instruction
   static MachineInstr* minstrVec[MAX_INSTR_PER_VMINSTR];
@@ -220,7 +219,7 @@ SelectInstructionsForTree(BasicTreeNode* treeRoot,
       InstructionNode* instrNode = (InstructionNode*) MainTreeNode(treeRoot);
       assert(instrNode->getNodeType() == InstrTreeNode::NTInstructionNode);
       
-      unsigned N = GetInstructionsByRule(instrNode, ruleForNode, nts, ccontext,
+      unsigned N = GetInstructionsByRule(instrNode, ruleForNode, nts, Target,
                                         minstrVec);
       assert(N <= MAX_INSTR_PER_VMINSTR);
       for (unsigned i=0; i < N; i++)
@@ -260,8 +259,7 @@ SelectInstructionsForTree(BasicTreeNode* treeRoot,
          if (nodeType == InstrTreeNode::NTVRegListNode ||
              nodeType == InstrTreeNode::NTInstructionNode)
            {
-             bool failed= SelectInstructionsForTree(kids[i], nts[i],ccontext);
-             if (failed)
+             if (SelectInstructionsForTree(kids[i], nts[i], Target))
                return true;                    // failure
            }
        }

diff --git a/lib/CodeGen/TargetMachine/Sparc/SparcInstrSelection.cpp b/lib/CodeGen/TargetMachine/Sparc/SparcInstrSelection.cpp
index 50fcb0499d12c4550e995494efe2214b4f7ce005..b33dd022f1b9862dc5e2be24802111533461e3e4 100644 (file)
--- a/lib/CodeGen/TargetMachine/Sparc/SparcInstrSelection.cpp
+++ b/lib/CodeGen/TargetMachine/Sparc/SparcInstrSelection.cpp
@@ -9,8 +9,6 @@
 //     7/02/01  -  Vikram Adve  -  Created
 //***************************************************************************
 
-//*************************** User Include Files ***************************/
-
 #include "llvm/Type.h"
 #include "llvm/DerivedTypes.h"
 #include "llvm/SymbolTable.h"
@@ -23,7 +21,6 @@
 #include "llvm/BasicBlock.h"
 #include "llvm/Method.h"
 #include "llvm/ConstPoolVals.h"
-#include "llvm/LLC/CompileContext.h"
 #include "llvm/CodeGen/Sparc.h"
 #include "llvm/CodeGen/MachineInstr.h"
 #include "llvm/CodeGen/InstrForest.h"
@@ -148,7 +145,7 @@ unsigned
 GetInstructionsByRule(InstructionNode* subtreeRoot,
                      int ruleForNode,
                      short* nts,
-                     CompileContext& ccontext,
+                     TargetMachine &Target,
                      MachineInstr** mvec)
 {
   int numInstr = 1;                    // initialize for common case
@@ -183,7 +180,7 @@ GetInstructionsByRule(InstructionNode* subtreeRoot,
   case 3:      // stmt:   Store(reg,reg)
   case 4:      // stmt:   Store(reg,ptrreg)
     mvec[0] = new MachineInstr(ChooseStoreInstruction(subtreeRoot->leftChild()->getValue()->getType()));
-    SetOperandsForMemInstr(mvec[0], subtreeRoot, ccontext.getTarget());
+    SetOperandsForMemInstr(mvec[0], subtreeRoot, Target);
     break;
     
   case 5:      // stmt:   BrUncond
@@ -307,7 +304,7 @@ GetInstructionsByRule(InstructionNode* subtreeRoot,
     else
       {
        mvec[0] =new MachineInstr(ChooseConvertToIntInstr(subtreeRoot,opType));
-       Set2OperandsFromInstr(mvec[0], subtreeRoot, ccontext.getTarget());
+       Set2OperandsFromInstr(mvec[0], subtreeRoot, Target);
       }
     break;
     
@@ -329,7 +326,7 @@ GetInstructionsByRule(InstructionNode* subtreeRoot,
       {
        opType = subtreeRoot->leftChild()->getValue()->getType();
        mvec[0] = new MachineInstr(ChooseConvertToFloatInstr(subtreeRoot, opType));
-       Set2OperandsFromInstr(mvec[0], subtreeRoot, ccontext.getTarget());
+       Set2OperandsFromInstr(mvec[0], subtreeRoot, Target);
       }
     break;
     
@@ -340,12 +337,12 @@ GetInstructionsByRule(InstructionNode* subtreeRoot,
     
   case 33:     // reg:   Add(reg, reg)
     mvec[0] = new MachineInstr(ChooseAddInstruction(subtreeRoot));
-    Set3OperandsFromInstr(mvec[0], subtreeRoot, ccontext.getTarget());
+    Set3OperandsFromInstr(mvec[0], subtreeRoot, Target);
     break;
     
   case 34:     // reg:   Sub(reg, reg)
     mvec[0] = new MachineInstr(ChooseSubInstruction(subtreeRoot));
-    Set3OperandsFromInstr(mvec[0], subtreeRoot, ccontext.getTarget());
+    Set3OperandsFromInstr(mvec[0], subtreeRoot, Target);
     break;
     
   case 135:    // reg:   Mul(todouble, todouble)
@@ -354,12 +351,12 @@ GetInstructionsByRule(InstructionNode* subtreeRoot,
     
   case 35:     // reg:   Mul(reg, reg)
     mvec[0] = new MachineInstr(ChooseMulInstruction(subtreeRoot, checkCast));
-    Set3OperandsFromInstr(mvec[0], subtreeRoot, ccontext.getTarget());
+    Set3OperandsFromInstr(mvec[0], subtreeRoot, Target);
     break;
     
   case 36:     // reg:   Div(reg, reg)
     mvec[0] = new MachineInstr(ChooseDivInstruction(subtreeRoot));
-    Set3OperandsFromInstr(mvec[0], subtreeRoot, ccontext.getTarget());
+    Set3OperandsFromInstr(mvec[0], subtreeRoot, Target);
     break;
     
   case 37:     // reg:   Rem(reg, reg)
@@ -368,32 +365,32 @@ GetInstructionsByRule(InstructionNode* subtreeRoot,
     
   case 38:     // reg:   And(reg, reg)
     mvec[0] = new MachineInstr(AND);
-    Set3OperandsFromInstr(mvec[0], subtreeRoot, ccontext.getTarget());
+    Set3OperandsFromInstr(mvec[0], subtreeRoot, Target);
     break;
     
   case 138:    // reg:   And(reg, not)
     mvec[0] = new MachineInstr(ANDN);
-    Set3OperandsFromInstr(mvec[0], subtreeRoot, ccontext.getTarget());
+    Set3OperandsFromInstr(mvec[0], subtreeRoot, Target);
     break;
     
   case 39:     // reg:   Or(reg, reg)
     mvec[0] = new MachineInstr(ORN);
-    Set3OperandsFromInstr(mvec[0], subtreeRoot, ccontext.getTarget());
+    Set3OperandsFromInstr(mvec[0], subtreeRoot, Target);
     break;
     
   case 139:    // reg:   Or(reg, not)
     mvec[0] = new MachineInstr(ORN);
-    Set3OperandsFromInstr(mvec[0], subtreeRoot, ccontext.getTarget());
+    Set3OperandsFromInstr(mvec[0], subtreeRoot, Target);
     break;
     
   case 40:     // reg:   Xor(reg, reg)
     mvec[0] = new MachineInstr(XOR);
-    Set3OperandsFromInstr(mvec[0], subtreeRoot, ccontext.getTarget());
+    Set3OperandsFromInstr(mvec[0], subtreeRoot, Target);
     break;
     
   case 140:    // reg:   Xor(reg, not)
     mvec[0] = new MachineInstr(XNOR);
-    Set3OperandsFromInstr(mvec[0], subtreeRoot, ccontext.getTarget());
+    Set3OperandsFromInstr(mvec[0], subtreeRoot, Target);
     break;
     
   case 41:     // boolconst:   SetCC(reg, Constant)
@@ -430,7 +427,7 @@ GetInstructionsByRule(InstructionNode* subtreeRoot,
       {
        // integer condition: destination should be %g0
        mvec[0] = new MachineInstr(SUBcc);
-       Set3OperandsFromInstr(mvec[0], subtreeRoot, ccontext.getTarget(),
+       Set3OperandsFromInstr(mvec[0], subtreeRoot, Target,
                              /*canDiscardResult*/ true);
       }
     else
@@ -456,7 +453,7 @@ GetInstructionsByRule(InstructionNode* subtreeRoot,
   case 53:     // reg:   LoadIdx(reg,reg)
   case 54:     // reg:   LoadIdx(ptrreg,reg)
     mvec[0] = new MachineInstr(ChooseLoadInstruction(subtreeRoot->getValue()->getType()));
-    SetOperandsForMemInstr(mvec[0], subtreeRoot, ccontext.getTarget());
+    SetOperandsForMemInstr(mvec[0], subtreeRoot, Target);
     break;
     
   case 55:     // reg:   GetElemPtr(reg)
@@ -476,7 +473,7 @@ GetInstructionsByRule(InstructionNode* subtreeRoot,
       }
     // else in all other cases we need to a separate ADD instruction
     mvec[0] = new MachineInstr(ADD);
-    SetOperandsForMemInstr(mvec[0], subtreeRoot, ccontext.getTarget());
+    SetOperandsForMemInstr(mvec[0], subtreeRoot, Target);
     break;
     
   case 57:     // reg:   Alloca: Implement as 2 instructions:
@@ -485,8 +482,7 @@ GetInstructionsByRule(InstructionNode* subtreeRoot,
     Instruction* instr = subtreeRoot->getInstruction();
     const PointerType* instrType = (const PointerType*) instr->getType();
     assert(instrType->isPointerType());
-    int tsize = (int) ccontext.getTarget().findOptimalStorageSize(
-                                                   instrType->getValueType());
+    int tsize = (int) Target.findOptimalStorageSize(instrType->getValueType());
     if (tsize == 0)
       {
        numInstr = 0;
@@ -528,7 +524,7 @@ GetInstructionsByRule(InstructionNode* subtreeRoot,
           instrType->getValueType()->isArrayType());
     const Type* eltType =
       ((ArrayType*) instrType->getValueType())->getElementType();
-    int tsize = (int) ccontext.getTarget().findOptimalStorageSize(eltType);
+    int tsize = (int) Target.findOptimalStorageSize(eltType);
     
     if (tsize == 0)
       {
@@ -600,7 +596,7 @@ GetInstructionsByRule(InstructionNode* subtreeRoot,
     opType = subtreeRoot->leftChild()->getValue()->getType();
     assert(opType->isIntegral() || opType == Type::BoolTy); 
     mvec[0] = new MachineInstr((opType == Type::LongTy)? SLLX : SLL);
-    Set3OperandsFromInstr(mvec[0], subtreeRoot, ccontext.getTarget());
+    Set3OperandsFromInstr(mvec[0], subtreeRoot, Target);
     break;
     
   case 63:     // reg:   Shr(reg, reg)
@@ -609,7 +605,7 @@ GetInstructionsByRule(InstructionNode* subtreeRoot,
     mvec[0] = new MachineInstr((opType->isSigned()
                                ? ((opType == Type::LongTy)? SRAX : SRA)
                                : ((opType == Type::LongTy)? SRLX : SRL)));
-    Set3OperandsFromInstr(mvec[0], subtreeRoot, ccontext.getTarget());
+    Set3OperandsFromInstr(mvec[0], subtreeRoot, Target);
     break;
     
   case 71:     // reg:     VReg
@@ -642,7 +638,7 @@ GetInstructionsByRule(InstructionNode* subtreeRoot,
           && "A chain rule should have only one RHS non-terminal!");
     nextRule = burm_rule(subtreeRoot->getBasicNode()->state, nts[0]);
     nts = burm_nts[nextRule];
-    numInstr = GetInstructionsByRule(subtreeRoot, nextRule, nts,ccontext,mvec);
+    numInstr = GetInstructionsByRule(subtreeRoot, nextRule, nts,Target,mvec);
     break;
     
   default:
@@ -651,7 +647,7 @@ GetInstructionsByRule(InstructionNode* subtreeRoot,
   }
   
   numInstr =
-    FixConstantOperands(subtreeRoot, mvec, numInstr, ccontext.getTarget());
+    FixConstantOperands(subtreeRoot, mvec, numInstr, Target);
   
   return numInstr;
 }

diff --git a/lib/Target/SparcV9/InstrSelection/InstrSelection.cpp b/lib/Target/SparcV9/InstrSelection/InstrSelection.cpp
index 0ad1dbdb5478aab7aca48c4404d2bf572eb62559..c8efb3bf34c9a36c388b043323b9953d17a58f6a 100644 (file)
--- a/lib/Target/SparcV9/InstrSelection/InstrSelection.cpp
+++ b/lib/Target/SparcV9/InstrSelection/InstrSelection.cpp
@@ -16,7 +16,6 @@
 #include "llvm/Type.h"
 #include "llvm/iMemory.h"
 #include "llvm/Instruction.h"
-#include "llvm/LLC/CompileContext.h"
 #include "llvm/CodeGen/MachineInstr.h"
 #include "llvm/Tools/CommandLine.h"
 
@@ -36,7 +35,7 @@ cl::Enum<enum DebugLev> DebugLevel("debug_select", cl::NoFlags, // cl::Hidden
 //************************* Forward Declarations ***************************/
 
 static bool SelectInstructionsForTree(BasicTreeNode* treeRoot, int goalnt,
-                                     CompileContext& ccontext);
+                                     TargetMachine &Target);
 
 
 //******************* Externally Visible Functions *************************/
@@ -47,7 +46,7 @@ static bool SelectInstructionsForTree(BasicTreeNode* treeRoot, int goalnt,
 // Returns true if instruction selection failed, false otherwise.
 //---------------------------------------------------------------------------
 
-bool SelectInstructionsForMethod(Method* method, CompileContext& ccontext) {
+bool SelectInstructionsForMethod(Method* method, TargetMachine &Target) {
   bool failed = false;
   
   InstrForest instrForest;
@@ -77,7 +76,7 @@ bool SelectInstructionsForMethod(Method* method, CompileContext& ccontext) {
        }
       
       // Then recursively walk the tree to select instructions
-      if (SelectInstructionsForTree(basicNode, /*goalnt*/1, ccontext))
+      if (SelectInstructionsForTree(basicNode, /*goalnt*/1, Target))
        {
          failed = true;
          break;
@@ -191,7 +190,7 @@ void PrintMachineInstructions(Method* method) {
 bool
 SelectInstructionsForTree(BasicTreeNode* treeRoot,
                          int goalnt,
-                         CompileContext& ccontext)
+                         TargetMachine &Target)
 {
   // Use a static vector to avoid allocating a new one per VM instruction
   static MachineInstr* minstrVec[MAX_INSTR_PER_VMINSTR];
@@ -220,7 +219,7 @@ SelectInstructionsForTree(BasicTreeNode* treeRoot,
       InstructionNode* instrNode = (InstructionNode*) MainTreeNode(treeRoot);
       assert(instrNode->getNodeType() == InstrTreeNode::NTInstructionNode);
       
-      unsigned N = GetInstructionsByRule(instrNode, ruleForNode, nts, ccontext,
+      unsigned N = GetInstructionsByRule(instrNode, ruleForNode, nts, Target,
                                         minstrVec);
       assert(N <= MAX_INSTR_PER_VMINSTR);
       for (unsigned i=0; i < N; i++)
@@ -260,8 +259,7 @@ SelectInstructionsForTree(BasicTreeNode* treeRoot,
          if (nodeType == InstrTreeNode::NTVRegListNode ||
              nodeType == InstrTreeNode::NTInstructionNode)
            {
-             bool failed= SelectInstructionsForTree(kids[i], nts[i],ccontext);
-             if (failed)
+             if (SelectInstructionsForTree(kids[i], nts[i], Target))
                return true;                    // failure
            }
        }

diff --git a/tools/llc/llc.cpp b/tools/llc/llc.cpp
index 1ebfb5037e800ec367d70cf89c88149cbef71e6f..ab1f532b36b76669ab83ee36850a6e3a3e233851 100644 (file)
--- a/tools/llc/llc.cpp
+++ b/tools/llc/llc.cpp
@@ -16,17 +16,13 @@
 #include "llvm/Bytecode/Reader.h"
 #include "llvm/Bytecode/Writer.h"
 #include "llvm/CodeGen/InstrSelection.h"
-#include "llvm/LLC/CompileContext.h"
 #include "llvm/CodeGen/Sparc.h"
 #include "llvm/Tools/CommandLine.h"
 
 cl::String InputFilename ("", "Input filename", cl::NoFlags, "");
 cl::String OutputFilename("o", "Output filename", cl::NoFlags, "");
 
-
-CompileContext::~CompileContext() { delete targetMachine; }
-
-static bool CompileModule(Module *module, CompileContext& ccontext) {
+static bool CompileModule(Module *module, TargetMachine &Target) {
   bool failed = false;
   
   for (Module::MethodListType::const_iterator
@@ -36,7 +32,7 @@ static bool CompileModule(Module *module, CompileContext& ccontext) {
     {
       Method* method = *methodIter;
       
-      if (SelectInstructionsForMethod(method, ccontext))
+      if (SelectInstructionsForMethod(method, Target))
        {
          failed = true;
          cerr << "Instruction selection failed for method "
@@ -56,7 +52,7 @@ static bool CompileModule(Module *module, CompileContext& ccontext) {
 
 int main(int argc, char** argv) {
   cl::ParseCommandLineOptions(argc, argv, " llvm system compiler\n");
-  CompileContext compileContext(new UltraSparc());
+  UltraSparc Target;
 
   Module *module = ParseBytecodeFile(InputFilename.getValue());
   if (module == 0) {
@@ -64,7 +60,7 @@ int main(int argc, char** argv) {
     return 1;
   }
   
-  bool failure = CompileModule(module, compileContext);
+  bool failure = CompileModule(module, Target);
   
   if (failure) {
       cerr << "Error compiling "