xref: /netbsd-src/external/apache2/llvm/dist/llvm/tools/lli/lli.cpp (revision 82d56013d7b633d116a93943de88e08335357a7c) 
1 //===- lli.cpp - LLVM Interpreter / Dynamic compiler ----------------------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 //
9 // This utility provides a simple wrapper around the LLVM Execution Engines,
10 // which allow the direct execution of LLVM programs through a Just-In-Time
11 // compiler, or through an interpreter if no JIT is available for this platform.
12 //
13 //===----------------------------------------------------------------------===//
14 
15 #include "ExecutionUtils.h"
16 #include "RemoteJITUtils.h"
17 #include "llvm/ADT/StringExtras.h"
18 #include "llvm/ADT/Triple.h"
19 #include "llvm/Bitcode/BitcodeReader.h"
20 #include "llvm/CodeGen/CommandFlags.h"
21 #include "llvm/CodeGen/LinkAllCodegenComponents.h"
22 #include "llvm/Config/llvm-config.h"
23 #include "llvm/ExecutionEngine/GenericValue.h"
24 #include "llvm/ExecutionEngine/Interpreter.h"
25 #include "llvm/ExecutionEngine/JITSymbol.h"
26 #include "llvm/ExecutionEngine/JITEventListener.h"
27 #include "llvm/ExecutionEngine/MCJIT.h"
28 #include "llvm/ExecutionEngine/ObjectCache.h"
29 #include "llvm/ExecutionEngine/Orc/DebugObjectManagerPlugin.h"
30 #include "llvm/ExecutionEngine/Orc/DebugUtils.h"
31 #include "llvm/ExecutionEngine/Orc/ExecutionUtils.h"
32 #include "llvm/ExecutionEngine/Orc/JITTargetMachineBuilder.h"
33 #include "llvm/ExecutionEngine/Orc/LLJIT.h"
34 #include "llvm/ExecutionEngine/Orc/MachOPlatform.h"
35 #include "llvm/ExecutionEngine/Orc/OrcRemoteTargetClient.h"
36 #include "llvm/ExecutionEngine/Orc/RTDyldObjectLinkingLayer.h"
37 #include "llvm/ExecutionEngine/Orc/SymbolStringPool.h"
38 #include "llvm/ExecutionEngine/Orc/TPCDebugObjectRegistrar.h"
39 #include "llvm/ExecutionEngine/Orc/TPCEHFrameRegistrar.h"
40 #include "llvm/ExecutionEngine/Orc/TargetProcess/JITLoaderGDB.h"
41 #include "llvm/ExecutionEngine/Orc/TargetProcess/RegisterEHFrames.h"
42 #include "llvm/ExecutionEngine/Orc/TargetProcess/TargetExecutionUtils.h"
43 #include "llvm/ExecutionEngine/SectionMemoryManager.h"
44 #include "llvm/IR/IRBuilder.h"
45 #include "llvm/IR/LLVMContext.h"
46 #include "llvm/IR/Module.h"
47 #include "llvm/IR/Type.h"
48 #include "llvm/IR/Verifier.h"
49 #include "llvm/IRReader/IRReader.h"
50 #include "llvm/Object/Archive.h"
51 #include "llvm/Object/ObjectFile.h"
52 #include "llvm/Support/CommandLine.h"
53 #include "llvm/Support/Debug.h"
54 #include "llvm/Support/DynamicLibrary.h"
55 #include "llvm/Support/Format.h"
56 #include "llvm/Support/InitLLVM.h"
57 #include "llvm/Support/ManagedStatic.h"
58 #include "llvm/Support/MathExtras.h"
59 #include "llvm/Support/Memory.h"
60 #include "llvm/Support/MemoryBuffer.h"
61 #include "llvm/Support/Path.h"
62 #include "llvm/Support/PluginLoader.h"
63 #include "llvm/Support/Process.h"
64 #include "llvm/Support/Program.h"
65 #include "llvm/Support/SourceMgr.h"
66 #include "llvm/Support/TargetSelect.h"
67 #include "llvm/Support/WithColor.h"
68 #include "llvm/Support/raw_ostream.h"
69 #include "llvm/Transforms/Instrumentation.h"
70 #include <cerrno>
71 
72 #ifdef __CYGWIN__
73 #include <cygwin/version.h>
74 #if defined(CYGWIN_VERSION_DLL_MAJOR) && CYGWIN_VERSION_DLL_MAJOR<1007
75 #define DO_NOTHING_ATEXIT 1
76 #endif
77 #endif
78 
79 using namespace llvm;
80 
81 static codegen::RegisterCodeGenFlags CGF;
82 
83 #define DEBUG_TYPE "lli"
84 
85 namespace {
86 
87   enum class JITKind { MCJIT, Orc, OrcLazy };
88   enum class JITLinkerKind { Default, RuntimeDyld, JITLink };
89 
90   cl::opt<std::string>
91   InputFile(cl::desc("<input bitcode>"), cl::Positional, cl::init("-"));
92 
93   cl::list<std::string>
94   InputArgv(cl::ConsumeAfter, cl::desc("<program arguments>..."));
95 
96   cl::opt<bool> ForceInterpreter("force-interpreter",
97                                  cl::desc("Force interpretation: disable JIT"),
98                                  cl::init(false));
99 
100   cl::opt<JITKind> UseJITKind(
101       "jit-kind", cl::desc("Choose underlying JIT kind."),
102       cl::init(JITKind::Orc),
103       cl::values(clEnumValN(JITKind::MCJIT, "mcjit", "MCJIT"),
104                  clEnumValN(JITKind::Orc, "orc", "Orc JIT"),
105                  clEnumValN(JITKind::OrcLazy, "orc-lazy",
106                             "Orc-based lazy JIT.")));
107 
108   cl::opt<JITLinkerKind>
109       JITLinker("jit-linker", cl::desc("Choose the dynamic linker/loader."),
110                 cl::init(JITLinkerKind::Default),
111                 cl::values(clEnumValN(JITLinkerKind::Default, "default",
112                                       "Default for platform and JIT-kind"),
113                            clEnumValN(JITLinkerKind::RuntimeDyld, "rtdyld",
114                                       "RuntimeDyld"),
115                            clEnumValN(JITLinkerKind::JITLink, "jitlink",
116                                       "Orc-specific linker")));
117 
118   cl::opt<unsigned>
119   LazyJITCompileThreads("compile-threads",
120                         cl::desc("Choose the number of compile threads "
121                                  "(jit-kind=orc-lazy only)"),
122                         cl::init(0));
123 
124   cl::list<std::string>
125   ThreadEntryPoints("thread-entry",
126                     cl::desc("calls the given entry-point on a new thread "
127                              "(jit-kind=orc-lazy only)"));
128 
129   cl::opt<bool> PerModuleLazy(
130       "per-module-lazy",
131       cl::desc("Performs lazy compilation on whole module boundaries "
132                "rather than individual functions"),
133       cl::init(false));
134 
135   cl::list<std::string>
136       JITDylibs("jd",
137                 cl::desc("Specifies the JITDylib to be used for any subsequent "
138                          "-extra-module arguments."));
139 
140   cl::list<std::string>
141     Dylibs("dlopen", cl::desc("Dynamic libraries to load before linking"),
142            cl::ZeroOrMore);
143 
144   // The MCJIT supports building for a target address space separate from
145   // the JIT compilation process. Use a forked process and a copying
146   // memory manager with IPC to execute using this functionality.
147   cl::opt<bool> RemoteMCJIT("remote-mcjit",
148     cl::desc("Execute MCJIT'ed code in a separate process."),
149     cl::init(false));
150 
151   // Manually specify the child process for remote execution. This overrides
152   // the simulated remote execution that allocates address space for child
153   // execution. The child process will be executed and will communicate with
154   // lli via stdin/stdout pipes.
155   cl::opt<std::string>
156   ChildExecPath("mcjit-remote-process",
157                 cl::desc("Specify the filename of the process to launch "
158                          "for remote MCJIT execution.  If none is specified,"
159                          "\n\tremote execution will be simulated in-process."),
160                 cl::value_desc("filename"), cl::init(""));
161 
162   // Determine optimization level.
163   cl::opt<char>
164   OptLevel("O",
165            cl::desc("Optimization level. [-O0, -O1, -O2, or -O3] "
166                     "(default = '-O2')"),
167            cl::Prefix,
168            cl::ZeroOrMore,
169            cl::init(' '));
170 
171   cl::opt<std::string>
172   TargetTriple("mtriple", cl::desc("Override target triple for module"));
173 
174   cl::opt<std::string>
175   EntryFunc("entry-function",
176             cl::desc("Specify the entry function (default = 'main') "
177                      "of the executable"),
178             cl::value_desc("function"),
179             cl::init("main"));
180 
181   cl::list<std::string>
182   ExtraModules("extra-module",
183          cl::desc("Extra modules to be loaded"),
184          cl::value_desc("input bitcode"));
185 
186   cl::list<std::string>
187   ExtraObjects("extra-object",
188          cl::desc("Extra object files to be loaded"),
189          cl::value_desc("input object"));
190 
191   cl::list<std::string>
192   ExtraArchives("extra-archive",
193          cl::desc("Extra archive files to be loaded"),
194          cl::value_desc("input archive"));
195 
196   cl::opt<bool>
197   EnableCacheManager("enable-cache-manager",
198         cl::desc("Use cache manager to save/load modules"),
199         cl::init(false));
200 
201   cl::opt<std::string>
202   ObjectCacheDir("object-cache-dir",
203                   cl::desc("Directory to store cached object files "
204                            "(must be user writable)"),
205                   cl::init(""));
206 
207   cl::opt<std::string>
208   FakeArgv0("fake-argv0",
209             cl::desc("Override the 'argv[0]' value passed into the executing"
210                      " program"), cl::value_desc("executable"));
211 
212   cl::opt<bool>
213   DisableCoreFiles("disable-core-files", cl::Hidden,
214                    cl::desc("Disable emission of core files if possible"));
215 
216   cl::opt<bool>
217   NoLazyCompilation("disable-lazy-compilation",
218                   cl::desc("Disable JIT lazy compilation"),
219                   cl::init(false));
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<bool> NoProcessSymbols(
227       "no-process-syms",
228       cl::desc("Do not resolve lli process symbols in JIT'd code"),
229       cl::init(false));
230 
231   enum class LLJITPlatform { Inactive, DetectHost, GenericIR, MachO };
232 
233   cl::opt<LLJITPlatform>
234       Platform("lljit-platform", cl::desc("Platform to use with LLJIT"),
235                cl::init(LLJITPlatform::DetectHost),
236                cl::values(clEnumValN(LLJITPlatform::DetectHost, "DetectHost",
237                                      "Select based on JIT target triple"),
238                           clEnumValN(LLJITPlatform::GenericIR, "GenericIR",
239                                      "Use LLJITGenericIRPlatform"),
240                           clEnumValN(LLJITPlatform::MachO, "MachO",
241                                      "Use LLJITMachOPlatform"),
242                           clEnumValN(LLJITPlatform::Inactive, "Inactive",
243                                      "Disable platform support explicitly")),
244                cl::Hidden);
245 
246   enum class DumpKind {
247     NoDump,
248     DumpFuncsToStdOut,
249     DumpModsToStdOut,
250     DumpModsToDisk
251   };
252 
253   cl::opt<DumpKind> OrcDumpKind(
254       "orc-lazy-debug", cl::desc("Debug dumping for the orc-lazy JIT."),
255       cl::init(DumpKind::NoDump),
256       cl::values(clEnumValN(DumpKind::NoDump, "no-dump",
257                             "Don't dump anything."),
258                  clEnumValN(DumpKind::DumpFuncsToStdOut, "funcs-to-stdout",
259                             "Dump function names to stdout."),
260                  clEnumValN(DumpKind::DumpModsToStdOut, "mods-to-stdout",
261                             "Dump modules to stdout."),
262                  clEnumValN(DumpKind::DumpModsToDisk, "mods-to-disk",
263                             "Dump modules to the current "
264                             "working directory. (WARNING: "
265                             "will overwrite existing files).")),
266       cl::Hidden);
267 
268   cl::list<BuiltinFunctionKind> GenerateBuiltinFunctions(
269       "generate",
270       cl::desc("Provide built-in functions for access by JITed code "
271                "(jit-kind=orc-lazy only)"),
272       cl::values(clEnumValN(BuiltinFunctionKind::DumpDebugDescriptor,
273                             "__dump_jit_debug_descriptor",
274                             "Dump __jit_debug_descriptor contents to stdout"),
275                  clEnumValN(BuiltinFunctionKind::DumpDebugObjects,
276                             "__dump_jit_debug_objects",
277                             "Dump __jit_debug_descriptor in-memory debug "
278                             "objects as tool output")),
279       cl::Hidden);
280 
281   ExitOnError ExitOnErr;
282 }
283 
linkComponents()284 LLVM_ATTRIBUTE_USED void linkComponents() {
285   errs() << (void *)&llvm_orc_registerEHFrameSectionWrapper
286          << (void *)&llvm_orc_deregisterEHFrameSectionWrapper
287          << (void *)&llvm_orc_registerJITLoaderGDBWrapper;
288 }
289 
290 //===----------------------------------------------------------------------===//
291 // Object cache
292 //
293 // This object cache implementation writes cached objects to disk to the
294 // directory specified by CacheDir, using a filename provided in the module
295 // descriptor. The cache tries to load a saved object using that path if the
296 // file exists. CacheDir defaults to "", in which case objects are cached
297 // alongside their originating bitcodes.
298 //
299 class LLIObjectCache : public ObjectCache {
300 public:
LLIObjectCache(const std::string & CacheDir)301   LLIObjectCache(const std::string& CacheDir) : CacheDir(CacheDir) {
302     // Add trailing '/' to cache dir if necessary.
303     if (!this->CacheDir.empty() &&
304         this->CacheDir[this->CacheDir.size() - 1] != '/')
305       this->CacheDir += '/';
306   }
~LLIObjectCache()307   ~LLIObjectCache() override {}
308 
notifyObjectCompiled(const Module * M,MemoryBufferRef Obj)309   void notifyObjectCompiled(const Module *M, MemoryBufferRef Obj) override {
310     const std::string &ModuleID = M->getModuleIdentifier();
311     std::string CacheName;
312     if (!getCacheFilename(ModuleID, CacheName))
313       return;
314     if (!CacheDir.empty()) { // Create user-defined cache dir.
315       SmallString<128> dir(sys::path::parent_path(CacheName));
316       sys::fs::create_directories(Twine(dir));
317     }
318 
319     std::error_code EC;
320     raw_fd_ostream outfile(CacheName, EC, sys::fs::OF_None);
321     outfile.write(Obj.getBufferStart(), Obj.getBufferSize());
322     outfile.close();
323   }
324 
getObject(const Module * M)325   std::unique_ptr<MemoryBuffer> getObject(const Module* M) override {
326     const std::string &ModuleID = M->getModuleIdentifier();
327     std::string CacheName;
328     if (!getCacheFilename(ModuleID, CacheName))
329       return nullptr;
330     // Load the object from the cache filename
331     ErrorOr<std::unique_ptr<MemoryBuffer>> IRObjectBuffer =
332         MemoryBuffer::getFile(CacheName, /*IsText=*/false,
333                               /*RequiresNullTerminator=*/false);
334     // If the file isn't there, that's OK.
335     if (!IRObjectBuffer)
336       return nullptr;
337     // MCJIT will want to write into this buffer, and we don't want that
338     // because the file has probably just been mmapped.  Instead we make
339     // a copy.  The filed-based buffer will be released when it goes
340     // out of scope.
341     return MemoryBuffer::getMemBufferCopy(IRObjectBuffer.get()->getBuffer());
342   }
343 
344 private:
345   std::string CacheDir;
346 
getCacheFilename(const std::string & ModID,std::string & CacheName)347   bool getCacheFilename(const std::string &ModID, std::string &CacheName) {
348     std::string Prefix("file:");
349     size_t PrefixLength = Prefix.length();
350     if (ModID.substr(0, PrefixLength) != Prefix)
351       return false;
352 
353     std::string CacheSubdir = ModID.substr(PrefixLength);
354 #if defined(_WIN32)
355     // Transform "X:\foo" => "/X\foo" for convenience.
356     if (isalpha(CacheSubdir[0]) && CacheSubdir[1] == ':') {
357       CacheSubdir[1] = CacheSubdir[0];
358       CacheSubdir[0] = '/';
359     }
360 #endif
361 
362     CacheName = CacheDir + CacheSubdir;
363     size_t pos = CacheName.rfind('.');
364     CacheName.replace(pos, CacheName.length() - pos, ".o");
365     return true;
366   }
367 };
368 
369 // On Mingw and Cygwin, an external symbol named '__main' is called from the
370 // generated 'main' function to allow static initialization.  To avoid linking
371 // problems with remote targets (because lli's remote target support does not
372 // currently handle external linking) we add a secondary module which defines
373 // an empty '__main' function.
addCygMingExtraModule(ExecutionEngine & EE,LLVMContext & Context,StringRef TargetTripleStr)374 static void addCygMingExtraModule(ExecutionEngine &EE, LLVMContext &Context,
375                                   StringRef TargetTripleStr) {
376   IRBuilder<> Builder(Context);
377   Triple TargetTriple(TargetTripleStr);
378 
379   // Create a new module.
380   std::unique_ptr<Module> M = std::make_unique<Module>("CygMingHelper", Context);
381   M->setTargetTriple(TargetTripleStr);
382 
383   // Create an empty function named "__main".
384   Type *ReturnTy;
385   if (TargetTriple.isArch64Bit())
386     ReturnTy = Type::getInt64Ty(Context);
387   else
388     ReturnTy = Type::getInt32Ty(Context);
389   Function *Result =
390       Function::Create(FunctionType::get(ReturnTy, {}, false),
391                        GlobalValue::ExternalLinkage, "__main", M.get());
392 
393   BasicBlock *BB = BasicBlock::Create(Context, "__main", Result);
394   Builder.SetInsertPoint(BB);
395   Value *ReturnVal = ConstantInt::get(ReturnTy, 0);
396   Builder.CreateRet(ReturnVal);
397 
398   // Add this new module to the ExecutionEngine.
399   EE.addModule(std::move(M));
400 }
401 
getOptLevel()402 CodeGenOpt::Level getOptLevel() {
403   switch (OptLevel) {
404   default:
405     WithColor::error(errs(), "lli") << "invalid optimization level.\n";
406     exit(1);
407   case '0': return CodeGenOpt::None;
408   case '1': return CodeGenOpt::Less;
409   case ' ':
410   case '2': return CodeGenOpt::Default;
411   case '3': return CodeGenOpt::Aggressive;
412   }
413   llvm_unreachable("Unrecognized opt level.");
414 }
415 
416 LLVM_ATTRIBUTE_NORETURN
reportError(SMDiagnostic Err,const char * ProgName)417 static void reportError(SMDiagnostic Err, const char *ProgName) {
418   Err.print(ProgName, errs());
419   exit(1);
420 }
421 
422 Error loadDylibs();
423 int runOrcJIT(const char *ProgName);
424 void disallowOrcOptions();
425 
426 //===----------------------------------------------------------------------===//
427 // main Driver function
428 //
main(int argc,char ** argv,char * const * envp)429 int main(int argc, char **argv, char * const *envp) {
430   InitLLVM X(argc, argv);
431 
432   if (argc > 1)
433     ExitOnErr.setBanner(std::string(argv[0]) + ": ");
434 
435   // If we have a native target, initialize it to ensure it is linked in and
436   // usable by the JIT.
437   InitializeNativeTarget();
438   InitializeNativeTargetAsmPrinter();
439   InitializeNativeTargetAsmParser();
440 
441   cl::ParseCommandLineOptions(argc, argv,
442                               "llvm interpreter & dynamic compiler\n");
443 
444   // If the user doesn't want core files, disable them.
445   if (DisableCoreFiles)
446     sys::Process::PreventCoreFiles();
447 
448   ExitOnErr(loadDylibs());
449 
450   if (UseJITKind == JITKind::MCJIT)
451     disallowOrcOptions();
452   else
453     return runOrcJIT(argv[0]);
454 
455   // Old lli implementation based on ExecutionEngine and MCJIT.
456   LLVMContext Context;
457 
458   // Load the bitcode...
459   SMDiagnostic Err;
460   std::unique_ptr<Module> Owner = parseIRFile(InputFile, Err, Context);
461   Module *Mod = Owner.get();
462   if (!Mod)
463     reportError(Err, argv[0]);
464 
465   if (EnableCacheManager) {
466     std::string CacheName("file:");
467     CacheName.append(InputFile);
468     Mod->setModuleIdentifier(CacheName);
469   }
470 
471   // If not jitting lazily, load the whole bitcode file eagerly too.
472   if (NoLazyCompilation) {
473     // Use *argv instead of argv[0] to work around a wrong GCC warning.
474     ExitOnError ExitOnErr(std::string(*argv) +
475                           ": bitcode didn't read correctly: ");
476     ExitOnErr(Mod->materializeAll());
477   }
478 
479   std::string ErrorMsg;
480   EngineBuilder builder(std::move(Owner));
481   builder.setMArch(codegen::getMArch());
482   builder.setMCPU(codegen::getCPUStr());
483   builder.setMAttrs(codegen::getFeatureList());
484   if (auto RM = codegen::getExplicitRelocModel())
485     builder.setRelocationModel(RM.getValue());
486   if (auto CM = codegen::getExplicitCodeModel())
487     builder.setCodeModel(CM.getValue());
488   builder.setErrorStr(&ErrorMsg);
489   builder.setEngineKind(ForceInterpreter
490                         ? EngineKind::Interpreter
491                         : EngineKind::JIT);
492 
493   // If we are supposed to override the target triple, do so now.
494   if (!TargetTriple.empty())
495     Mod->setTargetTriple(Triple::normalize(TargetTriple));
496 
497   // Enable MCJIT if desired.
498   RTDyldMemoryManager *RTDyldMM = nullptr;
499   if (!ForceInterpreter) {
500     if (RemoteMCJIT)
501       RTDyldMM = new ForwardingMemoryManager();
502     else
503       RTDyldMM = new SectionMemoryManager();
504 
505     // Deliberately construct a temp std::unique_ptr to pass in. Do not null out
506     // RTDyldMM: We still use it below, even though we don't own it.
507     builder.setMCJITMemoryManager(
508       std::unique_ptr<RTDyldMemoryManager>(RTDyldMM));
509   } else if (RemoteMCJIT) {
510     WithColor::error(errs(), argv[0])
511         << "remote process execution does not work with the interpreter.\n";
512     exit(1);
513   }
514 
515   builder.setOptLevel(getOptLevel());
516 
517   TargetOptions Options =
518       codegen::InitTargetOptionsFromCodeGenFlags(Triple(TargetTriple));
519   if (codegen::getFloatABIForCalls() != FloatABI::Default)
520     Options.FloatABIType = codegen::getFloatABIForCalls();
521 
522   builder.setTargetOptions(Options);
523 
524   std::unique_ptr<ExecutionEngine> EE(builder.create());
525   if (!EE) {
526     if (!ErrorMsg.empty())
527       WithColor::error(errs(), argv[0])
528           << "error creating EE: " << ErrorMsg << "\n";
529     else
530       WithColor::error(errs(), argv[0]) << "unknown error creating EE!\n";
531     exit(1);
532   }
533 
534   std::unique_ptr<LLIObjectCache> CacheManager;
535   if (EnableCacheManager) {
536     CacheManager.reset(new LLIObjectCache(ObjectCacheDir));
537     EE->setObjectCache(CacheManager.get());
538   }
539 
540   // Load any additional modules specified on the command line.
541   for (unsigned i = 0, e = ExtraModules.size(); i != e; ++i) {
542     std::unique_ptr<Module> XMod = parseIRFile(ExtraModules[i], Err, Context);
543     if (!XMod)
544       reportError(Err, argv[0]);
545     if (EnableCacheManager) {
546       std::string CacheName("file:");
547       CacheName.append(ExtraModules[i]);
548       XMod->setModuleIdentifier(CacheName);
549     }
550     EE->addModule(std::move(XMod));
551   }
552 
553   for (unsigned i = 0, e = ExtraObjects.size(); i != e; ++i) {
554     Expected<object::OwningBinary<object::ObjectFile>> Obj =
555         object::ObjectFile::createObjectFile(ExtraObjects[i]);
556     if (!Obj) {
557       // TODO: Actually report errors helpfully.
558       consumeError(Obj.takeError());
559       reportError(Err, argv[0]);
560     }
561     object::OwningBinary<object::ObjectFile> &O = Obj.get();
562     EE->addObjectFile(std::move(O));
563   }
564 
565   for (unsigned i = 0, e = ExtraArchives.size(); i != e; ++i) {
566     ErrorOr<std::unique_ptr<MemoryBuffer>> ArBufOrErr =
567         MemoryBuffer::getFileOrSTDIN(ExtraArchives[i]);
568     if (!ArBufOrErr)
569       reportError(Err, argv[0]);
570     std::unique_ptr<MemoryBuffer> &ArBuf = ArBufOrErr.get();
571 
572     Expected<std::unique_ptr<object::Archive>> ArOrErr =
573         object::Archive::create(ArBuf->getMemBufferRef());
574     if (!ArOrErr) {
575       std::string Buf;
576       raw_string_ostream OS(Buf);
577       logAllUnhandledErrors(ArOrErr.takeError(), OS);
578       OS.flush();
579       errs() << Buf;
580       exit(1);
581     }
582     std::unique_ptr<object::Archive> &Ar = ArOrErr.get();
583 
584     object::OwningBinary<object::Archive> OB(std::move(Ar), std::move(ArBuf));
585 
586     EE->addArchive(std::move(OB));
587   }
588 
589   // If the target is Cygwin/MingW and we are generating remote code, we
590   // need an extra module to help out with linking.
591   if (RemoteMCJIT && Triple(Mod->getTargetTriple()).isOSCygMing()) {
592     addCygMingExtraModule(*EE, Context, Mod->getTargetTriple());
593   }
594 
595   // The following functions have no effect if their respective profiling
596   // support wasn't enabled in the build configuration.
597   EE->RegisterJITEventListener(
598                 JITEventListener::createOProfileJITEventListener());
599   EE->RegisterJITEventListener(
600                 JITEventListener::createIntelJITEventListener());
601   if (!RemoteMCJIT)
602     EE->RegisterJITEventListener(
603                 JITEventListener::createPerfJITEventListener());
604 
605   if (!NoLazyCompilation && RemoteMCJIT) {
606     WithColor::warning(errs(), argv[0])
607         << "remote mcjit does not support lazy compilation\n";
608     NoLazyCompilation = true;
609   }
610   EE->DisableLazyCompilation(NoLazyCompilation);
611 
612   // If the user specifically requested an argv[0] to pass into the program,
613   // do it now.
614   if (!FakeArgv0.empty()) {
615     InputFile = static_cast<std::string>(FakeArgv0);
616   } else {
617     // Otherwise, if there is a .bc suffix on the executable strip it off, it
618     // might confuse the program.
619     if (StringRef(InputFile).endswith(".bc"))
620       InputFile.erase(InputFile.length() - 3);
621   }
622 
623   // Add the module's name to the start of the vector of arguments to main().
624   InputArgv.insert(InputArgv.begin(), InputFile);
625 
626   // Call the main function from M as if its signature were:
627   //   int main (int argc, char **argv, const char **envp)
628   // using the contents of Args to determine argc & argv, and the contents of
629   // EnvVars to determine envp.
630   //
631   Function *EntryFn = Mod->getFunction(EntryFunc);
632   if (!EntryFn) {
633     WithColor::error(errs(), argv[0])
634         << '\'' << EntryFunc << "\' function not found in module.\n";
635     return -1;
636   }
637 
638   // Reset errno to zero on entry to main.
639   errno = 0;
640 
641   int Result = -1;
642 
643   // Sanity check use of remote-jit: LLI currently only supports use of the
644   // remote JIT on Unix platforms.
645   if (RemoteMCJIT) {
646 #ifndef LLVM_ON_UNIX
647     WithColor::warning(errs(), argv[0])
648         << "host does not support external remote targets.\n";
649     WithColor::note() << "defaulting to local execution\n";
650     return -1;
651 #else
652     if (ChildExecPath.empty()) {
653       WithColor::error(errs(), argv[0])
654           << "-remote-mcjit requires -mcjit-remote-process.\n";
655       exit(1);
656     } else if (!sys::fs::can_execute(ChildExecPath)) {
657       WithColor::error(errs(), argv[0])
658           << "unable to find usable child executable: '" << ChildExecPath
659           << "'\n";
660       return -1;
661     }
662 #endif
663   }
664 
665   if (!RemoteMCJIT) {
666     // If the program doesn't explicitly call exit, we will need the Exit
667     // function later on to make an explicit call, so get the function now.
668     FunctionCallee Exit = Mod->getOrInsertFunction(
669         "exit", Type::getVoidTy(Context), Type::getInt32Ty(Context));
670 
671     // Run static constructors.
672     if (!ForceInterpreter) {
673       // Give MCJIT a chance to apply relocations and set page permissions.
674       EE->finalizeObject();
675     }
676     EE->runStaticConstructorsDestructors(false);
677 
678     // Trigger compilation separately so code regions that need to be
679     // invalidated will be known.
680     (void)EE->getPointerToFunction(EntryFn);
681     // Clear instruction cache before code will be executed.
682     if (RTDyldMM)
683       static_cast<SectionMemoryManager*>(RTDyldMM)->invalidateInstructionCache();
684 
685     // Run main.
686     Result = EE->runFunctionAsMain(EntryFn, InputArgv, envp);
687 
688     // Run static destructors.
689     EE->runStaticConstructorsDestructors(true);
690 
691     // If the program didn't call exit explicitly, we should call it now.
692     // This ensures that any atexit handlers get called correctly.
693     if (Function *ExitF =
694             dyn_cast<Function>(Exit.getCallee()->stripPointerCasts())) {
695       if (ExitF->getFunctionType() == Exit.getFunctionType()) {
696         std::vector<GenericValue> Args;
697         GenericValue ResultGV;
698         ResultGV.IntVal = APInt(32, Result);
699         Args.push_back(ResultGV);
700         EE->runFunction(ExitF, Args);
701         WithColor::error(errs(), argv[0])
702             << "exit(" << Result << ") returned!\n";
703         abort();
704       }
705     }
706     WithColor::error(errs(), argv[0]) << "exit defined with wrong prototype!\n";
707     abort();
708   } else {
709     // else == "if (RemoteMCJIT)"
710 
711     // Remote target MCJIT doesn't (yet) support static constructors. No reason
712     // it couldn't. This is a limitation of the LLI implementation, not the
713     // MCJIT itself. FIXME.
714 
715     // Lanch the remote process and get a channel to it.
716     std::unique_ptr<orc::shared::FDRawByteChannel> C = launchRemote();
717     if (!C) {
718       WithColor::error(errs(), argv[0]) << "failed to launch remote JIT.\n";
719       exit(1);
720     }
721 
722     // Create a remote target client running over the channel.
723     llvm::orc::ExecutionSession ES;
724     ES.setErrorReporter([&](Error Err) { ExitOnErr(std::move(Err)); });
725     typedef orc::remote::OrcRemoteTargetClient MyRemote;
726     auto R = ExitOnErr(MyRemote::Create(*C, ES));
727 
728     // Create a remote memory manager.
729     auto RemoteMM = ExitOnErr(R->createRemoteMemoryManager());
730 
731     // Forward MCJIT's memory manager calls to the remote memory manager.
732     static_cast<ForwardingMemoryManager*>(RTDyldMM)->setMemMgr(
733       std::move(RemoteMM));
734 
735     // Forward MCJIT's symbol resolution calls to the remote.
736     static_cast<ForwardingMemoryManager *>(RTDyldMM)->setResolver(
737         std::make_unique<RemoteResolver<MyRemote>>(*R));
738 
739     // Grab the target address of the JIT'd main function on the remote and call
740     // it.
741     // FIXME: argv and envp handling.
742     JITTargetAddress Entry = EE->getFunctionAddress(EntryFn->getName().str());
743     EE->finalizeObject();
744     LLVM_DEBUG(dbgs() << "Executing '" << EntryFn->getName() << "' at 0x"
745                       << format("%llx", Entry) << "\n");
746     Result = ExitOnErr(R->callIntVoid(Entry));
747 
748     // Like static constructors, the remote target MCJIT support doesn't handle
749     // this yet. It could. FIXME.
750 
751     // Delete the EE - we need to tear it down *before* we terminate the session
752     // with the remote, otherwise it'll crash when it tries to release resources
753     // on a remote that has already been disconnected.
754     EE.reset();
755 
756     // Signal the remote target that we're done JITing.
757     ExitOnErr(R->terminateSession());
758   }
759 
760   return Result;
761 }
762 
createDebugDumper()763 static std::function<void(Module &)> createDebugDumper() {
764   switch (OrcDumpKind) {
765   case DumpKind::NoDump:
766     return [](Module &M) {};
767 
768   case DumpKind::DumpFuncsToStdOut:
769     return [](Module &M) {
770       printf("[ ");
771 
772       for (const auto &F : M) {
773         if (F.isDeclaration())
774           continue;
775 
776         if (F.hasName()) {
777           std::string Name(std::string(F.getName()));
778           printf("%s ", Name.c_str());
779         } else
780           printf("<anon> ");
781       }
782 
783       printf("]\n");
784     };
785 
786   case DumpKind::DumpModsToStdOut:
787     return [](Module &M) {
788       outs() << "----- Module Start -----\n" << M << "----- Module End -----\n";
789     };
790 
791   case DumpKind::DumpModsToDisk:
792     return [](Module &M) {
793       std::error_code EC;
794       raw_fd_ostream Out(M.getModuleIdentifier() + ".ll", EC,
795                          sys::fs::OF_TextWithCRLF);
796       if (EC) {
797         errs() << "Couldn't open " << M.getModuleIdentifier()
798                << " for dumping.\nError:" << EC.message() << "\n";
799         exit(1);
800       }
801       Out << M;
802     };
803   }
804   llvm_unreachable("Unknown DumpKind");
805 }
806 
loadDylibs()807 Error loadDylibs() {
808   for (const auto &Dylib : Dylibs) {
809     std::string ErrMsg;
810     if (sys::DynamicLibrary::LoadLibraryPermanently(Dylib.c_str(), &ErrMsg))
811       return make_error<StringError>(ErrMsg, inconvertibleErrorCode());
812   }
813 
814   return Error::success();
815 }
816 
exitOnLazyCallThroughFailure()817 static void exitOnLazyCallThroughFailure() { exit(1); }
818 
819 Expected<orc::ThreadSafeModule>
loadModule(StringRef Path,orc::ThreadSafeContext TSCtx)820 loadModule(StringRef Path, orc::ThreadSafeContext TSCtx) {
821   SMDiagnostic Err;
822   auto M = parseIRFile(Path, Err, *TSCtx.getContext());
823   if (!M) {
824     std::string ErrMsg;
825     {
826       raw_string_ostream ErrMsgStream(ErrMsg);
827       Err.print("lli", ErrMsgStream);
828     }
829     return make_error<StringError>(std::move(ErrMsg), inconvertibleErrorCode());
830   }
831 
832   if (EnableCacheManager)
833     M->setModuleIdentifier("file:" + M->getModuleIdentifier());
834 
835   return orc::ThreadSafeModule(std::move(M), std::move(TSCtx));
836 }
837 
runOrcJIT(const char * ProgName)838 int runOrcJIT(const char *ProgName) {
839   // Start setting up the JIT environment.
840 
841   // Parse the main module.
842   orc::ThreadSafeContext TSCtx(std::make_unique<LLVMContext>());
843   auto MainModule = ExitOnErr(loadModule(InputFile, TSCtx));
844 
845   // Get TargetTriple and DataLayout from the main module if they're explicitly
846   // set.
847   Optional<Triple> TT;
848   Optional<DataLayout> DL;
849   MainModule.withModuleDo([&](Module &M) {
850       if (!M.getTargetTriple().empty())
851         TT = Triple(M.getTargetTriple());
852       if (!M.getDataLayout().isDefault())
853         DL = M.getDataLayout();
854     });
855 
856   orc::LLLazyJITBuilder Builder;
857 
858   Builder.setJITTargetMachineBuilder(
859       TT ? orc::JITTargetMachineBuilder(*TT)
860          : ExitOnErr(orc::JITTargetMachineBuilder::detectHost()));
861 
862   TT = Builder.getJITTargetMachineBuilder()->getTargetTriple();
863   if (DL)
864     Builder.setDataLayout(DL);
865 
866   if (!codegen::getMArch().empty())
867     Builder.getJITTargetMachineBuilder()->getTargetTriple().setArchName(
868         codegen::getMArch());
869 
870   Builder.getJITTargetMachineBuilder()
871       ->setCPU(codegen::getCPUStr())
872       .addFeatures(codegen::getFeatureList())
873       .setRelocationModel(codegen::getExplicitRelocModel())
874       .setCodeModel(codegen::getExplicitCodeModel());
875 
876   // FIXME: Setting a dummy call-through manager in non-lazy mode prevents the
877   // JIT builder to instantiate a default (which would fail with an error for
878   // unsupported architectures).
879   if (UseJITKind != JITKind::OrcLazy) {
880     auto ES = std::make_unique<orc::ExecutionSession>();
881     Builder.setLazyCallthroughManager(
882         std::make_unique<orc::LazyCallThroughManager>(*ES, 0, nullptr));
883     Builder.setExecutionSession(std::move(ES));
884   }
885 
886   Builder.setLazyCompileFailureAddr(
887       pointerToJITTargetAddress(exitOnLazyCallThroughFailure));
888   Builder.setNumCompileThreads(LazyJITCompileThreads);
889 
890   // If the object cache is enabled then set a custom compile function
891   // creator to use the cache.
892   std::unique_ptr<LLIObjectCache> CacheManager;
893   if (EnableCacheManager) {
894 
895     CacheManager = std::make_unique<LLIObjectCache>(ObjectCacheDir);
896 
897     Builder.setCompileFunctionCreator(
898       [&](orc::JITTargetMachineBuilder JTMB)
899             -> Expected<std::unique_ptr<orc::IRCompileLayer::IRCompiler>> {
900         if (LazyJITCompileThreads > 0)
901           return std::make_unique<orc::ConcurrentIRCompiler>(std::move(JTMB),
902                                                         CacheManager.get());
903 
904         auto TM = JTMB.createTargetMachine();
905         if (!TM)
906           return TM.takeError();
907 
908         return std::make_unique<orc::TMOwningSimpleCompiler>(std::move(*TM),
909                                                         CacheManager.get());
910       });
911   }
912 
913   // Set up LLJIT platform.
914   {
915     LLJITPlatform P = Platform;
916     if (P == LLJITPlatform::DetectHost) {
917       if (TT->isOSBinFormatMachO())
918         P = LLJITPlatform::MachO;
919       else
920         P = LLJITPlatform::GenericIR;
921     }
922 
923     switch (P) {
924     case LLJITPlatform::GenericIR:
925       // Nothing to do: LLJITBuilder will use this by default.
926       break;
927     case LLJITPlatform::MachO:
928       Builder.setPlatformSetUp(orc::setUpMachOPlatform);
929       ExitOnErr(orc::enableObjCRegistration("libobjc.dylib"));
930       break;
931     case LLJITPlatform::Inactive:
932       Builder.setPlatformSetUp(orc::setUpInactivePlatform);
933       break;
934     default:
935       llvm_unreachable("Unrecognized platform value");
936     }
937   }
938 
939   std::unique_ptr<orc::TargetProcessControl> TPC = nullptr;
940   if (JITLinker == JITLinkerKind::JITLink) {
941     TPC = ExitOnErr(orc::SelfTargetProcessControl::Create(
942         std::make_shared<orc::SymbolStringPool>()));
943 
944     Builder.setObjectLinkingLayerCreator([&TPC](orc::ExecutionSession &ES,
945                                                 const Triple &) {
946       auto L = std::make_unique<orc::ObjectLinkingLayer>(ES, TPC->getMemMgr());
947       L->addPlugin(std::make_unique<orc::EHFrameRegistrationPlugin>(
948           ES, ExitOnErr(orc::TPCEHFrameRegistrar::Create(*TPC))));
949       L->addPlugin(std::make_unique<orc::DebugObjectManagerPlugin>(
950           ES, ExitOnErr(orc::createJITLoaderGDBRegistrar(*TPC))));
951       return L;
952     });
953   }
954 
955   auto J = ExitOnErr(Builder.create());
956 
957   auto *ObjLayer = &J->getObjLinkingLayer();
958   if (auto *RTDyldObjLayer = dyn_cast<orc::RTDyldObjectLinkingLayer>(ObjLayer))
959     RTDyldObjLayer->registerJITEventListener(
960         *JITEventListener::createGDBRegistrationListener());
961 
962   if (PerModuleLazy)
963     J->setPartitionFunction(orc::CompileOnDemandLayer::compileWholeModule);
964 
965   auto Dump = createDebugDumper();
966 
967   J->getIRTransformLayer().setTransform(
968       [&](orc::ThreadSafeModule TSM,
969           const orc::MaterializationResponsibility &R) {
970         TSM.withModuleDo([&](Module &M) {
971           if (verifyModule(M, &dbgs())) {
972             dbgs() << "Bad module: " << &M << "\n";
973             exit(1);
974           }
975           Dump(M);
976         });
977         return TSM;
978       });
979 
980   orc::MangleAndInterner Mangle(J->getExecutionSession(), J->getDataLayout());
981 
982   // Unless they've been explicitly disabled, make process symbols available to
983   // JIT'd code.
984   if (!NoProcessSymbols)
985     J->getMainJITDylib().addGenerator(
986         ExitOnErr(orc::DynamicLibrarySearchGenerator::GetForCurrentProcess(
987             J->getDataLayout().getGlobalPrefix(),
988             [MainName = Mangle("main")](const orc::SymbolStringPtr &Name) {
989               return Name != MainName;
990             })));
991 
992   if (GenerateBuiltinFunctions.size() > 0)
993     J->getMainJITDylib().addGenerator(
994         std::make_unique<LLIBuiltinFunctionGenerator>(GenerateBuiltinFunctions,
995                                                       Mangle));
996 
997   // Regular modules are greedy: They materialize as a whole and trigger
998   // materialization for all required symbols recursively. Lazy modules go
999   // through partitioning and they replace outgoing calls with reexport stubs
1000   // that resolve on call-through.
1001   auto AddModule = [&](orc::JITDylib &JD, orc::ThreadSafeModule M) {
1002     return UseJITKind == JITKind::OrcLazy ? J->addLazyIRModule(JD, std::move(M))
1003                                           : J->addIRModule(JD, std::move(M));
1004   };
1005 
1006   // Add the main module.
1007   ExitOnErr(AddModule(J->getMainJITDylib(), std::move(MainModule)));
1008 
1009   // Create JITDylibs and add any extra modules.
1010   {
1011     // Create JITDylibs, keep a map from argument index to dylib. We will use
1012     // -extra-module argument indexes to determine what dylib to use for each
1013     // -extra-module.
1014     std::map<unsigned, orc::JITDylib *> IdxToDylib;
1015     IdxToDylib[0] = &J->getMainJITDylib();
1016     for (auto JDItr = JITDylibs.begin(), JDEnd = JITDylibs.end();
1017          JDItr != JDEnd; ++JDItr) {
1018       orc::JITDylib *JD = J->getJITDylibByName(*JDItr);
1019       if (!JD) {
1020         JD = &ExitOnErr(J->createJITDylib(*JDItr));
1021         J->getMainJITDylib().addToLinkOrder(*JD);
1022         JD->addToLinkOrder(J->getMainJITDylib());
1023       }
1024       IdxToDylib[JITDylibs.getPosition(JDItr - JITDylibs.begin())] = JD;
1025     }
1026 
1027     for (auto EMItr = ExtraModules.begin(), EMEnd = ExtraModules.end();
1028          EMItr != EMEnd; ++EMItr) {
1029       auto M = ExitOnErr(loadModule(*EMItr, TSCtx));
1030 
1031       auto EMIdx = ExtraModules.getPosition(EMItr - ExtraModules.begin());
1032       assert(EMIdx != 0 && "ExtraModule should have index > 0");
1033       auto JDItr = std::prev(IdxToDylib.lower_bound(EMIdx));
1034       auto &JD = *JDItr->second;
1035       ExitOnErr(AddModule(JD, std::move(M)));
1036     }
1037 
1038     for (auto EAItr = ExtraArchives.begin(), EAEnd = ExtraArchives.end();
1039          EAItr != EAEnd; ++EAItr) {
1040       auto EAIdx = ExtraArchives.getPosition(EAItr - ExtraArchives.begin());
1041       assert(EAIdx != 0 && "ExtraArchive should have index > 0");
1042       auto JDItr = std::prev(IdxToDylib.lower_bound(EAIdx));
1043       auto &JD = *JDItr->second;
1044       JD.addGenerator(ExitOnErr(orc::StaticLibraryDefinitionGenerator::Load(
1045           J->getObjLinkingLayer(), EAItr->c_str(), *TT)));
1046     }
1047   }
1048 
1049   // Add the objects.
1050   for (auto &ObjPath : ExtraObjects) {
1051     auto Obj = ExitOnErr(errorOrToExpected(MemoryBuffer::getFile(ObjPath)));
1052     ExitOnErr(J->addObjectFile(std::move(Obj)));
1053   }
1054 
1055   // Run any static constructors.
1056   ExitOnErr(J->initialize(J->getMainJITDylib()));
1057 
1058   // Run any -thread-entry points.
1059   std::vector<std::thread> AltEntryThreads;
1060   for (auto &ThreadEntryPoint : ThreadEntryPoints) {
1061     auto EntryPointSym = ExitOnErr(J->lookup(ThreadEntryPoint));
1062     typedef void (*EntryPointPtr)();
1063     auto EntryPoint =
1064       reinterpret_cast<EntryPointPtr>(static_cast<uintptr_t>(EntryPointSym.getAddress()));
1065     AltEntryThreads.push_back(std::thread([EntryPoint]() { EntryPoint(); }));
1066   }
1067 
1068   // Resolve and run the main function.
1069   JITEvaluatedSymbol MainSym = ExitOnErr(J->lookup(EntryFunc));
1070   int Result;
1071 
1072   if (TPC) {
1073     // TargetProcessControl-based execution with JITLink.
1074     Result = ExitOnErr(TPC->runAsMain(MainSym.getAddress(), InputArgv));
1075   } else {
1076     // Manual in-process execution with RuntimeDyld.
1077     using MainFnTy = int(int, char *[]);
1078     auto MainFn = jitTargetAddressToFunction<MainFnTy *>(MainSym.getAddress());
1079     Result = orc::runAsMain(MainFn, InputArgv, StringRef(InputFile));
1080   }
1081 
1082   // Wait for -entry-point threads.
1083   for (auto &AltEntryThread : AltEntryThreads)
1084     AltEntryThread.join();
1085 
1086   // Run destructors.
1087   ExitOnErr(J->deinitialize(J->getMainJITDylib()));
1088 
1089   return Result;
1090 }
1091 
disallowOrcOptions()1092 void disallowOrcOptions() {
1093   // Make sure nobody used an orc-lazy specific option accidentally.
1094 
1095   if (LazyJITCompileThreads != 0) {
1096     errs() << "-compile-threads requires -jit-kind=orc-lazy\n";
1097     exit(1);
1098   }
1099 
1100   if (!ThreadEntryPoints.empty()) {
1101     errs() << "-thread-entry requires -jit-kind=orc-lazy\n";
1102     exit(1);
1103   }
1104 
1105   if (PerModuleLazy) {
1106     errs() << "-per-module-lazy requires -jit-kind=orc-lazy\n";
1107     exit(1);
1108   }
1109 }
1110 
launchRemote()1111 std::unique_ptr<orc::shared::FDRawByteChannel> launchRemote() {
1112 #ifndef LLVM_ON_UNIX
1113   llvm_unreachable("launchRemote not supported on non-Unix platforms");
1114 #else
1115   int PipeFD[2][2];
1116   pid_t ChildPID;
1117 
1118   // Create two pipes.
1119   if (pipe(PipeFD[0]) != 0 || pipe(PipeFD[1]) != 0)
1120     perror("Error creating pipe: ");
1121 
1122   ChildPID = fork();
1123 
1124   if (ChildPID == 0) {
1125     // In the child...
1126 
1127     // Close the parent ends of the pipes
1128     close(PipeFD[0][1]);
1129     close(PipeFD[1][0]);
1130 
1131 
1132     // Execute the child process.
1133     std::unique_ptr<char[]> ChildPath, ChildIn, ChildOut;
1134     {
1135       ChildPath.reset(new char[ChildExecPath.size() + 1]);
1136       std::copy(ChildExecPath.begin(), ChildExecPath.end(), &ChildPath[0]);
1137       ChildPath[ChildExecPath.size()] = '\0';
1138       std::string ChildInStr = utostr(PipeFD[0][0]);
1139       ChildIn.reset(new char[ChildInStr.size() + 1]);
1140       std::copy(ChildInStr.begin(), ChildInStr.end(), &ChildIn[0]);
1141       ChildIn[ChildInStr.size()] = '\0';
1142       std::string ChildOutStr = utostr(PipeFD[1][1]);
1143       ChildOut.reset(new char[ChildOutStr.size() + 1]);
1144       std::copy(ChildOutStr.begin(), ChildOutStr.end(), &ChildOut[0]);
1145       ChildOut[ChildOutStr.size()] = '\0';
1146     }
1147 
1148     char * const args[] = { &ChildPath[0], &ChildIn[0], &ChildOut[0], nullptr };
1149     int rc = execv(ChildExecPath.c_str(), args);
1150     if (rc != 0)
1151       perror("Error executing child process: ");
1152     llvm_unreachable("Error executing child process");
1153   }
1154   // else we're the parent...
1155 
1156   // Close the child ends of the pipes
1157   close(PipeFD[0][0]);
1158   close(PipeFD[1][1]);
1159 
1160   // Return an RPC channel connected to our end of the pipes.
1161   return std::make_unique<orc::shared::FDRawByteChannel>(PipeFD[1][0],
1162                                                          PipeFD[0][1]);
1163 #endif
1164 }
1165