//===-- TargetSelect.cpp - Target Chooser Code ----------------------------===//
-//
+//
// The LLVM Compiler Infrastructure
//
-// This file was developed by the LLVM research group and is distributed under
-// the University of Illinois Open Source License. See LICENSE.TXT for details.
-//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
//===----------------------------------------------------------------------===//
//
-// This file contains the hideously gross code that is currently used to select
-// a particular TargetMachine for the JIT to use. This should obviously be
-// improved in the future, probably by having the TargetMachines register
-// themselves with the runtime, and then have them choose themselves if they
-// match the current machine.
+// This just asks the TargetRegistry for the appropriate JIT to use, and allows
+// the user to specify a specific one on the commandline with -march=x. Clients
+// should initialize targets prior to calling createJIT.
//
//===----------------------------------------------------------------------===//
#include "JIT.h"
#include "llvm/Module.h"
#include "llvm/ModuleProvider.h"
+#include "llvm/ADT/Triple.h"
+#include "llvm/Support/CommandLine.h"
+#include "llvm/Support/raw_ostream.h"
+#include "llvm/System/Host.h"
+#include "llvm/Target/SubtargetFeature.h"
#include "llvm/Target/TargetMachine.h"
-#include "llvm/Target/TargetMachineImpls.h"
-#include "Support/CommandLine.h"
+#include "llvm/Target/TargetRegistry.h"
using namespace llvm;
-#if !defined(ENABLE_X86_JIT) && !defined(ENABLE_SPARC_JIT)
-#define NO_JITS_ENABLED
-#endif
+static cl::opt<std::string>
+MArch("march",
+ cl::desc("Architecture to generate assembly for (see --version)"));
-namespace {
- enum ArchName { x86, SparcV9 };
+static cl::opt<std::string>
+MCPU("mcpu",
+ cl::desc("Target a specific cpu type (-mcpu=help for details)"),
+ cl::value_desc("cpu-name"),
+ cl::init(""));
-#ifndef NO_JITS_ENABLED
- cl::opt<ArchName>
- Arch("march", cl::desc("Architecture to JIT to:"), cl::Prefix,
- cl::values(
-#ifdef ENABLE_X86_JIT
- clEnumVal(x86, " IA-32 (Pentium and above)"),
-#endif
-#ifdef ENABLE_SPARC_JIT
- clEnumValN(Sparc, "sparcv9", " Sparc-V9"),
-#endif
- 0),
-#if defined(ENABLE_X86_JIT)
- cl::init(x86)
-#elif defined(ENABLE_SPARC_JIT)
- cl::init(SparcV9)
-#endif
- );
-#endif /* NO_JITS_ENABLED */
-}
+static cl::list<std::string>
+MAttrs("mattr",
+ cl::CommaSeparated,
+ cl::desc("Target specific attributes (-mattr=help for details)"),
+ cl::value_desc("a1,+a2,-a3,..."));
+
+/// selectTarget - Pick a target either via -march or by guessing the native
+/// arch. Add any CPU features specified via -mcpu or -mattr.
+TargetMachine *JIT::selectTarget(ModuleProvider *MP, std::string *ErrorStr) {
+ Module &Mod = *MP->getModule();
+
+ Triple TheTriple(Mod.getTargetTriple());
+ if (TheTriple.getTriple().empty())
+ TheTriple.setTriple(sys::getHostTriple());
+
+ // Adjust the triple to match what the user requested.
+ const Target *TheTarget = 0;
+ if (!MArch.empty()) {
+ for (TargetRegistry::iterator it = TargetRegistry::begin(),
+ ie = TargetRegistry::end(); it != ie; ++it) {
+ if (MArch == it->getName()) {
+ TheTarget = &*it;
+ break;
+ }
+ }
-/// create - Create an return a new JIT compiler if there is one available
-/// for the current target. Otherwise, return null.
-///
-ExecutionEngine *JIT::create(ModuleProvider *MP, IntrinsicLowering *IL) {
- TargetMachine* (*TargetMachineAllocator)(const Module &,
- IntrinsicLowering *IL) = 0;
+ if (!TheTarget) {
+ *ErrorStr = "No available targets are compatible with this -march, "
+ "see -version for the available targets.\n";
+ return 0;
+ }
- // Allow a command-line switch to override what *should* be the default target
- // machine for this platform. This allows for debugging a Sparc JIT on X86 --
- // our X86 machines are much faster at recompiling LLVM and linking LLI.
-#ifndef NO_JITS_ENABLED
+ // Adjust the triple to match (if known), otherwise stick with the
+ // module/host triple.
+ Triple::ArchType Type = Triple::getArchTypeForLLVMName(MArch);
+ if (Type != Triple::UnknownArch)
+ TheTriple.setArch(Type);
+ } else {
+ std::string Error;
+ TheTarget = TargetRegistry::lookupTarget(TheTriple.getTriple(), Error);
+ if (TheTarget == 0) {
+ if (ErrorStr)
+ *ErrorStr = Error;
+ return 0;
+ }
+ }
+
+ if (!TheTarget->hasJIT()) {
+ errs() << "WARNING: This target JIT is not designed for the host you are"
+ << " running. If bad things happen, please choose a different "
+ << "-march switch.\n";
+ }
- switch (Arch) {
-#ifdef ENABLE_X86_JIT
- case x86:
- TargetMachineAllocator = allocateX86TargetMachine;
- break;
-#endif
-#ifdef ENABLE_SPARC_JIT
- case SparcV9:
- TargetMachineAllocator = allocateSparcV9TargetMachine;
- break;
-#endif
- default:
- assert(0 && "-march flag not supported on this host!");
+ // Package up features to be passed to target/subtarget
+ std::string FeaturesStr;
+ if (!MCPU.empty() || !MAttrs.empty()) {
+ SubtargetFeatures Features;
+ Features.setCPU(MCPU);
+ for (unsigned i = 0; i != MAttrs.size(); ++i)
+ Features.AddFeature(MAttrs[i]);
+ FeaturesStr = Features.getString();
}
-#else
- return 0;
-#endif
// Allocate a target...
- TargetMachine *Target = TargetMachineAllocator(*MP->getModule(), IL);
+ TargetMachine *Target =
+ TheTarget->createTargetMachine(TheTriple.getTriple(), FeaturesStr);
assert(Target && "Could not allocate target machine!");
-
- // If the target supports JIT code generation, return a new JIT now.
- if (TargetJITInfo *TJ = Target->getJITInfo())
- return new JIT(MP, *Target, *TJ);
- return 0;
+ return Target;
}
-
-
projects / oota-llvm.git / blobdiff