[orc] Pass big JITTargetMachineBuilder parameters by reference to avoid unnecessary copies

[fzou1]

Apply clang format

[fzou1]

Update other big JITTargetMachineBuilder parameters passed by reference and format changes by clang-format tool

[fzou1]

Update another parameter passed by reference and tutorials of building JIT and add const

[lhames]

Hi @fzou1,

JITTargetMachineBuilders are only moved around at startup at the moment, and they're only ~0.5kb. Have they been observed to have a performance impact? If so we should probably transfer them via unique_ptr to avoid the copies, but I'm not sure it's necessary yet.

llvm/docs/tutorial/BuildingAJIT1.rst

195–197

The introduction of EPC here seems unrelated to the other changes?

llvm/docs/tutorial/BuildingAJIT2.rst

61

Is this change related to the rest of the patch?

[fzou1]

In D140627#4075812, @lhames wrote:

Hi @fzou1,

JITTargetMachineBuilders are only moved around at startup at the moment, and they're only ~0.5kb. Have they been observed to have a performance impact? If so we should probably transfer them via unique_ptr to avoid the copies, but I'm not sure it's necessary yet.

Sorry. No performance impact observed. They're nice-to-have changes. If needed, I'll update the patch with unique_ptr.

llvm/docs/tutorial/BuildingAJIT1.rst

195–197

Yes. But the example code is out of date and should be same as in KaleidoscopeJIT.h header file.

llvm/docs/tutorial/BuildingAJIT2.rst

61

Partly yes. This example code is out of date. I updated it together with the code of passing argument by reference.

llvm/docs/tutorial/BuildingAJIT1.rst

.. code-block:: c++
   #ifndef LLVM_EXECUTIONENGINE_ORC_KALEIDOSCOPEJIT_H
   #define LLVM_EXECUTIONENGINE_ORC_KALEIDOSCOPEJIT_H
 
   #include "llvm/ADT/StringRef.h"
   #include "llvm/ExecutionEngine/JITSymbol.h"
   #include "llvm/ExecutionEngine/Orc/CompileUtils.h"
   #include "llvm/ExecutionEngine/Orc/Core.h"
   #include "llvm/ExecutionEngine/Orc/ExecutionUtils.h"
+  #include "llvm/ExecutionEngine/Orc/ExecutorProcessControl.h"
   #include "llvm/ExecutionEngine/Orc/IRCompileLayer.h"
   #include "llvm/ExecutionEngine/Orc/JITTargetMachineBuilder.h"
   #include "llvm/ExecutionEngine/Orc/RTDyldObjectLinkingLayer.h"
   #include "llvm/ExecutionEngine/SectionMemoryManager.h"
   #include "llvm/IR/DataLayout.h"
   #include "llvm/IR/LLVMContext.h"
   #include <memory>
 
   namespace llvm {
   namespace orc {
 
   class KaleidoscopeJIT {
   private:
-    ExecutionSession ES;
-    RTDyldObjectLinkingLayer ObjectLayer;
-    IRCompileLayer CompileLayer;
+    std::unique_ptr<ExecutionSession> ES;
 
     DataLayout DL;
     MangleAndInterner Mangle;
-    ThreadSafeContext Ctx;
+
+    RTDyldObjectLinkingLayer ObjectLayer;
+    IRCompileLayer CompileLayer;
+
+    JITDylib &MainJD;
 
   public:
-    KaleidoscopeJIT(JITTargetMachineBuilder JTMB, DataLayout DL)
-        : ObjectLayer(ES,
-                      []() { return std::make_unique<SectionMemoryManager>(); }),
-          CompileLayer(ES, ObjectLayer, ConcurrentIRCompiler(std::move(JTMB))),
-          DL(std::move(DL)), Mangle(ES, this->DL),
-          Ctx(std::make_unique<LLVMContext>()) {
-      ES.getMainJITDylib().addGenerator(
-          cantFail(DynamicLibrarySearchGenerator::GetForCurrentProcess(DL.getGlobalPrefix())));
+    KaleidoscopeJIT(std::unique_ptr<ExecutionSession> ES,
+                    const JITTargetMachineBuilder &JTMB, DataLayout DL)
+      : ES(std::move(ES)), DL(std::move(DL)), Mangle(*this->ES, this->DL),
+      ObjectLayer(*this->ES,
+      CompileLayer(*this->ES, ObjectLayer,
+                   std::make_unique<ConcurrentIRCompiler>(JTMB)),
+      MainJD(this->ES->createBareJITDylib("<main>")) {
+        MainJD.addGenerator(
+          cantFail(DynamicLibrarySearchGenerator::GetForCurrentProcess(
+              DL.getGlobalPrefix())));
       }
 
 Our class begins with six member variables: An ExecutionSession member, ``ES``,
 which provides context for our running JIT'd code (including the string pool,
 global mutex, and error reporting facilities); An RTDyldObjectLinkingLayer,
 ``ObjectLayer``, that can be used to add object files to our JIT (though we will
 not use it directly); An IRCompileLayer, ``CompileLayer``, that can be used to
 add LLVM Modules to our JIT (and which builds on the ObjectLayer), A DataLayout
 and MangleAndInterner, ``DL`` and ``Mangle``, that will be used for symbol mangling

 REPL process as well. We do this by attaching a
 ``DynamicLibrarySearchGenerator`` instance using the
 ``DynamicLibrarySearchGenerator::GetForCurrentProcess`` method.
 
 
 .. code-block:: c++
 
   static Expected<std::unique_ptr<KaleidoscopeJIT>> Create() {
-    auto JTMB = JITTargetMachineBuilder::detectHost();
+    auto EPC = SelfExecutorProcessControl::Create();
+    if (!EPC)
+      return EPC.takeError();
+
+    auto ES = std::make_unique<ExecutionSession>(std::move(*EPC));
 
-    if (!JTMB)
-      return JTMB.takeError();
+    JITTargetMachineBuilder JTMB(
+        ES->getExecutorProcessControl().getTargetTriple());
 
-    auto DL = JTMB->getDefaultDataLayoutForTarget();
+    auto DL = JTMB.getDefaultDataLayoutForTarget();
     if (!DL)
       return DL.takeError();
 
-    return std::make_unique<KaleidoscopeJIT>(std::move(*JTMB), std::move(*DL));
+    return std::make_unique<KaleidoscopeJIT>(std::move(ES), JTMB,
+                                             std::move(*DL));
   }
 
   const DataLayout &getDataLayout() const { return DL; }
 
   LLVMContext &getContext() { return *Ctx.getContext(); }
 
 Next we have a named constructor, ``Create``, which will build a KaleidoscopeJIT
 instance that is configured to generate code for our host process. It does this

llvm/docs/tutorial/BuildingAJIT2.rst

 constructor for this layer takes a reference to the execution session and the
 layer below (as all layers do) plus an *IR optimization function* that it will
 apply to each Module that is added via addModule:
 
 .. code-block:: c++
 
   class KaleidoscopeJIT {
   private:
-    ExecutionSession ES;
-    RTDyldObjectLinkingLayer ObjectLayer;
-    IRCompileLayer CompileLayer;
-    IRTransformLayer TransformLayer;
+    std::unique_ptr<ExecutionSession> ES;
 
     DataLayout DL;
     MangleAndInterner Mangle;
-    ThreadSafeContext Ctx;
+
+    RTDyldObjectLinkingLayer ObjectLayer;
+    IRCompileLayer CompileLayer;
+    IRTransformLayer OptimizeLayer;
+
+    JITDylib &MainJD;
 
   public:
 
-    KaleidoscopeJIT(JITTargetMachineBuilder JTMB, DataLayout DL)
-        : ObjectLayer(ES,
-                      []() { return std::make_unique<SectionMemoryManager>(); }),
-          CompileLayer(ES, ObjectLayer, ConcurrentIRCompiler(std::move(JTMB))),
-          TransformLayer(ES, CompileLayer, optimizeModule),
-          DL(std::move(DL)), Mangle(ES, this->DL),
-          Ctx(std::make_unique<LLVMContext>()) {
-      ES.getMainJITDylib().addGenerator(
-          cantFail(DynamicLibrarySearchGenerator::GetForCurrentProcess(DL.getGlobalPrefix())));
+    KaleidoscopeJIT(std::unique_ptr<ExecutionSession> ES,
+                    const JITTargetMachineBuilder &JTMB, DataLayout DL)
+      : ES(std::move(ES)), DL(std::move(DL)), Mangle(*this->ES, this->DL),
+      ObjectLayer(*this->ES,
+      CompileLayer(*this->ES, ObjectLayer,
+                   std::make_unique<ConcurrentIRCompiler>(JTMB)),
+      OptimizeLayer(*this->ES, CompileLayer, optimizeModule),
+      MainJD(this->ES->createBareJITDylib("<main>")) {
+        MainJD.addGenerator(
+          cantFail(DynamicLibrarySearchGenerator::GetForCurrentProcess(
+              DL.getGlobalPrefix())));
       }
 
 Our extended KaleidoscopeJIT class starts out the same as it did in Chapter 1,
 but after the CompileLayer we introduce a new member, TransformLayer, which sits
 on top of our CompileLayer. We initialize our OptimizeLayer with a reference to
 the ExecutionSession and output layer (standard practice for layers), along with
 a *transform function*. For our transform function we supply our classes
 optimizeModule static method.
 

llvm/examples/Kaleidoscope/BuildingAJIT/Chapter1/KaleidoscopeJIT.h

private:
 
   RTDyldObjectLinkingLayer ObjectLayer;
   IRCompileLayer CompileLayer;
 
   JITDylib &MainJD;
 
 public:
   KaleidoscopeJIT(std::unique_ptr<ExecutionSession> ES,
-                  JITTargetMachineBuilder JTMB, DataLayout DL)
+                  const JITTargetMachineBuilder &JTMB, DataLayout DL)
       : ES(std::move(ES)), DL(std::move(DL)), Mangle(*this->ES, this->DL),
         ObjectLayer(*this->ES,
                     []() { return std::make_unique<SectionMemoryManager>(); }),
         CompileLayer(*this->ES, ObjectLayer,
-                     std::make_unique<ConcurrentIRCompiler>(std::move(JTMB))),
+                     std::make_unique<ConcurrentIRCompiler>(JTMB)),
         MainJD(this->ES->createBareJITDylib("<main>")) {
     MainJD.addGenerator(
         cantFail(DynamicLibrarySearchGenerator::GetForCurrentProcess(
             DL.getGlobalPrefix())));
   }
 
   ~KaleidoscopeJIT() {
     if (auto Err = ES->endSession())
static Expected<std::unique_ptr<KaleidoscopeJIT>> Create() {
 
     JITTargetMachineBuilder JTMB(
         ES->getExecutorProcessControl().getTargetTriple());
 
     auto DL = JTMB.getDefaultDataLayoutForTarget();
     if (!DL)
       return DL.takeError();
 
-    return std::make_unique<KaleidoscopeJIT>(std::move(ES), std::move(JTMB),
+    return std::make_unique<KaleidoscopeJIT>(std::move(ES), JTMB,
                                              std::move(*DL));
   }
 
   const DataLayout &getDataLayout() const { return DL; }
 
   JITDylib &getMainJITDylib() { return MainJD; }
 
   Error addModule(ThreadSafeModule TSM, ResourceTrackerSP RT = nullptr) {

llvm/examples/Kaleidoscope/BuildingAJIT/Chapter2/KaleidoscopeJIT.h

private:
   RTDyldObjectLinkingLayer ObjectLayer;
   IRCompileLayer CompileLayer;
   IRTransformLayer OptimizeLayer;
 
   JITDylib &MainJD;
 
 public:
   KaleidoscopeJIT(std::unique_ptr<ExecutionSession> ES,
-                  JITTargetMachineBuilder JTMB, DataLayout DL)
+                  const JITTargetMachineBuilder &JTMB, DataLayout DL)
       : ES(std::move(ES)), DL(std::move(DL)), Mangle(*this->ES, this->DL),
         ObjectLayer(*this->ES,
                     []() { return std::make_unique<SectionMemoryManager>(); }),
         CompileLayer(*this->ES, ObjectLayer,
-                     std::make_unique<ConcurrentIRCompiler>(std::move(JTMB))),
+                     std::make_unique<ConcurrentIRCompiler>(JTMB)),
         OptimizeLayer(*this->ES, CompileLayer, optimizeModule),
         MainJD(this->ES->createBareJITDylib("<main>")) {
     MainJD.addGenerator(
         cantFail(DynamicLibrarySearchGenerator::GetForCurrentProcess(
             DL.getGlobalPrefix())));
   }
 
   ~KaleidoscopeJIT() {
static Expected<std::unique_ptr<KaleidoscopeJIT>> Create() {
 
     JITTargetMachineBuilder JTMB(
         ES->getExecutorProcessControl().getTargetTriple());
 
     auto DL = JTMB.getDefaultDataLayoutForTarget();
     if (!DL)
       return DL.takeError();
 
-    return std::make_unique<KaleidoscopeJIT>(std::move(ES), std::move(JTMB),
+    return std::make_unique<KaleidoscopeJIT>(std::move(ES), JTMB,
                                              std::move(*DL));
   }
 
   const DataLayout &getDataLayout() const { return DL; }
 
   JITDylib &getMainJITDylib() { return MainJD; }
 
   Error addModule(ThreadSafeModule TSM, ResourceTrackerSP RT = nullptr) {

llvm/examples/Kaleidoscope/BuildingAJIT/Chapter3/KaleidoscopeJIT.h

private:
   static void handleLazyCallThroughError() {
     errs() << "LazyCallThrough error: Could not find function body";
     exit(1);
   }
 
 public:
   KaleidoscopeJIT(std::unique_ptr<ExecutionSession> ES,
                   std::unique_ptr<EPCIndirectionUtils> EPCIU,
-                  JITTargetMachineBuilder JTMB, DataLayout DL)
+                  const JITTargetMachineBuilder &JTMB, DataLayout DL)
       : ES(std::move(ES)), EPCIU(std::move(EPCIU)), DL(std::move(DL)),
         Mangle(*this->ES, this->DL),
         ObjectLayer(*this->ES,
                     []() { return std::make_unique<SectionMemoryManager>(); }),
         CompileLayer(*this->ES, ObjectLayer,
-                     std::make_unique<ConcurrentIRCompiler>(std::move(JTMB))),
+                     std::make_unique<ConcurrentIRCompiler>(JTMB)),
         OptimizeLayer(*this->ES, CompileLayer, optimizeModule),
         CODLayer(*this->ES, OptimizeLayer,
                  this->EPCIU->getLazyCallThroughManager(),
                  [this] { return this->EPCIU->createIndirectStubsManager(); }),
         MainJD(this->ES->createBareJITDylib("<main>")) {
     MainJD.addGenerator(
         cantFail(DynamicLibrarySearchGenerator::GetForCurrentProcess(
             DL.getGlobalPrefix())));
static Expected<std::unique_ptr<KaleidoscopeJIT>> Create() {
     JITTargetMachineBuilder JTMB(
         ES->getExecutorProcessControl().getTargetTriple());
 
     auto DL = JTMB.getDefaultDataLayoutForTarget();
     if (!DL)
       return DL.takeError();
 
     return std::make_unique<KaleidoscopeJIT>(std::move(ES), std::move(*EPCIU),
-                                             std::move(JTMB), std::move(*DL));
+                                             JTMB, std::move(*DL));
   }
 
   const DataLayout &getDataLayout() const { return DL; }
 
   JITDylib &getMainJITDylib() { return MainJD; }
 
   Error addModule(ThreadSafeModule TSM, ResourceTrackerSP RT = nullptr) {
     if (!RT)

llvm/examples/Kaleidoscope/BuildingAJIT/Chapter4/KaleidoscopeJIT.h

private:
   static void handleLazyCallThroughError() {
     errs() << "LazyCallThrough error: Could not find function body";
     exit(1);
   }
 
 public:
   KaleidoscopeJIT(std::unique_ptr<ExecutionSession> ES,
                   std::unique_ptr<EPCIndirectionUtils> EPCIU,
-                  JITTargetMachineBuilder JTMB, DataLayout DL)
+                  const JITTargetMachineBuilder &JTMB, DataLayout DL)
       : ES(std::move(ES)), EPCIU(std::move(EPCIU)), DL(std::move(DL)),
         Mangle(*this->ES, this->DL),
         ObjectLayer(*this->ES,
                     []() { return std::make_unique<SectionMemoryManager>(); }),
         CompileLayer(*this->ES, ObjectLayer,
-                     std::make_unique<ConcurrentIRCompiler>(std::move(JTMB))),
+                     std::make_unique<ConcurrentIRCompiler>(JTMB)),
         OptimizeLayer(*this->ES, CompileLayer, optimizeModule),
         ASTLayer(OptimizeLayer, this->DL),
         MainJD(this->ES->createBareJITDylib("<main>")) {
     MainJD.addGenerator(
         cantFail(DynamicLibrarySearchGenerator::GetForCurrentProcess(
             DL.getGlobalPrefix())));
   }
 
static Expected<std::unique_ptr<KaleidoscopeJIT>> Create() {
     JITTargetMachineBuilder JTMB(
         ES->getExecutorProcessControl().getTargetTriple());
 
     auto DL = JTMB.getDefaultDataLayoutForTarget();
     if (!DL)
       return DL.takeError();
 
     return std::make_unique<KaleidoscopeJIT>(std::move(ES), std::move(*EPCIU),
-                                             std::move(JTMB), std::move(*DL));
+                                             JTMB, std::move(*DL));
   }
 
   const DataLayout &getDataLayout() const { return DL; }
 
   JITDylib &getMainJITDylib() { return MainJD; }
 
   Error addModule(ThreadSafeModule TSM, ResourceTrackerSP RT = nullptr) {
     if (!RT)

llvm/examples/Kaleidoscope/include/KaleidoscopeJIT.h

private:
 
   RTDyldObjectLinkingLayer ObjectLayer;
   IRCompileLayer CompileLayer;
 
   JITDylib &MainJD;
 
 public:
   KaleidoscopeJIT(std::unique_ptr<ExecutionSession> ES,
-                  JITTargetMachineBuilder JTMB, DataLayout DL)
+                  const JITTargetMachineBuilder &JTMB, DataLayout DL)
       : ES(std::move(ES)), DL(std::move(DL)), Mangle(*this->ES, this->DL),
         ObjectLayer(*this->ES,
                     []() { return std::make_unique<SectionMemoryManager>(); }),
         CompileLayer(*this->ES, ObjectLayer,
-                     std::make_unique<ConcurrentIRCompiler>(std::move(JTMB))),
+                     std::make_unique<ConcurrentIRCompiler>(JTMB)),
         MainJD(this->ES->createBareJITDylib("<main>")) {
     MainJD.addGenerator(
         cantFail(DynamicLibrarySearchGenerator::GetForCurrentProcess(
             DL.getGlobalPrefix())));
     if (JTMB.getTargetTriple().isOSBinFormatCOFF()) {
       ObjectLayer.setOverrideObjectFlagsWithResponsibilityFlags(true);
       ObjectLayer.setAutoClaimResponsibilityForObjectSymbols(true);
     }
static Expected<std::unique_ptr<KaleidoscopeJIT>> Create() {
 
     JITTargetMachineBuilder JTMB(
         ES->getExecutorProcessControl().getTargetTriple());
 
     auto DL = JTMB.getDefaultDataLayoutForTarget();
     if (!DL)
       return DL.takeError();
 
-    return std::make_unique<KaleidoscopeJIT>(std::move(ES), std::move(JTMB),
+    return std::make_unique<KaleidoscopeJIT>(std::move(ES), JTMB,
                                              std::move(*DL));
   }
 
   const DataLayout &getDataLayout() const { return DL; }
 
   JITDylib &getMainJITDylib() { return MainJD; }
 
   Error addModule(ThreadSafeModule TSM, ResourceTrackerSP RT = nullptr) {

llvm/examples/OrcV2Examples/LLJITWithCustomObjectLinkingLayer/LLJITWithCustomObjectLinkingLayer.cpp

int main(int argc, char *argv[]) {
 
   // Detect the host and set code model to small.
   auto JTMB = ExitOnErr(JITTargetMachineBuilder::detectHost());
   JTMB.setCodeModel(CodeModel::Small);
 
   // Create an LLJIT instance with an ObjectLinkingLayer as the base layer.
   auto J = ExitOnErr(
       LLJITBuilder()
-          .setJITTargetMachineBuilder(std::move(JTMB))
+          .setJITTargetMachineBuilder(JTMB)
           .setObjectLinkingLayerCreator(
               [&](ExecutionSession &ES, const Triple &TT) {
                 return std::make_unique<ObjectLinkingLayer>(
                     ES, ExitOnErr(jitlink::InProcessMemoryManager::Create()));
               })
           .create());
 
   auto M = ExitOnErr(parseExampleModule(Add1Example, "add1"));

llvm/examples/OrcV2Examples/LLJITWithGDBRegistrationListener/LLJITWithGDBRegistrationListener.cpp

int main(int argc, char *argv[]) {
   if (!JTMB.getTargetTriple().isOSLinux())
     errs()
         << "Warning: This demo may not work for platforms other than Linux.\n";
 
   // Create an LLJIT instance and use a custom object linking layer creator to
   // register the GDBRegistrationListener with our RTDyldObjectLinkingLayer.
   auto J =
       ExitOnErr(LLJITBuilder()
-                    .setJITTargetMachineBuilder(std::move(JTMB))
+                    .setJITTargetMachineBuilder(JTMB)
                     .setObjectLinkingLayerCreator([&](ExecutionSession &ES,
                                                       const Triple &TT) {
                       auto GetMemMgr = []() {
                         return std::make_unique<SectionMemoryManager>();
                       };
                       auto ObjLinkingLayer =
                           std::make_unique<RTDyldObjectLinkingLayer>(
                               ES, std::move(GetMemMgr));

llvm/examples/OrcV2Examples/LLJITWithObjectCache/LLJITWithObjectCache.cpp

 };
 
 void runJITWithCache(ObjectCache &ObjCache) {
 
   // Create an LLJIT instance with a custom IRCompiler.
   auto J = ExitOnErr(
       LLJITBuilder()
           .setCompileFunctionCreator(
-              [&](JITTargetMachineBuilder JTMB)
+              [&](JITTargetMachineBuilder &JTMB)
                   -> Expected<std::unique_ptr<IRCompileLayer::IRCompiler>> {
                 auto TM = JTMB.createTargetMachine();
                 if (!TM)
                   return TM.takeError();
                 return std::make_unique<TMOwningSimpleCompiler>(std::move(*TM),
                                                                 &ObjCache);
               })
           .create());

llvm/examples/OrcV2Examples/LLJITWithObjectLinkingLayerPlugin/LLJITWithObjectLinkingLayerPlugin.cpp

int main(int argc, char *argv[]) {
   auto JTMB = ExitOnErr(JITTargetMachineBuilder::detectHost());
   JTMB.setCodeModel(CodeModel::Small);
 
   // Create an LLJIT instance with an ObjectLinkingLayer as the base layer.
   // We attach our plugin in to the newly created ObjectLinkingLayer before
   // returning it.
   auto J = ExitOnErr(
       LLJITBuilder()
-          .setJITTargetMachineBuilder(std::move(JTMB))
+          .setJITTargetMachineBuilder(JTMB)
           .setObjectLinkingLayerCreator(
               [&](ExecutionSession &ES, const Triple &TT) {
                 // Create ObjectLinkingLayer.
                 auto ObjLinkingLayer = std::make_unique<ObjectLinkingLayer>(
                     ES, ExitOnErr(jitlink::InProcessMemoryManager::Create()));
                 // Add an instance of our plugin.
                 ObjLinkingLayer->addPlugin(std::make_unique<MyPlugin>());
                 return ObjLinkingLayer;

llvm/examples/OrcV2Examples/LLJITWithRemoteDebugging/LLJITWithRemoteDebugging.cpp

int main(int argc, char *argv[]) {
 
   // Create a target machine that matches the input triple.
   JITTargetMachineBuilder JTMB((Triple(TT)));
   JTMB.setCodeModel(CodeModel::Small);
   JTMB.setRelocationModel(Reloc::PIC_);
 
   // Create LLJIT and destroy it before disconnecting the target process.
   outs() << "Initializing LLJIT for remote executor\n";
-  auto J = ExitOnErr(LLJITBuilder()
-                          .setExecutorProcessControl(std::move(EPC))
-                          .setJITTargetMachineBuilder(std::move(JTMB))
-                          .setObjectLinkingLayerCreator([&](auto &ES, const auto &TT) {
-                            return std::make_unique<ObjectLinkingLayer>(ES);
-                          })
-                          .create());
+  auto J = ExitOnErr(
+      LLJITBuilder()
+          .setJITTargetMachineBuilder(JTMB)
 
   // Add plugin for debug support.
   ExitOnErr(addDebugSupport(J->getObjLinkingLayer()));
 
   // Load required shared libraries on the remote target and add a generator
   // for each of it, so the compiler can lookup their symbols.
   for (const std::string &Path : Dylibs)
     J->getMainJITDylib().addGenerator(

llvm/examples/SpeculativeJIT/SpeculativeJIT.cpp

static Expected<std::unique_ptr<SpeculativeJIT>> Create() {
 
     auto ProcessSymbolsSearchGenerator =
         DynamicLibrarySearchGenerator::GetForCurrentProcess(
             DL->getGlobalPrefix());
     if (!ProcessSymbolsSearchGenerator)
       return ProcessSymbolsSearchGenerator.takeError();
 
     std::unique_ptr<SpeculativeJIT> SJ(new SpeculativeJIT(
-        std::move(ES), std::move(*DL), std::move(*JTMB), std::move(*LCTMgr),
+        std::move(ES), std::move(*DL), *JTMB, std::move(*LCTMgr),
         std::move(ISMBuilder), std::move(*ProcessSymbolsSearchGenerator)));
     return std::move(SJ);
   }
 
   ExecutionSession &getES() { return *ES; }
 
   Error addModule(ThreadSafeModule TSM) {
     return CODLayer.add(MainJD, std::move(TSM));
private:
 
   static void explodeOnLazyCompileFailure() {
     errs() << "Lazy compilation failed, Symbol Implmentation not found!\n";
     exit(1);
   }
 
   SpeculativeJIT(
       std::unique_ptr<ExecutionSession> ES, DataLayout DL,
-      orc::JITTargetMachineBuilder JTMB,
+      const orc::JITTargetMachineBuilder &JTMB,
       std::unique_ptr<LazyCallThroughManager> LCTMgr,
       IndirectStubsManagerBuilderFunction ISMBuilder,
       std::unique_ptr<DynamicLibrarySearchGenerator> ProcessSymbolsGenerator)
       : ES(std::move(ES)), DL(std::move(DL)),
-        MainJD(this->ES->createBareJITDylib("<main>")), LCTMgr(std::move(LCTMgr)),
+        MainJD(this->ES->createBareJITDylib("<main>")),
+        LCTMgr(std::move(LCTMgr)),
         CompileLayer(*this->ES, ObjLayer,
-                     std::make_unique<ConcurrentIRCompiler>(std::move(JTMB))),
+                     std::make_unique<ConcurrentIRCompiler>(JTMB)),
         S(Imps, *this->ES),
         SpeculateLayer(*this->ES, CompileLayer, S, Mangle, BlockFreqQuery()),
         CODLayer(*this->ES, SpeculateLayer, *this->LCTMgr,
                  std::move(ISMBuilder)) {
     MainJD.addGenerator(std::move(ProcessSymbolsGenerator));
     this->CODLayer.setImplMap(&Imps);
     this->ES->setDispatchTask(
         [this](std::unique_ptr<Task> T) {

llvm/include/llvm/ExecutionEngine/Orc/CompileUtils.h

 };
 
 /// A thread-safe version of SimpleCompiler.
 ///
 /// This class creates a new TargetMachine and SimpleCompiler instance for each
 /// compile.
 class ConcurrentIRCompiler : public IRCompileLayer::IRCompiler {
 public:
-  ConcurrentIRCompiler(JITTargetMachineBuilder JTMB,
+  ConcurrentIRCompiler(const JITTargetMachineBuilder &JTMB,
                        ObjectCache *ObjCache = nullptr);
 
   void setObjectCache(ObjectCache *ObjCache) { this->ObjCache = ObjCache; }
 
   Expected<std::unique_ptr<MemoryBuffer>> operator()(Module &M) override;
 
 private:
   JITTargetMachineBuilder JTMB;
   ObjectCache *ObjCache = nullptr;
 };
 
 } // end namespace orc
 
 } // end namespace llvm
 
 #endif // LLVM_EXECUTIONENGINE_ORC_COMPILEUTILS_H

llvm/include/llvm/ExecutionEngine/Orc/LLJIT.h

SymbolStringPtr mangleAndIntern(StringRef UnmangledName) const {
     return ES->intern(mangle(UnmangledName));
   }
 
 protected:
   static Expected<std::unique_ptr<ObjectLayer>>
   createObjectLinkingLayer(LLJITBuilderState &S, ExecutionSession &ES);
 
   static Expected<std::unique_ptr<IRCompileLayer::IRCompiler>>
-  createCompileFunction(LLJITBuilderState &S, JITTargetMachineBuilder JTMB);
+  createCompileFunction(LLJITBuilderState &S, JITTargetMachineBuilder &JTMB);
 
   /// Create an LLJIT instance with a single compile thread.
   LLJIT(LLJITBuilderState &S, Error &Err);
 
   Error applyDataLayout(Module &M);
 
   void recordCtorDtors(Module &M);
 

 class LLJITBuilderState {
 public:
   using ObjectLinkingLayerCreator =
       std::function<Expected<std::unique_ptr<ObjectLayer>>(ExecutionSession &,
                                                            const Triple &)>;
 
   using CompileFunctionCreator =
       std::function<Expected<std::unique_ptr<IRCompileLayer::IRCompiler>>(
-          JITTargetMachineBuilder JTMB)>;
+          JITTargetMachineBuilder &JTMB)>;
 
   using PlatformSetupFunction = std::function<Error(LLJIT &J)>;
 
   std::unique_ptr<ExecutorProcessControl> EPC;
   std::unique_ptr<ExecutionSession> ES;
   std::optional<JITTargetMachineBuilder> JTMB;
   std::optional<DataLayout> DL;
   ObjectLinkingLayerCreator CreateObjectLinkingLayer;
SetterImpl &setExecutionSession(std::unique_ptr<ExecutionSession> ES) {
     impl().ES = std::move(ES);
     return impl();
   }
 
   /// Set the JITTargetMachineBuilder for this instance.
   ///
   /// If this method is not called, JITTargetMachineBuilder::detectHost will be
   /// used to construct a default target machine builder for the host platform.
-  SetterImpl &setJITTargetMachineBuilder(JITTargetMachineBuilder JTMB) {
-    impl().JTMB = std::move(JTMB);
+  SetterImpl &setJITTargetMachineBuilder(const JITTargetMachineBuilder &JTMB) {
+    impl().JTMB = JTMB;
     return impl();
   }
 
   /// Return a reference to the JITTargetMachineBuilder.
   ///
   std::optional<JITTargetMachineBuilder> &getJITTargetMachineBuilder() {
     return impl().JTMB;
   }

llvm/lib/ExecutionEngine/Orc/CompileUtils.cpp

 }
 
 void SimpleCompiler::notifyObjectCompiled(const Module &M,
                                           const MemoryBuffer &ObjBuffer) {
   if (ObjCache)
     ObjCache->notifyObjectCompiled(&M, ObjBuffer.getMemBufferRef());
 }
 
-ConcurrentIRCompiler::ConcurrentIRCompiler(JITTargetMachineBuilder JTMB,
+ConcurrentIRCompiler::ConcurrentIRCompiler(const JITTargetMachineBuilder &JTMB,
                                            ObjectCache *ObjCache)
     : IRCompiler(irManglingOptionsFromTargetOptions(JTMB.getOptions())),
-      JTMB(std::move(JTMB)), ObjCache(ObjCache) {}
+      JTMB(JTMB), ObjCache(ObjCache) {}
 
 Expected<std::unique_ptr<MemoryBuffer>>
 ConcurrentIRCompiler::operator()(Module &M) {
   auto TM = cantFail(JTMB.createTargetMachine());
   SimpleCompiler C(*TM, ObjCache);
   return C(M);
 }
 
 } // end namespace orc
 } // end namespace llvm

llvm/lib/ExecutionEngine/Orc/LLJIT.cpp

LLJIT::createObjectLinkingLayer(LLJITBuilderState &S, ExecutionSession &ES) {
   // FIXME: Explicit conversion to std::unique_ptr<ObjectLayer> added to silence
   //        errors from some GCC / libstdc++ bots. Remove this conversion (i.e.
   //        just return ObjLinkingLayer) once those bots are upgraded.
   return std::unique_ptr<ObjectLayer>(std::move(Layer));
 }
 
 Expected<std::unique_ptr<IRCompileLayer::IRCompiler>>
 LLJIT::createCompileFunction(LLJITBuilderState &S,
-                             JITTargetMachineBuilder JTMB) {
+                             JITTargetMachineBuilder &JTMB) {
 
   /// If there is a custom compile function creator set then use it.
   if (S.CreateCompileFunction)
-    return S.CreateCompileFunction(std::move(JTMB));
+    return S.CreateCompileFunction(JTMB);
 
   // Otherwise default to creating a SimpleCompiler, or ConcurrentIRCompiler,
   // depending on the number of threads requested.
   if (S.NumCompileThreads > 0)
-    return std::make_unique<ConcurrentIRCompiler>(std::move(JTMB));
+    return std::make_unique<ConcurrentIRCompiler>(JTMB);
 
   auto TM = JTMB.createTargetMachine();
   if (!TM)
     return TM.takeError();
 
   return std::make_unique<TMOwningSimpleCompiler>(std::move(*TM));
 }
 
if (!ObjLayer) {
     Err = ObjLayer.takeError();
     return;
   }
   ObjLinkingLayer = std::move(*ObjLayer);
   ObjTransformLayer =
       std::make_unique<ObjectTransformLayer>(*ES, *ObjLinkingLayer);
 
   {
-    auto CompileFunction = createCompileFunction(S, std::move(*S.JTMB));
+    auto CompileFunction = createCompileFunction(S, *S.JTMB);
     if (!CompileFunction) {
       Err = CompileFunction.takeError();
       return;
     }
     CompileLayer = std::make_unique<IRCompileLayer>(
         *ES, *ObjTransformLayer, std::move(*CompileFunction));
     TransformLayer = std::make_unique<IRTransformLayer>(*ES, *CompileLayer);
     InitHelperTransformLayer =

llvm/lib/ExecutionEngine/Orc/OrcV2CBindings.cpp

 }
 
 void LLVMOrcDisposeLLJITBuilder(LLVMOrcLLJITBuilderRef Builder) {
   delete unwrap(Builder);
 }
 
 void LLVMOrcLLJITBuilderSetJITTargetMachineBuilder(
     LLVMOrcLLJITBuilderRef Builder, LLVMOrcJITTargetMachineBuilderRef JTMB) {
-  unwrap(Builder)->setJITTargetMachineBuilder(std::move(*unwrap(JTMB)));
+  unwrap(Builder)->setJITTargetMachineBuilder(*unwrap(JTMB));
   LLVMOrcDisposeJITTargetMachineBuilder(JTMB);
 }
 
 void LLVMOrcLLJITBuilderSetObjectLinkingLayerCreator(
     LLVMOrcLLJITBuilderRef Builder,
     LLVMOrcLLJITBuilderObjectLinkingLayerCreatorFunction F, void *Ctx) {
   unwrap(Builder)->setObjectLinkingLayerCreator(
       [=](ExecutionSession &ES, const Triple &TT) {

llvm/tools/lli/lli.cpp

int runOrcJIT(const char *ProgName) {
   // If the object cache is enabled then set a custom compile function
   // creator to use the cache.
   std::unique_ptr<LLIObjectCache> CacheManager;
   if (EnableCacheManager) {
 
     CacheManager = std::make_unique<LLIObjectCache>(ObjectCacheDir);
 
     Builder.setCompileFunctionCreator(
-      [&](orc::JITTargetMachineBuilder JTMB)
+        [&](orc::JITTargetMachineBuilder &JTMB)
             -> Expected<std::unique_ptr<orc::IRCompileLayer::IRCompiler>> {
           if (LazyJITCompileThreads > 0)
-          return std::make_unique<orc::ConcurrentIRCompiler>(std::move(JTMB),
-                                                        CacheManager.get());
+            return std::make_unique<orc::ConcurrentIRCompiler>(
+                JTMB, CacheManager.get());
 
           auto TM = JTMB.createTargetMachine();
           if (!TM)
             return TM.takeError();
 
-        return std::make_unique<orc::TMOwningSimpleCompiler>(std::move(*TM),
-                                                        CacheManager.get());
+          return std::make_unique<orc::TMOwningSimpleCompiler>(
+              std::move(*TM), CacheManager.get());
         });
   }
 
   // Set up LLJIT platform.
   LLJITPlatform P = Platform;
   if (P == LLJITPlatform::DetectHost) {
     if (JITLinker == JITLinkerKind::JITLink && !OrcRuntime.empty() &&
         (TT->isOSBinFormatMachO() || TT->isOSBinFormatELF()))
       P = LLJITPlatform::ORC;