[Orc] Allow LLJITBuilder's CreateObjectLinkingLayer to return errors

[sgraenitz]

Summary

It can be useful for an ObjectLinkingLayerCreator to allow callee errors to get propagated to the builder. Specifically, this is the case when the ObjectLayer uses the EHFrameRegistrationPlugin, because it requires a TPCEHFrameRegistrar and instantiation for it may fail (e.g. if the required registration symbols are missing in the target process).

[lhames]

llvm/examples/OrcV2Examples/LLJITWithCustomObjectLinkingLayer/LLJITWithCustomObjectLinkingLayer.cpp

48

Rather than pass an Error by reference here, could you change ObjectLinkingLayerCreator's signature to return an Expected<std::unique_ptr<ObjectLayer>> ?

[sgraenitz]

llvm/examples/OrcV2Examples/LLJITWithCustomObjectLinkingLayer/LLJITWithCustomObjectLinkingLayer.cpp

48

Yes good point. I will make an update.

[sgraenitz]

Drop the Error output parameter and return an Expected instead

[lhames]

Great. Thanks very much Stefan!

llvm/examples/OrcV2Examples/LLJITWithCustomObjectLinkingLayer/LLJITWithCustomObjectLinkingLayer.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.
   auto J = ExitOnErr(
       LLJITBuilder()
           .setJITTargetMachineBuilder(std::move(JTMB))
           .setObjectLinkingLayerCreator(
-              [&](ExecutionSession &ES, const Triple &TT) {
+              [&](ExecutionSession &ES, const Triple &TT, Error &Err) {
                 return std::make_unique<ObjectLinkingLayer>(
                     ES, std::make_unique<jitlink::InProcessMemoryManager>());
               })
           .create());
 
   auto M = ExitOnErr(parseExampleModule(Add1Example, "add1"));
 
   ExitOnErr(J->addIRModule(std::move(M)));

llvm/examples/OrcV2Examples/LLJITWithGDBRegistrationListener/LLJITWithGDBRegistrationListener.cpp

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))
                     .setObjectLinkingLayerCreator([&](ExecutionSession &ES,
-                                                      const Triple &TT) {
+                                                      const Triple &TT,
+                                                      Error &Err) {
                       auto GetMemMgr = []() {
                         return std::make_unique<SectionMemoryManager>();
                       };
                       auto ObjLinkingLayer =
                           std::make_unique<RTDyldObjectLinkingLayer>(
                               ES, std::move(GetMemMgr));
 
                       // Register the event listener.

llvm/examples/OrcV2Examples/LLJITWithObjectLinkingLayerPlugin/LLJITWithObjectLinkingLayerPlugin.cpp

int main(int argc, char *argv[]) {
 
   // 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))
           .setObjectLinkingLayerCreator(
-              [&](ExecutionSession &ES, const Triple &TT) {
+              [&](ExecutionSession &ES, const Triple &TT, Error &Err) {
                 // Create ObjectLinkingLayer.
                 auto ObjLinkingLayer = std::make_unique<ObjectLinkingLayer>(
                     ES, std::make_unique<jitlink::InProcessMemoryManager>());
                 // Add an instance of our plugin.
                 ObjLinkingLayer->addPlugin(std::make_unique<MyPlugin>());
                 return ObjLinkingLayer;
               })
           .create());

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

public:
   std::string mangle(StringRef UnmangledName) const;
 
   /// Returns an interned, linker-mangled version of UnmangledName.
   SymbolStringPtr mangleAndIntern(StringRef UnmangledName) const {
     return ES->intern(mangle(UnmangledName));
   }
 
 protected:
-  static std::unique_ptr<ObjectLayer>
+  static Expected<std::unique_ptr<ObjectLayer>>
   createObjectLinkingLayer(LLJITBuilderState &S, ExecutionSession &ES);
 
   static Expected<std::unique_ptr<IRCompileLayer::IRCompiler>>
   createCompileFunction(LLJITBuilderState &S, JITTargetMachineBuilder JTMB);
 
   /// Create an LLJIT instance with a single compile thread.
   LLJIT(LLJITBuilderState &S, Error &Err);
 
private:
 
   std::unique_ptr<LazyCallThroughManager> LCTMgr;
   std::unique_ptr<CompileOnDemandLayer> CODLayer;
 };
 
 class LLJITBuilderState {
 public:
   using ObjectLinkingLayerCreator = std::function<std::unique_ptr<ObjectLayer>(
-      ExecutionSession &, const Triple &TT)>;
+      ExecutionSession &, const Triple &, Error &)>;
 
   using CompileFunctionCreator =
       std::function<Expected<std::unique_ptr<IRCompileLayer::IRCompiler>>(
           JITTargetMachineBuilder JTMB)>;
 
   using PlatformSetupFunction = std::function<Error(LLJIT &J)>;
 
   std::unique_ptr<ExecutionSession> ES;

llvm/lib/ExecutionEngine/Orc/LLJIT.cpp

Error LLJITBuilderState::prepareForConstruction() {
   if (!CreateObjectLinkingLayer) {
     auto &TT = JTMB->getTargetTriple();
     if (TT.isOSBinFormatMachO() &&
         (TT.getArch() == Triple::aarch64 || TT.getArch() == Triple::x86_64)) {
 
       JTMB->setRelocationModel(Reloc::PIC_);
       JTMB->setCodeModel(CodeModel::Small);
       CreateObjectLinkingLayer =
-          [TPC = this->TPC](ExecutionSession &ES,
-                            const Triple &) -> std::unique_ptr<ObjectLayer> {
+          [TPC = this->TPC](ExecutionSession &ES, const Triple &,
+                            Error &Err) -> std::unique_ptr<ObjectLayer> {
         std::unique_ptr<ObjectLinkingLayer> ObjLinkingLayer;
         if (TPC)
           ObjLinkingLayer =
               std::make_unique<ObjectLinkingLayer>(ES, TPC->getMemMgr());
         else
           ObjLinkingLayer = std::make_unique<ObjectLinkingLayer>(
               ES, std::make_unique<jitlink::InProcessMemoryManager>());
         ObjLinkingLayer->addPlugin(std::make_unique<EHFrameRegistrationPlugin>(

 }
 
 Expected<JITEvaluatedSymbol> LLJIT::lookupLinkerMangled(JITDylib &JD,
                                                         SymbolStringPtr Name) {
   return ES->lookup(
       makeJITDylibSearchOrder(&JD, JITDylibLookupFlags::MatchAllSymbols), Name);
 }
 
-std::unique_ptr<ObjectLayer>
+Expected<std::unique_ptr<ObjectLayer>>
 LLJIT::createObjectLinkingLayer(LLJITBuilderState &S, ExecutionSession &ES) {
 
   // If the config state provided an ObjectLinkingLayer factory then use it.
-  if (S.CreateObjectLinkingLayer)
-    return S.CreateObjectLinkingLayer(ES, S.JTMB->getTargetTriple());
+  if (S.CreateObjectLinkingLayer) {
+    Error Err = Error::success();
+    std::unique_ptr<ObjectLayer> ObjLayer =
+        S.CreateObjectLinkingLayer(ES, S.JTMB->getTargetTriple(), Err);
+    if (Err)
+      return std::move(Err);
+    return std::move(ObjLayer);
+  }
 
   // Otherwise default to creating an RTDyldObjectLinkingLayer that constructs
   // a new SectionMemoryManager for each object.
   auto GetMemMgr = []() { return std::make_unique<SectionMemoryManager>(); };
   auto ObjLinkingLayer =
       std::make_unique<RTDyldObjectLinkingLayer>(ES, std::move(GetMemMgr));
 
   if (S.JTMB->getTargetTriple().isOSBinFormatCOFF()) {
LLJIT::createCompileFunction(LLJITBuilderState &S,
   if (!TM)
     return TM.takeError();
 
   return std::make_unique<TMOwningSimpleCompiler>(std::move(*TM));
 }
 
 LLJIT::LLJIT(LLJITBuilderState &S, Error &Err)
     : ES(S.ES ? std::move(S.ES) : std::make_unique<ExecutionSession>()), Main(),
-      DL(""), TT(S.JTMB->getTargetTriple()),
-      ObjLinkingLayer(createObjectLinkingLayer(S, *ES)) {
+      DL(""), TT(S.JTMB->getTargetTriple()) {
 
   ErrorAsOutParameter _(&Err);
 
   if (auto MainOrErr = this->ES->createJITDylib("main"))
     Main = &*MainOrErr;
   else {
     Err = MainOrErr.takeError();
     return;
   }
 
   if (S.DL)
     DL = std::move(*S.DL);
   else if (auto DLOrErr = S.JTMB->getDefaultDataLayoutForTarget())
     DL = std::move(*DLOrErr);
   else {
     Err = DLOrErr.takeError();
     return;
   }
 
+  auto ObjLayer = createObjectLinkingLayer(S, *ES);
+  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));
     if (!CompileFunction) {
       Err = CompileFunction.takeError();
       return;

llvm/lib/ExecutionEngine/Orc/OrcV2CBindings.cpp

void LLVMOrcLLJITBuilderSetJITTargetMachineBuilder(
     LLVMOrcLLJITBuilderRef Builder, LLVMOrcJITTargetMachineBuilderRef JTMB) {
   unwrap(Builder)->setJITTargetMachineBuilder(*unwrap(JTMB));
 }
 
 void LLVMOrcLLJITBuilderSetObjectLinkingLayerCreator(
     LLVMOrcLLJITBuilderRef Builder,
     LLVMOrcLLJITBuilderObjectLinkingLayerCreatorFunction F, void *Ctx) {
   unwrap(Builder)->setObjectLinkingLayerCreator(
-      [=](ExecutionSession &ES, const Triple &TT) {
+      [=](ExecutionSession &ES, const Triple &TT, Error &Err) {
         auto TTStr = TT.str();
         return std::unique_ptr<ObjectLayer>(
             unwrap(F(Ctx, wrap(&ES), TTStr.c_str())));
       });
 }
 
 LLVMErrorRef LLVMOrcCreateLLJIT(LLVMOrcLLJITRef *Result,
                                 LLVMOrcLLJITBuilderRef Builder) {