mirror of
https://github.com/c64scene-ar/llvm-6502.git
synced 2024-08-23 02:29:18 +00:00
Rename MachineFrameInfo variables to MFI, for consistency with
the rest of CodeGen. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@101146 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
parent
13e73f483e
commit
9e9aa44d1a
@ -131,10 +131,10 @@ void PEI::getAnalysisUsage(AnalysisUsage &AU) const {
|
||||
/// pseudo instructions.
|
||||
void PEI::calculateCallsInformation(MachineFunction &Fn) {
|
||||
const TargetRegisterInfo *RegInfo = Fn.getTarget().getRegisterInfo();
|
||||
MachineFrameInfo *FFI = Fn.getFrameInfo();
|
||||
MachineFrameInfo *MFI = Fn.getFrameInfo();
|
||||
|
||||
unsigned MaxCallFrameSize = 0;
|
||||
bool HasCalls = FFI->hasCalls();
|
||||
bool HasCalls = MFI->hasCalls();
|
||||
|
||||
// Get the function call frame set-up and tear-down instruction opcode
|
||||
int FrameSetupOpcode = RegInfo->getCallFrameSetupOpcode();
|
||||
@ -162,8 +162,8 @@ void PEI::calculateCallsInformation(MachineFunction &Fn) {
|
||||
HasCalls = true;
|
||||
}
|
||||
|
||||
FFI->setHasCalls(HasCalls);
|
||||
FFI->setMaxCallFrameSize(MaxCallFrameSize);
|
||||
MFI->setHasCalls(HasCalls);
|
||||
MFI->setMaxCallFrameSize(MaxCallFrameSize);
|
||||
|
||||
for (std::vector<MachineBasicBlock::iterator>::iterator
|
||||
i = FrameSDOps.begin(), e = FrameSDOps.end(); i != e; ++i) {
|
||||
@ -184,7 +184,7 @@ void PEI::calculateCallsInformation(MachineFunction &Fn) {
|
||||
void PEI::calculateCalleeSavedRegisters(MachineFunction &Fn) {
|
||||
const TargetRegisterInfo *RegInfo = Fn.getTarget().getRegisterInfo();
|
||||
const TargetFrameInfo *TFI = Fn.getTarget().getFrameInfo();
|
||||
MachineFrameInfo *FFI = Fn.getFrameInfo();
|
||||
MachineFrameInfo *MFI = Fn.getFrameInfo();
|
||||
|
||||
// Get the callee saved register list...
|
||||
const unsigned *CSRegs = RegInfo->getCalleeSavedRegs(&Fn);
|
||||
@ -255,19 +255,19 @@ void PEI::calculateCalleeSavedRegisters(MachineFunction &Fn) {
|
||||
// the TargetRegisterClass if the stack alignment is smaller. Use the
|
||||
// min.
|
||||
Align = std::min(Align, StackAlign);
|
||||
FrameIdx = FFI->CreateStackObject(RC->getSize(), Align, true);
|
||||
FrameIdx = MFI->CreateStackObject(RC->getSize(), Align, true);
|
||||
if ((unsigned)FrameIdx < MinCSFrameIndex) MinCSFrameIndex = FrameIdx;
|
||||
if ((unsigned)FrameIdx > MaxCSFrameIndex) MaxCSFrameIndex = FrameIdx;
|
||||
} else {
|
||||
// Spill it to the stack where we must.
|
||||
FrameIdx = FFI->CreateFixedObject(RC->getSize(), FixedSlot->Offset,
|
||||
FrameIdx = MFI->CreateFixedObject(RC->getSize(), FixedSlot->Offset,
|
||||
true, false);
|
||||
}
|
||||
|
||||
I->setFrameIdx(FrameIdx);
|
||||
}
|
||||
|
||||
FFI->setCalleeSavedInfo(CSI);
|
||||
MFI->setCalleeSavedInfo(CSI);
|
||||
}
|
||||
|
||||
/// insertCSRSpillsAndRestores - Insert spill and restore code for
|
||||
@ -275,10 +275,10 @@ void PEI::calculateCalleeSavedRegisters(MachineFunction &Fn) {
|
||||
///
|
||||
void PEI::insertCSRSpillsAndRestores(MachineFunction &Fn) {
|
||||
// Get callee saved register information.
|
||||
MachineFrameInfo *FFI = Fn.getFrameInfo();
|
||||
const std::vector<CalleeSavedInfo> &CSI = FFI->getCalleeSavedInfo();
|
||||
MachineFrameInfo *MFI = Fn.getFrameInfo();
|
||||
const std::vector<CalleeSavedInfo> &CSI = MFI->getCalleeSavedInfo();
|
||||
|
||||
FFI->setCalleeSavedInfoValid(true);
|
||||
MFI->setCalleeSavedInfoValid(true);
|
||||
|
||||
// Early exit if no callee saved registers are modified!
|
||||
if (CSI.empty())
|
||||
@ -436,14 +436,14 @@ void PEI::insertCSRSpillsAndRestores(MachineFunction &Fn) {
|
||||
|
||||
/// AdjustStackOffset - Helper function used to adjust the stack frame offset.
|
||||
static inline void
|
||||
AdjustStackOffset(MachineFrameInfo *FFI, int FrameIdx,
|
||||
AdjustStackOffset(MachineFrameInfo *MFI, int FrameIdx,
|
||||
bool StackGrowsDown, int64_t &Offset,
|
||||
unsigned &MaxAlign) {
|
||||
// If the stack grows down, add the object size to find the lowest address.
|
||||
if (StackGrowsDown)
|
||||
Offset += FFI->getObjectSize(FrameIdx);
|
||||
Offset += MFI->getObjectSize(FrameIdx);
|
||||
|
||||
unsigned Align = FFI->getObjectAlignment(FrameIdx);
|
||||
unsigned Align = MFI->getObjectAlignment(FrameIdx);
|
||||
|
||||
// If the alignment of this object is greater than that of the stack, then
|
||||
// increase the stack alignment to match.
|
||||
@ -453,10 +453,10 @@ AdjustStackOffset(MachineFrameInfo *FFI, int FrameIdx,
|
||||
Offset = (Offset + Align - 1) / Align * Align;
|
||||
|
||||
if (StackGrowsDown) {
|
||||
FFI->setObjectOffset(FrameIdx, -Offset); // Set the computed offset
|
||||
MFI->setObjectOffset(FrameIdx, -Offset); // Set the computed offset
|
||||
} else {
|
||||
FFI->setObjectOffset(FrameIdx, Offset);
|
||||
Offset += FFI->getObjectSize(FrameIdx);
|
||||
MFI->setObjectOffset(FrameIdx, Offset);
|
||||
Offset += MFI->getObjectSize(FrameIdx);
|
||||
}
|
||||
}
|
||||
|
||||
@ -470,7 +470,7 @@ void PEI::calculateFrameObjectOffsets(MachineFunction &Fn) {
|
||||
TFI.getStackGrowthDirection() == TargetFrameInfo::StackGrowsDown;
|
||||
|
||||
// Loop over all of the stack objects, assigning sequential addresses...
|
||||
MachineFrameInfo *FFI = Fn.getFrameInfo();
|
||||
MachineFrameInfo *MFI = Fn.getFrameInfo();
|
||||
|
||||
// Start at the beginning of the local area.
|
||||
// The Offset is the distance from the stack top in the direction
|
||||
@ -487,17 +487,17 @@ void PEI::calculateFrameObjectOffsets(MachineFunction &Fn) {
|
||||
// We currently don't support filling in holes in between fixed sized
|
||||
// objects, so we adjust 'Offset' to point to the end of last fixed sized
|
||||
// preallocated object.
|
||||
for (int i = FFI->getObjectIndexBegin(); i != 0; ++i) {
|
||||
for (int i = MFI->getObjectIndexBegin(); i != 0; ++i) {
|
||||
int64_t FixedOff;
|
||||
if (StackGrowsDown) {
|
||||
// The maximum distance from the stack pointer is at lower address of
|
||||
// the object -- which is given by offset. For down growing stack
|
||||
// the offset is negative, so we negate the offset to get the distance.
|
||||
FixedOff = -FFI->getObjectOffset(i);
|
||||
FixedOff = -MFI->getObjectOffset(i);
|
||||
} else {
|
||||
// The maximum distance from the start pointer is at the upper
|
||||
// address of the object.
|
||||
FixedOff = FFI->getObjectOffset(i) + FFI->getObjectSize(i);
|
||||
FixedOff = MFI->getObjectOffset(i) + MFI->getObjectSize(i);
|
||||
}
|
||||
if (FixedOff > Offset) Offset = FixedOff;
|
||||
}
|
||||
@ -508,27 +508,27 @@ void PEI::calculateFrameObjectOffsets(MachineFunction &Fn) {
|
||||
for (unsigned i = MinCSFrameIndex; i <= MaxCSFrameIndex; ++i) {
|
||||
// If stack grows down, we need to add size of find the lowest
|
||||
// address of the object.
|
||||
Offset += FFI->getObjectSize(i);
|
||||
Offset += MFI->getObjectSize(i);
|
||||
|
||||
unsigned Align = FFI->getObjectAlignment(i);
|
||||
unsigned Align = MFI->getObjectAlignment(i);
|
||||
// Adjust to alignment boundary
|
||||
Offset = (Offset+Align-1)/Align*Align;
|
||||
|
||||
FFI->setObjectOffset(i, -Offset); // Set the computed offset
|
||||
MFI->setObjectOffset(i, -Offset); // Set the computed offset
|
||||
}
|
||||
} else {
|
||||
int MaxCSFI = MaxCSFrameIndex, MinCSFI = MinCSFrameIndex;
|
||||
for (int i = MaxCSFI; i >= MinCSFI ; --i) {
|
||||
unsigned Align = FFI->getObjectAlignment(i);
|
||||
unsigned Align = MFI->getObjectAlignment(i);
|
||||
// Adjust to alignment boundary
|
||||
Offset = (Offset+Align-1)/Align*Align;
|
||||
|
||||
FFI->setObjectOffset(i, Offset);
|
||||
Offset += FFI->getObjectSize(i);
|
||||
MFI->setObjectOffset(i, Offset);
|
||||
Offset += MFI->getObjectSize(i);
|
||||
}
|
||||
}
|
||||
|
||||
unsigned MaxAlign = FFI->getMaxAlignment();
|
||||
unsigned MaxAlign = MFI->getMaxAlignment();
|
||||
|
||||
// Make sure the special register scavenging spill slot is closest to the
|
||||
// frame pointer if a frame pointer is required.
|
||||
@ -536,28 +536,28 @@ void PEI::calculateFrameObjectOffsets(MachineFunction &Fn) {
|
||||
if (RS && RegInfo->hasFP(Fn) && !RegInfo->needsStackRealignment(Fn)) {
|
||||
int SFI = RS->getScavengingFrameIndex();
|
||||
if (SFI >= 0)
|
||||
AdjustStackOffset(FFI, SFI, StackGrowsDown, Offset, MaxAlign);
|
||||
AdjustStackOffset(MFI, SFI, StackGrowsDown, Offset, MaxAlign);
|
||||
}
|
||||
|
||||
// Make sure that the stack protector comes before the local variables on the
|
||||
// stack.
|
||||
if (FFI->getStackProtectorIndex() >= 0)
|
||||
AdjustStackOffset(FFI, FFI->getStackProtectorIndex(), StackGrowsDown,
|
||||
if (MFI->getStackProtectorIndex() >= 0)
|
||||
AdjustStackOffset(MFI, MFI->getStackProtectorIndex(), StackGrowsDown,
|
||||
Offset, MaxAlign);
|
||||
|
||||
// Then assign frame offsets to stack objects that are not used to spill
|
||||
// callee saved registers.
|
||||
for (unsigned i = 0, e = FFI->getObjectIndexEnd(); i != e; ++i) {
|
||||
for (unsigned i = 0, e = MFI->getObjectIndexEnd(); i != e; ++i) {
|
||||
if (i >= MinCSFrameIndex && i <= MaxCSFrameIndex)
|
||||
continue;
|
||||
if (RS && (int)i == RS->getScavengingFrameIndex())
|
||||
continue;
|
||||
if (FFI->isDeadObjectIndex(i))
|
||||
if (MFI->isDeadObjectIndex(i))
|
||||
continue;
|
||||
if (FFI->getStackProtectorIndex() == (int)i)
|
||||
if (MFI->getStackProtectorIndex() == (int)i)
|
||||
continue;
|
||||
|
||||
AdjustStackOffset(FFI, i, StackGrowsDown, Offset, MaxAlign);
|
||||
AdjustStackOffset(MFI, i, StackGrowsDown, Offset, MaxAlign);
|
||||
}
|
||||
|
||||
// Make sure the special register scavenging spill slot is closest to the
|
||||
@ -565,15 +565,15 @@ void PEI::calculateFrameObjectOffsets(MachineFunction &Fn) {
|
||||
if (RS && (!RegInfo->hasFP(Fn) || RegInfo->needsStackRealignment(Fn))) {
|
||||
int SFI = RS->getScavengingFrameIndex();
|
||||
if (SFI >= 0)
|
||||
AdjustStackOffset(FFI, SFI, StackGrowsDown, Offset, MaxAlign);
|
||||
AdjustStackOffset(MFI, SFI, StackGrowsDown, Offset, MaxAlign);
|
||||
}
|
||||
|
||||
if (!RegInfo->targetHandlesStackFrameRounding()) {
|
||||
// If we have reserved argument space for call sites in the function
|
||||
// immediately on entry to the current function, count it as part of the
|
||||
// overall stack size.
|
||||
if (FFI->hasCalls() && RegInfo->hasReservedCallFrame(Fn))
|
||||
Offset += FFI->getMaxCallFrameSize();
|
||||
if (MFI->hasCalls() && RegInfo->hasReservedCallFrame(Fn))
|
||||
Offset += MFI->getMaxCallFrameSize();
|
||||
|
||||
// Round up the size to a multiple of the alignment. If the function has
|
||||
// any calls or alloca's, align to the target's StackAlignment value to
|
||||
@ -581,8 +581,8 @@ void PEI::calculateFrameObjectOffsets(MachineFunction &Fn) {
|
||||
// otherwise, for leaf functions, align to the TransientStackAlignment
|
||||
// value.
|
||||
unsigned StackAlign;
|
||||
if (FFI->hasCalls() || FFI->hasVarSizedObjects() ||
|
||||
(RegInfo->needsStackRealignment(Fn) && FFI->getObjectIndexEnd() != 0))
|
||||
if (MFI->hasCalls() || MFI->hasVarSizedObjects() ||
|
||||
(RegInfo->needsStackRealignment(Fn) && MFI->getObjectIndexEnd() != 0))
|
||||
StackAlign = TFI.getStackAlignment();
|
||||
else
|
||||
StackAlign = TFI.getTransientStackAlignment();
|
||||
@ -594,7 +594,7 @@ void PEI::calculateFrameObjectOffsets(MachineFunction &Fn) {
|
||||
}
|
||||
|
||||
// Update frame info to pretend that this is part of the stack...
|
||||
FFI->setStackSize(Offset - LocalAreaOffset);
|
||||
MFI->setStackSize(Offset - LocalAreaOffset);
|
||||
}
|
||||
|
||||
|
||||
|
Loading…
Reference in New Issue
Block a user