mirror of
https://github.com/c64scene-ar/llvm-6502.git
synced 2024-11-15 04:08:07 +00:00
bbe51362d5
Added fp register clobbering during calls. Added AsmPrinter support for "fmask", a bitmask that indicates where on the stack the fp callee saved registers are. Fixed the stack frame layout for Mips, now the callee saved regs are in the right stack location (a little documentation about how this stack frame must look like is present in MipsRegisterInfo.cpp). This was done using the method MipsRegisterInfo::adjustMipsStackFrame To be more clear, these are examples of what is solves : 1) FP and RA are also callee saved, and despite they aren't in CSI they must be saved before the fp callee saved registers. 2) The ABI requires that local varibles are allocated before the callee saved register area, the opposite behavior from the default allocation. 3) CPU and FPU saved register area must be aligned independent of each other. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@54403 91177308-0d34-0410-b5e6-96231b3b80d8
126 lines
3.9 KiB
C++
126 lines
3.9 KiB
C++
//===-- MipsTargetMachine.cpp - Define TargetMachine for Mips -------------===//
|
|
//
|
|
// The LLVM Compiler Infrastructure
|
|
//
|
|
// This file is distributed under the University of Illinois Open Source
|
|
// License. See LICENSE.TXT for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
// Implements the info about Mips target spec.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "Mips.h"
|
|
#include "MipsTargetAsmInfo.h"
|
|
#include "MipsTargetMachine.h"
|
|
#include "llvm/Module.h"
|
|
#include "llvm/PassManager.h"
|
|
#include "llvm/Target/TargetMachineRegistry.h"
|
|
using namespace llvm;
|
|
|
|
// Register the target.
|
|
static RegisterTarget<MipsTargetMachine> X("mips", " Mips");
|
|
static RegisterTarget<MipselTargetMachine> Y("mipsel", " Mipsel");
|
|
|
|
const TargetAsmInfo *MipsTargetMachine::
|
|
createTargetAsmInfo() const
|
|
{
|
|
return new MipsTargetAsmInfo(*this);
|
|
}
|
|
|
|
// DataLayout --> Big-endian, 32-bit pointer/ABI/alignment
|
|
// The stack is always 8 byte aligned
|
|
// On function prologue, the stack is created by decrementing
|
|
// its pointer. Once decremented, all references are done with positive
|
|
// offset from the stack/frame pointer, using StackGrowsUp enables
|
|
// an easier handling.
|
|
// Using CodeModel::Large enables different CALL behavior.
|
|
MipsTargetMachine::
|
|
MipsTargetMachine(const Module &M, const std::string &FS, bool isLittle=false):
|
|
Subtarget(*this, M, FS, isLittle),
|
|
DataLayout(isLittle ? std::string("e-p:32:32:32-i8:8:32-i16:16:32") :
|
|
std::string("E-p:32:32:32-i8:8:32-i16:16:32")),
|
|
InstrInfo(*this),
|
|
FrameInfo(TargetFrameInfo::StackGrowsUp, 8, 0),
|
|
TLInfo(*this)
|
|
{
|
|
// Abicall enables PIC by default
|
|
if (Subtarget.hasABICall() && (getRelocationModel() != Reloc::Static))
|
|
setRelocationModel(Reloc::PIC_);
|
|
|
|
// TODO: create an option to enable long calls, like -mlong-calls,
|
|
// that would be our CodeModel::Large. It must not work with Abicall.
|
|
if (getCodeModel() == CodeModel::Default)
|
|
setCodeModel(CodeModel::Small);
|
|
}
|
|
|
|
MipselTargetMachine::
|
|
MipselTargetMachine(const Module &M, const std::string &FS) :
|
|
MipsTargetMachine(M, FS, true) {}
|
|
|
|
// return 0 and must specify -march to gen MIPS code.
|
|
unsigned MipsTargetMachine::
|
|
getModuleMatchQuality(const Module &M)
|
|
{
|
|
// We strongly match "mips*-*".
|
|
std::string TT = M.getTargetTriple();
|
|
if (TT.size() >= 5 && std::string(TT.begin(), TT.begin()+5) == "mips-")
|
|
return 20;
|
|
|
|
if (TT.size() >= 13 && std::string(TT.begin(),
|
|
TT.begin()+13) == "mipsallegrex-")
|
|
return 20;
|
|
|
|
return 0;
|
|
}
|
|
|
|
// return 0 and must specify -march to gen MIPSEL code.
|
|
unsigned MipselTargetMachine::
|
|
getModuleMatchQuality(const Module &M)
|
|
{
|
|
// We strongly match "mips*el-*".
|
|
std::string TT = M.getTargetTriple();
|
|
if (TT.size() >= 7 && std::string(TT.begin(), TT.begin()+7) == "mipsel-")
|
|
return 20;
|
|
|
|
if (TT.size() >= 15 && std::string(TT.begin(),
|
|
TT.begin()+15) == "mipsallegrexel-")
|
|
return 20;
|
|
|
|
if (TT.size() == 3 && std::string(TT.begin(), TT.begin()+3) == "psp")
|
|
return 20;
|
|
|
|
return 0;
|
|
}
|
|
|
|
// Install an instruction selector pass using
|
|
// the ISelDag to gen Mips code.
|
|
bool MipsTargetMachine::
|
|
addInstSelector(PassManagerBase &PM, bool Fast)
|
|
{
|
|
PM.add(createMipsISelDag(*this));
|
|
return false;
|
|
}
|
|
|
|
// Implemented by targets that want to run passes immediately before
|
|
// machine code is emitted. return true if -print-machineinstrs should
|
|
// print out the code after the passes.
|
|
bool MipsTargetMachine::
|
|
addPreEmitPass(PassManagerBase &PM, bool Fast)
|
|
{
|
|
PM.add(createMipsDelaySlotFillerPass(*this));
|
|
return true;
|
|
}
|
|
|
|
// Implements the AssemblyEmitter for the target. Must return
|
|
// true if AssemblyEmitter is supported
|
|
bool MipsTargetMachine::
|
|
addAssemblyEmitter(PassManagerBase &PM, bool Fast,
|
|
std::ostream &Out)
|
|
{
|
|
// Output assembly language.
|
|
PM.add(createMipsCodePrinterPass(Out, *this));
|
|
return false;
|
|
}
|