Allow emission of names that start with an underscore. This is needed to

[oota-llvm.git] / lib / Target / SparcV9 / SparcV9PrologEpilogInserter.cpp

diff --git a/lib/Target/SparcV9/SparcV9PrologEpilogInserter.cpp b/lib/Target/SparcV9/SparcV9PrologEpilogInserter.cpp
index 17cd73bfc3428bb92fdb61447f72b42e4b56b81b..75146c072ed94d1598080b0fcd1387b4d575ee77 100644 (file)
--- a/lib/Target/SparcV9/SparcV9PrologEpilogInserter.cpp
+++ b/lib/Target/SparcV9/SparcV9PrologEpilogInserter.cpp
@@ -12,31 +12,33 @@
 #include "SparcInternals.h"
 #include "SparcRegClassInfo.h"
 #include "llvm/CodeGen/MachineCodeForMethod.h"
+#include "llvm/CodeGen/MachineCodeForBasicBlock.h"
 #include "llvm/CodeGen/MachineCodeForInstruction.h"
 #include "llvm/CodeGen/MachineInstr.h"
+#include "llvm/CodeGen/InstrSelectionSupport.h"
 #include "llvm/Pass.h"
 #include "llvm/Function.h"
-#include "llvm/BasicBlock.h"
-#include "llvm/Instruction.h"
 
 namespace {
-
-class InsertPrologEpilogCode : public FunctionPass {
-  TargetMachine &Target;
-public:
-  InsertPrologEpilogCode(TargetMachine &T) : Target(T) {}
-  bool runOnFunction(Function *F) {
-    MachineCodeForMethod &mcodeInfo = MachineCodeForMethod::get(F);
-    if (!mcodeInfo.isCompiledAsLeafMethod()) {
-      InsertPrologCode(F);
-      InsertEpilogCode(F);
+  class InsertPrologEpilogCode : public FunctionPass {
+    TargetMachine &Target;
+  public:
+    InsertPrologEpilogCode(TargetMachine &T) : Target(T) {}
+    
+    const char *getPassName() const { return "Sparc Prolog/Epilog Inserter"; }
+    
+    bool runOnFunction(Function &F) {
+      MachineCodeForMethod &mcodeInfo = MachineCodeForMethod::get(&F);
+      if (!mcodeInfo.isCompiledAsLeafMethod()) {
+        InsertPrologCode(F);
+        InsertEpilogCode(F);
+      }
+      return false;
     }
-    return false;
-  }
-
-  void InsertPrologCode(Function *F);
-  void InsertEpilogCode(Function *F);
-};
+    
+    void InsertPrologCode(Function &F);
+    void InsertEpilogCode(Function &F);
+  };
 
 }  // End anonymous namespace
 
@@ -48,25 +50,22 @@ public:
 //   Create prolog and epilog code for procedure entry and exit
 //------------------------------------------------------------------------ 
 
-void InsertPrologEpilogCode::InsertPrologCode(Function *F)
+void InsertPrologEpilogCode::InsertPrologCode(Function &F)
 {
-  BasicBlock *entryBB = F->getEntryNode();
-
-  vector<MachineInstr*> mvec;
+  std::vector<MachineInstr*> mvec;
   MachineInstr* M;
   const MachineFrameInfo& frameInfo = Target.getFrameInfo();
   
   // The second operand is the stack size. If it does not fit in the
   // immediate field, we have to use a free register to hold the size.
-  // We will assume that local register `l0' is unused since the SAVE
-  // instruction must be the first instruction in each procedure.
+  // See the comments below for the choice of this register.
   // 
-  MachineCodeForMethod& mcInfo = MachineCodeForMethod::get(F);
+  MachineCodeForMethod& mcInfo = MachineCodeForMethod::get(&F);
   unsigned int staticStackSize = mcInfo.getStaticStackSize();
   
   if (staticStackSize < (unsigned) frameInfo.getMinStackFrameSize())
     staticStackSize = (unsigned) frameInfo.getMinStackFrameSize();
-  
+
   if (unsigned padsz = (staticStackSize %
                         (unsigned) frameInfo.getStackFrameSizeAlignment()))
     staticStackSize += frameInfo.getStackFrameSizeAlignment() - padsz;
@@ -82,45 +81,60 @@ void InsertPrologEpilogCode::InsertPrologCode(Function *F)
     }
   else
     {
-      M = new MachineInstr(SETSW);
-      M->SetMachineOperandConst(0, MachineOperand::MO_SignExtendedImmed,
-                                - (int) staticStackSize);
-      M->SetMachineOperandReg(1, MachineOperand::MO_MachineRegister,
-                                 Target.getRegInfo().getUnifiedRegNum(
+      // We have to put the stack size value into a register before SAVE.
+      // Use register %g1 since it is volatile across calls.  Note that the
+      // local (%l) and in (%i) registers cannot be used before the SAVE!
+      // Do this by creating a code sequence equivalent to:
+      //        SETSW -(stackSize), %g1
+      int32_t C = - (int) staticStackSize;
+      int uregNum = Target.getRegInfo().getUnifiedRegNum(
                            Target.getRegInfo().getRegClassIDOfType(Type::IntTy),
-                                  SparcIntRegOrder::l0));
+                           SparcIntRegClass::g1);
+      
+      M = new MachineInstr(SETHI);
+      M->SetMachineOperandConst(0, MachineOperand::MO_SignExtendedImmed, C);
+      M->SetMachineOperandReg(1, uregNum); 
+      M->setOperandHi32(0);
+      mvec.push_back(M);
+      
+      M = new MachineInstr(OR);
+      M->SetMachineOperandReg(0, uregNum);
+      M->SetMachineOperandConst(1, MachineOperand::MO_SignExtendedImmed, C);
+      M->SetMachineOperandReg(2, uregNum);
+      M->setOperandLo32(1);
       mvec.push_back(M);
       
+      M = new MachineInstr(SRA);
+      M->SetMachineOperandReg(0, uregNum);
+      M->SetMachineOperandConst(1, MachineOperand::MO_UnextendedImmed, 0);
+      M->SetMachineOperandReg(2, uregNum);
+      mvec.push_back(M);
+      
+      // Now generate the SAVE using the value in register %g1
       M = new MachineInstr(SAVE);
       M->SetMachineOperandReg(0, Target.getRegInfo().getStackPointer());
-      M->SetMachineOperandReg(1, MachineOperand::MO_MachineRegister,
-                                 Target.getRegInfo().getUnifiedRegNum(
-                           Target.getRegInfo().getRegClassIDOfType(Type::IntTy),
-                                  SparcIntRegOrder::l0));
+      M->SetMachineOperandReg(1, uregNum);
       M->SetMachineOperandReg(2, Target.getRegInfo().getStackPointer());
       mvec.push_back(M);
     }
 
-  MachineCodeForBasicBlock& bbMvec = entryBB->getMachineInstrVec();
-  bbMvec.insert(entryBB->getMachineInstrVec().begin(),
-                mvec.begin(), mvec.end());
+  MachineCodeForBasicBlock& bbMvec = MachineCodeForBasicBlock::get(&F.getEntryNode());
+  bbMvec.insert(bbMvec.begin(), mvec.begin(), mvec.end());
 }
 
-void InsertPrologEpilogCode::InsertEpilogCode(Function *F)
+void InsertPrologEpilogCode::InsertEpilogCode(Function &F)
 {
-  for (Function::iterator I = F->begin(), E = F->end(); I != E; ++I) {
-    Instruction *TermInst = (Instruction*)(*I)->getTerminator();
+  for (Function::iterator I = F.begin(), E = F.end(); I != E; ++I) {
+    Instruction *TermInst = (Instruction*)I->getTerminator();
     if (TermInst->getOpcode() == Instruction::Ret)
       {
-        BasicBlock* exitBB = *I;
-
         MachineInstr *Restore = new MachineInstr(RESTORE);
         Restore->SetMachineOperandReg(0, Target.getRegInfo().getZeroRegNum());
         Restore->SetMachineOperandConst(1, MachineOperand::MO_SignExtendedImmed,
                                         (int64_t)0);
         Restore->SetMachineOperandReg(2, Target.getRegInfo().getZeroRegNum());
         
-        MachineCodeForBasicBlock& bbMvec = exitBB->getMachineInstrVec();
+        MachineCodeForBasicBlock& bbMvec = MachineCodeForBasicBlock::get(I);
         MachineCodeForInstruction &termMvec =
           MachineCodeForInstruction::get(TermInst);
         
@@ -148,6 +162,6 @@ void InsertPrologEpilogCode::InsertEpilogCode(Function *F)
   }
 }
 
-Pass *createPrologEpilogCodeInserter(TargetMachine &TM) {
-  return new InsertPrologEpilogCode(TM);
+Pass* UltraSparc::getPrologEpilogInsertionPass() {
+  return new InsertPrologEpilogCode(*this);
 }