Home | History | Annotate | Download | only in lli
      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(sys::path::parent_path(CacheName));
    266       sys::fs::create_directories(Twine(dir));
    267     }
    268     std::error_code EC;
    269     raw_fd_ostream outfile(CacheName, EC, sys::fs::F_None);
    270     outfile.write(Obj.getBufferStart(), Obj.getBufferSize());
    271     outfile.close();
    272   }
    273 
    274   std::unique_ptr<MemoryBuffer> getObject(const Module* M) override {
    275     const std::string ModuleID = M->getModuleIdentifier();
    276     std::string CacheName;
    277     if (!getCacheFilename(ModuleID, CacheName))
    278       return nullptr;
    279     // Load the object from the cache filename
    280     ErrorOr<std::unique_ptr<MemoryBuffer>> IRObjectBuffer =
    281         MemoryBuffer::getFile(CacheName.c_str(), -1, false);
    282     // If the file isn't there, that's OK.
    283     if (!IRObjectBuffer)
    284       return nullptr;
    285     // MCJIT will want to write into this buffer, and we don't want that
    286     // because the file has probably just been mmapped.  Instead we make
    287     // a copy.  The filed-based buffer will be released when it goes
    288     // out of scope.
    289     return MemoryBuffer::getMemBufferCopy(IRObjectBuffer.get()->getBuffer());
    290   }
    291 
    292 private:
    293   std::string CacheDir;
    294 
    295   bool getCacheFilename(const std::string &ModID, std::string &CacheName) {
    296     std::string Prefix("file:");
    297     size_t PrefixLength = Prefix.length();
    298     if (ModID.substr(0, PrefixLength) != Prefix)
    299       return false;
    300         std::string CacheSubdir = ModID.substr(PrefixLength);
    301 #if defined(_WIN32)
    302         // Transform "X:\foo" => "/X\foo" for convenience.
    303         if (isalpha(CacheSubdir[0]) && CacheSubdir[1] == ':') {
    304           CacheSubdir[1] = CacheSubdir[0];
    305           CacheSubdir[0] = '/';
    306         }
    307 #endif
    308     CacheName = CacheDir + CacheSubdir;
    309     size_t pos = CacheName.rfind('.');
    310     CacheName.replace(pos, CacheName.length() - pos, ".o");
    311     return true;
    312   }
    313 };
    314 
    315 static ExecutionEngine *EE = nullptr;
    316 static LLIObjectCache *CacheManager = nullptr;
    317 
    318 static void do_shutdown() {
    319   // Cygwin-1.5 invokes DLL's dtors before atexit handler.
    320 #ifndef DO_NOTHING_ATEXIT
    321   delete EE;
    322   if (CacheManager)
    323     delete CacheManager;
    324   llvm_shutdown();
    325 #endif
    326 }
    327 
    328 // On Mingw and Cygwin, an external symbol named '__main' is called from the
    329 // generated 'main' function to allow static intialization.  To avoid linking
    330 // problems with remote targets (because lli's remote target support does not
    331 // currently handle external linking) we add a secondary module which defines
    332 // an empty '__main' function.
    333 static void addCygMingExtraModule(ExecutionEngine *EE,
    334                                   LLVMContext &Context,
    335                                   StringRef TargetTripleStr) {
    336   IRBuilder<> Builder(Context);
    337   Triple TargetTriple(TargetTripleStr);
    338 
    339   // Create a new module.
    340   std::unique_ptr<Module> M = make_unique<Module>("CygMingHelper", Context);
    341   M->setTargetTriple(TargetTripleStr);
    342 
    343   // Create an empty function named "__main".
    344   Function *Result;
    345   if (TargetTriple.isArch64Bit()) {
    346     Result = Function::Create(
    347       TypeBuilder<int64_t(void), false>::get(Context),
    348       GlobalValue::ExternalLinkage, "__main", M.get());
    349   } else {
    350     Result = Function::Create(
    351       TypeBuilder<int32_t(void), false>::get(Context),
    352       GlobalValue::ExternalLinkage, "__main", M.get());
    353   }
    354   BasicBlock *BB = BasicBlock::Create(Context, "__main", Result);
    355   Builder.SetInsertPoint(BB);
    356   Value *ReturnVal;
    357   if (TargetTriple.isArch64Bit())
    358     ReturnVal = ConstantInt::get(Context, APInt(64, 0));
    359   else
    360     ReturnVal = ConstantInt::get(Context, APInt(32, 0));
    361   Builder.CreateRet(ReturnVal);
    362 
    363   // Add this new module to the ExecutionEngine.
    364   EE->addModule(std::move(M));
    365 }
    366 
    367 CodeGenOpt::Level getOptLevel() {
    368   switch (OptLevel) {
    369   default:
    370     errs() << "lli: Invalid optimization level.\n";
    371     exit(1);
    372   case '0': return CodeGenOpt::None;
    373   case '1': return CodeGenOpt::Less;
    374   case ' ':
    375   case '2': return CodeGenOpt::Default;
    376   case '3': return CodeGenOpt::Aggressive;
    377   }
    378   llvm_unreachable("Unrecognized opt level.");
    379 }
    380 
    381 //===----------------------------------------------------------------------===//
    382 // main Driver function
    383 //
    384 int main(int argc, char **argv, char * const *envp) {
    385   sys::PrintStackTraceOnErrorSignal();
    386   PrettyStackTraceProgram X(argc, argv);
    387 
    388   LLVMContext &Context = getGlobalContext();
    389   atexit(do_shutdown);  // Call llvm_shutdown() on exit.
    390 
    391   // If we have a native target, initialize it to ensure it is linked in and
    392   // usable by the JIT.
    393   InitializeNativeTarget();
    394   InitializeNativeTargetAsmPrinter();
    395   InitializeNativeTargetAsmParser();
    396 
    397   cl::ParseCommandLineOptions(argc, argv,
    398                               "llvm interpreter & dynamic compiler\n");
    399 
    400   // If the user doesn't want core files, disable them.
    401   if (DisableCoreFiles)
    402     sys::Process::PreventCoreFiles();
    403 
    404   // Load the bitcode...
    405   SMDiagnostic Err;
    406   std::unique_ptr<Module> Owner = parseIRFile(InputFile, Err, Context);
    407   Module *Mod = Owner.get();
    408   if (!Mod) {
    409     Err.print(argv[0], errs());
    410     return 1;
    411   }
    412 
    413   if (UseJITKind == JITKind::OrcLazy)
    414     return runOrcLazyJIT(std::move(Owner), argc, argv);
    415 
    416   if (EnableCacheManager) {
    417     std::string CacheName("file:");
    418     CacheName.append(InputFile);
    419     Mod->setModuleIdentifier(CacheName);
    420   }
    421 
    422   // If not jitting lazily, load the whole bitcode file eagerly too.
    423   if (NoLazyCompilation) {
    424     if (std::error_code EC = Mod->materializeAll()) {
    425       errs() << argv[0] << ": bitcode didn't read correctly.\n";
    426       errs() << "Reason: " << EC.message() << "\n";
    427       exit(1);
    428     }
    429   }
    430 
    431   std::string ErrorMsg;
    432   EngineBuilder builder(std::move(Owner));
    433   builder.setMArch(MArch);
    434   builder.setMCPU(MCPU);
    435   builder.setMAttrs(MAttrs);
    436   builder.setRelocationModel(RelocModel);
    437   builder.setCodeModel(CMModel);
    438   builder.setErrorStr(&ErrorMsg);
    439   builder.setEngineKind(ForceInterpreter
    440                         ? EngineKind::Interpreter
    441                         : EngineKind::JIT);
    442   builder.setUseOrcMCJITReplacement(UseJITKind == JITKind::OrcMCJITReplacement);
    443 
    444   // If we are supposed to override the target triple, do so now.
    445   if (!TargetTriple.empty())
    446     Mod->setTargetTriple(Triple::normalize(TargetTriple));
    447 
    448   // Enable MCJIT if desired.
    449   RTDyldMemoryManager *RTDyldMM = nullptr;
    450   if (!ForceInterpreter) {
    451     if (RemoteMCJIT)
    452       RTDyldMM = new RemoteMemoryManager();
    453     else
    454       RTDyldMM = new SectionMemoryManager();
    455 
    456     // Deliberately construct a temp std::unique_ptr to pass in. Do not null out
    457     // RTDyldMM: We still use it below, even though we don't own it.
    458     builder.setMCJITMemoryManager(
    459       std::unique_ptr<RTDyldMemoryManager>(RTDyldMM));
    460   } else if (RemoteMCJIT) {
    461     errs() << "error: Remote process execution does not work with the "
    462               "interpreter.\n";
    463     exit(1);
    464   }
    465 
    466   builder.setOptLevel(getOptLevel());
    467 
    468   TargetOptions Options;
    469   if (FloatABIForCalls != FloatABI::Default)
    470     Options.FloatABIType = FloatABIForCalls;
    471 
    472   builder.setTargetOptions(Options);
    473 
    474   EE = builder.create();
    475   if (!EE) {
    476     if (!ErrorMsg.empty())
    477       errs() << argv[0] << ": error creating EE: " << ErrorMsg << "\n";
    478     else
    479       errs() << argv[0] << ": unknown error creating EE!\n";
    480     exit(1);
    481   }
    482 
    483   if (EnableCacheManager) {
    484     CacheManager = new LLIObjectCache(ObjectCacheDir);
    485     EE->setObjectCache(CacheManager);
    486   }
    487 
    488   // Load any additional modules specified on the command line.
    489   for (unsigned i = 0, e = ExtraModules.size(); i != e; ++i) {
    490     std::unique_ptr<Module> XMod = parseIRFile(ExtraModules[i], Err, Context);
    491     if (!XMod) {
    492       Err.print(argv[0], errs());
    493       return 1;
    494     }
    495     if (EnableCacheManager) {
    496       std::string CacheName("file:");
    497       CacheName.append(ExtraModules[i]);
    498       XMod->setModuleIdentifier(CacheName);
    499     }
    500     EE->addModule(std::move(XMod));
    501   }
    502 
    503   for (unsigned i = 0, e = ExtraObjects.size(); i != e; ++i) {
    504     ErrorOr<object::OwningBinary<object::ObjectFile>> Obj =
    505         object::ObjectFile::createObjectFile(ExtraObjects[i]);
    506     if (!Obj) {
    507       Err.print(argv[0], errs());
    508       return 1;
    509     }
    510     object::OwningBinary<object::ObjectFile> &O = Obj.get();
    511     EE->addObjectFile(std::move(O));
    512   }
    513 
    514   for (unsigned i = 0, e = ExtraArchives.size(); i != e; ++i) {
    515     ErrorOr<std::unique_ptr<MemoryBuffer>> ArBufOrErr =
    516         MemoryBuffer::getFileOrSTDIN(ExtraArchives[i]);
    517     if (!ArBufOrErr) {
    518       Err.print(argv[0], errs());
    519       return 1;
    520     }
    521     std::unique_ptr<MemoryBuffer> &ArBuf = ArBufOrErr.get();
    522 
    523     ErrorOr<std::unique_ptr<object::Archive>> ArOrErr =
    524         object::Archive::create(ArBuf->getMemBufferRef());
    525     if (std::error_code EC = ArOrErr.getError()) {
    526       errs() << EC.message();
    527       return 1;
    528     }
    529     std::unique_ptr<object::Archive> &Ar = ArOrErr.get();
    530 
    531     object::OwningBinary<object::Archive> OB(std::move(Ar), std::move(ArBuf));
    532 
    533     EE->addArchive(std::move(OB));
    534   }
    535 
    536   // If the target is Cygwin/MingW and we are generating remote code, we
    537   // need an extra module to help out with linking.
    538   if (RemoteMCJIT && Triple(Mod->getTargetTriple()).isOSCygMing()) {
    539     addCygMingExtraModule(EE, Context, Mod->getTargetTriple());
    540   }
    541 
    542   // The following functions have no effect if their respective profiling
    543   // support wasn't enabled in the build configuration.
    544   EE->RegisterJITEventListener(
    545                 JITEventListener::createOProfileJITEventListener());
    546   EE->RegisterJITEventListener(
    547                 JITEventListener::createIntelJITEventListener());
    548 
    549   if (!NoLazyCompilation && RemoteMCJIT) {
    550     errs() << "warning: remote mcjit does not support lazy compilation\n";
    551     NoLazyCompilation = true;
    552   }
    553   EE->DisableLazyCompilation(NoLazyCompilation);
    554 
    555   // If the user specifically requested an argv[0] to pass into the program,
    556   // do it now.
    557   if (!FakeArgv0.empty()) {
    558     InputFile = static_cast<std::string>(FakeArgv0);
    559   } else {
    560     // Otherwise, if there is a .bc suffix on the executable strip it off, it
    561     // might confuse the program.
    562     if (StringRef(InputFile).endswith(".bc"))
    563       InputFile.erase(InputFile.length() - 3);
    564   }
    565 
    566   // Add the module's name to the start of the vector of arguments to main().
    567   InputArgv.insert(InputArgv.begin(), InputFile);
    568 
    569   // Call the main function from M as if its signature were:
    570   //   int main (int argc, char **argv, const char **envp)
    571   // using the contents of Args to determine argc & argv, and the contents of
    572   // EnvVars to determine envp.
    573   //
    574   Function *EntryFn = Mod->getFunction(EntryFunc);
    575   if (!EntryFn) {
    576     errs() << '\'' << EntryFunc << "\' function not found in module.\n";
    577     return -1;
    578   }
    579 
    580   // Reset errno to zero on entry to main.
    581   errno = 0;
    582 
    583   int Result;
    584 
    585   if (!RemoteMCJIT) {
    586     // If the program doesn't explicitly call exit, we will need the Exit
    587     // function later on to make an explicit call, so get the function now.
    588     Constant *Exit = Mod->getOrInsertFunction("exit", Type::getVoidTy(Context),
    589                                                       Type::getInt32Ty(Context),
    590                                                       nullptr);
    591 
    592     // Run static constructors.
    593     if (!ForceInterpreter) {
    594       // Give MCJIT a chance to apply relocations and set page permissions.
    595       EE->finalizeObject();
    596     }
    597     EE->runStaticConstructorsDestructors(false);
    598 
    599     // Trigger compilation separately so code regions that need to be
    600     // invalidated will be known.
    601     (void)EE->getPointerToFunction(EntryFn);
    602     // Clear instruction cache before code will be executed.
    603     if (RTDyldMM)
    604       static_cast<SectionMemoryManager*>(RTDyldMM)->invalidateInstructionCache();
    605 
    606     // Run main.
    607     Result = EE->runFunctionAsMain(EntryFn, InputArgv, envp);
    608 
    609     // Run static destructors.
    610     EE->runStaticConstructorsDestructors(true);
    611 
    612     // If the program didn't call exit explicitly, we should call it now.
    613     // This ensures that any atexit handlers get called correctly.
    614     if (Function *ExitF = dyn_cast<Function>(Exit)) {
    615       std::vector<GenericValue> Args;
    616       GenericValue ResultGV;
    617       ResultGV.IntVal = APInt(32, Result);
    618       Args.push_back(ResultGV);
    619       EE->runFunction(ExitF, Args);
    620       errs() << "ERROR: exit(" << Result << ") returned!\n";
    621       abort();
    622     } else {
    623       errs() << "ERROR: exit defined with wrong prototype!\n";
    624       abort();
    625     }
    626   } else {
    627     // else == "if (RemoteMCJIT)"
    628 
    629     // Remote target MCJIT doesn't (yet) support static constructors. No reason
    630     // it couldn't. This is a limitation of the LLI implemantation, not the
    631     // MCJIT itself. FIXME.
    632     //
    633     RemoteMemoryManager *MM = static_cast<RemoteMemoryManager*>(RTDyldMM);
    634     // Everything is prepared now, so lay out our program for the target
    635     // address space, assign the section addresses to resolve any relocations,
    636     // and send it to the target.
    637 
    638     std::unique_ptr<RemoteTarget> Target;
    639     if (!ChildExecPath.empty()) { // Remote execution on a child process
    640 #ifndef LLVM_ON_UNIX
    641       // FIXME: Remove this pointless fallback mode which causes tests to "pass"
    642       // on platforms where they should XFAIL.
    643       errs() << "Warning: host does not support external remote targets.\n"
    644              << "  Defaulting to simulated remote execution\n";
    645       Target.reset(new RemoteTarget);
    646 #else
    647       if (!sys::fs::can_execute(ChildExecPath)) {
    648         errs() << "Unable to find usable child executable: '" << ChildExecPath
    649                << "'\n";
    650         return -1;
    651       }
    652       Target.reset(new RemoteTargetExternal(ChildExecPath));
    653 #endif
    654     } else {
    655       // No child process name provided, use simulated remote execution.
    656       Target.reset(new RemoteTarget);
    657     }
    658 
    659     // Give the memory manager a pointer to our remote target interface object.
    660     MM->setRemoteTarget(Target.get());
    661 
    662     // Create the remote target.
    663     if (!Target->create()) {
    664       errs() << "ERROR: " << Target->getErrorMsg() << "\n";
    665       return EXIT_FAILURE;
    666     }
    667 
    668     // Since we're executing in a (at least simulated) remote address space,
    669     // we can't use the ExecutionEngine::runFunctionAsMain(). We have to
    670     // grab the function address directly here and tell the remote target
    671     // to execute the function.
    672     //
    673     // Our memory manager will map generated code into the remote address
    674     // space as it is loaded and copy the bits over during the finalizeMemory
    675     // operation.
    676     //
    677     // FIXME: argv and envp handling.
    678     uint64_t Entry = EE->getFunctionAddress(EntryFn->getName().str());
    679 
    680     DEBUG(dbgs() << "Executing '" << EntryFn->getName() << "' at 0x"
    681                  << format("%llx", Entry) << "\n");
    682 
    683     if (!Target->executeCode(Entry, Result))
    684       errs() << "ERROR: " << Target->getErrorMsg() << "\n";
    685 
    686     // Like static constructors, the remote target MCJIT support doesn't handle
    687     // this yet. It could. FIXME.
    688 
    689     // Stop the remote target
    690     Target->stop();
    691   }
    692 
    693   return Result;
    694 }
    695