1 //===- lli.cpp - LLVM Interpreter / Dynamic compiler ----------------------===// 2 // 3 // The LLVM Compiler Infrastructure 4 // 5 // This file is distributed under the University of Illinois Open Source 6 // License. See LICENSE.TXT for details. 7 // 8 //===----------------------------------------------------------------------===// 9 // 10 // This utility provides a simple wrapper around the LLVM Execution Engines, 11 // which allow the direct execution of LLVM programs through a Just-In-Time 12 // compiler, or through an interpreter if no JIT is available for this platform. 13 // 14 //===----------------------------------------------------------------------===// 15 16 #include "llvm/IR/LLVMContext.h" 17 #include "OrcLazyJIT.h" 18 #include "RemoteMemoryManager.h" 19 #include "RemoteTarget.h" 20 #include "RemoteTargetExternal.h" 21 #include "llvm/ADT/Triple.h" 22 #include "llvm/Bitcode/ReaderWriter.h" 23 #include "llvm/CodeGen/LinkAllCodegenComponents.h" 24 #include "llvm/ExecutionEngine/GenericValue.h" 25 #include "llvm/ExecutionEngine/Interpreter.h" 26 #include "llvm/ExecutionEngine/JITEventListener.h" 27 #include "llvm/ExecutionEngine/MCJIT.h" 28 #include "llvm/ExecutionEngine/ObjectCache.h" 29 #include "llvm/ExecutionEngine/OrcMCJITReplacement.h" 30 #include "llvm/ExecutionEngine/SectionMemoryManager.h" 31 #include "llvm/IR/IRBuilder.h" 32 #include "llvm/IR/Module.h" 33 #include "llvm/IR/Type.h" 34 #include "llvm/IR/TypeBuilder.h" 35 #include "llvm/IRReader/IRReader.h" 36 #include "llvm/Object/Archive.h" 37 #include "llvm/Object/ObjectFile.h" 38 #include "llvm/Support/CommandLine.h" 39 #include "llvm/Support/Debug.h" 40 #include "llvm/Support/DynamicLibrary.h" 41 #include "llvm/Support/Format.h" 42 #include "llvm/Support/ManagedStatic.h" 43 #include "llvm/Support/MathExtras.h" 44 #include "llvm/Support/Memory.h" 45 #include "llvm/Support/MemoryBuffer.h" 46 #include "llvm/Support/Path.h" 47 #include "llvm/Support/PluginLoader.h" 48 #include "llvm/Support/PrettyStackTrace.h" 49 #include "llvm/Support/Process.h" 50 #include "llvm/Support/Program.h" 51 #include "llvm/Support/Signals.h" 52 #include "llvm/Support/SourceMgr.h" 53 #include "llvm/Support/TargetSelect.h" 54 #include "llvm/Support/raw_ostream.h" 55 #include "llvm/Transforms/Instrumentation.h" 56 #include <cerrno> 57 58 #ifdef __CYGWIN__ 59 #include <cygwin/version.h> 60 #if defined(CYGWIN_VERSION_DLL_MAJOR) && CYGWIN_VERSION_DLL_MAJOR<1007 61 #define DO_NOTHING_ATEXIT 1 62 #endif 63 #endif 64 65 using namespace llvm; 66 67 #define DEBUG_TYPE "lli" 68 69 namespace { 70 71 enum class JITKind { MCJIT, OrcMCJITReplacement, OrcLazy }; 72 73 cl::opt<std::string> 74 InputFile(cl::desc("<input bitcode>"), cl::Positional, cl::init("-")); 75 76 cl::list<std::string> 77 InputArgv(cl::ConsumeAfter, cl::desc("<program arguments>...")); 78 79 cl::opt<bool> ForceInterpreter("force-interpreter", 80 cl::desc("Force interpretation: disable JIT"), 81 cl::init(false)); 82 83 cl::opt<JITKind> UseJITKind("jit-kind", 84 cl::desc("Choose underlying JIT kind."), 85 cl::init(JITKind::MCJIT), 86 cl::values( 87 clEnumValN(JITKind::MCJIT, "mcjit", 88 "MCJIT"), 89 clEnumValN(JITKind::OrcMCJITReplacement, 90 "orc-mcjit", 91 "Orc-based MCJIT replacement"), 92 clEnumValN(JITKind::OrcLazy, 93 "orc-lazy", 94 "Orc-based lazy JIT."), 95 clEnumValEnd)); 96 97 // The MCJIT supports building for a target address space separate from 98 // the JIT compilation process. Use a forked process and a copying 99 // memory manager with IPC to execute using this functionality. 100 cl::opt<bool> RemoteMCJIT("remote-mcjit", 101 cl::desc("Execute MCJIT'ed code in a separate process."), 102 cl::init(false)); 103 104 // Manually specify the child process for remote execution. This overrides 105 // the simulated remote execution that allocates address space for child 106 // execution. The child process will be executed and will communicate with 107 // lli via stdin/stdout pipes. 108 cl::opt<std::string> 109 ChildExecPath("mcjit-remote-process", 110 cl::desc("Specify the filename of the process to launch " 111 "for remote MCJIT execution. If none is specified," 112 "\n\tremote execution will be simulated in-process."), 113 cl::value_desc("filename"), cl::init("")); 114 115 // Determine optimization level. 116 cl::opt<char> 117 OptLevel("O", 118 cl::desc("Optimization level. [-O0, -O1, -O2, or -O3] " 119 "(default = '-O2')"), 120 cl::Prefix, 121 cl::ZeroOrMore, 122 cl::init(' ')); 123 124 cl::opt<std::string> 125 TargetTriple("mtriple", cl::desc("Override target triple for module")); 126 127 cl::opt<std::string> 128 MArch("march", 129 cl::desc("Architecture to generate assembly for (see --version)")); 130 131 cl::opt<std::string> 132 MCPU("mcpu", 133 cl::desc("Target a specific cpu type (-mcpu=help for details)"), 134 cl::value_desc("cpu-name"), 135 cl::init("")); 136 137 cl::list<std::string> 138 MAttrs("mattr", 139 cl::CommaSeparated, 140 cl::desc("Target specific attributes (-mattr=help for details)"), 141 cl::value_desc("a1,+a2,-a3,...")); 142 143 cl::opt<std::string> 144 EntryFunc("entry-function", 145 cl::desc("Specify the entry function (default = 'main') " 146 "of the executable"), 147 cl::value_desc("function"), 148 cl::init("main")); 149 150 cl::list<std::string> 151 ExtraModules("extra-module", 152 cl::desc("Extra modules to be loaded"), 153 cl::value_desc("input bitcode")); 154 155 cl::list<std::string> 156 ExtraObjects("extra-object", 157 cl::desc("Extra object files to be loaded"), 158 cl::value_desc("input object")); 159 160 cl::list<std::string> 161 ExtraArchives("extra-archive", 162 cl::desc("Extra archive files to be loaded"), 163 cl::value_desc("input archive")); 164 165 cl::opt<bool> 166 EnableCacheManager("enable-cache-manager", 167 cl::desc("Use cache manager to save/load mdoules"), 168 cl::init(false)); 169 170 cl::opt<std::string> 171 ObjectCacheDir("object-cache-dir", 172 cl::desc("Directory to store cached object files " 173 "(must be user writable)"), 174 cl::init("")); 175 176 cl::opt<std::string> 177 FakeArgv0("fake-argv0", 178 cl::desc("Override the 'argv[0]' value passed into the executing" 179 " program"), cl::value_desc("executable")); 180 181 cl::opt<bool> 182 DisableCoreFiles("disable-core-files", cl::Hidden, 183 cl::desc("Disable emission of core files if possible")); 184 185 cl::opt<bool> 186 NoLazyCompilation("disable-lazy-compilation", 187 cl::desc("Disable JIT lazy compilation"), 188 cl::init(false)); 189 190 cl::opt<Reloc::Model> 191 RelocModel("relocation-model", 192 cl::desc("Choose relocation model"), 193 cl::init(Reloc::Default), 194 cl::values( 195 clEnumValN(Reloc::Default, "default", 196 "Target default relocation model"), 197 clEnumValN(Reloc::Static, "static", 198 "Non-relocatable code"), 199 clEnumValN(Reloc::PIC_, "pic", 200 "Fully relocatable, position independent code"), 201 clEnumValN(Reloc::DynamicNoPIC, "dynamic-no-pic", 202 "Relocatable external references, non-relocatable code"), 203 clEnumValEnd)); 204 205 cl::opt<llvm::CodeModel::Model> 206 CMModel("code-model", 207 cl::desc("Choose code model"), 208 cl::init(CodeModel::JITDefault), 209 cl::values(clEnumValN(CodeModel::JITDefault, "default", 210 "Target default JIT code model"), 211 clEnumValN(CodeModel::Small, "small", 212 "Small code model"), 213 clEnumValN(CodeModel::Kernel, "kernel", 214 "Kernel code model"), 215 clEnumValN(CodeModel::Medium, "medium", 216 "Medium code model"), 217 clEnumValN(CodeModel::Large, "large", 218 "Large code model"), 219 clEnumValEnd)); 220 221 cl::opt<bool> 222 GenerateSoftFloatCalls("soft-float", 223 cl::desc("Generate software floating point library calls"), 224 cl::init(false)); 225 226 cl::opt<llvm::FloatABI::ABIType> 227 FloatABIForCalls("float-abi", 228 cl::desc("Choose float ABI type"), 229 cl::init(FloatABI::Default), 230 cl::values( 231 clEnumValN(FloatABI::Default, "default", 232 "Target default float ABI type"), 233 clEnumValN(FloatABI::Soft, "soft", 234 "Soft float ABI (implied by -soft-float)"), 235 clEnumValN(FloatABI::Hard, "hard", 236 "Hard float ABI (uses FP registers)"), 237 clEnumValEnd)); 238 } 239 240 //===----------------------------------------------------------------------===// 241 // Object cache 242 // 243 // This object cache implementation writes cached objects to disk to the 244 // directory specified by CacheDir, using a filename provided in the module 245 // descriptor. The cache tries to load a saved object using that path if the 246 // file exists. CacheDir defaults to "", in which case objects are cached 247 // alongside their originating bitcodes. 248 // 249 class LLIObjectCache : public ObjectCache { 250 public: 251 LLIObjectCache(const std::string& CacheDir) : CacheDir(CacheDir) { 252 // Add trailing '/' to cache dir if necessary. 253 if (!this->CacheDir.empty() && 254 this->CacheDir[this->CacheDir.size() - 1] != '/') 255 this->CacheDir += '/'; 256 } 257 ~LLIObjectCache() override {} 258 259 void notifyObjectCompiled(const Module *M, MemoryBufferRef Obj) override { 260 const std::string ModuleID = M->getModuleIdentifier(); 261 std::string CacheName; 262 if (!getCacheFilename(ModuleID, CacheName)) 263 return; 264 if (!CacheDir.empty()) { // Create user-defined cache dir. 265 SmallString<128> dir(CacheName); 266 sys::path::remove_filename(dir); 267 sys::fs::create_directories(Twine(dir)); 268 } 269 std::error_code EC; 270 raw_fd_ostream outfile(CacheName, EC, sys::fs::F_None); 271 outfile.write(Obj.getBufferStart(), Obj.getBufferSize()); 272 outfile.close(); 273 } 274 275 std::unique_ptr<MemoryBuffer> getObject(const Module* M) override { 276 const std::string ModuleID = M->getModuleIdentifier(); 277 std::string CacheName; 278 if (!getCacheFilename(ModuleID, CacheName)) 279 return nullptr; 280 // Load the object from the cache filename 281 ErrorOr<std::unique_ptr<MemoryBuffer>> IRObjectBuffer = 282 MemoryBuffer::getFile(CacheName.c_str(), -1, false); 283 // If the file isn't there, that's OK. 284 if (!IRObjectBuffer) 285 return nullptr; 286 // MCJIT will want to write into this buffer, and we don't want that 287 // because the file has probably just been mmapped. Instead we make 288 // a copy. The filed-based buffer will be released when it goes 289 // out of scope. 290 return MemoryBuffer::getMemBufferCopy(IRObjectBuffer.get()->getBuffer()); 291 } 292 293 private: 294 std::string CacheDir; 295 296 bool getCacheFilename(const std::string &ModID, std::string &CacheName) { 297 std::string Prefix("file:"); 298 size_t PrefixLength = Prefix.length(); 299 if (ModID.substr(0, PrefixLength) != Prefix) 300 return false; 301 std::string CacheSubdir = ModID.substr(PrefixLength); 302 #if defined(_WIN32) 303 // Transform "X:\foo" => "/X\foo" for convenience. 304 if (isalpha(CacheSubdir[0]) && CacheSubdir[1] == ':') { 305 CacheSubdir[1] = CacheSubdir[0]; 306 CacheSubdir[0] = '/'; 307 } 308 #endif 309 CacheName = CacheDir + CacheSubdir; 310 size_t pos = CacheName.rfind('.'); 311 CacheName.replace(pos, CacheName.length() - pos, ".o"); 312 return true; 313 } 314 }; 315 316 static ExecutionEngine *EE = nullptr; 317 static LLIObjectCache *CacheManager = nullptr; 318 319 static void do_shutdown() { 320 // Cygwin-1.5 invokes DLL's dtors before atexit handler. 321 #ifndef DO_NOTHING_ATEXIT 322 delete EE; 323 if (CacheManager) 324 delete CacheManager; 325 llvm_shutdown(); 326 #endif 327 } 328 329 // On Mingw and Cygwin, an external symbol named '__main' is called from the 330 // generated 'main' function to allow static intialization. To avoid linking 331 // problems with remote targets (because lli's remote target support does not 332 // currently handle external linking) we add a secondary module which defines 333 // an empty '__main' function. 334 static void addCygMingExtraModule(ExecutionEngine *EE, 335 LLVMContext &Context, 336 StringRef TargetTripleStr) { 337 IRBuilder<> Builder(Context); 338 Triple TargetTriple(TargetTripleStr); 339 340 // Create a new module. 341 std::unique_ptr<Module> M = make_unique<Module>("CygMingHelper", Context); 342 M->setTargetTriple(TargetTripleStr); 343 344 // Create an empty function named "__main". 345 Function *Result; 346 if (TargetTriple.isArch64Bit()) { 347 Result = Function::Create( 348 TypeBuilder<int64_t(void), false>::get(Context), 349 GlobalValue::ExternalLinkage, "__main", M.get()); 350 } else { 351 Result = Function::Create( 352 TypeBuilder<int32_t(void), false>::get(Context), 353 GlobalValue::ExternalLinkage, "__main", M.get()); 354 } 355 BasicBlock *BB = BasicBlock::Create(Context, "__main", Result); 356 Builder.SetInsertPoint(BB); 357 Value *ReturnVal; 358 if (TargetTriple.isArch64Bit()) 359 ReturnVal = ConstantInt::get(Context, APInt(64, 0)); 360 else 361 ReturnVal = ConstantInt::get(Context, APInt(32, 0)); 362 Builder.CreateRet(ReturnVal); 363 364 // Add this new module to the ExecutionEngine. 365 EE->addModule(std::move(M)); 366 } 367 368 CodeGenOpt::Level getOptLevel() { 369 switch (OptLevel) { 370 default: 371 errs() << "lli: Invalid optimization level.\n"; 372 exit(1); 373 case '0': return CodeGenOpt::None; 374 case '1': return CodeGenOpt::Less; 375 case ' ': 376 case '2': return CodeGenOpt::Default; 377 case '3': return CodeGenOpt::Aggressive; 378 } 379 llvm_unreachable("Unrecognized opt level."); 380 } 381 382 //===----------------------------------------------------------------------===// 383 // main Driver function 384 // 385 int main(int argc, char **argv, char * const *envp) { 386 sys::PrintStackTraceOnErrorSignal(); 387 PrettyStackTraceProgram X(argc, argv); 388 389 LLVMContext &Context = getGlobalContext(); 390 atexit(do_shutdown); // Call llvm_shutdown() on exit. 391 392 // If we have a native target, initialize it to ensure it is linked in and 393 // usable by the JIT. 394 InitializeNativeTarget(); 395 InitializeNativeTargetAsmPrinter(); 396 InitializeNativeTargetAsmParser(); 397 398 cl::ParseCommandLineOptions(argc, argv, 399 "llvm interpreter & dynamic compiler\n"); 400 401 // If the user doesn't want core files, disable them. 402 if (DisableCoreFiles) 403 sys::Process::PreventCoreFiles(); 404 405 // Load the bitcode... 406 SMDiagnostic Err; 407 std::unique_ptr<Module> Owner = parseIRFile(InputFile, Err, Context); 408 Module *Mod = Owner.get(); 409 if (!Mod) { 410 Err.print(argv[0], errs()); 411 return 1; 412 } 413 414 if (UseJITKind == JITKind::OrcLazy) 415 return runOrcLazyJIT(std::move(Owner), argc, argv); 416 417 if (EnableCacheManager) { 418 std::string CacheName("file:"); 419 CacheName.append(InputFile); 420 Mod->setModuleIdentifier(CacheName); 421 } 422 423 // If not jitting lazily, load the whole bitcode file eagerly too. 424 if (NoLazyCompilation) { 425 if (std::error_code EC = Mod->materializeAllPermanently()) { 426 errs() << argv[0] << ": bitcode didn't read correctly.\n"; 427 errs() << "Reason: " << EC.message() << "\n"; 428 exit(1); 429 } 430 } 431 432 std::string ErrorMsg; 433 EngineBuilder builder(std::move(Owner)); 434 builder.setMArch(MArch); 435 builder.setMCPU(MCPU); 436 builder.setMAttrs(MAttrs); 437 builder.setRelocationModel(RelocModel); 438 builder.setCodeModel(CMModel); 439 builder.setErrorStr(&ErrorMsg); 440 builder.setEngineKind(ForceInterpreter 441 ? EngineKind::Interpreter 442 : EngineKind::JIT); 443 builder.setUseOrcMCJITReplacement(UseJITKind == JITKind::OrcMCJITReplacement); 444 445 // If we are supposed to override the target triple, do so now. 446 if (!TargetTriple.empty()) 447 Mod->setTargetTriple(Triple::normalize(TargetTriple)); 448 449 // Enable MCJIT if desired. 450 RTDyldMemoryManager *RTDyldMM = nullptr; 451 if (!ForceInterpreter) { 452 if (RemoteMCJIT) 453 RTDyldMM = new RemoteMemoryManager(); 454 else 455 RTDyldMM = new SectionMemoryManager(); 456 457 // Deliberately construct a temp std::unique_ptr to pass in. Do not null out 458 // RTDyldMM: We still use it below, even though we don't own it. 459 builder.setMCJITMemoryManager( 460 std::unique_ptr<RTDyldMemoryManager>(RTDyldMM)); 461 } else if (RemoteMCJIT) { 462 errs() << "error: Remote process execution does not work with the " 463 "interpreter.\n"; 464 exit(1); 465 } 466 467 builder.setOptLevel(getOptLevel()); 468 469 TargetOptions Options; 470 if (FloatABIForCalls != FloatABI::Default) 471 Options.FloatABIType = FloatABIForCalls; 472 473 builder.setTargetOptions(Options); 474 475 EE = builder.create(); 476 if (!EE) { 477 if (!ErrorMsg.empty()) 478 errs() << argv[0] << ": error creating EE: " << ErrorMsg << "\n"; 479 else 480 errs() << argv[0] << ": unknown error creating EE!\n"; 481 exit(1); 482 } 483 484 if (EnableCacheManager) { 485 CacheManager = new LLIObjectCache(ObjectCacheDir); 486 EE->setObjectCache(CacheManager); 487 } 488 489 // Load any additional modules specified on the command line. 490 for (unsigned i = 0, e = ExtraModules.size(); i != e; ++i) { 491 std::unique_ptr<Module> XMod = parseIRFile(ExtraModules[i], Err, Context); 492 if (!XMod) { 493 Err.print(argv[0], errs()); 494 return 1; 495 } 496 if (EnableCacheManager) { 497 std::string CacheName("file:"); 498 CacheName.append(ExtraModules[i]); 499 XMod->setModuleIdentifier(CacheName); 500 } 501 EE->addModule(std::move(XMod)); 502 } 503 504 for (unsigned i = 0, e = ExtraObjects.size(); i != e; ++i) { 505 ErrorOr<object::OwningBinary<object::ObjectFile>> Obj = 506 object::ObjectFile::createObjectFile(ExtraObjects[i]); 507 if (!Obj) { 508 Err.print(argv[0], errs()); 509 return 1; 510 } 511 object::OwningBinary<object::ObjectFile> &O = Obj.get(); 512 EE->addObjectFile(std::move(O)); 513 } 514 515 for (unsigned i = 0, e = ExtraArchives.size(); i != e; ++i) { 516 ErrorOr<std::unique_ptr<MemoryBuffer>> ArBufOrErr = 517 MemoryBuffer::getFileOrSTDIN(ExtraArchives[i]); 518 if (!ArBufOrErr) { 519 Err.print(argv[0], errs()); 520 return 1; 521 } 522 std::unique_ptr<MemoryBuffer> &ArBuf = ArBufOrErr.get(); 523 524 ErrorOr<std::unique_ptr<object::Archive>> ArOrErr = 525 object::Archive::create(ArBuf->getMemBufferRef()); 526 if (std::error_code EC = ArOrErr.getError()) { 527 errs() << EC.message(); 528 return 1; 529 } 530 std::unique_ptr<object::Archive> &Ar = ArOrErr.get(); 531 532 object::OwningBinary<object::Archive> OB(std::move(Ar), std::move(ArBuf)); 533 534 EE->addArchive(std::move(OB)); 535 } 536 537 // If the target is Cygwin/MingW and we are generating remote code, we 538 // need an extra module to help out with linking. 539 if (RemoteMCJIT && Triple(Mod->getTargetTriple()).isOSCygMing()) { 540 addCygMingExtraModule(EE, Context, Mod->getTargetTriple()); 541 } 542 543 // The following functions have no effect if their respective profiling 544 // support wasn't enabled in the build configuration. 545 EE->RegisterJITEventListener( 546 JITEventListener::createOProfileJITEventListener()); 547 EE->RegisterJITEventListener( 548 JITEventListener::createIntelJITEventListener()); 549 550 if (!NoLazyCompilation && RemoteMCJIT) { 551 errs() << "warning: remote mcjit does not support lazy compilation\n"; 552 NoLazyCompilation = true; 553 } 554 EE->DisableLazyCompilation(NoLazyCompilation); 555 556 // If the user specifically requested an argv[0] to pass into the program, 557 // do it now. 558 if (!FakeArgv0.empty()) { 559 InputFile = static_cast<std::string>(FakeArgv0); 560 } else { 561 // Otherwise, if there is a .bc suffix on the executable strip it off, it 562 // might confuse the program. 563 if (StringRef(InputFile).endswith(".bc")) 564 InputFile.erase(InputFile.length() - 3); 565 } 566 567 // Add the module's name to the start of the vector of arguments to main(). 568 InputArgv.insert(InputArgv.begin(), InputFile); 569 570 // Call the main function from M as if its signature were: 571 // int main (int argc, char **argv, const char **envp) 572 // using the contents of Args to determine argc & argv, and the contents of 573 // EnvVars to determine envp. 574 // 575 Function *EntryFn = Mod->getFunction(EntryFunc); 576 if (!EntryFn) { 577 errs() << '\'' << EntryFunc << "\' function not found in module.\n"; 578 return -1; 579 } 580 581 // Reset errno to zero on entry to main. 582 errno = 0; 583 584 int Result; 585 586 if (!RemoteMCJIT) { 587 // If the program doesn't explicitly call exit, we will need the Exit 588 // function later on to make an explicit call, so get the function now. 589 Constant *Exit = Mod->getOrInsertFunction("exit", Type::getVoidTy(Context), 590 Type::getInt32Ty(Context), 591 nullptr); 592 593 // Run static constructors. 594 if (!ForceInterpreter) { 595 // Give MCJIT a chance to apply relocations and set page permissions. 596 EE->finalizeObject(); 597 } 598 EE->runStaticConstructorsDestructors(false); 599 600 // Trigger compilation separately so code regions that need to be 601 // invalidated will be known. 602 (void)EE->getPointerToFunction(EntryFn); 603 // Clear instruction cache before code will be executed. 604 if (RTDyldMM) 605 static_cast<SectionMemoryManager*>(RTDyldMM)->invalidateInstructionCache(); 606 607 // Run main. 608 Result = EE->runFunctionAsMain(EntryFn, InputArgv, envp); 609 610 // Run static destructors. 611 EE->runStaticConstructorsDestructors(true); 612 613 // If the program didn't call exit explicitly, we should call it now. 614 // This ensures that any atexit handlers get called correctly. 615 if (Function *ExitF = dyn_cast<Function>(Exit)) { 616 std::vector<GenericValue> Args; 617 GenericValue ResultGV; 618 ResultGV.IntVal = APInt(32, Result); 619 Args.push_back(ResultGV); 620 EE->runFunction(ExitF, Args); 621 errs() << "ERROR: exit(" << Result << ") returned!\n"; 622 abort(); 623 } else { 624 errs() << "ERROR: exit defined with wrong prototype!\n"; 625 abort(); 626 } 627 } else { 628 // else == "if (RemoteMCJIT)" 629 630 // Remote target MCJIT doesn't (yet) support static constructors. No reason 631 // it couldn't. This is a limitation of the LLI implemantation, not the 632 // MCJIT itself. FIXME. 633 // 634 RemoteMemoryManager *MM = static_cast<RemoteMemoryManager*>(RTDyldMM); 635 // Everything is prepared now, so lay out our program for the target 636 // address space, assign the section addresses to resolve any relocations, 637 // and send it to the target. 638 639 std::unique_ptr<RemoteTarget> Target; 640 if (!ChildExecPath.empty()) { // Remote execution on a child process 641 #ifndef LLVM_ON_UNIX 642 // FIXME: Remove this pointless fallback mode which causes tests to "pass" 643 // on platforms where they should XFAIL. 644 errs() << "Warning: host does not support external remote targets.\n" 645 << " Defaulting to simulated remote execution\n"; 646 Target.reset(new RemoteTarget); 647 #else 648 if (!sys::fs::can_execute(ChildExecPath)) { 649 errs() << "Unable to find usable child executable: '" << ChildExecPath 650 << "'\n"; 651 return -1; 652 } 653 Target.reset(new RemoteTargetExternal(ChildExecPath)); 654 #endif 655 } else { 656 // No child process name provided, use simulated remote execution. 657 Target.reset(new RemoteTarget); 658 } 659 660 // Give the memory manager a pointer to our remote target interface object. 661 MM->setRemoteTarget(Target.get()); 662 663 // Create the remote target. 664 if (!Target->create()) { 665 errs() << "ERROR: " << Target->getErrorMsg() << "\n"; 666 return EXIT_FAILURE; 667 } 668 669 // Since we're executing in a (at least simulated) remote address space, 670 // we can't use the ExecutionEngine::runFunctionAsMain(). We have to 671 // grab the function address directly here and tell the remote target 672 // to execute the function. 673 // 674 // Our memory manager will map generated code into the remote address 675 // space as it is loaded and copy the bits over during the finalizeMemory 676 // operation. 677 // 678 // FIXME: argv and envp handling. 679 uint64_t Entry = EE->getFunctionAddress(EntryFn->getName().str()); 680 681 DEBUG(dbgs() << "Executing '" << EntryFn->getName() << "' at 0x" 682 << format("%llx", Entry) << "\n"); 683 684 if (!Target->executeCode(Entry, Result)) 685 errs() << "ERROR: " << Target->getErrorMsg() << "\n"; 686 687 // Like static constructors, the remote target MCJIT support doesn't handle 688 // this yet. It could. FIXME. 689 690 // Stop the remote target 691 Target->stop(); 692 } 693 694 return Result; 695 } 696