2010-11-15 00:06:54 +00:00
|
|
|
//=======- MBlazeFrameInfo.cpp - MBlaze Frame Information ------*- 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 the MBlaze implementation of TargetFrameInfo class.
|
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
|
|
|
#include "MBlazeFrameInfo.h"
|
|
|
|
#include "MBlazeInstrInfo.h"
|
|
|
|
#include "MBlazeMachineFunction.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/Target/TargetData.h"
|
|
|
|
#include "llvm/Target/TargetOptions.h"
|
|
|
|
#include "llvm/Support/CommandLine.h"
|
|
|
|
|
|
|
|
using namespace llvm;
|
|
|
|
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
//
|
|
|
|
// Stack Frame Processing methods
|
|
|
|
// +----------------------------+
|
|
|
|
//
|
|
|
|
// The stack is allocated decrementing the stack pointer on
|
|
|
|
// the first instruction of a function prologue. Once decremented,
|
|
|
|
// all stack references are are done through a positive offset
|
|
|
|
// from the stack/frame pointer, so the stack is considered
|
|
|
|
// to grow up.
|
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
2010-11-18 21:19:35 +00:00
|
|
|
// hasFP - Return true if the specified function should have a dedicated frame
|
|
|
|
// pointer register. This is true if the function has variable sized allocas or
|
|
|
|
// if frame pointer elimination is disabled.
|
|
|
|
bool MBlazeFrameInfo::hasFP(const MachineFunction &MF) const {
|
|
|
|
const MachineFrameInfo *MFI = MF.getFrameInfo();
|
|
|
|
return DisableFramePointerElim(MF) || MFI->hasVarSizedObjects();
|
|
|
|
}
|
|
|
|
|
2010-11-15 00:06:54 +00:00
|
|
|
void MBlazeFrameInfo::emitPrologue(MachineFunction &MF) const {
|
|
|
|
MachineBasicBlock &MBB = MF.front();
|
|
|
|
MachineFrameInfo *MFI = MF.getFrameInfo();
|
|
|
|
const MBlazeInstrInfo &TII =
|
|
|
|
*static_cast<const MBlazeInstrInfo*>(MF.getTarget().getInstrInfo());
|
|
|
|
MBlazeFunctionInfo *MBlazeFI = MF.getInfo<MBlazeFunctionInfo>();
|
|
|
|
MachineBasicBlock::iterator MBBI = MBB.begin();
|
|
|
|
DebugLoc DL = MBBI != MBB.end() ? MBBI->getDebugLoc() : DebugLoc();
|
|
|
|
|
2010-12-09 03:42:04 +00:00
|
|
|
// Replace the dummy '0' SPOffset by the negative offsets, as explained on
|
|
|
|
// LowerFORMAL_ARGUMENTS. Leaving '0' for while is necessary to avoid
|
|
|
|
// the approach done by calculateFrameObjectOffsets to the stack frame.
|
|
|
|
MBlazeFI->adjustLoadArgsFI(MFI);
|
|
|
|
MBlazeFI->adjustStoreVarArgsFI(MFI);
|
2010-11-15 00:06:54 +00:00
|
|
|
|
|
|
|
// Get the number of bytes to allocate from the FrameInfo.
|
|
|
|
unsigned StackSize = MFI->getStackSize();
|
|
|
|
|
|
|
|
// No need to allocate space on the stack.
|
|
|
|
if (StackSize == 0 && !MFI->adjustsStack()) return;
|
|
|
|
|
|
|
|
int FPOffset = MBlazeFI->getFPStackOffset();
|
|
|
|
int RAOffset = MBlazeFI->getRAStackOffset();
|
|
|
|
|
|
|
|
// Adjust stack : addi R1, R1, -imm
|
|
|
|
BuildMI(MBB, MBBI, DL, TII.get(MBlaze::ADDI), MBlaze::R1)
|
|
|
|
.addReg(MBlaze::R1).addImm(-StackSize);
|
|
|
|
|
|
|
|
// swi R15, R1, stack_loc
|
|
|
|
if (MFI->adjustsStack()) {
|
|
|
|
BuildMI(MBB, MBBI, DL, TII.get(MBlaze::SWI))
|
|
|
|
.addReg(MBlaze::R15).addReg(MBlaze::R1).addImm(RAOffset);
|
|
|
|
}
|
|
|
|
|
2010-11-18 21:19:35 +00:00
|
|
|
if (hasFP(MF)) {
|
2010-11-15 00:06:54 +00:00
|
|
|
// swi R19, R1, stack_loc
|
|
|
|
BuildMI(MBB, MBBI, DL, TII.get(MBlaze::SWI))
|
|
|
|
.addReg(MBlaze::R19).addReg(MBlaze::R1).addImm(FPOffset);
|
|
|
|
|
|
|
|
// add R19, R1, R0
|
|
|
|
BuildMI(MBB, MBBI, DL, TII.get(MBlaze::ADD), MBlaze::R19)
|
|
|
|
.addReg(MBlaze::R1).addReg(MBlaze::R0);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void MBlazeFrameInfo::emitEpilogue(MachineFunction &MF,
|
|
|
|
MachineBasicBlock &MBB) const {
|
|
|
|
MachineBasicBlock::iterator MBBI = prior(MBB.end());
|
|
|
|
MachineFrameInfo *MFI = MF.getFrameInfo();
|
2010-11-18 21:19:35 +00:00
|
|
|
MBlazeFunctionInfo *MBlazeFI = MF.getInfo<MBlazeFunctionInfo>();
|
2010-11-15 00:06:54 +00:00
|
|
|
const MBlazeInstrInfo &TII =
|
|
|
|
*static_cast<const MBlazeInstrInfo*>(MF.getTarget().getInstrInfo());
|
|
|
|
|
|
|
|
DebugLoc dl = MBBI->getDebugLoc();
|
|
|
|
|
|
|
|
// Get the FI's where RA and FP are saved.
|
|
|
|
int FPOffset = MBlazeFI->getFPStackOffset();
|
|
|
|
int RAOffset = MBlazeFI->getRAStackOffset();
|
|
|
|
|
2010-11-18 21:19:35 +00:00
|
|
|
if (hasFP(MF)) {
|
2010-11-15 00:06:54 +00:00
|
|
|
// add R1, R19, R0
|
|
|
|
BuildMI(MBB, MBBI, dl, TII.get(MBlaze::ADD), MBlaze::R1)
|
|
|
|
.addReg(MBlaze::R19).addReg(MBlaze::R0);
|
|
|
|
|
|
|
|
// lwi R19, R1, stack_loc
|
|
|
|
BuildMI(MBB, MBBI, dl, TII.get(MBlaze::LWI), MBlaze::R19)
|
|
|
|
.addReg(MBlaze::R1).addImm(FPOffset);
|
|
|
|
}
|
|
|
|
|
|
|
|
// lwi R15, R1, stack_loc
|
|
|
|
if (MFI->adjustsStack()) {
|
|
|
|
BuildMI(MBB, MBBI, dl, TII.get(MBlaze::LWI), MBlaze::R15)
|
|
|
|
.addReg(MBlaze::R1).addImm(RAOffset);
|
|
|
|
}
|
|
|
|
|
|
|
|
// Get the number of bytes from FrameInfo
|
|
|
|
int StackSize = (int) MFI->getStackSize();
|
|
|
|
|
|
|
|
// addi R1, R1, imm
|
|
|
|
if (StackSize) {
|
|
|
|
BuildMI(MBB, MBBI, dl, TII.get(MBlaze::ADDI), MBlaze::R1)
|
|
|
|
.addReg(MBlaze::R1).addImm(StackSize);
|
|
|
|
}
|
|
|
|
}
|
2010-12-09 03:42:04 +00:00
|
|
|
|
|
|
|
void MBlazeFrameInfo::processFunctionBeforeCalleeSavedScan(MachineFunction &MF, RegScavenger *RS)
|
|
|
|
const {
|
|
|
|
MachineFrameInfo *MFI = MF.getFrameInfo();
|
|
|
|
MBlazeFunctionInfo *MBlazeFI = MF.getInfo<MBlazeFunctionInfo>();
|
|
|
|
|
|
|
|
if (MFI->adjustsStack()) {
|
|
|
|
MBlazeFI->setRAStackOffset(0);
|
|
|
|
MFI->CreateFixedObject(4,0,true);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (hasFP(MF)) {
|
|
|
|
MBlazeFI->setFPStackOffset(4);
|
|
|
|
MFI->CreateFixedObject(4,4,true);
|
|
|
|
}
|
|
|
|
}
|