Chris Lattner | 5074bb5 | 2002-04-09 05:18:31 +0000 | [diff] [blame] | 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" |
Chris Lattner | d2a67df | 2002-12-28 20:16:08 +0000 | [diff] [blame] | 14 | #include "llvm/CodeGen/MachineFunctionPass.h" |
| 15 | #include "llvm/CodeGen/MachineFunctionInfo.h" |
Chris Lattner | 5074bb5 | 2002-04-09 05:18:31 +0000 | [diff] [blame] | 16 | #include "llvm/CodeGen/MachineCodeForInstruction.h" |
Chris Lattner | cbe6385 | 2002-10-28 21:43:57 +0000 | [diff] [blame] | 17 | #include "llvm/CodeGen/MachineInstrBuilder.h" |
Chris Lattner | 5074bb5 | 2002-04-09 05:18:31 +0000 | [diff] [blame] | 18 | #include "llvm/Pass.h" |
| 19 | #include "llvm/Function.h" |
Chris Lattner | 5074bb5 | 2002-04-09 05:18:31 +0000 | [diff] [blame] | 20 | |
| 21 | namespace { |
Chris Lattner | d2a67df | 2002-12-28 20:16:08 +0000 | [diff] [blame] | 22 | struct InsertPrologEpilogCode : public MachineFunctionPass { |
Chris Lattner | 7076ff2 | 2002-06-25 16:13:21 +0000 | [diff] [blame] | 23 | const char *getPassName() const { return "Sparc Prolog/Epilog Inserter"; } |
| 24 | |
Chris Lattner | d2a67df | 2002-12-28 20:16:08 +0000 | [diff] [blame] | 25 | bool runOnMachineFunction(MachineFunction &F) { |
| 26 | if (!F.getInfo()->isCompiledAsLeafMethod()) { |
Chris Lattner | 7076ff2 | 2002-06-25 16:13:21 +0000 | [diff] [blame] | 27 | InsertPrologCode(F); |
| 28 | InsertEpilogCode(F); |
| 29 | } |
| 30 | return false; |
Chris Lattner | 5074bb5 | 2002-04-09 05:18:31 +0000 | [diff] [blame] | 31 | } |
Chris Lattner | 7076ff2 | 2002-06-25 16:13:21 +0000 | [diff] [blame] | 32 | |
Chris Lattner | d2a67df | 2002-12-28 20:16:08 +0000 | [diff] [blame] | 33 | void InsertPrologCode(MachineFunction &F); |
| 34 | void InsertEpilogCode(MachineFunction &F); |
Chris Lattner | 7076ff2 | 2002-06-25 16:13:21 +0000 | [diff] [blame] | 35 | }; |
Chris Lattner | 5074bb5 | 2002-04-09 05:18:31 +0000 | [diff] [blame] | 36 | |
| 37 | } // End anonymous namespace |
| 38 | |
| 39 | //------------------------------------------------------------------------ |
Chris Lattner | 5074bb5 | 2002-04-09 05:18:31 +0000 | [diff] [blame] | 40 | // Create prolog and epilog code for procedure entry and exit |
| 41 | //------------------------------------------------------------------------ |
| 42 | |
Chris Lattner | d2a67df | 2002-12-28 20:16:08 +0000 | [diff] [blame] | 43 | void InsertPrologEpilogCode::InsertPrologCode(MachineFunction &MF) |
Chris Lattner | 5074bb5 | 2002-04-09 05:18:31 +0000 | [diff] [blame] | 44 | { |
Anand Shukla | 458496c | 2002-06-25 20:55:50 +0000 | [diff] [blame] | 45 | std::vector<MachineInstr*> mvec; |
Chris Lattner | d2a67df | 2002-12-28 20:16:08 +0000 | [diff] [blame] | 46 | const TargetMachine &TM = MF.getTarget(); |
| 47 | const TargetFrameInfo& frameInfo = TM.getFrameInfo(); |
Chris Lattner | 5074bb5 | 2002-04-09 05:18:31 +0000 | [diff] [blame] | 48 | |
| 49 | // The second operand is the stack size. If it does not fit in the |
| 50 | // immediate field, we have to use a free register to hold the size. |
Vikram S. Adve | 78044fb | 2002-10-13 00:24:06 +0000 | [diff] [blame] | 51 | // See the comments below for the choice of this register. |
Chris Lattner | 5074bb5 | 2002-04-09 05:18:31 +0000 | [diff] [blame] | 52 | // |
Chris Lattner | d2a67df | 2002-12-28 20:16:08 +0000 | [diff] [blame] | 53 | unsigned staticStackSize = MF.getInfo()->getStaticStackSize(); |
Chris Lattner | 5074bb5 | 2002-04-09 05:18:31 +0000 | [diff] [blame] | 54 | |
| 55 | if (staticStackSize < (unsigned) frameInfo.getMinStackFrameSize()) |
| 56 | staticStackSize = (unsigned) frameInfo.getMinStackFrameSize(); |
Vikram S. Adve | 78044fb | 2002-10-13 00:24:06 +0000 | [diff] [blame] | 57 | |
Chris Lattner | 5074bb5 | 2002-04-09 05:18:31 +0000 | [diff] [blame] | 58 | if (unsigned padsz = (staticStackSize % |
| 59 | (unsigned) frameInfo.getStackFrameSizeAlignment())) |
| 60 | staticStackSize += frameInfo.getStackFrameSizeAlignment() - padsz; |
| 61 | |
Chris Lattner | cbe6385 | 2002-10-28 21:43:57 +0000 | [diff] [blame] | 62 | int32_t C = - (int) staticStackSize; |
Chris Lattner | d2a67df | 2002-12-28 20:16:08 +0000 | [diff] [blame] | 63 | int SP = TM.getRegInfo().getStackPointer(); |
Misha Brukman | 56f4fa1 | 2003-05-20 20:32:24 +0000 | [diff] [blame] | 64 | if (TM.getInstrInfo().constantFitsInImmedField(V9::SAVE,staticStackSize)) { |
| 65 | mvec.push_back(BuildMI(V9::SAVE, 3).addMReg(SP).addSImm(C).addMReg(SP, |
| 66 | MOTy::Def)); |
Chris Lattner | cbe6385 | 2002-10-28 21:43:57 +0000 | [diff] [blame] | 67 | } else { |
Chris Lattner | d2a67df | 2002-12-28 20:16:08 +0000 | [diff] [blame] | 68 | // We have to put the stack size value into a register before SAVE. |
| 69 | // Use register %g1 since it is volatile across calls. Note that the |
| 70 | // local (%l) and in (%i) registers cannot be used before the SAVE! |
| 71 | // Do this by creating a code sequence equivalent to: |
| 72 | // SETSW -(stackSize), %g1 |
| 73 | int uregNum = TM.getRegInfo().getUnifiedRegNum( |
| 74 | TM.getRegInfo().getRegClassIDOfType(Type::IntTy), |
| 75 | SparcIntRegClass::g1); |
Chris Lattner | 5074bb5 | 2002-04-09 05:18:31 +0000 | [diff] [blame] | 76 | |
Misha Brukman | 56f4fa1 | 2003-05-20 20:32:24 +0000 | [diff] [blame] | 77 | MachineInstr* M = BuildMI(V9::SETHI, 2).addSImm(C) |
| 78 | .addMReg(uregNum, MOTy::Def); |
Chris Lattner | d2a67df | 2002-12-28 20:16:08 +0000 | [diff] [blame] | 79 | M->setOperandHi32(0); |
| 80 | mvec.push_back(M); |
| 81 | |
Misha Brukman | 56f4fa1 | 2003-05-20 20:32:24 +0000 | [diff] [blame] | 82 | M = BuildMI(V9::OR, 3).addMReg(uregNum).addSImm(C) |
| 83 | .addMReg(uregNum, MOTy::Def); |
Chris Lattner | d2a67df | 2002-12-28 20:16:08 +0000 | [diff] [blame] | 84 | M->setOperandLo32(1); |
| 85 | mvec.push_back(M); |
| 86 | |
Misha Brukman | 56f4fa1 | 2003-05-20 20:32:24 +0000 | [diff] [blame] | 87 | M = BuildMI(V9::SRA, 3).addMReg(uregNum).addZImm(0) |
| 88 | .addMReg(uregNum, MOTy::Def); |
Chris Lattner | d2a67df | 2002-12-28 20:16:08 +0000 | [diff] [blame] | 89 | mvec.push_back(M); |
| 90 | |
| 91 | // Now generate the SAVE using the value in register %g1 |
Misha Brukman | 56f4fa1 | 2003-05-20 20:32:24 +0000 | [diff] [blame] | 92 | M = BuildMI(V9::SAVE, 3).addMReg(SP).addMReg(uregNum).addMReg(SP,MOTy::Def); |
Chris Lattner | d2a67df | 2002-12-28 20:16:08 +0000 | [diff] [blame] | 93 | mvec.push_back(M); |
| 94 | } |
| 95 | |
| 96 | MF.front().insert(MF.front().begin(), mvec.begin(), mvec.end()); |
Chris Lattner | 5074bb5 | 2002-04-09 05:18:31 +0000 | [diff] [blame] | 97 | } |
| 98 | |
Chris Lattner | d2a67df | 2002-12-28 20:16:08 +0000 | [diff] [blame] | 99 | void InsertPrologEpilogCode::InsertEpilogCode(MachineFunction &MF) |
Chris Lattner | 5074bb5 | 2002-04-09 05:18:31 +0000 | [diff] [blame] | 100 | { |
Chris Lattner | d2a67df | 2002-12-28 20:16:08 +0000 | [diff] [blame] | 101 | const TargetMachine &TM = MF.getTarget(); |
Chris Lattner | b4d58d7 | 2003-01-14 22:00:31 +0000 | [diff] [blame] | 102 | const TargetInstrInfo &MII = TM.getInstrInfo(); |
Chris Lattner | d2a67df | 2002-12-28 20:16:08 +0000 | [diff] [blame] | 103 | |
Misha Brukman | 181ea4a | 2002-10-28 20:01:13 +0000 | [diff] [blame] | 104 | for (MachineFunction::iterator I = MF.begin(), E = MF.end(); I != E; ++I) { |
| 105 | MachineBasicBlock &MBB = *I; |
| 106 | BasicBlock &BB = *I->getBasicBlock(); |
| 107 | Instruction *TermInst = (Instruction*)BB.getTerminator(); |
Chris Lattner | 5074bb5 | 2002-04-09 05:18:31 +0000 | [diff] [blame] | 108 | if (TermInst->getOpcode() == Instruction::Ret) |
Misha Brukman | 56f4fa1 | 2003-05-20 20:32:24 +0000 | [diff] [blame] | 109 | { |
| 110 | int ZR = TM.getRegInfo().getZeroRegNum(); |
| 111 | MachineInstr *Restore = |
| 112 | BuildMI(V9::RESTORE, 3).addMReg(ZR).addSImm(0).addMReg(ZR, MOTy::Def); |
| 113 | |
| 114 | MachineCodeForInstruction &termMvec = |
| 115 | MachineCodeForInstruction::get(TermInst); |
| 116 | |
| 117 | // Remove the NOPs in the delay slots of the return instruction |
| 118 | unsigned numNOPs = 0; |
| 119 | while (termMvec.back()->getOpCode() == V9::NOP) |
Chris Lattner | 5074bb5 | 2002-04-09 05:18:31 +0000 | [diff] [blame] | 120 | { |
Misha Brukman | 56f4fa1 | 2003-05-20 20:32:24 +0000 | [diff] [blame] | 121 | assert( termMvec.back() == MBB.back()); |
| 122 | delete MBB.pop_back(); |
| 123 | termMvec.pop_back(); |
| 124 | ++numNOPs; |
Chris Lattner | 5074bb5 | 2002-04-09 05:18:31 +0000 | [diff] [blame] | 125 | } |
Misha Brukman | 56f4fa1 | 2003-05-20 20:32:24 +0000 | [diff] [blame] | 126 | assert(termMvec.back() == MBB.back()); |
| 127 | |
| 128 | // Check that we found the right number of NOPs and have the right |
| 129 | // number of instructions to replace them. |
| 130 | unsigned ndelays = MII.getNumDelaySlots(termMvec.back()->getOpCode()); |
| 131 | assert(numNOPs == ndelays && "Missing NOPs in delay slots?"); |
| 132 | assert(ndelays == 1 && "Cannot use epilog code for delay slots?"); |
| 133 | |
| 134 | // Append the epilog code to the end of the basic block. |
| 135 | MBB.push_back(Restore); |
| 136 | } |
Chris Lattner | 5074bb5 | 2002-04-09 05:18:31 +0000 | [diff] [blame] | 137 | } |
| 138 | } |
| 139 | |
Vikram S. Adve | 36d3e03 | 2002-09-16 15:39:26 +0000 | [diff] [blame] | 140 | Pass* UltraSparc::getPrologEpilogInsertionPass() { |
Chris Lattner | d2a67df | 2002-12-28 20:16:08 +0000 | [diff] [blame] | 141 | return new InsertPrologEpilogCode(); |
Chris Lattner | 5074bb5 | 2002-04-09 05:18:31 +0000 | [diff] [blame] | 142 | } |