/// getShortDescription - Get a short description of the target.
const char *getShortDescription() const { return ShortDesc; }
+ /// getJITMatchQuality - Get the quality of this targets match for use as a
+ /// JIT.
+ unsigned getJITMatchQuality() const { return JITMatchQualityFn(); }
+
/// createTargetMachine - Create a target specific machine implementation.
TargetMachine *createTargetMachine(const Module &M,
const std::string &Features) const {
JITMemoryManager *JMM,
CodeGenOpt::Level OptLevel,
bool AllocateGVsWithCode) {
- const TargetMachineRegistry::entry *TheArch = MArch;
- if (TheArch == 0) {
+ const Target *TheTarget;
+ if (MArch == 0) {
std::string Error;
- TheArch = TargetMachineRegistry::getClosestTargetForJIT(Error);
- if (TheArch == 0) {
+ TheTarget = TargetRegistry::getClosestTargetForJIT(Error);
+ if (TheTarget == 0) {
if (ErrorStr)
*ErrorStr = Error;
return 0;
}
- } else if (TheArch->JITMatchQualityFn() == 0) {
+ } else if (TheTarget->getJITMatchQuality() == 0) {
cerr << "WARNING: This target JIT is not designed for the host you are"
<< " running. If bad things happen, please choose a different "
<< "-march switch.\n";
}
// Allocate a target...
- TargetMachine *Target = TheArch->CtorFn(*MP->getModule(), FeaturesStr);
+ TargetMachine *Target =
+ TheTarget->createTargetMachine(*MP->getModule(), FeaturesStr);
assert(Target && "Could not allocate target machine!");
// If the target supports JIT code generation, return a new JIT now.
return outputFilename;
}
-static formatted_raw_ostream *GetOutputStream(const char *ProgName) {
+static formatted_raw_ostream *GetOutputStream(const char *TargetName,
+ const char *ProgName) {
if (OutputFilename != "") {
if (OutputFilename == "-")
return &fouts();
bool Binary = false;
switch (FileType) {
case TargetMachine::AssemblyFile:
- if (MArch->Name[0] == 'c') {
- if (MArch->Name[1] == 0)
+ if (TargetName[0] == 'c') {
+ if (TargetName[1] == 0)
OutputFilename += ".cbe.c";
- else if (MArch->Name[1] == 'p' && MArch->Name[2] == 'p')
+ else if (TargetName[1] == 'p' && TargetName[2] == 'p')
OutputFilename += ".cpp";
else
OutputFilename += ".s";
// Allocate target machine. First, check whether the user has
// explicitly specified an architecture to compile for.
- if (MArch == 0) {
+ const Target *TheTarget;
+ if (MArch) {
+ TheTarget = &MArch->TheTarget;
+ } else {
std::string Err;
- MArch = TargetMachineRegistry::getClosestStaticTargetForModule(mod, Err);
- if (MArch == 0) {
+ TheTarget = TargetRegistry::getClosestStaticTargetForModule(mod, Err);
+ if (TheTarget == 0) {
std::cerr << argv[0] << ": error auto-selecting target for module '"
<< Err << "'. Please use the -march option to explicitly "
<< "pick a target.\n";
FeaturesStr = Features.getString();
}
- std::auto_ptr<TargetMachine> target(MArch->CtorFn(mod, FeaturesStr));
+ std::auto_ptr<TargetMachine>
+ target(TheTarget->createTargetMachine(mod, FeaturesStr));
assert(target.get() && "Could not allocate target machine!");
TargetMachine &Target = *target.get();
// Figure out where we are going to send the output...
- formatted_raw_ostream *Out = GetOutputStream(argv[0]);
+ formatted_raw_ostream *Out = GetOutputStream(TheTarget->getName(), argv[0]);
if (Out == 0) return 1;
CodeGenOpt::Level OLvl = CodeGenOpt::Default;