ARM64MCTargetDesc.cpp [plain text]
#include "ARM64MCTargetDesc.h"
#include "ARM64ELFStreamer.h"
#include "ARM64MCAsmInfo.h"
#include "InstPrinter/ARM64InstPrinter.h"
#include "llvm/MC/MCCodeGenInfo.h"
#include "llvm/MC/MCInstrInfo.h"
#include "llvm/MC/MCRegisterInfo.h"
#include "llvm/MC/MCStreamer.h"
#include "llvm/MC/MCSubtargetInfo.h"
#include "llvm/Support/ErrorHandling.h"
#include "llvm/Support/TargetRegistry.h"
#define GET_INSTRINFO_MC_DESC
#include "ARM64GenInstrInfo.inc"
#define GET_SUBTARGETINFO_MC_DESC
#include "ARM64GenSubtargetInfo.inc"
#define GET_REGINFO_MC_DESC
#include "ARM64GenRegisterInfo.inc"
using namespace llvm;
static MCInstrInfo *createARM64MCInstrInfo() {
MCInstrInfo *X = new MCInstrInfo();
InitARM64MCInstrInfo(X);
return X;
}
static MCSubtargetInfo *createARM64MCSubtargetInfo(StringRef TT, StringRef CPU,
StringRef FS) {
MCSubtargetInfo *X = new MCSubtargetInfo();
InitARM64MCSubtargetInfo(X, TT, CPU, FS);
return X;
}
static MCRegisterInfo *createARM64MCRegisterInfo(StringRef Triple) {
MCRegisterInfo *X = new MCRegisterInfo();
InitARM64MCRegisterInfo(X, ARM64::LR);
return X;
}
static MCAsmInfo *createARM64MCAsmInfo(const MCRegisterInfo &MRI,
StringRef TT) {
Triple TheTriple(TT);
MCAsmInfo *MAI;
if (TheTriple.isOSDarwin())
MAI = new ARM64MCAsmInfoDarwin();
else {
assert(TheTriple.isOSBinFormatELF() && "Only expect Darwin or ELF");
MAI = new ARM64MCAsmInfoELF();
}
unsigned Reg = MRI.getDwarfRegNum(ARM64::SP, true);
MCCFIInstruction Inst = MCCFIInstruction::createDefCfa(0, Reg, 0);
MAI->addInitialFrameState(Inst);
return MAI;
}
MCCodeGenInfo *createARM64MCCodeGenInfo(StringRef TT, Reloc::Model RM,
CodeModel::Model CM,
CodeGenOpt::Level OL) {
Triple TheTriple(TT);
MCCodeGenInfo *X = new MCCodeGenInfo();
if (TheTriple.isOSDarwin()) {
X->InitMCCodeGenInfo(Reloc::PIC_, CM, OL);
return X;
}
assert(TheTriple.isOSBinFormatELF() && "Only expect Darwin and ELF targets");
if (RM == Reloc::Default || RM == Reloc::DynamicNoPIC) {
RM = Reloc::Static;
}
if (CM == CodeModel::Default)
CM = CodeModel::Small;
else if (CM == CodeModel::JITDefault) {
CM = CodeModel::Large;
}
X->InitMCCodeGenInfo(RM, CM, OL);
return X;
}
static MCInstPrinter *createARM64MCInstPrinter(const Target &T,
unsigned SyntaxVariant,
const MCAsmInfo &MAI,
const MCInstrInfo &MII,
const MCRegisterInfo &MRI,
const MCSubtargetInfo &STI) {
if (SyntaxVariant == 0)
return new ARM64InstPrinter(MAI, MII, MRI, STI);
return 0;
}
static MCStreamer *createMCStreamer(const Target &T, StringRef TT,
MCContext &Ctx, MCAsmBackend &TAB,
raw_ostream &OS,
MCCodeEmitter *Emitter,
bool RelaxAll, bool NoExecStack) {
Triple TheTriple(TT);
if (TheTriple.isOSDarwin())
return createMachOStreamer(Ctx, TAB, OS, Emitter, RelaxAll,
true);
return createARM64ELFStreamer(Ctx, TAB, OS, Emitter, RelaxAll, NoExecStack);
}
extern "C" void LLVMInitializeARM64TargetMC() {
RegisterMCAsmInfoFn X(TheARM64Target, createARM64MCAsmInfo);
TargetRegistry::RegisterMCCodeGenInfo(TheARM64Target, createARM64MCCodeGenInfo);
TargetRegistry::RegisterMCInstrInfo(TheARM64Target, createARM64MCInstrInfo);
TargetRegistry::RegisterMCRegInfo(TheARM64Target, createARM64MCRegisterInfo);
TargetRegistry::RegisterMCSubtargetInfo(TheARM64Target,
createARM64MCSubtargetInfo);
TargetRegistry::RegisterMCAsmBackend(TheARM64Target, createARM64AsmBackend);
TargetRegistry::RegisterMCCodeEmitter(TheARM64Target, createARM64MCCodeEmitter);
TargetRegistry::RegisterMCObjectStreamer(TheARM64Target, createMCStreamer);
TargetRegistry::RegisterMCInstPrinter(TheARM64Target,
createARM64MCInstPrinter);
}