#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 {
// 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);
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;
}
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 = F.getEntryNode().getMachineInstrVec();
+ MachineCodeForBasicBlock& bbMvec = MachineCodeForBasicBlock::get(&F.getEntryNode());
bbMvec.insert(bbMvec.begin(), mvec.begin(), mvec.end());
}
(int64_t)0);
Restore->SetMachineOperandReg(2, Target.getRegInfo().getZeroRegNum());
- MachineCodeForBasicBlock& bbMvec = I->getMachineInstrVec();
+ MachineCodeForBasicBlock& bbMvec = MachineCodeForBasicBlock::get(I);
MachineCodeForInstruction &termMvec =
MachineCodeForInstruction::get(TermInst);
}
}
-Pass *createPrologEpilogCodeInserter(TargetMachine &TM) {
- return new InsertPrologEpilogCode(TM);
+Pass* UltraSparc::getPrologEpilogInsertionPass() {
+ return new InsertPrologEpilogCode(*this);
}