#include "llvm/Target/MRegisterInfo.h"
#include "llvm/Target/TargetFrameInfo.h"
#include "llvm/Target/TargetInstrInfo.h"
+#include "llvm/Support/Visibility.h"
using namespace llvm;
namespace {
- struct PEI : public MachineFunctionPass {
+ struct VISIBILITY_HIDDEN PEI : public MachineFunctionPass {
const char *getPassName() const {
return "Prolog/Epilog Insertion & Frame Finalization";
}
/// frame indexes with appropriate references.
///
bool runOnMachineFunction(MachineFunction &Fn) {
+ // Get MachineDebugInfo so that we can track the construction of the
+ // frame.
+ if (MachineDebugInfo *DI = getAnalysisToUpdate<MachineDebugInfo>()) {
+ Fn.getFrameInfo()->setMachineDebugInfo(DI);
+ }
+
// Scan the function for modified caller saved registers and insert spill
// code for any caller saved registers that are modified. Also calculate
// the MaxCallFrameSize and HasCalls variables for the function's frame
//
replaceFrameIndices(Fn);
- RegsToSave.clear();
- StackSlots.clear();
return true;
}
-
+
private:
- std::vector<std::pair<unsigned, const TargetRegisterClass*> > RegsToSave;
- std::vector<int> StackSlots;
-
void calculateCallerSavedRegisters(MachineFunction &Fn);
void saveCallerSavedRegisters(MachineFunction &Fn);
void calculateFrameObjectOffsets(MachineFunction &Fn);
void PEI::calculateCallerSavedRegisters(MachineFunction &Fn) {
const MRegisterInfo *RegInfo = Fn.getTarget().getRegisterInfo();
const TargetFrameInfo *TFI = Fn.getTarget().getFrameInfo();
- const TargetInstrInfo &TII = *Fn.getTarget().getInstrInfo();
// Get the callee saved register list...
const unsigned *CSRegs = RegInfo->getCalleeSaveRegs();
const bool *PhysRegsUsed = Fn.getUsedPhysregs();
const TargetRegisterClass* const *CSRegClasses =
RegInfo->getCalleeSaveRegClasses();
+ std::vector<CalleeSavedInfo> CSI;
for (unsigned i = 0; CSRegs[i]; ++i) {
unsigned Reg = CSRegs[i];
if (PhysRegsUsed[Reg]) {
// If the reg is modified, save it!
- RegsToSave.push_back(std::make_pair(Reg, CSRegClasses[i]));
+ CSI.push_back(CalleeSavedInfo(Reg, CSRegClasses[i]));
} else {
for (const unsigned *AliasSet = RegInfo->getAliasSet(Reg);
*AliasSet; ++AliasSet) { // Check alias registers too.
if (PhysRegsUsed[*AliasSet]) {
- RegsToSave.push_back(std::make_pair(Reg, CSRegClasses[i]));
+ CSI.push_back(CalleeSavedInfo(Reg, CSRegClasses[i]));
break;
}
}
}
}
- if (RegsToSave.empty())
+ if (CSI.empty())
return; // Early exit if no caller saved registers are modified!
unsigned NumFixedSpillSlots;
// Now that we know which registers need to be saved and restored, allocate
// stack slots for them.
- for (unsigned i = 0, e = RegsToSave.size(); i != e; ++i) {
- unsigned Reg = RegsToSave[i].first;
- const TargetRegisterClass *RC = RegsToSave[i].second;
+ for (unsigned i = 0, e = CSI.size(); i != e; ++i) {
+ unsigned Reg = CSI[i].getReg();
+ const TargetRegisterClass *RC = CSI[i].getRegClass();
// Check to see if this physreg must be spilled to a particular stack slot
// on this target.
// Spill it to the stack where we must.
FrameIdx = FFI->CreateFixedObject(RC->getSize(), FixedSlot->second);
}
- StackSlots.push_back(FrameIdx);
+ CSI[i].setFrameIdx(FrameIdx);
}
+
+ FFI->setCalleeSavedInfo(CSI);
}
/// saveCallerSavedRegisters - Insert spill code for any caller saved registers
/// that are modified in the function.
///
void PEI::saveCallerSavedRegisters(MachineFunction &Fn) {
+ // Get callee saved register information.
+ MachineFrameInfo *FFI = Fn.getFrameInfo();
+ const std::vector<CalleeSavedInfo> &CSI = FFI->getCalleeSavedInfo();
+
// Early exit if no caller saved registers are modified!
- if (RegsToSave.empty())
+ if (CSI.empty())
return;
const MRegisterInfo *RegInfo = Fn.getTarget().getRegisterInfo();
// code into the entry block.
MachineBasicBlock *MBB = Fn.begin();
MachineBasicBlock::iterator I = MBB->begin();
- for (unsigned i = 0, e = RegsToSave.size(); i != e; ++i) {
+ for (unsigned i = 0, e = CSI.size(); i != e; ++i) {
// Insert the spill to the stack frame.
- RegInfo->storeRegToStackSlot(*MBB, I, RegsToSave[i].first, StackSlots[i],
- RegsToSave[i].second);
+ RegInfo->storeRegToStackSlot(*MBB, I, CSI[i].getReg(), CSI[i].getFrameIdx(),
+ CSI[i].getRegClass());
}
// Add code to restore the callee-save registers in each exiting block.
// Restore all registers immediately before the return and any terminators
// that preceed it.
- for (unsigned i = 0, e = RegsToSave.size(); i != e; ++i) {
- RegInfo->loadRegFromStackSlot(*MBB, I, RegsToSave[i].first,
- StackSlots[i], RegsToSave[i].second);
+ for (unsigned i = 0, e = CSI.size(); i != e; ++i) {
+ RegInfo->loadRegFromStackSlot(*MBB, I, CSI[i].getReg(),
+ CSI[i].getFrameIdx(),
+ CSI[i].getRegClass());
assert(I != MBB->begin() &&
"loadRegFromStackSlot didn't insert any code!");
// Insert in reverse order. loadRegFromStackSlot can insert multiple
MachineFrameInfo *FFI = Fn.getFrameInfo();
unsigned StackAlignment = TFI.getStackAlignment();
- unsigned MaxAlign = StackAlignment;
+ unsigned MaxAlign = 0;
// Start at the beginning of the local area.
// The Offset is the distance from the stack top in the direction
// Set the final value of the stack pointer...
FFI->setStackSize(Offset+TFI.getOffsetOfLocalArea());
- // If we have a new stack alignment, set the preferred stack alignment so that
- // the targets can do the appropriate thing to properly align the stack above
- // the default alignment.
- if (MaxAlign > StackAlignment)
- FFI->setMaxAlignment(MaxAlign);
+
+ // Remember the required stack alignment in case targets need it to perform
+ // dynamic stack alignment.
+ assert(FFI->getMaxAlignment() == MaxAlign &&
+ "Stack alignment calculation broken!");
}