JITTargetAddress JITCompileCallbackManager::executeCompileCallback( JITTargetAddress TrampolineAddr) { SymbolStringPtr Name; { std::unique_lock<std::mutex> Lock(CCMgrMutex); auto I = AddrToSymbol.find(TrampolineAddr); // If this address is not associated with a compile callback then report an // error to the execution session and return ErrorHandlerAddress to the // callee. if (I == AddrToSymbol.end()) { Lock.unlock(); std::string ErrMsg; { raw_string_ostream ErrMsgStream(ErrMsg); ErrMsgStream << "No compile callback for trampoline at " << format("0x%016x", TrampolineAddr); } ES.reportError( make_error<StringError>(std::move(ErrMsg), inconvertibleErrorCode())); return ErrorHandlerAddress; } else Name = I->second; } if (auto Sym = lookup({&CallbacksJD}, Name)) return Sym->getAddress(); else { // If anything goes wrong materializing Sym then report it to the session // and return the ErrorHandlerAddress; ES.reportError(Sym.takeError()); return ErrorHandlerAddress; } }
Expected<const CodeRegions &> AsmCodeRegionGenerator::parseCodeRegions() { MCTargetOptions Opts; Opts.PreserveAsmComments = false; MCStreamerWrapper Str(Ctx, Regions); // Create a MCAsmParser and setup the lexer to recognize llvm-mca ASM // comments. std::unique_ptr<MCAsmParser> Parser( createMCAsmParser(Regions.getSourceMgr(), Ctx, Str, MAI)); MCAsmLexer &Lexer = Parser->getLexer(); MCACommentConsumer CC(Regions); Lexer.setCommentConsumer(&CC); // Create a target-specific parser and perform the parse. std::unique_ptr<MCTargetAsmParser> TAP( TheTarget.createMCAsmParser(STI, *Parser, MCII, Opts)); if (!TAP) return make_error<StringError>( "This target does not support assembly parsing.", inconvertibleErrorCode()); Parser->setTargetParser(*TAP); Parser->Run(false); // Get the assembler dialect from the input. llvm-mca will use this as the // default dialect when printing reports. AssemblerDialect = Parser->getAssemblerDialect(); return Regions; }
std::error_code errorToErrorCode(Error Err) { std::error_code EC; handleAllErrors(std::move(Err), [&](const ErrorInfoBase &EI) { EC = EI.convertToErrorCode(); }); if (EC == inconvertibleErrorCode()) report_fatal_error(EC.message()); return EC; }
Expected<DynamicLibrarySearchGenerator> DynamicLibrarySearchGenerator::Load(const char *FileName, const DataLayout &DL, SymbolPredicate Allow) { std::string ErrMsg; auto Lib = sys::DynamicLibrary::getPermanentLibrary(FileName, &ErrMsg); if (!Lib.isValid()) return make_error<StringError>(std::move(ErrMsg), inconvertibleErrorCode()); return DynamicLibrarySearchGenerator(std::move(Lib), DL, std::move(Allow)); }
Error LLJIT::applyDataLayout(Module &M) { if (M.getDataLayout().isDefault()) M.setDataLayout(DL); if (M.getDataLayout() != DL) return make_error<StringError>( "Added modules have incompatible data layouts", inconvertibleErrorCode()); return Error::success(); }
LLLazyJIT::LLLazyJIT(LLLazyJITBuilderState &S, Error &Err) : LLJIT(S, Err) { // If LLJIT construction failed then bail out. if (Err) return; ErrorAsOutParameter _(&Err); /// Take/Create the lazy-compile callthrough manager. if (S.LCTMgr) LCTMgr = std::move(S.LCTMgr); else { if (auto LCTMgrOrErr = createLocalLazyCallThroughManager( S.TT, *ES, S.LazyCompileFailureAddr)) LCTMgr = std::move(*LCTMgrOrErr); else { Err = LCTMgrOrErr.takeError(); return; } } // Take/Create the indirect stubs manager builder. auto ISMBuilder = std::move(S.ISMBuilder); // If none was provided, try to build one. if (!ISMBuilder) ISMBuilder = createLocalIndirectStubsManagerBuilder(S.TT); // No luck. Bail out. if (!ISMBuilder) { Err = make_error<StringError>("Could not construct " "IndirectStubsManagerBuilder for target " + S.TT.str(), inconvertibleErrorCode()); return; } // Create the transform layer. TransformLayer = llvm::make_unique<IRTransformLayer>(*ES, *CompileLayer); // Create the COD layer. CODLayer = llvm::make_unique<CompileOnDemandLayer>( *ES, *TransformLayer, *LCTMgr, std::move(ISMBuilder)); if (S.NumCompileThreads > 0) CODLayer->setCloneToNewContextOnEmit(true); }
Expected<std::unique_ptr<LazyCallThroughManager>> createLocalLazyCallThroughManager(const Triple &T, ExecutionSession &ES, JITTargetAddress ErrorHandlerAddr) { switch (T.getArch()) { default: return make_error<StringError>( std::string("No callback manager available for ") + T.str(), inconvertibleErrorCode()); case Triple::aarch64: return LocalLazyCallThroughManager::Create<OrcAArch64>(ES, ErrorHandlerAddr); case Triple::x86: return LocalLazyCallThroughManager::Create<OrcI386>(ES, ErrorHandlerAddr); case Triple::mips: return LocalLazyCallThroughManager::Create<OrcMips32Be>(ES, ErrorHandlerAddr); case Triple::mipsel: return LocalLazyCallThroughManager::Create<OrcMips32Le>(ES, ErrorHandlerAddr); case Triple::mips64: case Triple::mips64el: return LocalLazyCallThroughManager::Create<OrcMips64>(ES, ErrorHandlerAddr); case Triple::x86_64: if (T.getOS() == Triple::OSType::Win32) return LocalLazyCallThroughManager::Create<OrcX86_64_Win32>( ES, ErrorHandlerAddr); else return LocalLazyCallThroughManager::Create<OrcX86_64_SysV>( ES, ErrorHandlerAddr); } }