lib/Target/SparcV9/SparcV9PrologEpilogInserter.cpp

   1 //===-- PrologEpilogCodeInserter.cpp - Insert Prolog & Epilog code for fn -===//
   2 //
   3 // Insert SAVE/RESTORE instructions for the function
   4 //
   5 // Insert prolog code at the unique function entry point.
   6 // Insert epilog code at each function exit point.
   7 // InsertPrologEpilog invokes these only if the function is not compiled
   8 // with the leaf function optimization.
   9 //
  10 //===----------------------------------------------------------------------===//
  11
  12 #include "SparcInternals.h"
  13 #include "SparcRegClassInfo.h"
  14 #include "llvm/CodeGen/MachineCodeForMethod.h"
  15 #include "llvm/CodeGen/MachineCodeForBasicBlock.h"
  16 #include "llvm/CodeGen/MachineCodeForInstruction.h"
  17 #include "llvm/CodeGen/MachineInstr.h"
  18 #include "llvm/CodeGen/InstrSelectionSupport.h"
  19 #include "llvm/Pass.h"
  20 #include "llvm/Function.h"
  21
  22 namespace {
  23   class InsertPrologEpilogCode : public FunctionPass {
  24     TargetMachine &Target;
  25   public:
  26     InsertPrologEpilogCode(TargetMachine &T) : Target(T) {}
  27
  28     const char *getPassName() const { return "Sparc Prolog/Epilog Inserter"; }
  29
  30     bool runOnFunction(Function &F) {
  31       MachineCodeForMethod &mcodeInfo = MachineCodeForMethod::get(&F);
  32       if (!mcodeInfo.isCompiledAsLeafMethod()) {
  33         InsertPrologCode(F);
  34         InsertEpilogCode(F);
  35       }
  36       return false;
  37     }
  38
  39     void InsertPrologCode(Function &F);
  40     void InsertEpilogCode(Function &F);
  41   };
  42
  43 }  // End anonymous namespace
  44
  45 //------------------------------------------------------------------------
  46 // External Function: GetInstructionsForProlog
  47 // External Function: GetInstructionsForEpilog
  48 //
  49 // Purpose:
  50 //   Create prolog and epilog code for procedure entry and exit
  51 //------------------------------------------------------------------------
  52
  53 void InsertPrologEpilogCode::InsertPrologCode(Function &F)
  54 {
  55   std::vector<MachineInstr*> mvec;
  56   MachineInstr* M;
  57   const MachineFrameInfo& frameInfo = Target.getFrameInfo();
  58
  59   // The second operand is the stack size. If it does not fit in the
  60   // immediate field, we have to use a free register to hold the size.
  61   // See the comments below for the choice of this register.
  62   //
  63   MachineCodeForMethod& mcInfo = MachineCodeForMethod::get(&F);
  64   unsigned int staticStackSize = mcInfo.getStaticStackSize();
  65
  66   if (staticStackSize < (unsigned) frameInfo.getMinStackFrameSize())
  67     staticStackSize = (unsigned) frameInfo.getMinStackFrameSize();
  68
  69   if (unsigned padsz = (staticStackSize %
  70                         (unsigned) frameInfo.getStackFrameSizeAlignment()))
  71     staticStackSize += frameInfo.getStackFrameSizeAlignment() - padsz;
  72
  73   if (Target.getInstrInfo().constantFitsInImmedField(SAVE, staticStackSize))
  74     {
  75       M = new MachineInstr(SAVE);
  76       M->SetMachineOperandReg(0, Target.getRegInfo().getStackPointer());
  77       M->SetMachineOperandConst(1, MachineOperand::MO_SignExtendedImmed,
  78                                    - (int) staticStackSize);
  79       M->SetMachineOperandReg(2, Target.getRegInfo().getStackPointer());
  80       mvec.push_back(M);
  81     }
  82   else
  83     {
  84       // We have to put the stack size value into a register before SAVE.
  85       // Use register %g1 since it is volatile across calls.  Note that the
  86       // local (%l) and in (%i) registers cannot be used before the SAVE!
  87       // Do this by creating a code sequence equivalent to:
  88       //        SETSW -(stackSize), %g1
  89       int32_t C = - (int) staticStackSize;
  90       int uregNum = Target.getRegInfo().getUnifiedRegNum(
  91                            Target.getRegInfo().getRegClassIDOfType(Type::IntTy),
  92                            SparcIntRegClass::g1);
  93
  94       M = new MachineInstr(SETHI);
  95       M->SetMachineOperandConst(0, MachineOperand::MO_SignExtendedImmed, C);
  96       M->SetMachineOperandReg(1, uregNum);
  97       M->setOperandHi32(0);
  98       mvec.push_back(M);
  99
 100       M = new MachineInstr(OR);
 101       M->SetMachineOperandReg(0, uregNum);
 102       M->SetMachineOperandConst(1, MachineOperand::MO_SignExtendedImmed, C);
 103       M->SetMachineOperandReg(2, uregNum);
 104       M->setOperandLo32(1);
 105       mvec.push_back(M);
 106
 107       M = new MachineInstr(SRA);
 108       M->SetMachineOperandReg(0, uregNum);
 109       M->SetMachineOperandConst(1, MachineOperand::MO_UnextendedImmed, 0);
 110       M->SetMachineOperandReg(2, uregNum);
 111       mvec.push_back(M);
 112
 113       // Now generate the SAVE using the value in register %g1
 114       M = new MachineInstr(SAVE);
 115       M->SetMachineOperandReg(0, Target.getRegInfo().getStackPointer());
 116       M->SetMachineOperandReg(1, uregNum);
 117       M->SetMachineOperandReg(2, Target.getRegInfo().getStackPointer());
 118       mvec.push_back(M);
 119     }
 120
 121   MachineCodeForBasicBlock& bbMvec = MachineCodeForBasicBlock::get(&F.getEntryNode());
 122   bbMvec.insert(bbMvec.begin(), mvec.begin(), mvec.end());
 123 }
 124
 125 void InsertPrologEpilogCode::InsertEpilogCode(Function &F)
 126 {
 127   for (Function::iterator I = F.begin(), E = F.end(); I != E; ++I) {
 128     Instruction *TermInst = (Instruction*)I->getTerminator();
 129     if (TermInst->getOpcode() == Instruction::Ret)
 130       {
 131         MachineInstr *Restore = new MachineInstr(RESTORE);
 132         Restore->SetMachineOperandReg(0, Target.getRegInfo().getZeroRegNum());
 133         Restore->SetMachineOperandConst(1, MachineOperand::MO_SignExtendedImmed,
 134                                         (int64_t)0);
 135         Restore->SetMachineOperandReg(2, Target.getRegInfo().getZeroRegNum());
 136
 137         MachineCodeForBasicBlock& bbMvec = MachineCodeForBasicBlock::get(I);
 138         MachineCodeForInstruction &termMvec =
 139           MachineCodeForInstruction::get(TermInst);
 140
 141         // Remove the NOPs in the delay slots of the return instruction
 142         const MachineInstrInfo &mii = Target.getInstrInfo();
 143         unsigned numNOPs = 0;
 144         while (termMvec.back()->getOpCode() == NOP)
 145           {
 146             assert( termMvec.back() == bbMvec.back());
 147             delete bbMvec.pop_back();
 148             termMvec.pop_back();
 149             ++numNOPs;
 150           }
 151         assert(termMvec.back() == bbMvec.back());
 152
 153         // Check that we found the right number of NOPs and have the right
 154         // number of instructions to replace them.
 155         unsigned ndelays = mii.getNumDelaySlots(termMvec.back()->getOpCode());
 156         assert(numNOPs == ndelays && "Missing NOPs in delay slots?");
 157         assert(ndelays == 1 && "Cannot use epilog code for delay slots?");
 158
 159         // Append the epilog code to the end of the basic block.
 160         bbMvec.push_back(Restore);
 161       }
 162   }
 163 }
 164
 165 Pass* UltraSparc::getPrologEpilogInsertionPass() {
 166   return new InsertPrologEpilogCode(*this);
 167 }