ExecutionEngine *JIT::createJIT(ModuleProvider *MP, std::string *ErrorStr, JITMemoryManager *JMM, CodeGenOpt::Level OptLevel, bool GVsWithCode, CodeModel::Model CMM) { // Make sure we can resolve symbols in the program as well. The zero arg // to the function tells DynamicLibrary to load the program, not a library. if (sys::DynamicLibrary::LoadLibraryPermanently(0, ErrorStr)) return 0; // Pick a target either via -march or by guessing the native arch. TargetMachine *TM = JIT::selectTarget(MP, ErrorStr); if (!TM || (ErrorStr && ErrorStr->length() > 0)) return 0; TM->setCodeModel(CMM); // If the target supports JIT code generation, create a the JIT. if (TargetJITInfo *TJ = TM->getJITInfo()) { return new JIT(MP, *TM, *TJ, JMM, OptLevel, GVsWithCode); } else { if (ErrorStr) *ErrorStr = "target does not support JIT code generation"; return 0; } }
ExecutionEngine *JIT::createJIT(Module *M, std::string *ErrorStr, JITMemoryManager *JMM, CodeGenOpt::Level OptLevel, bool GVsWithCode, CodeModel::Model CMM, StringRef MArch, StringRef MCPU, const SmallVectorImpl<std::string>& MAttrs) { // Try to register the program as a source of symbols to resolve against. sys::DynamicLibrary::LoadLibraryPermanently(0, NULL); /* CLAMAV LOCAL: no dlopen */ // if (sys::DynamicLibrary::LoadLibraryPermanently(0, ErrorStr)) // return 0; // Pick a target either via -march or by guessing the native arch. TargetMachine *TM = JIT::selectTarget(M, MArch, MCPU, MAttrs, ErrorStr); if (!TM || (ErrorStr && ErrorStr->length() > 0)) return 0; TM->setCodeModel(CMM); // If the target supports JIT code generation, create a the JIT. if (TargetJITInfo *TJ = TM->getJITInfo()) { return new JIT(M, *TM, *TJ, JMM, OptLevel, GVsWithCode); } else { if (ErrorStr) *ErrorStr = "target does not support JIT code generation"; return 0; } }
ExecutionEngine *MCJIT::createJIT(Module *M, std::string *ErrorStr, JITMemoryManager *JMM, CodeGenOpt::Level OptLevel, bool GVsWithCode, CodeModel::Model CMM, StringRef MArch, StringRef MCPU, const SmallVectorImpl<std::string>& MAttrs) { // Try to register the program as a source of symbols to resolve against. // // FIXME: Don't do this here. sys::DynamicLibrary::LoadLibraryPermanently(0, NULL); // Pick a target either via -march or by guessing the native arch. // // FIXME: This should be lifted out of here, it isn't something which should // be part of the JIT policy, rather the burden for this selection should be // pushed to clients. TargetMachine *TM = MCJIT::selectTarget(M, MArch, MCPU, MAttrs, ErrorStr); if (!TM || (ErrorStr && ErrorStr->length() > 0)) return 0; TM->setCodeModel(CMM); // If the target supports JIT code generation, create the JIT. if (TargetJITInfo *TJ = TM->getJITInfo()) return new MCJIT(M, *TM, *TJ, JMM, OptLevel, GVsWithCode); if (ErrorStr) *ErrorStr = "target does not support JIT code generation"; return 0; }
/// 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) { if (MArch == 0) { std::string Error; MArch = TargetMachineRegistry::getClosestTargetForJIT(Error); if (MArch == 0) return 0; } else if (MArch->JITMatchQualityFn() == 0) { std::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 = MArch->CtorFn(*MP->getModule(), IL); 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; }