[examples] Fix the clang-interpreter example for changes in 2487db1f2862

[rmansfield]

This got fixed by b4c0307d598004cfd96c770d2a4a84a37c838ba9

clang/examples/clang-interpreter/main.cpp

std::string GetExecutablePath(const char *Argv0, void *MainAddr) {
   return llvm::sys::fs::getMainExecutable(Argv0, MainAddr);
 }
 
 namespace llvm {
 namespace orc {
 
 class SimpleJIT {
 private:
-  ExecutionSession ES;
+  std::unique_ptr<ExecutionSession> ES;
   std::unique_ptr<TargetMachine> TM;
   const DataLayout DL;
-  MangleAndInterner Mangle{ES, DL};
-  JITDylib &MainJD{ES.createBareJITDylib("<main>")};
-  RTDyldObjectLinkingLayer ObjectLayer{ES, createMemMgr};
-  IRCompileLayer CompileLayer{ES, ObjectLayer,
-                              std::make_unique<SimpleCompiler>(*TM)};
+  MangleAndInterner Mangle;
+  JITDylib &MainJD;
+  RTDyldObjectLinkingLayer ObjectLayer;
+  IRCompileLayer CompileLayer;
 
   static std::unique_ptr<SectionMemoryManager> createMemMgr() {
     return std::make_unique<SectionMemoryManager>();
   }
 
   SimpleJIT(
-      std::unique_ptr<TargetMachine> TM, DataLayout DL,
+      std::unique_ptr<ExecutionSession> ES, std::unique_ptr<TargetMachine> TM,
+      DataLayout DL,
       std::unique_ptr<DynamicLibrarySearchGenerator> ProcessSymbolsGenerator)
-      : TM(std::move(TM)), DL(std::move(DL)) {
+      : ES(std::move(ES)), TM(std::move(TM)), DL(std::move(DL)),
+        Mangle(*this->ES, this->DL),
+        MainJD(this->ES->createBareJITDylib("<main>")),
+        ObjectLayer(*this->ES, createMemMgr),
+        CompileLayer(*this->ES, ObjectLayer,
+                     std::make_unique<SimpleCompiler>(*this->TM)) {
+
     llvm::sys::DynamicLibrary::LoadLibraryPermanently(nullptr);
     MainJD.addGenerator(std::move(ProcessSymbolsGenerator));
   }
 
 public:
   ~SimpleJIT() {
-    if (auto Err = ES.endSession())
-      ES.reportError(std::move(Err));
+    if (auto Err = ES->endSession())
+      ES->reportError(std::move(Err));
   }
 
   static Expected<std::unique_ptr<SimpleJIT>> Create() {
     auto JTMB = JITTargetMachineBuilder::detectHost();
     if (!JTMB)
       return JTMB.takeError();
 
     auto TM = JTMB->createTargetMachine();
     if (!TM)
       return TM.takeError();
 
+    auto EPC = SelfExecutorProcessControl::Create();
+    if (!EPC)
+      return EPC.takeError();
+
+    auto ES = std::make_unique<ExecutionSession>(std::move(*EPC));
+
     auto DL = (*TM)->createDataLayout();
 
     auto ProcessSymbolsGenerator =
         DynamicLibrarySearchGenerator::GetForCurrentProcess(
             DL.getGlobalPrefix());
 
     if (!ProcessSymbolsGenerator)
       return ProcessSymbolsGenerator.takeError();
 
-    return std::unique_ptr<SimpleJIT>(new SimpleJIT(
-        std::move(*TM), std::move(DL), std::move(*ProcessSymbolsGenerator)));
+    return std::unique_ptr<SimpleJIT>(
+        new SimpleJIT(std::move(ES), std::move(*TM), std::move(DL),
+                      std::move(*ProcessSymbolsGenerator)));
   }
 
   const TargetMachine &getTargetMachine() const { return *TM; }
 
   Error addModule(ThreadSafeModule M) {
     return CompileLayer.add(MainJD, std::move(M));
   }
 
   Expected<JITEvaluatedSymbol> findSymbol(const StringRef &Name) {
-    return ES.lookup({&MainJD}, Mangle(Name));
+    return ES->lookup({&MainJD}, Mangle(Name));
   }
 
   Expected<JITTargetAddress> getSymbolAddress(const StringRef &Name) {
     auto Sym = findSymbol(Name);
     if (!Sym)
       return Sym.takeError();
     return Sym->getAddress();
   }
 };
 
 } // end namespace orc
 } // end namespace llvm
 
 llvm::ExitOnError ExitOnErr;
 
 int main(int argc, const char **argv) {
   // This just needs to be some symbol in the binary; C++ doesn't
   // allow taking the address of ::main however.
-  void *MainAddr = (void*) (intptr_t) GetExecutablePath;
+  void *MainAddr = (void *)(intptr_t)GetExecutablePath;
   std::string Path = GetExecutablePath(argv[0], MainAddr);
   IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts = new DiagnosticOptions();
   TextDiagnosticPrinter *DiagClient =
       new TextDiagnosticPrinter(llvm::errs(), &*DiagOpts);
 
   IntrusiveRefCntPtr<DiagnosticIDs> DiagID(new DiagnosticIDs());
   DiagnosticsEngine Diags(DiagID, &*DiagOpts, DiagClient);
 
   const std::string TripleStr = llvm::sys::getProcessTriple();
   llvm::Triple T(TripleStr);
 
   // Use ELF on Windows-32 and MingW for now.
#endif
   Clang.createDiagnostics();
   if (!Clang.hasDiagnostics())
     return 1;
 
   // Infer the builtin include path if unspecified.
   if (Clang.getHeaderSearchOpts().UseBuiltinIncludes &&
       Clang.getHeaderSearchOpts().ResourceDir.empty())
     Clang.getHeaderSearchOpts().ResourceDir =
         CompilerInvocation::GetResourcesPath(argv[0], MainAddr);
 
   // Create and execute the frontend to generate an LLVM bitcode module.
   std::unique_ptr<CodeGenAction> Act(new EmitLLVMOnlyAction());
   if (!Clang.ExecuteAction(*Act))
     return 1;
 
   llvm::InitializeNativeTarget();
   llvm::InitializeNativeTargetAsmPrinter();