mirror of
https://github.com/c64scene-ar/llvm-6502.git
synced 2025-06-13 22:24:07 +00:00
Rename TargetFrameInfo into TargetFrameLowering. Also, put couple of FIXMEs and fixes here and there.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@123170 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Anton Korobeynikov
382
lib/Target/XCore/XCoreFrameLowering.cpp
Normal file
382
lib/Target/XCore/XCoreFrameLowering.cpp
Normal file
@ -0,0 +1,382 @@
|
||||
//===-- XCoreFrameLowering.cpp - Frame info for XCore Target -----*- C++ -*-==//
|
||||
//
|
||||
// The LLVM Compiler Infrastructure
|
||||
//
|
||||
// This file is distributed under the University of Illinois Open Source
|
||||
// License. See LICENSE.TXT for details.
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// This file contains XCore frame information that doesn't fit anywhere else
|
||||
// cleanly...
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
#include "XCore.h"
|
||||
#include "XCoreFrameLowering.h"
|
||||
#include "XCoreInstrInfo.h"
|
||||
#include "XCoreMachineFunctionInfo.h"
|
||||
#include "llvm/Function.h"
|
||||
#include "llvm/CodeGen/MachineFrameInfo.h"
|
||||
#include "llvm/CodeGen/MachineFunction.h"
|
||||
#include "llvm/CodeGen/MachineInstrBuilder.h"
|
||||
#include "llvm/CodeGen/MachineModuleInfo.h"
|
||||
#include "llvm/CodeGen/MachineRegisterInfo.h"
|
||||
#include "llvm/CodeGen/RegisterScavenging.h"
|
||||
#include "llvm/Target/TargetData.h"
|
||||
#include "llvm/Target/TargetOptions.h"
|
||||
#include "llvm/Support/ErrorHandling.h"
|
||||
|
||||
using namespace llvm;
|
||||
|
||||
// helper functions. FIXME: Eliminate.
|
||||
static inline bool isImmUs(unsigned val) {
|
||||
return val <= 11;
|
||||
}
|
||||
|
||||
static inline bool isImmU6(unsigned val) {
|
||||
return val < (1 << 6);
|
||||
}
|
||||
|
||||
static inline bool isImmU16(unsigned val) {
|
||||
return val < (1 << 16);
|
||||
}
|
||||
|
||||
static void loadFromStack(MachineBasicBlock &MBB,
|
||||
MachineBasicBlock::iterator I,
|
||||
unsigned DstReg, int Offset, DebugLoc dl,
|
||||
const TargetInstrInfo &TII) {
|
||||
assert(Offset%4 == 0 && "Misaligned stack offset");
|
||||
Offset/=4;
|
||||
bool isU6 = isImmU6(Offset);
|
||||
if (!isU6 && !isImmU16(Offset))
|
||||
report_fatal_error("loadFromStack offset too big " + Twine(Offset));
|
||||
int Opcode = isU6 ? XCore::LDWSP_ru6 : XCore::LDWSP_lru6;
|
||||
BuildMI(MBB, I, dl, TII.get(Opcode), DstReg)
|
||||
.addImm(Offset);
|
||||
}
|
||||
|
||||
|
||||
static void storeToStack(MachineBasicBlock &MBB,
|
||||
MachineBasicBlock::iterator I,
|
||||
unsigned SrcReg, int Offset, DebugLoc dl,
|
||||
const TargetInstrInfo &TII) {
|
||||
assert(Offset%4 == 0 && "Misaligned stack offset");
|
||||
Offset/=4;
|
||||
bool isU6 = isImmU6(Offset);
|
||||
if (!isU6 && !isImmU16(Offset))
|
||||
report_fatal_error("storeToStack offset too big " + Twine(Offset));
|
||||
int Opcode = isU6 ? XCore::STWSP_ru6 : XCore::STWSP_lru6;
|
||||
BuildMI(MBB, I, dl, TII.get(Opcode))
|
||||
.addReg(SrcReg)
|
||||
.addImm(Offset);
|
||||
}
|
||||
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
// XCoreFrameLowering:
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
XCoreFrameLowering::XCoreFrameLowering(const XCoreSubtarget &sti)
|
||||
: TargetFrameLowering(TargetFrameLowering::StackGrowsDown, 4, 0),
|
||||
STI(sti) {
|
||||
// Do nothing
|
||||
}
|
||||
|
||||
bool XCoreFrameLowering::hasFP(const MachineFunction &MF) const {
|
||||
return DisableFramePointerElim(MF) || MF.getFrameInfo()->hasVarSizedObjects();
|
||||
}
|
||||
|
||||
void XCoreFrameLowering::emitPrologue(MachineFunction &MF) const {
|
||||
MachineBasicBlock &MBB = MF.front(); // Prolog goes in entry BB
|
||||
MachineBasicBlock::iterator MBBI = MBB.begin();
|
||||
MachineFrameInfo *MFI = MF.getFrameInfo();
|
||||
MachineModuleInfo *MMI = &MF.getMMI();
|
||||
const XCoreRegisterInfo *RegInfo =
|
||||
static_cast<const XCoreRegisterInfo*>(MF.getTarget().getRegisterInfo());
|
||||
const XCoreInstrInfo &TII =
|
||||
*static_cast<const XCoreInstrInfo*>(MF.getTarget().getInstrInfo());
|
||||
XCoreFunctionInfo *XFI = MF.getInfo<XCoreFunctionInfo>();
|
||||
DebugLoc dl = MBBI != MBB.end() ? MBBI->getDebugLoc() : DebugLoc();
|
||||
|
||||
bool FP = hasFP(MF);
|
||||
|
||||
// Work out frame sizes.
|
||||
int FrameSize = MFI->getStackSize();
|
||||
assert(FrameSize%4 == 0 && "Misaligned frame size");
|
||||
FrameSize/=4;
|
||||
|
||||
bool isU6 = isImmU6(FrameSize);
|
||||
|
||||
if (!isU6 && !isImmU16(FrameSize)) {
|
||||
// FIXME could emit multiple instructions.
|
||||
report_fatal_error("emitPrologue Frame size too big: " + Twine(FrameSize));
|
||||
}
|
||||
bool emitFrameMoves = RegInfo->needsFrameMoves(MF);
|
||||
|
||||
// Do we need to allocate space on the stack?
|
||||
if (FrameSize) {
|
||||
bool saveLR = XFI->getUsesLR();
|
||||
bool LRSavedOnEntry = false;
|
||||
int Opcode;
|
||||
if (saveLR && (MFI->getObjectOffset(XFI->getLRSpillSlot()) == 0)) {
|
||||
Opcode = (isU6) ? XCore::ENTSP_u6 : XCore::ENTSP_lu6;
|
||||
MBB.addLiveIn(XCore::LR);
|
||||
saveLR = false;
|
||||
LRSavedOnEntry = true;
|
||||
} else {
|
||||
Opcode = (isU6) ? XCore::EXTSP_u6 : XCore::EXTSP_lu6;
|
||||
}
|
||||
BuildMI(MBB, MBBI, dl, TII.get(Opcode)).addImm(FrameSize);
|
||||
|
||||
if (emitFrameMoves) {
|
||||
std::vector<MachineMove> &Moves = MMI->getFrameMoves();
|
||||
|
||||
// Show update of SP.
|
||||
MCSymbol *FrameLabel = MMI->getContext().CreateTempSymbol();
|
||||
BuildMI(MBB, MBBI, dl, TII.get(XCore::PROLOG_LABEL)).addSym(FrameLabel);
|
||||
|
||||
MachineLocation SPDst(MachineLocation::VirtualFP);
|
||||
MachineLocation SPSrc(MachineLocation::VirtualFP, -FrameSize * 4);
|
||||
Moves.push_back(MachineMove(FrameLabel, SPDst, SPSrc));
|
||||
|
||||
if (LRSavedOnEntry) {
|
||||
MachineLocation CSDst(MachineLocation::VirtualFP, 0);
|
||||
MachineLocation CSSrc(XCore::LR);
|
||||
Moves.push_back(MachineMove(FrameLabel, CSDst, CSSrc));
|
||||
}
|
||||
}
|
||||
if (saveLR) {
|
||||
int LRSpillOffset = MFI->getObjectOffset(XFI->getLRSpillSlot());
|
||||
storeToStack(MBB, MBBI, XCore::LR, LRSpillOffset + FrameSize*4, dl, TII);
|
||||
MBB.addLiveIn(XCore::LR);
|
||||
|
||||
if (emitFrameMoves) {
|
||||
MCSymbol *SaveLRLabel = MMI->getContext().CreateTempSymbol();
|
||||
BuildMI(MBB, MBBI, dl, TII.get(XCore::PROLOG_LABEL)).addSym(SaveLRLabel);
|
||||
MachineLocation CSDst(MachineLocation::VirtualFP, LRSpillOffset);
|
||||
MachineLocation CSSrc(XCore::LR);
|
||||
MMI->getFrameMoves().push_back(MachineMove(SaveLRLabel, CSDst, CSSrc));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (FP) {
|
||||
// Save R10 to the stack.
|
||||
int FPSpillOffset = MFI->getObjectOffset(XFI->getFPSpillSlot());
|
||||
storeToStack(MBB, MBBI, XCore::R10, FPSpillOffset + FrameSize*4, dl, TII);
|
||||
// R10 is live-in. It is killed at the spill.
|
||||
MBB.addLiveIn(XCore::R10);
|
||||
if (emitFrameMoves) {
|
||||
MCSymbol *SaveR10Label = MMI->getContext().CreateTempSymbol();
|
||||
BuildMI(MBB, MBBI, dl, TII.get(XCore::PROLOG_LABEL)).addSym(SaveR10Label);
|
||||
MachineLocation CSDst(MachineLocation::VirtualFP, FPSpillOffset);
|
||||
MachineLocation CSSrc(XCore::R10);
|
||||
MMI->getFrameMoves().push_back(MachineMove(SaveR10Label, CSDst, CSSrc));
|
||||
}
|
||||
// Set the FP from the SP.
|
||||
unsigned FramePtr = XCore::R10;
|
||||
BuildMI(MBB, MBBI, dl, TII.get(XCore::LDAWSP_ru6), FramePtr)
|
||||
.addImm(0);
|
||||
if (emitFrameMoves) {
|
||||
// Show FP is now valid.
|
||||
MCSymbol *FrameLabel = MMI->getContext().CreateTempSymbol();
|
||||
BuildMI(MBB, MBBI, dl, TII.get(XCore::PROLOG_LABEL)).addSym(FrameLabel);
|
||||
MachineLocation SPDst(FramePtr);
|
||||
MachineLocation SPSrc(MachineLocation::VirtualFP);
|
||||
MMI->getFrameMoves().push_back(MachineMove(FrameLabel, SPDst, SPSrc));
|
||||
}
|
||||
}
|
||||
|
||||
if (emitFrameMoves) {
|
||||
// Frame moves for callee saved.
|
||||
std::vector<MachineMove> &Moves = MMI->getFrameMoves();
|
||||
std::vector<std::pair<MCSymbol*, CalleeSavedInfo> >&SpillLabels =
|
||||
XFI->getSpillLabels();
|
||||
for (unsigned I = 0, E = SpillLabels.size(); I != E; ++I) {
|
||||
MCSymbol *SpillLabel = SpillLabels[I].first;
|
||||
CalleeSavedInfo &CSI = SpillLabels[I].second;
|
||||
int Offset = MFI->getObjectOffset(CSI.getFrameIdx());
|
||||
unsigned Reg = CSI.getReg();
|
||||
MachineLocation CSDst(MachineLocation::VirtualFP, Offset);
|
||||
MachineLocation CSSrc(Reg);
|
||||
Moves.push_back(MachineMove(SpillLabel, CSDst, CSSrc));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void XCoreFrameLowering::emitEpilogue(MachineFunction &MF,
|
||||
MachineBasicBlock &MBB) const {
|
||||
MachineFrameInfo *MFI = MF.getFrameInfo();
|
||||
MachineBasicBlock::iterator MBBI = prior(MBB.end());
|
||||
const XCoreInstrInfo &TII =
|
||||
*static_cast<const XCoreInstrInfo*>(MF.getTarget().getInstrInfo());
|
||||
DebugLoc dl = MBBI->getDebugLoc();
|
||||
|
||||
bool FP = hasFP(MF);
|
||||
if (FP) {
|
||||
// Restore the stack pointer.
|
||||
unsigned FramePtr = XCore::R10;
|
||||
BuildMI(MBB, MBBI, dl, TII.get(XCore::SETSP_1r))
|
||||
.addReg(FramePtr);
|
||||
}
|
||||
|
||||
// Work out frame sizes.
|
||||
int FrameSize = MFI->getStackSize();
|
||||
|
||||
assert(FrameSize%4 == 0 && "Misaligned frame size");
|
||||
|
||||
FrameSize/=4;
|
||||
|
||||
bool isU6 = isImmU6(FrameSize);
|
||||
|
||||
if (!isU6 && !isImmU16(FrameSize)) {
|
||||
// FIXME could emit multiple instructions.
|
||||
report_fatal_error("emitEpilogue Frame size too big: " + Twine(FrameSize));
|
||||
}
|
||||
|
||||
if (FrameSize) {
|
||||
XCoreFunctionInfo *XFI = MF.getInfo<XCoreFunctionInfo>();
|
||||
|
||||
if (FP) {
|
||||
// Restore R10
|
||||
int FPSpillOffset = MFI->getObjectOffset(XFI->getFPSpillSlot());
|
||||
FPSpillOffset += FrameSize*4;
|
||||
loadFromStack(MBB, MBBI, XCore::R10, FPSpillOffset, dl, TII);
|
||||
}
|
||||
bool restoreLR = XFI->getUsesLR();
|
||||
if (restoreLR && MFI->getObjectOffset(XFI->getLRSpillSlot()) != 0) {
|
||||
int LRSpillOffset = MFI->getObjectOffset(XFI->getLRSpillSlot());
|
||||
LRSpillOffset += FrameSize*4;
|
||||
loadFromStack(MBB, MBBI, XCore::LR, LRSpillOffset, dl, TII);
|
||||
restoreLR = false;
|
||||
}
|
||||
if (restoreLR) {
|
||||
// Fold prologue into return instruction
|
||||
assert(MBBI->getOpcode() == XCore::RETSP_u6
|
||||
|| MBBI->getOpcode() == XCore::RETSP_lu6);
|
||||
int Opcode = (isU6) ? XCore::RETSP_u6 : XCore::RETSP_lu6;
|
||||
BuildMI(MBB, MBBI, dl, TII.get(Opcode)).addImm(FrameSize);
|
||||
MBB.erase(MBBI);
|
||||
} else {
|
||||
int Opcode = (isU6) ? XCore::LDAWSP_ru6_RRegs : XCore::LDAWSP_lru6_RRegs;
|
||||
BuildMI(MBB, MBBI, dl, TII.get(Opcode), XCore::SP).addImm(FrameSize);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void XCoreFrameLowering::getInitialFrameState(std::vector<MachineMove> &Moves)
|
||||
const {
|
||||
// Initial state of the frame pointer is SP.
|
||||
MachineLocation Dst(MachineLocation::VirtualFP);
|
||||
MachineLocation Src(XCore::SP, 0);
|
||||
Moves.push_back(MachineMove(0, Dst, Src));
|
||||
}
|
||||
|
||||
bool XCoreFrameLowering::spillCalleeSavedRegisters(MachineBasicBlock &MBB,
|
||||
MachineBasicBlock::iterator MI,
|
||||
const std::vector<CalleeSavedInfo> &CSI,
|
||||
const TargetRegisterInfo *TRI) const {
|
||||
if (CSI.empty())
|
||||
return true;
|
||||
|
||||
MachineFunction *MF = MBB.getParent();
|
||||
const TargetInstrInfo &TII = *MF->getTarget().getInstrInfo();
|
||||
|
||||
XCoreFunctionInfo *XFI = MF->getInfo<XCoreFunctionInfo>();
|
||||
bool emitFrameMoves = XCoreRegisterInfo::needsFrameMoves(*MF);
|
||||
|
||||
DebugLoc DL;
|
||||
if (MI != MBB.end()) DL = MI->getDebugLoc();
|
||||
|
||||
for (std::vector<CalleeSavedInfo>::const_iterator it = CSI.begin();
|
||||
it != CSI.end(); ++it) {
|
||||
// Add the callee-saved register as live-in. It's killed at the spill.
|
||||
MBB.addLiveIn(it->getReg());
|
||||
|
||||
unsigned Reg = it->getReg();
|
||||
const TargetRegisterClass *RC = TRI->getMinimalPhysRegClass(Reg);
|
||||
TII.storeRegToStackSlot(MBB, MI, Reg, true,
|
||||
it->getFrameIdx(), RC, TRI);
|
||||
if (emitFrameMoves) {
|
||||
MCSymbol *SaveLabel = MF->getContext().CreateTempSymbol();
|
||||
BuildMI(MBB, MI, DL, TII.get(XCore::PROLOG_LABEL)).addSym(SaveLabel);
|
||||
XFI->getSpillLabels().push_back(std::make_pair(SaveLabel, *it));
|
||||
}
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
bool XCoreFrameLowering::restoreCalleeSavedRegisters(MachineBasicBlock &MBB,
|
||||
MachineBasicBlock::iterator MI,
|
||||
const std::vector<CalleeSavedInfo> &CSI,
|
||||
const TargetRegisterInfo *TRI) const{
|
||||
MachineFunction *MF = MBB.getParent();
|
||||
const TargetInstrInfo &TII = *MF->getTarget().getInstrInfo();
|
||||
|
||||
bool AtStart = MI == MBB.begin();
|
||||
MachineBasicBlock::iterator BeforeI = MI;
|
||||
if (!AtStart)
|
||||
--BeforeI;
|
||||
for (std::vector<CalleeSavedInfo>::const_iterator it = CSI.begin();
|
||||
it != CSI.end(); ++it) {
|
||||
unsigned Reg = it->getReg();
|
||||
const TargetRegisterClass *RC = TRI->getMinimalPhysRegClass(Reg);
|
||||
TII.loadRegFromStackSlot(MBB, MI, it->getReg(), it->getFrameIdx(),
|
||||
RC, TRI);
|
||||
assert(MI != MBB.begin() &&
|
||||
"loadRegFromStackSlot didn't insert any code!");
|
||||
// Insert in reverse order. loadRegFromStackSlot can insert multiple
|
||||
// instructions.
|
||||
if (AtStart)
|
||||
MI = MBB.begin();
|
||||
else {
|
||||
MI = BeforeI;
|
||||
++MI;
|
||||
}
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
void
|
||||
XCoreFrameLowering::processFunctionBeforeCalleeSavedScan(MachineFunction &MF,
|
||||
RegScavenger *RS) const {
|
||||
MachineFrameInfo *MFI = MF.getFrameInfo();
|
||||
const TargetRegisterInfo *RegInfo = MF.getTarget().getRegisterInfo();
|
||||
bool LRUsed = MF.getRegInfo().isPhysRegUsed(XCore::LR);
|
||||
const TargetRegisterClass *RC = XCore::GRRegsRegisterClass;
|
||||
XCoreFunctionInfo *XFI = MF.getInfo<XCoreFunctionInfo>();
|
||||
if (LRUsed) {
|
||||
MF.getRegInfo().setPhysRegUnused(XCore::LR);
|
||||
|
||||
bool isVarArg = MF.getFunction()->isVarArg();
|
||||
int FrameIdx;
|
||||
if (! isVarArg) {
|
||||
// A fixed offset of 0 allows us to save / restore LR using entsp / retsp.
|
||||
FrameIdx = MFI->CreateFixedObject(RC->getSize(), 0, true);
|
||||
} else {
|
||||
FrameIdx = MFI->CreateStackObject(RC->getSize(), RC->getAlignment(),
|
||||
false);
|
||||
}
|
||||
XFI->setUsesLR(FrameIdx);
|
||||
XFI->setLRSpillSlot(FrameIdx);
|
||||
}
|
||||
if (RegInfo->requiresRegisterScavenging(MF)) {
|
||||
// Reserve a slot close to SP or frame pointer.
|
||||
RS->setScavengingFrameIndex(MFI->CreateStackObject(RC->getSize(),
|
||||
RC->getAlignment(),
|
||||
false));
|
||||
}
|
||||
if (hasFP(MF)) {
|
||||
// A callee save register is used to hold the FP.
|
||||
// This needs saving / restoring in the epilogue / prologue.
|
||||
XFI->setFPSpillSlot(MFI->CreateStackObject(RC->getSize(),
|
||||
RC->getAlignment(),
|
||||
false));
|
||||
}
|
||||
}
|
||||
|
||||
void XCoreFrameLowering::
|
||||
processFunctionBeforeFrameFinalized(MachineFunction &MF) const {
|
||||
|
||||
}
|
||||
Reference in New Issue
Block a user