#include "llvm/Module.h"
#include "llvm/Support/Registry.h"
+#include "llvm/Target/TargetRegistry.h"
namespace llvm {
class Module;
template<class TargetMachineImpl>
struct RegisterTarget {
- RegisterTarget(const char *Name, const char *ShortDesc)
+ RegisterTarget(Target &T, const char *Name, const char *ShortDesc)
: Entry(Name, ShortDesc, &Allocator,
&TargetMachineImpl::getModuleMatchQuality,
&TargetMachineImpl::getJITMatchQuality),
- Node(Entry)
- {}
+ Node(Entry) {
+ TargetRegistry::RegisterTargetMachine(T, &Allocator);
+ }
private:
TargetMachineRegistry::entry Entry;
FunctionPass *createARMISelDag(ARMBaseTargetMachine &TM);
FunctionPass *createARMCodePrinterPass(formatted_raw_ostream &O,
- ARMBaseTargetMachine &TM,
+ TargetMachine &TM,
bool Verbose);
FunctionPass *createARMCodeEmitterPass(ARMBaseTargetMachine &TM,
MachineCodeEmitter &MCE);
int ARMTargetMachineModule = 0;
// Register the target.
-static RegisterTarget<ARMTargetMachine> X("arm", "ARM");
-static RegisterTarget<ThumbTargetMachine> Y("thumb", "Thumb");
+extern Target TheARMTarget;
+static RegisterTarget<ARMTargetMachine> X(TheARMTarget, "arm", "ARM");
+
+extern Target TheThumbTarget;
+static RegisterTarget<ThumbTargetMachine> Y(TheThumbTarget, "thumb", "Thumb");
// Force static initialization.
extern "C" void LLVMInitializeARMTarget() { }
// To avoid having target depend on the asmprinter stuff libraries, asmprinter
// set this functions to ctor pointer at startup time if they are linked in.
typedef FunctionPass *(*AsmPrinterCtorFn)(formatted_raw_ostream &o,
- ARMBaseTargetMachine &tm,
+ TargetMachine &tm,
bool verbose);
static AsmPrinterCtorFn AsmPrinterCtor;
#include "llvm/Target/TargetData.h"
#include "llvm/Target/TargetMachine.h"
#include "llvm/Target/TargetOptions.h"
+#include "llvm/Target/TargetRegistry.h"
#include "llvm/ADT/Statistic.h"
#include "llvm/ADT/StringExtras.h"
#include "llvm/ADT/StringSet.h"
/// regardless of whether the function is in SSA form.
///
FunctionPass *llvm::createARMCodePrinterPass(formatted_raw_ostream &o,
- ARMBaseTargetMachine &tm,
+ TargetMachine &tm,
bool verbose) {
return new ARMAsmPrinter(o, tm, tm.getTargetAsmInfo(), verbose);
}
}
// Force static initialization.
-extern "C" void LLVMInitializeARMAsmPrinter() { }
+extern "C" void LLVMInitializeARMAsmPrinter() {
+ extern Target TheARMTarget, TheThumbTarget;
+ TargetRegistry::RegisterAsmPrinter(TheARMTarget, createARMCodePrinterPass);
+ TargetRegistry::RegisterAsmPrinter(TheThumbTarget, createARMCodePrinterPass);
+}
using namespace llvm;
// Register the targets
-static RegisterTarget<AlphaTargetMachine> X("alpha", "Alpha [experimental]");
+extern Target TheAlphaTarget;
+static RegisterTarget<AlphaTargetMachine> X(TheAlphaTarget, "alpha",
+ "Alpha [experimental]");
// No assembler printer by default
AlphaTargetMachine::AsmPrinterCtorFn AlphaTargetMachine::AsmPrinterCtor = 0;
#include "llvm/CodeGen/DwarfWriter.h"
#include "llvm/Target/TargetAsmInfo.h"
#include "llvm/Target/TargetMachine.h"
+#include "llvm/Target/TargetRegistry.h"
#include "llvm/Support/Compiler.h"
#include "llvm/Support/ErrorHandling.h"
#include "llvm/Support/Mangler.h"
return false;
}
-// Force static initialization.
-extern "C" void LLVMInitializeAlphaAsmPrinter() { }
-
namespace {
static struct Register {
Register() {
}
} Registrator;
}
+
+// Force static initialization.
+extern "C" void LLVMInitializeAlphaAsmPrinter() {
+ extern Target TheAlphaTarget;
+ TargetRegistry::RegisterAsmPrinter(TheAlphaTarget,
+ createAlphaCodePrinterPass);
+}
int CBackendTargetMachineModule = 0;
// Register the target.
-static RegisterTarget<CTargetMachine> X("c", "C backend");
+extern Target TheCBackendTarget;
+static RegisterTarget<CTargetMachine> X(TheCBackendTarget, "c", "C backend");
// Force static initialization.
extern "C" void LLVMInitializeCBackendTarget() { }
#include "llvm/Target/TargetRegisterInfo.h"
#include "llvm/Target/TargetInstrInfo.h"
#include "llvm/Target/TargetOptions.h"
+#include "llvm/Target/TargetRegistry.h"
#include "llvm/ADT/Statistic.h"
#include "llvm/ADT/StringExtras.h"
#include <set>
class VISIBILITY_HIDDEN LinuxAsmPrinter : public SPUAsmPrinter {
DwarfWriter *DW;
public:
- explicit LinuxAsmPrinter(formatted_raw_ostream &O, SPUTargetMachine &TM,
+ explicit LinuxAsmPrinter(formatted_raw_ostream &O, TargetMachine &TM,
const TargetAsmInfo *T, bool V)
: SPUAsmPrinter(O, TM, T, V), DW(0) {}
/// that the Linux SPU assembler can deal with.
///
FunctionPass *llvm::createSPUAsmPrinterPass(formatted_raw_ostream &o,
- SPUTargetMachine &tm,
+ TargetMachine &tm,
bool verbose) {
return new LinuxAsmPrinter(o, tm, tm.getTargetAsmInfo(), verbose);
}
-// Force static initialization.
-extern "C" void LLVMInitializeCellSPUAsmPrinter() { }
-
namespace {
static struct Register {
Register() {
}
} Registrator;
}
+
+// Force static initialization.
+extern "C" void LLVMInitializeCellSPUAsmPrinter() {
+ extern Target TheCellSPUTarget;
+ TargetRegistry::RegisterAsmPrinter(TheCellSPUTarget, createSPUAsmPrinterPass);
+}
FunctionPass *createSPUISelDag(SPUTargetMachine &TM);
FunctionPass *createSPUAsmPrinterPass(formatted_raw_ostream &o,
- SPUTargetMachine &tm,
+ TargetMachine &tm,
bool verbose);
/*--== Utility functions/predicates/etc used all over the place: --==*/
using namespace llvm;
+extern Target TheCellSPUTarget;
namespace {
// Register the targets
RegisterTarget<SPUTargetMachine>
- CELLSPU("cellspu", "STI CBEA Cell SPU [experimental]");
+ CELLSPU(TheCellSPUTarget, "cellspu", "STI CBEA Cell SPU [experimental]");
}
// No assembler printer by default
// To avoid having target depend on the asmprinter stuff libraries, asmprinter
// set this functions to ctor pointer at startup time if they are linked in.
typedef FunctionPass *(*AsmPrinterCtorFn)(formatted_raw_ostream &o,
- SPUTargetMachine &tm,
+ TargetMachine &tm,
bool verbose);
static AsmPrinterCtorFn AsmPrinterCtor;
int CppBackendTargetMachineModule = 0;
// Register the target.
-static RegisterTarget<CPPTargetMachine> X("cpp", "C++ backend");
+extern Target TheCppBackendTarget;
+static RegisterTarget<CPPTargetMachine> X(TheCppBackendTarget, "cpp", "C++ backend");
// Force static initialization.
extern "C" void LLVMInitializeCppBackendTarget() { }
#include "llvm/CodeGen/DwarfWriter.h"
#include "llvm/CodeGen/MachineFunctionPass.h"
#include "llvm/Target/TargetAsmInfo.h"
+#include "llvm/Target/TargetRegistry.h"
#include "llvm/Support/ErrorHandling.h"
#include "llvm/Support/FormattedStream.h"
#include "llvm/Support/Mangler.h"
/// the given target machine description.
///
FunctionPass *llvm::createIA64CodePrinterPass(formatted_raw_ostream &o,
- IA64TargetMachine &tm,
+ TargetMachine &tm,
bool verbose) {
return new IA64AsmPrinter(o, tm, tm.getTargetAsmInfo(), verbose);
}
// Force static initialization.
-extern "C" void LLVMInitializeIA64AsmPrinter() { }
+extern "C" void LLVMInitializeIA64AsmPrinter() {
+ extern Target TheIA64Target;
+ TargetRegistry::RegisterAsmPrinter(TheIA64Target, createIA64CodePrinterPass);
+}
/// regardless of whether the function is in SSA form.
///
FunctionPass *createIA64CodePrinterPass(formatted_raw_ostream &o,
- IA64TargetMachine &tm,
+ TargetMachine &tm,
bool verbose);
} // End llvm namespace
using namespace llvm;
// Register the target
-static RegisterTarget<IA64TargetMachine> X("ia64",
+extern Target TheIA64Target;
+static RegisterTarget<IA64TargetMachine> X(TheIA64Target, "ia64",
"IA-64 (Itanium) [experimental]");
// No assembler printer by default
// To avoid having target depend on the asmprinter stuff libraries, asmprinter
// set this functions to ctor pointer at startup time if they are linked in.
typedef FunctionPass *(*AsmPrinterCtorFn)(formatted_raw_ostream &o,
- IA64TargetMachine &tm,
+ TargetMachine &tm,
bool verbose);
static AsmPrinterCtorFn AsmPrinterCtor;
extern "C" int MSILTargetMachineModule;
int MSILTargetMachineModule = 0;
-static RegisterTarget<MSILTarget> X("msil", "MSIL backend");
+extern Target TheMSILTarget;
+static RegisterTarget<MSILTarget> X(TheMSILTarget, "msil", "MSIL backend");
// Force static initialization.
extern "C" void LLVMInitializeMSILTarget() { }
// Register the targets
+extern Target TheMSP430Target;
static RegisterTarget<MSP430TargetMachine>
-X("msp430", "MSP430 [experimental]");
+X(TheMSP430Target, "msp430", "MSP430 [experimental]");
// Force static initialization.
extern "C" void LLVMInitializeMSP430Target() { }
#include "llvm/Target/TargetData.h"
#include "llvm/Target/TargetMachine.h"
#include "llvm/Target/TargetOptions.h"
+#include "llvm/Target/TargetRegistry.h"
#include "llvm/Support/ErrorHandling.h"
#include "llvm/Support/Mangler.h"
#include "llvm/ADT/Statistic.h"
class VISIBILITY_HIDDEN MipsAsmPrinter : public AsmPrinter {
const MipsSubtarget *Subtarget;
public:
- explicit MipsAsmPrinter(formatted_raw_ostream &O, MipsTargetMachine &TM,
+ explicit MipsAsmPrinter(formatted_raw_ostream &O, TargetMachine &TM,
const TargetAsmInfo *T, bool V)
: AsmPrinter(O, TM, T, V) {
Subtarget = &TM.getSubtarget<MipsSubtarget>();
/// using the given target machine description. This should work
/// regardless of whether the function is in SSA form.
FunctionPass *llvm::createMipsCodePrinterPass(formatted_raw_ostream &o,
- MipsTargetMachine &tm,
+ TargetMachine &tm,
bool verbose) {
return new MipsAsmPrinter(o, tm, tm.getTargetAsmInfo(), verbose);
}
}
// Force static initialization.
-extern "C" void LLVMInitializeMipsAsmPrinter() { }
+extern "C" void LLVMInitializeMipsAsmPrinter() {
+ extern Target TheMipsTarget;
+ TargetRegistry::RegisterAsmPrinter(TheMipsTarget, createMipsCodePrinterPass);
+
+ extern Target TheMipselTarget;
+ TargetRegistry::RegisterAsmPrinter(TheMipselTarget,
+ createMipsCodePrinterPass);
+}
FunctionPass *createMipsISelDag(MipsTargetMachine &TM);
FunctionPass *createMipsDelaySlotFillerPass(MipsTargetMachine &TM);
FunctionPass *createMipsCodePrinterPass(formatted_raw_ostream &OS,
- MipsTargetMachine &TM,
+ TargetMachine &TM,
bool Verbose);
} // end namespace llvm;
int MipsTargetMachineModule = 0;
// Register the target.
-static RegisterTarget<MipsTargetMachine> X("mips", "Mips");
-static RegisterTarget<MipselTargetMachine> Y("mipsel", "Mipsel");
+extern Target TheMipsTarget;
+static RegisterTarget<MipsTargetMachine> X(TheMipsTarget, "mips", "Mips");
+
+extern Target TheMipselTarget;
+static RegisterTarget<MipselTargetMachine> Y(TheMipselTarget, "mipsel",
+ "Mipsel");
MipsTargetMachine::AsmPrinterCtorFn MipsTargetMachine::AsmPrinterCtor = 0;
// asmprinter set this functions to ctor pointer at startup time if they are
// linked in.
typedef FunctionPass *(*AsmPrinterCtorFn)(formatted_raw_ostream &o,
- MipsTargetMachine &tm,
+ TargetMachine &tm,
bool verbose);
static AsmPrinterCtorFn AsmPrinterCtor;
// Register the targets
+extern Target ThePIC16Target;
static RegisterTarget<PIC16TargetMachine>
-X("pic16", "PIC16 14-bit [experimental].");
+X(ThePIC16Target, "pic16", "PIC16 14-bit [experimental].");
+
+extern Target TheCooperTarget;
static RegisterTarget<CooperTargetMachine>
-Y("cooper", "PIC16 Cooper [experimental].");
+Y(TheCooperTarget, "cooper", "PIC16 Cooper [experimental].");
// Force static initialization.
extern "C" void LLVMInitializePIC16Target() { }
#include "llvm/Target/TargetRegisterInfo.h"
#include "llvm/Target/TargetInstrInfo.h"
#include "llvm/Target/TargetOptions.h"
+#include "llvm/Target/TargetRegistry.h"
#include "llvm/ADT/Statistic.h"
#include "llvm/ADT/StringExtras.h"
#include "llvm/ADT/StringSet.h"
/// PPCLinuxAsmPrinter - PowerPC assembly printer, customized for Linux
class VISIBILITY_HIDDEN PPCLinuxAsmPrinter : public PPCAsmPrinter {
public:
- explicit PPCLinuxAsmPrinter(formatted_raw_ostream &O, PPCTargetMachine &TM,
+ explicit PPCLinuxAsmPrinter(formatted_raw_ostream &O, TargetMachine &TM,
const TargetAsmInfo *T, bool V)
: PPCAsmPrinter(O, TM, T, V){}
class VISIBILITY_HIDDEN PPCDarwinAsmPrinter : public PPCAsmPrinter {
formatted_raw_ostream &OS;
public:
- explicit PPCDarwinAsmPrinter(formatted_raw_ostream &O, PPCTargetMachine &TM,
+ explicit PPCDarwinAsmPrinter(formatted_raw_ostream &O, TargetMachine &TM,
const TargetAsmInfo *T, bool V)
: PPCAsmPrinter(O, TM, T, V), OS(O) {}
/// Darwin assembler can deal with.
///
FunctionPass *llvm::createPPCAsmPrinterPass(formatted_raw_ostream &o,
- PPCTargetMachine &tm,
+ TargetMachine &tm,
bool verbose) {
const PPCSubtarget *Subtarget = &tm.getSubtarget<PPCSubtarget>();
int PowerPCAsmPrinterForceLink = 0;
// Force static initialization.
-extern "C" void LLVMInitializePowerPCAsmPrinter() { }
+extern "C" void LLVMInitializePowerPCAsmPrinter() {
+ extern Target ThePPC32Target;
+ TargetRegistry::RegisterAsmPrinter(ThePPC32Target, createPPCAsmPrinterPass);
+
+ extern Target ThePPC64Target;
+ TargetRegistry::RegisterAsmPrinter(ThePPC64Target, createPPCAsmPrinterPass);
+}
FunctionPass *createPPCBranchSelectionPass();
FunctionPass *createPPCISelDag(PPCTargetMachine &TM);
FunctionPass *createPPCAsmPrinterPass(formatted_raw_ostream &OS,
- PPCTargetMachine &TM,
+ TargetMachine &TM,
bool Verbose);
FunctionPass *createPPCCodeEmitterPass(PPCTargetMachine &TM,
MachineCodeEmitter &MCE);
int PowerPCTargetMachineModule = 0;
// Register the targets
+extern Target ThePPC32Target;
static RegisterTarget<PPC32TargetMachine>
-X("ppc32", "PowerPC 32");
+X(ThePPC32Target, "ppc32", "PowerPC 32");
+
+extern Target ThePPC64Target;
static RegisterTarget<PPC64TargetMachine>
-Y("ppc64", "PowerPC 64");
+Y(ThePPC64Target, "ppc64", "PowerPC 64");
// Force static initialization.
extern "C" void LLVMInitializePowerPCTarget() { }
// To avoid having target depend on the asmprinter stuff libraries, asmprinter
// set this functions to ctor pointer at startup time if they are linked in.
typedef FunctionPass *(*AsmPrinterCtorFn)(formatted_raw_ostream &o,
- PPCTargetMachine &tm,
+ TargetMachine &m,
bool verbose);
static AsmPrinterCtorFn AsmPrinterCtor;
#include "llvm/CodeGen/MachineConstantPool.h"
#include "llvm/CodeGen/MachineInstr.h"
#include "llvm/Target/TargetAsmInfo.h"
+#include "llvm/Target/TargetRegistry.h"
#include "llvm/Support/ErrorHandling.h"
#include "llvm/Support/FormattedStream.h"
#include "llvm/Support/Mangler.h"
}
// Force static initialization.
-extern "C" void LLVMInitializeSparcAsmPrinter() { }
+extern "C" void LLVMInitializeSparcAsmPrinter() {
+ extern Target TheSparcTarget;
+ TargetRegistry::RegisterAsmPrinter(TheSparcTarget,
+ createSparcCodePrinterPass);
+}
using namespace llvm;
// Register the target.
-static RegisterTarget<SparcTargetMachine> X("sparc", "SPARC");
+extern Target TheSparcTarget;
+static RegisterTarget<SparcTargetMachine> X(TheSparcTarget, "sparc", "SPARC");
// No assembler printer by default
SparcTargetMachine::AsmPrinterCtorFn SparcTargetMachine::AsmPrinterCtor = 0;
MCContext *Context;
MCStreamer *Streamer;
public:
- explicit X86ATTAsmPrinter(formatted_raw_ostream &O, X86TargetMachine &TM,
+ explicit X86ATTAsmPrinter(formatted_raw_ostream &O, TargetMachine &TM,
const TargetAsmInfo *T, bool V)
: AsmPrinter(O, TM, T, V) {
Subtarget = &TM.getSubtarget<X86Subtarget>();
#include "X86ATTAsmPrinter.h"
#include "X86IntelAsmPrinter.h"
#include "X86Subtarget.h"
+#include "llvm/Target/TargetRegistry.h"
using namespace llvm;
/// createX86CodePrinterPass - Returns a pass that prints the X86 assembly code
/// machine description.
///
FunctionPass *llvm::createX86CodePrinterPass(formatted_raw_ostream &o,
- X86TargetMachine &tm,
+ TargetMachine &tm,
bool verbose) {
const X86Subtarget *Subtarget = &tm.getSubtarget<X86Subtarget>();
int X86AsmPrinterForceLink = 0;
// Force static initialization.
-extern "C" void LLVMInitializeX86AsmPrinter() { }
+extern "C" void LLVMInitializeX86AsmPrinter() {
+ extern Target TheX86_32Target;
+ TargetRegistry::RegisterAsmPrinter(TheX86_32Target, createX86CodePrinterPass);
+
+ extern Target TheX86_64Target;
+ TargetRegistry::RegisterAsmPrinter(TheX86_64Target, createX86CodePrinterPass);
+}
namespace llvm {
struct VISIBILITY_HIDDEN X86IntelAsmPrinter : public AsmPrinter {
- explicit X86IntelAsmPrinter(formatted_raw_ostream &O, X86TargetMachine &TM,
+ explicit X86IntelAsmPrinter(formatted_raw_ostream &O, TargetMachine &TM,
const TargetAsmInfo *T, bool V)
: AsmPrinter(O, TM, T, V) {}
/// using the given target machine description.
///
FunctionPass *createX86CodePrinterPass(formatted_raw_ostream &o,
- X86TargetMachine &tm,
+ TargetMachine &tm,
bool Verbose);
/// createX86CodeEmitterPass - Return a pass that emits the collected X86 code
int X86TargetMachineModule = 0;
// Register the target.
+extern Target TheX86_32Target;
static RegisterTarget<X86_32TargetMachine>
-X("x86", "32-bit X86: Pentium-Pro and above");
+X(TheX86_32Target, "x86", "32-bit X86: Pentium-Pro and above");
+
+extern Target TheX86_64Target;
static RegisterTarget<X86_64TargetMachine>
-Y("x86-64", "64-bit X86: EM64T and AMD64");
+Y(TheX86_64Target, "x86-64", "64-bit X86: EM64T and AMD64");
// Force static initialization.
-extern "C" void LLVMInitializeX86Target() { }
+extern "C" void LLVMInitializeX86Target() {
+
+}
// No assembler printer by default
X86TargetMachine::AsmPrinterCtorFn X86TargetMachine::AsmPrinterCtor = 0;
// To avoid having target depend on the asmprinter stuff libraries, asmprinter
// set this functions to ctor pointer at startup time if they are linked in.
typedef FunctionPass *(*AsmPrinterCtorFn)(formatted_raw_ostream &o,
- X86TargetMachine &tm,
+ TargetMachine &tm,
bool verbose);
static AsmPrinterCtorFn AsmPrinterCtor;
extern "C" int XCoreTargetMachineModule;
int XCoreTargetMachineModule = 0;
+extern Target TheXCoreTarget;
namespace {
// Register the target.
- RegisterTarget<XCoreTargetMachine> X("xcore", "XCore");
+ RegisterTarget<XCoreTargetMachine> X(TheXCoreTarget, "xcore", "XCore");
}
// Force static initialization.