6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2025-06-30 05:24:22 +00:00
Code Issues Projects Releases Wiki Activity

ARM: rename ARMle/ARMbe with ARMLE/ARMBE, and Thumble/Thumbbe with ThumbLE/ThumbBE

Browse Source 
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@205317 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Christian Pirker
2014-04-01 15:19:30 +00:00
parent cb68a2e3ab
commit 3a64202502
10 changed files with 114 additions and 114 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
lib/Target/ARM/ARMAsmPrinter.cpp
View File

@ -1719,8 +1719,8 @@ void ARMAsmPrinter::EmitInstruction(const MachineInstr *MI) {
// Force static initialization. // Force static initialization.
extern "C" void LLVMInitializeARMAsmPrinter() { extern "C" void LLVMInitializeARMAsmPrinter() {
RegisterAsmPrinter<ARMAsmPrinter> X(TheARMleTarget); RegisterAsmPrinter<ARMAsmPrinter> X(TheARMLETarget);
RegisterAsmPrinter<ARMAsmPrinter> Y(TheARMbeTarget); RegisterAsmPrinter<ARMAsmPrinter> Y(TheARMBETarget);
RegisterAsmPrinter<ARMAsmPrinter> A(TheThumbleTarget); RegisterAsmPrinter<ARMAsmPrinter> A(TheThumbLETarget);
RegisterAsmPrinter<ARMAsmPrinter> B(TheThumbbeTarget); RegisterAsmPrinter<ARMAsmPrinter> B(TheThumbBETarget);
} }

32
lib/Target/ARM/ARMTargetMachine.cpp
View File

@ -30,10 +30,10 @@ DisableA15SDOptimization("disable-a15-sd-optimization", cl::Hidden,
extern "C" void LLVMInitializeARMTarget() { extern "C" void LLVMInitializeARMTarget() {
// Register the target. // Register the target.
RegisterTargetMachine<ARMleTargetMachine> X(TheARMleTarget); RegisterTargetMachine<ARMLETargetMachine> X(TheARMLETarget);
RegisterTargetMachine<ARMbeTargetMachine> Y(TheARMbeTarget); RegisterTargetMachine<ARMBETargetMachine> Y(TheARMBETarget);
RegisterTargetMachine<ThumbleTargetMachine> A(TheThumbleTarget); RegisterTargetMachine<ThumbLETargetMachine> A(TheThumbLETarget);
RegisterTargetMachine<ThumbbeTargetMachine> B(TheThumbbeTarget); RegisterTargetMachine<ThumbBETargetMachine> B(TheThumbBETarget);
} }
@ -141,19 +141,19 @@ ARMTargetMachine::ARMTargetMachine(const Target &T, StringRef TT,
"support ARM mode execution!"); "support ARM mode execution!");
} }
void ARMleTargetMachine::anchor() { } void ARMLETargetMachine::anchor() { }
ARMleTargetMachine:: ARMLETargetMachine::
ARMleTargetMachine(const Target &T, StringRef TT, ARMLETargetMachine(const Target &T, StringRef TT,
StringRef CPU, StringRef FS, const TargetOptions &Options, StringRef CPU, StringRef FS, const TargetOptions &Options,
Reloc::Model RM, CodeModel::Model CM, Reloc::Model RM, CodeModel::Model CM,
CodeGenOpt::Level OL) CodeGenOpt::Level OL)
: ARMTargetMachine(T, TT, CPU, FS, Options, RM, CM, OL, true) {} : ARMTargetMachine(T, TT, CPU, FS, Options, RM, CM, OL, true) {}
void ARMbeTargetMachine::anchor() { } void ARMBETargetMachine::anchor() { }
ARMbeTargetMachine:: ARMBETargetMachine::
ARMbeTargetMachine(const Target &T, StringRef TT, ARMBETargetMachine(const Target &T, StringRef TT,
StringRef CPU, StringRef FS, const TargetOptions &Options, StringRef CPU, StringRef FS, const TargetOptions &Options,
Reloc::Model RM, CodeModel::Model CM, Reloc::Model RM, CodeModel::Model CM,
CodeGenOpt::Level OL) CodeGenOpt::Level OL)
@ -180,19 +180,19 @@ ThumbTargetMachine::ThumbTargetMachine(const Target &T, StringRef TT,
initAsmInfo(); initAsmInfo();
} }
void ThumbleTargetMachine::anchor() { } void ThumbLETargetMachine::anchor() { }
ThumbleTargetMachine:: ThumbLETargetMachine::
ThumbleTargetMachine(const Target &T, StringRef TT, ThumbLETargetMachine(const Target &T, StringRef TT,
StringRef CPU, StringRef FS, const TargetOptions &Options, StringRef CPU, StringRef FS, const TargetOptions &Options,
Reloc::Model RM, CodeModel::Model CM, Reloc::Model RM, CodeModel::Model CM,
CodeGenOpt::Level OL) CodeGenOpt::Level OL)
: ThumbTargetMachine(T, TT, CPU, FS, Options, RM, CM, OL, true) {} : ThumbTargetMachine(T, TT, CPU, FS, Options, RM, CM, OL, true) {}
void ThumbbeTargetMachine::anchor() { } void ThumbBETargetMachine::anchor() { }
ThumbbeTargetMachine:: ThumbBETargetMachine::
ThumbbeTargetMachine(const Target &T, StringRef TT, ThumbBETargetMachine(const Target &T, StringRef TT,
StringRef CPU, StringRef FS, const TargetOptions &Options, StringRef CPU, StringRef FS, const TargetOptions &Options,
Reloc::Model RM, CodeModel::Model CM, Reloc::Model RM, CodeModel::Model CM,
CodeGenOpt::Level OL) CodeGenOpt::Level OL)

24
lib/Target/ARM/ARMTargetMachine.h
View File

@ -99,23 +99,23 @@ class ARMTargetMachine : public ARMBaseTargetMachine {
const DataLayout *getDataLayout() const override { return &DL; } const DataLayout *getDataLayout() const override { return &DL; }
}; };
/// ARMleTargetMachine - ARM little endian target machine. /// ARMLETargetMachine - ARM little endian target machine.
/// ///
class ARMleTargetMachine : public ARMTargetMachine { class ARMLETargetMachine : public ARMTargetMachine {
virtual void anchor(); virtual void anchor();
public: public:
ARMleTargetMachine(const Target &T, StringRef TT, ARMLETargetMachine(const Target &T, StringRef TT,
StringRef CPU, StringRef FS, const TargetOptions &Options, StringRef CPU, StringRef FS, const TargetOptions &Options,
Reloc::Model RM, CodeModel::Model CM, Reloc::Model RM, CodeModel::Model CM,
CodeGenOpt::Level OL); CodeGenOpt::Level OL);
}; };
/// ARMbeTargetMachine - ARM big endian target machine. /// ARMBETargetMachine - ARM big endian target machine.
/// ///
class ARMbeTargetMachine : public ARMTargetMachine { class ARMBETargetMachine : public ARMTargetMachine {
virtual void anchor(); virtual void anchor();
public: public:
ARMbeTargetMachine(const Target &T, StringRef TT, ARMBETargetMachine(const Target &T, StringRef TT,
StringRef CPU, StringRef FS, const TargetOptions &Options, StringRef CPU, StringRef FS, const TargetOptions &Options,
Reloc::Model RM, CodeModel::Model CM, Reloc::Model RM, CodeModel::Model CM,
CodeGenOpt::Level OL); CodeGenOpt::Level OL);
@ -166,23 +166,23 @@ public:
const DataLayout *getDataLayout() const override { return &DL; } const DataLayout *getDataLayout() const override { return &DL; }
}; };
/// ThumbleTargetMachine - Thumb little endian target machine. /// ThumbLETargetMachine - Thumb little endian target machine.
/// ///
class ThumbleTargetMachine : public ThumbTargetMachine { class ThumbLETargetMachine : public ThumbTargetMachine {
virtual void anchor(); virtual void anchor();
public: public:
ThumbleTargetMachine(const Target &T, StringRef TT, ThumbLETargetMachine(const Target &T, StringRef TT,
StringRef CPU, StringRef FS, const TargetOptions &Options, StringRef CPU, StringRef FS, const TargetOptions &Options,
Reloc::Model RM, CodeModel::Model CM, Reloc::Model RM, CodeModel::Model CM,
CodeGenOpt::Level OL); CodeGenOpt::Level OL);
}; };
/// ThumbbeTargetMachine - Thumb big endian target machine. /// ThumbBETargetMachine - Thumb big endian target machine.
/// ///
class ThumbbeTargetMachine : public ThumbTargetMachine { class ThumbBETargetMachine : public ThumbTargetMachine {
virtual void anchor(); virtual void anchor();
public: public:
ThumbbeTargetMachine(const Target &T, StringRef TT, ThumbBETargetMachine(const Target &T, StringRef TT,
StringRef CPU, StringRef FS, const TargetOptions &Options, StringRef CPU, StringRef FS, const TargetOptions &Options,
Reloc::Model RM, CodeModel::Model CM, Reloc::Model RM, CodeModel::Model CM,
CodeGenOpt::Level OL); CodeGenOpt::Level OL);

8
lib/Target/ARM/AsmParser/ARMAsmParser.cpp
View File

@ -9251,10 +9251,10 @@ bool ARMAsmParser::parseDirectiveThumbSet(SMLoc L) {
/// Force static initialization. /// Force static initialization.
extern "C" void LLVMInitializeARMAsmParser() { extern "C" void LLVMInitializeARMAsmParser() {
RegisterMCAsmParser<ARMAsmParser> X(TheARMleTarget); RegisterMCAsmParser<ARMAsmParser> X(TheARMLETarget);
RegisterMCAsmParser<ARMAsmParser> Y(TheARMbeTarget); RegisterMCAsmParser<ARMAsmParser> Y(TheARMBETarget);
RegisterMCAsmParser<ARMAsmParser> A(TheThumbleTarget); RegisterMCAsmParser<ARMAsmParser> A(TheThumbLETarget);
RegisterMCAsmParser<ARMAsmParser> B(TheThumbbeTarget); RegisterMCAsmParser<ARMAsmParser> B(TheThumbBETarget);
} }
#define GET_REGISTER_MATCHER #define GET_REGISTER_MATCHER

8
lib/Target/ARM/Disassembler/ARMDisassembler.cpp
View File

@ -856,13 +856,13 @@ DecodeStatus ThumbDisassembler::getInstruction(MCInst &MI, uint64_t &Size,
extern "C" void LLVMInitializeARMDisassembler() { extern "C" void LLVMInitializeARMDisassembler() {
TargetRegistry::RegisterMCDisassembler(TheARMleTarget, TargetRegistry::RegisterMCDisassembler(TheARMLETarget,
createARMDisassembler); createARMDisassembler);
TargetRegistry::RegisterMCDisassembler(TheARMbeTarget, TargetRegistry::RegisterMCDisassembler(TheARMBETarget,
createARMDisassembler); createARMDisassembler);
TargetRegistry::RegisterMCDisassembler(TheThumbleTarget, TargetRegistry::RegisterMCDisassembler(TheThumbLETarget,
createThumbDisassembler); createThumbDisassembler);
TargetRegistry::RegisterMCDisassembler(TheThumbbeTarget, TargetRegistry::RegisterMCDisassembler(TheThumbBETarget,
createThumbDisassembler); createThumbDisassembler);
} }

8
lib/Target/ARM/MCTargetDesc/ARMAsmBackend.cpp
View File

@ -803,25 +803,25 @@ MCAsmBackend *llvm::createARMAsmBackend(const Target &T,
return new ELFARMAsmBackend(T, TT, OSABI, isLittle); return new ELFARMAsmBackend(T, TT, OSABI, isLittle);
} }
MCAsmBackend *llvm::createARMleAsmBackend(const Target &T, MCAsmBackend *llvm::createARMLEAsmBackend(const Target &T,
const MCRegisterInfo &MRI, const MCRegisterInfo &MRI,
StringRef TT, StringRef CPU) { StringRef TT, StringRef CPU) {
return createARMAsmBackend(T, MRI, TT, CPU, true); return createARMAsmBackend(T, MRI, TT, CPU, true);
} }
MCAsmBackend *llvm::createARMbeAsmBackend(const Target &T, MCAsmBackend *llvm::createARMBEAsmBackend(const Target &T,
const MCRegisterInfo &MRI, const MCRegisterInfo &MRI,
StringRef TT, StringRef CPU) { StringRef TT, StringRef CPU) {
return createARMAsmBackend(T, MRI, TT, CPU, false); return createARMAsmBackend(T, MRI, TT, CPU, false);
} }
MCAsmBackend *llvm::createThumbleAsmBackend(const Target &T, MCAsmBackend *llvm::createThumbLEAsmBackend(const Target &T,
const MCRegisterInfo &MRI, const MCRegisterInfo &MRI,
StringRef TT, StringRef CPU) { StringRef TT, StringRef CPU) {
return createARMAsmBackend(T, MRI, TT, CPU, true); return createARMAsmBackend(T, MRI, TT, CPU, true);
} }
MCAsmBackend *llvm::createThumbbeAsmBackend(const Target &T, MCAsmBackend *llvm::createThumbBEAsmBackend(const Target &T,
const MCRegisterInfo &MRI, const MCRegisterInfo &MRI,
StringRef TT, StringRef CPU) { StringRef TT, StringRef CPU) {
return createARMAsmBackend(T, MRI, TT, CPU, false); return createARMAsmBackend(T, MRI, TT, CPU, false);

4
lib/Target/ARM/MCTargetDesc/ARMMCCodeEmitter.cpp
View File

@ -416,14 +416,14 @@ public:
} // end anonymous namespace } // end anonymous namespace
MCCodeEmitter *llvm::createARMleMCCodeEmitter(const MCInstrInfo &MCII, MCCodeEmitter *llvm::createARMLEMCCodeEmitter(const MCInstrInfo &MCII,
const MCRegisterInfo &MRI, const MCRegisterInfo &MRI,
const MCSubtargetInfo &STI, const MCSubtargetInfo &STI,
MCContext &Ctx) { MCContext &Ctx) {
return new ARMMCCodeEmitter(MCII, Ctx, true); return new ARMMCCodeEmitter(MCII, Ctx, true);
} }
MCCodeEmitter *llvm::createARMbeMCCodeEmitter(const MCInstrInfo &MCII, MCCodeEmitter *llvm::createARMBEMCCodeEmitter(const MCInstrInfo &MCII,
const MCRegisterInfo &MRI, const MCRegisterInfo &MRI,
const MCSubtargetInfo &STI, const MCSubtargetInfo &STI,
MCContext &Ctx) { MCContext &Ctx) {

108
lib/Target/ARM/MCTargetDesc/ARMMCTargetDesc.cpp
View File

@ -328,94 +328,94 @@ static MCInstrAnalysis *createARMMCInstrAnalysis(const MCInstrInfo *Info) {
// Force static initialization. // Force static initialization.
extern "C" void LLVMInitializeARMTargetMC() { extern "C" void LLVMInitializeARMTargetMC() {
// Register the MC asm info. // Register the MC asm info.
RegisterMCAsmInfoFn X(TheARMleTarget, createARMMCAsmInfo); RegisterMCAsmInfoFn X(TheARMLETarget, createARMMCAsmInfo);
RegisterMCAsmInfoFn Y(TheARMbeTarget, createARMMCAsmInfo); RegisterMCAsmInfoFn Y(TheARMBETarget, createARMMCAsmInfo);
RegisterMCAsmInfoFn A(TheThumbleTarget, createARMMCAsmInfo); RegisterMCAsmInfoFn A(TheThumbLETarget, createARMMCAsmInfo);
RegisterMCAsmInfoFn B(TheThumbbeTarget, createARMMCAsmInfo); RegisterMCAsmInfoFn B(TheThumbBETarget, createARMMCAsmInfo);
// Register the MC codegen info. // Register the MC codegen info.
TargetRegistry::RegisterMCCodeGenInfo(TheARMleTarget, createARMMCCodeGenInfo); TargetRegistry::RegisterMCCodeGenInfo(TheARMLETarget, createARMMCCodeGenInfo);
TargetRegistry::RegisterMCCodeGenInfo(TheARMbeTarget, createARMMCCodeGenInfo); TargetRegistry::RegisterMCCodeGenInfo(TheARMBETarget, createARMMCCodeGenInfo);
TargetRegistry::RegisterMCCodeGenInfo(TheThumbleTarget, createARMMCCodeGenInfo); TargetRegistry::RegisterMCCodeGenInfo(TheThumbLETarget, createARMMCCodeGenInfo);
TargetRegistry::RegisterMCCodeGenInfo(TheThumbbeTarget, createARMMCCodeGenInfo); TargetRegistry::RegisterMCCodeGenInfo(TheThumbBETarget, createARMMCCodeGenInfo);
// Register the MC instruction info. // Register the MC instruction info.
TargetRegistry::RegisterMCInstrInfo(TheARMleTarget, createARMMCInstrInfo); TargetRegistry::RegisterMCInstrInfo(TheARMLETarget, createARMMCInstrInfo);
TargetRegistry::RegisterMCInstrInfo(TheARMbeTarget, createARMMCInstrInfo); TargetRegistry::RegisterMCInstrInfo(TheARMBETarget, createARMMCInstrInfo);
TargetRegistry::RegisterMCInstrInfo(TheThumbleTarget, createARMMCInstrInfo); TargetRegistry::RegisterMCInstrInfo(TheThumbLETarget, createARMMCInstrInfo);
TargetRegistry::RegisterMCInstrInfo(TheThumbbeTarget, createARMMCInstrInfo); TargetRegistry::RegisterMCInstrInfo(TheThumbBETarget, createARMMCInstrInfo);
// Register the MC register info. // Register the MC register info.
TargetRegistry::RegisterMCRegInfo(TheARMleTarget, createARMMCRegisterInfo); TargetRegistry::RegisterMCRegInfo(TheARMLETarget, createARMMCRegisterInfo);
TargetRegistry::RegisterMCRegInfo(TheARMbeTarget, createARMMCRegisterInfo); TargetRegistry::RegisterMCRegInfo(TheARMBETarget, createARMMCRegisterInfo);
TargetRegistry::RegisterMCRegInfo(TheThumbleTarget, createARMMCRegisterInfo); TargetRegistry::RegisterMCRegInfo(TheThumbLETarget, createARMMCRegisterInfo);
TargetRegistry::RegisterMCRegInfo(TheThumbbeTarget, createARMMCRegisterInfo); TargetRegistry::RegisterMCRegInfo(TheThumbBETarget, createARMMCRegisterInfo);
// Register the MC subtarget info. // Register the MC subtarget info.
TargetRegistry::RegisterMCSubtargetInfo(TheARMleTarget, TargetRegistry::RegisterMCSubtargetInfo(TheARMLETarget,
ARM_MC::createARMMCSubtargetInfo); ARM_MC::createARMMCSubtargetInfo);
TargetRegistry::RegisterMCSubtargetInfo(TheARMbeTarget, TargetRegistry::RegisterMCSubtargetInfo(TheARMBETarget,
ARM_MC::createARMMCSubtargetInfo); ARM_MC::createARMMCSubtargetInfo);
TargetRegistry::RegisterMCSubtargetInfo(TheThumbleTarget, TargetRegistry::RegisterMCSubtargetInfo(TheThumbLETarget,
ARM_MC::createARMMCSubtargetInfo); ARM_MC::createARMMCSubtargetInfo);
TargetRegistry::RegisterMCSubtargetInfo(TheThumbbeTarget, TargetRegistry::RegisterMCSubtargetInfo(TheThumbBETarget,
ARM_MC::createARMMCSubtargetInfo); ARM_MC::createARMMCSubtargetInfo);
// Register the MC instruction analyzer. // Register the MC instruction analyzer.
TargetRegistry::RegisterMCInstrAnalysis(TheARMleTarget, TargetRegistry::RegisterMCInstrAnalysis(TheARMLETarget,
createARMMCInstrAnalysis); createARMMCInstrAnalysis);
TargetRegistry::RegisterMCInstrAnalysis(TheARMbeTarget, TargetRegistry::RegisterMCInstrAnalysis(TheARMBETarget,
createARMMCInstrAnalysis); createARMMCInstrAnalysis);
TargetRegistry::RegisterMCInstrAnalysis(TheThumbleTarget, TargetRegistry::RegisterMCInstrAnalysis(TheThumbLETarget,
createARMMCInstrAnalysis); createARMMCInstrAnalysis);
TargetRegistry::RegisterMCInstrAnalysis(TheThumbbeTarget, TargetRegistry::RegisterMCInstrAnalysis(TheThumbBETarget,
createARMMCInstrAnalysis); createARMMCInstrAnalysis);
// Register the MC Code Emitter // Register the MC Code Emitter
TargetRegistry::RegisterMCCodeEmitter(TheARMleTarget, TargetRegistry::RegisterMCCodeEmitter(TheARMLETarget,
createARMleMCCodeEmitter); createARMLEMCCodeEmitter);
TargetRegistry::RegisterMCCodeEmitter(TheARMbeTarget, TargetRegistry::RegisterMCCodeEmitter(TheARMBETarget,
createARMbeMCCodeEmitter); createARMBEMCCodeEmitter);
TargetRegistry::RegisterMCCodeEmitter(TheThumbleTarget, TargetRegistry::RegisterMCCodeEmitter(TheThumbLETarget,
createARMleMCCodeEmitter); createARMLEMCCodeEmitter);
TargetRegistry::RegisterMCCodeEmitter(TheThumbbeTarget, TargetRegistry::RegisterMCCodeEmitter(TheThumbBETarget,
createARMbeMCCodeEmitter); createARMBEMCCodeEmitter);
// Register the asm backend. // Register the asm backend.
TargetRegistry::RegisterMCAsmBackend(TheARMleTarget, createARMleAsmBackend); TargetRegistry::RegisterMCAsmBackend(TheARMLETarget, createARMLEAsmBackend);
TargetRegistry::RegisterMCAsmBackend(TheARMbeTarget, createARMbeAsmBackend); TargetRegistry::RegisterMCAsmBackend(TheARMBETarget, createARMBEAsmBackend);
TargetRegistry::RegisterMCAsmBackend(TheThumbleTarget, TargetRegistry::RegisterMCAsmBackend(TheThumbLETarget,
createThumbleAsmBackend); createThumbLEAsmBackend);
TargetRegistry::RegisterMCAsmBackend(TheThumbbeTarget, TargetRegistry::RegisterMCAsmBackend(TheThumbBETarget,
createThumbbeAsmBackend); createThumbBEAsmBackend);
// Register the object streamer. // Register the object streamer.
TargetRegistry::RegisterMCObjectStreamer(TheARMleTarget, createMCStreamer); TargetRegistry::RegisterMCObjectStreamer(TheARMLETarget, createMCStreamer);
TargetRegistry::RegisterMCObjectStreamer(TheARMbeTarget, createMCStreamer); TargetRegistry::RegisterMCObjectStreamer(TheARMBETarget, createMCStreamer);
TargetRegistry::RegisterMCObjectStreamer(TheThumbleTarget, createMCStreamer); TargetRegistry::RegisterMCObjectStreamer(TheThumbLETarget, createMCStreamer);
TargetRegistry::RegisterMCObjectStreamer(TheThumbbeTarget, createMCStreamer); TargetRegistry::RegisterMCObjectStreamer(TheThumbBETarget, createMCStreamer);
// Register the asm streamer. // Register the asm streamer.
TargetRegistry::RegisterAsmStreamer(TheARMleTarget, createMCAsmStreamer); TargetRegistry::RegisterAsmStreamer(TheARMLETarget, createMCAsmStreamer);
TargetRegistry::RegisterAsmStreamer(TheARMbeTarget, createMCAsmStreamer); TargetRegistry::RegisterAsmStreamer(TheARMBETarget, createMCAsmStreamer);
TargetRegistry::RegisterAsmStreamer(TheThumbleTarget, createMCAsmStreamer); TargetRegistry::RegisterAsmStreamer(TheThumbLETarget, createMCAsmStreamer);
TargetRegistry::RegisterAsmStreamer(TheThumbbeTarget, createMCAsmStreamer); TargetRegistry::RegisterAsmStreamer(TheThumbBETarget, createMCAsmStreamer);
// Register the MCInstPrinter. // Register the MCInstPrinter.
TargetRegistry::RegisterMCInstPrinter(TheARMleTarget, createARMMCInstPrinter); TargetRegistry::RegisterMCInstPrinter(TheARMLETarget, createARMMCInstPrinter);
TargetRegistry::RegisterMCInstPrinter(TheARMbeTarget, createARMMCInstPrinter); TargetRegistry::RegisterMCInstPrinter(TheARMBETarget, createARMMCInstPrinter);
TargetRegistry::RegisterMCInstPrinter(TheThumbleTarget, TargetRegistry::RegisterMCInstPrinter(TheThumbLETarget,
createARMMCInstPrinter); createARMMCInstPrinter);
TargetRegistry::RegisterMCInstPrinter(TheThumbbeTarget, TargetRegistry::RegisterMCInstPrinter(TheThumbBETarget,
createARMMCInstPrinter); createARMMCInstPrinter);
// Register the MC relocation info. // Register the MC relocation info.
TargetRegistry::RegisterMCRelocationInfo(TheARMleTarget, TargetRegistry::RegisterMCRelocationInfo(TheARMLETarget,
createARMMCRelocationInfo); createARMMCRelocationInfo);
TargetRegistry::RegisterMCRelocationInfo(TheARMbeTarget, TargetRegistry::RegisterMCRelocationInfo(TheARMBETarget,
createARMMCRelocationInfo); createARMMCRelocationInfo);
TargetRegistry::RegisterMCRelocationInfo(TheThumbleTarget, TargetRegistry::RegisterMCRelocationInfo(TheThumbLETarget,
createARMMCRelocationInfo); createARMMCRelocationInfo);
TargetRegistry::RegisterMCRelocationInfo(TheThumbbeTarget, TargetRegistry::RegisterMCRelocationInfo(TheThumbBETarget,
createARMMCRelocationInfo); createARMMCRelocationInfo);
} }

16
lib/Target/ARM/MCTargetDesc/ARMMCTargetDesc.h
View File

@ -33,8 +33,8 @@ class StringRef;
class Target; class Target;
class raw_ostream; class raw_ostream;
extern Target TheARMleTarget, TheThumbleTarget; extern Target TheARMLETarget, TheThumbLETarget;
extern Target TheARMbeTarget, TheThumbbeTarget; extern Target TheARMBETarget, TheThumbBETarget;
namespace ARM_MC { namespace ARM_MC {
std::string ParseARMTriple(StringRef TT, StringRef CPU); std::string ParseARMTriple(StringRef TT, StringRef CPU);
@ -52,12 +52,12 @@ MCStreamer *createMCAsmStreamer(MCContext &Ctx, formatted_raw_ostream &OS,
MCInstPrinter *InstPrint, MCCodeEmitter *CE, MCInstPrinter *InstPrint, MCCodeEmitter *CE,
MCAsmBackend *TAB, bool ShowInst); MCAsmBackend *TAB, bool ShowInst);
MCCodeEmitter *createARMleMCCodeEmitter(const MCInstrInfo &MCII, MCCodeEmitter *createARMLEMCCodeEmitter(const MCInstrInfo &MCII,
const MCRegisterInfo &MRI, const MCRegisterInfo &MRI,
const MCSubtargetInfo &STI, const MCSubtargetInfo &STI,
MCContext &Ctx); MCContext &Ctx);
MCCodeEmitter *createARMbeMCCodeEmitter(const MCInstrInfo &MCII, MCCodeEmitter *createARMBEMCCodeEmitter(const MCInstrInfo &MCII,
const MCRegisterInfo &MRI, const MCRegisterInfo &MRI,
const MCSubtargetInfo &STI, const MCSubtargetInfo &STI,
MCContext &Ctx); MCContext &Ctx);
@ -66,16 +66,16 @@ MCAsmBackend *createARMAsmBackend(const Target &T, const MCRegisterInfo &MRI,
StringRef TT, StringRef CPU, StringRef TT, StringRef CPU,
bool IsLittleEndian); bool IsLittleEndian);
MCAsmBackend *createARMleAsmBackend(const Target &T, const MCRegisterInfo &MRI, MCAsmBackend *createARMLEAsmBackend(const Target &T, const MCRegisterInfo &MRI,
StringRef TT, StringRef CPU); StringRef TT, StringRef CPU);
MCAsmBackend *createARMbeAsmBackend(const Target &T, const MCRegisterInfo &MRI, MCAsmBackend *createARMBEAsmBackend(const Target &T, const MCRegisterInfo &MRI,
StringRef TT, StringRef CPU); StringRef TT, StringRef CPU);
MCAsmBackend *createThumbleAsmBackend(const Target &T, const MCRegisterInfo &MRI, MCAsmBackend *createThumbLEAsmBackend(const Target &T, const MCRegisterInfo &MRI,
StringRef TT, StringRef CPU); StringRef TT, StringRef CPU);
MCAsmBackend *createThumbbeAsmBackend(const Target &T, const MCRegisterInfo &MRI, MCAsmBackend *createThumbBEAsmBackend(const Target &T, const MCRegisterInfo &MRI,
StringRef TT, StringRef CPU); StringRef TT, StringRef CPU);
/// createARMELFObjectWriter - Construct an ELF Mach-O object writer. /// createARMELFObjectWriter - Construct an ELF Mach-O object writer.

12
lib/Target/ARM/TargetInfo/ARMTargetInfo.cpp
View File

@ -12,17 +12,17 @@
#include "llvm/Support/TargetRegistry.h" #include "llvm/Support/TargetRegistry.h"
using namespace llvm; using namespace llvm;
Target llvm::TheARMleTarget, llvm::TheARMbeTarget; Target llvm::TheARMLETarget, llvm::TheARMBETarget;
Target llvm::TheThumbleTarget, llvm::TheThumbbeTarget; Target llvm::TheThumbLETarget, llvm::TheThumbBETarget;
extern "C" void LLVMInitializeARMTargetInfo() { extern "C" void LLVMInitializeARMTargetInfo() {
RegisterTarget<Triple::arm, /*HasJIT=*/true> RegisterTarget<Triple::arm, /*HasJIT=*/true>
X(TheARMleTarget, "arm", "ARM"); X(TheARMLETarget, "arm", "ARM");
RegisterTarget<Triple::armeb, /*HasJIT=*/true> RegisterTarget<Triple::armeb, /*HasJIT=*/true>
Y(TheARMbeTarget, "armeb", "ARM (big endian)"); Y(TheARMBETarget, "armeb", "ARM (big endian)");
RegisterTarget<Triple::thumb, /*HasJIT=*/true> RegisterTarget<Triple::thumb, /*HasJIT=*/true>
A(TheThumbleTarget, "thumb", "Thumb"); A(TheThumbLETarget, "thumb", "Thumb");
RegisterTarget<Triple::thumbeb, /*HasJIT=*/true> RegisterTarget<Triple::thumbeb, /*HasJIT=*/true>
B(TheThumbbeTarget, "thumbeb", "Thumb (big endian)"); B(TheThumbBETarget, "thumbeb", "Thumb (big endian)");
} }