[ORC] Fix in-process lookup of symbols without GlobalPrefix

[Hahnfeld]

Summary

On Windows, C++ symbols are prefixed not with the "global" prefix, but with a question mark. Their symbol names must be processed without stripping the first character.

[lhames]

This change won't work for other platforms at the moment. E.g. On Darwin where the global prefix is _ an ORC lookup (which uses mangled names) for [ "foo", "_foo" ] should return [ nullptr, <addr of _foo> ], but with this patch it will return [ <addr of foo>, <addr of foo> ].

GlobalPrefix was always a bit of a hack -- I think we want to make this a generalized demangle function that returns a std::optional<std::string>, then we can write:

for (auto &KV : Symbols) {
  auto &Name = KV.first;

  if ((*Name).empty())
    continue;

  if (Allow && !Allow(Name))
    continue;

  auto DemangledName = Demangle(Name);
  if (!DemangledName)
    continue;

  if (void *Addr = Dylib.getAddressOfSymbol(DemangledName->c_str())) {
    NewSymbols[Name] = JITEvaluatedSymbol(
        static_cast<JITTargetAddress>(reinterpret_cast<uintptr_t>(Addr)),
        JITSymbolFlags::Exported);
  }
}

On windows the demangler can conditionally drop the ?, and on Darwin it can require the _ prefix (returning std::noneopt` when it's not present.

[Hahnfeld]

Only allow leading question mark without GlobalPrefix according to DataLayout.

[Hahnfeld]

In D142188#4074287, @lhames wrote:

This change won't work for other platforms at the moment. E.g. On Darwin where the global prefix is _ an ORC lookup (which uses mangled names) for [ "foo", "_foo" ] should return [ nullptr, <addr of _foo> ], but with this patch it will return [ <addr of foo>, <addr of foo> ].

Sure, but is this actually relevant? Passing foo is not properly mangled and an error on the client side. *If* it is required to make this robust against all possible edge cases, we have to make fairly intrusive changes as shown in the last update to pass DataLayout::doNotMangleLeadingQuestionMark() to DynamicLibrarySearchGenerator (or require a DataLayout in the first place, but that's a bigger restriction IMO).

[lhames]

In D142188#4076374, @Hahnfeld wrote:

Sure, but is this actually relevant? Passing foo is not properly mangled and an error on the client side.

It's not an error: ORC lookups are always made in terms of raw symbol names (which we often refer to as "linker mangled"). The impedance mismatch in DynamicLibrarySearchGenerator comes from the fact that dlsym does not work with raw names, it works with C names, which will have been mangled with a leading underscore.

As an example, consider a JIT'd program consisting of two JITDylibs. JITDylib A contains an object built from assembly containing the label "foo" (no underscore, which is legal -- this isn't a C symbol). JITDylib B contains a DynamicLibraryDefinitionGenerator pointing at an on-disk libB.dylib which contains an _foo (presumably defined in C). A lookup with search order [ A, B ] for symbols [ "foo", "_foo" ] should find a result for "foo" from JITDylib A, and "_foo" from JITDylib B (where the result will have come from demangling "_foo" to "foo", then calling dlsym).

*If* it is required to make this robust against all possible edge cases, we have to make fairly intrusive changes as shown in the last update to pass DataLayout::doNotMangleLeadingQuestionMark() to DynamicLibrarySearchGenerator (or require a DataLayout in the first place, but that's a bigger restriction IMO).

As mentione, a good option for now would be to replace GlobalPrefix with a unique_function that takes a SymbolStringPtr and produces an optionally demangled string suitable for the platform's dynamic-symbol-lookup API.

Alternatively, maybe it's time to just add a DataLayout (or global default mangling and demangling functions) to ExecutionSession and let everybody reference that.

[Hahnfeld]

Ok, understood. I think this should already be taken care of by the last update from Tuesday.

In D142188#4077734, @lhames wrote:

As mentione, a good option for now would be to replace GlobalPrefix with a unique_function that takes a SymbolStringPtr and produces an optionally demangled string suitable for the platform's dynamic-symbol-lookup API.

I don't like this, we don't want every user of DynamicLibrarySearchGenerator to write their own demangler.

Alternatively, maybe it's time to just add a DataLayout (or global default mangling and demangling functions) to ExecutionSession and let everybody reference that.

We could, but it seems to work fine with an additional bool. Alternatively, we could just always treat '?' special at the beginning. Let me know.

clang/lib/Interpreter/IncrementalExecutor.cpp

IncrementalExecutor::IncrementalExecutor(llvm::orc::ThreadSafeContext &TSC,
   if (auto JitOrErr = LLJITBuilder().setJITTargetMachineBuilder(JTMB).create())
     Jit = std::move(*JitOrErr);
   else {
     Err = JitOrErr.takeError();
     return;
   }
 
   const char Pref = Jit->getDataLayout().getGlobalPrefix();
+  const bool DoNotMangleLeadingQuestionMark =
+      Jit->getDataLayout().doNotMangleLeadingQuestionMark();
   // Discover symbols from the process as a fallback.
-  if (auto PSGOrErr = DynamicLibrarySearchGenerator::GetForCurrentProcess(Pref))
+  if (auto PSGOrErr = DynamicLibrarySearchGenerator::GetForCurrentProcess(
+          Pref, DoNotMangleLeadingQuestionMark))
     Jit->getMainJITDylib().addGenerator(std::move(*PSGOrErr));
   else {
     Err = PSGOrErr.takeError();
     return;
   }
 }
 
 IncrementalExecutor::~IncrementalExecutor() {}

llvm/docs/ORCv2.rst

.. code-block:: c++
     DenseSet<SymbolStringPtr> AllowList({
         Mangle("puts"),
         Mangle("gets")
       });
 
     // Use GetForCurrentProcess with a predicate function that checks the
     // allowed list.
     JD.addGenerator(cantFail(DynamicLibrarySearchGenerator::GetForCurrentProcess(
-          DL.getGlobalPrefix(),
+          DL.getGlobalPrefix(), DL.doNotMangleLeadingQuestionMark(),
           [&](const SymbolStringPtr &S) { return AllowList.count(S); })));
 
     // IR added to JD can now link against any symbols exported by the process
     // and contained in the list.
     CompileLayer.add(JD, loadModule(...));
 
 References to process or library symbols could also be hardcoded into your IR
 or object files using the symbols' raw addresses, however symbolic resolution

llvm/docs/tutorial/BuildingAJIT1.rst

.. code-block:: c++
   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())));
+          cantFail(DynamicLibrarySearchGenerator::GetForCurrentProcess(
+              DL.getGlobalPrefix(), DL.doNotMangleLeadingQuestionMark())));
     }
 
 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

llvm/docs/tutorial/BuildingAJIT2.rst

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())));
+          cantFail(DynamicLibrarySearchGenerator::GetForCurrentProcess(
+              DL.getGlobalPrefix(), DL.doNotMangleLeadingQuestionMark())));
     }
 
 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

KaleidoscopeJIT(std::unique_ptr<ExecutionSession> ES,
       : 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))),
         MainJD(this->ES->createBareJITDylib("<main>")) {
     MainJD.addGenerator(
         cantFail(DynamicLibrarySearchGenerator::GetForCurrentProcess(
-            DL.getGlobalPrefix())));
+            DL.getGlobalPrefix(), DL.doNotMangleLeadingQuestionMark())));
   }
 
   ~KaleidoscopeJIT() {
     if (auto Err = ES->endSession())
       ES->reportError(std::move(Err));
   }
 
   static Expected<std::unique_ptr<KaleidoscopeJIT>> Create() {

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

KaleidoscopeJIT(std::unique_ptr<ExecutionSession> ES,
         ObjectLayer(*this->ES,
                     []() { return std::make_unique<SectionMemoryManager>(); }),
         CompileLayer(*this->ES, ObjectLayer,
                      std::make_unique<ConcurrentIRCompiler>(std::move(JTMB))),
         OptimizeLayer(*this->ES, CompileLayer, optimizeModule),
         MainJD(this->ES->createBareJITDylib("<main>")) {
     MainJD.addGenerator(
         cantFail(DynamicLibrarySearchGenerator::GetForCurrentProcess(
-            DL.getGlobalPrefix())));
+            DL.getGlobalPrefix(), DL.doNotMangleLeadingQuestionMark())));
   }
 
   ~KaleidoscopeJIT() {
     if (auto Err = ES->endSession())
       ES->reportError(std::move(Err));
   }
 
   static Expected<std::unique_ptr<KaleidoscopeJIT>> Create() {

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

KaleidoscopeJIT(std::unique_ptr<ExecutionSession> ES,
                      std::make_unique<ConcurrentIRCompiler>(std::move(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())));
+            DL.getGlobalPrefix(), DL.doNotMangleLeadingQuestionMark())));
   }
 
   ~KaleidoscopeJIT() {
     if (auto Err = ES->endSession())
       ES->reportError(std::move(Err));
     if (auto Err = EPCIU->cleanup())
       ES->reportError(std::move(Err));
   }

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

KaleidoscopeJIT(std::unique_ptr<ExecutionSession> ES,
                     []() { return std::make_unique<SectionMemoryManager>(); }),
         CompileLayer(*this->ES, ObjectLayer,
                      std::make_unique<ConcurrentIRCompiler>(std::move(JTMB))),
         OptimizeLayer(*this->ES, CompileLayer, optimizeModule),
         ASTLayer(OptimizeLayer, this->DL),
         MainJD(this->ES->createBareJITDylib("<main>")) {
     MainJD.addGenerator(
         cantFail(DynamicLibrarySearchGenerator::GetForCurrentProcess(
-            DL.getGlobalPrefix())));
+            DL.getGlobalPrefix(), DL.doNotMangleLeadingQuestionMark())));
   }
 
   ~KaleidoscopeJIT() {
     if (auto Err = ES->endSession())
       ES->reportError(std::move(Err));
     if (auto Err = EPCIU->cleanup())
       ES->reportError(std::move(Err));
   }

llvm/examples/Kaleidoscope/include/KaleidoscopeJIT.h

KaleidoscopeJIT(std::unique_ptr<ExecutionSession> ES,
       : 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))),
         MainJD(this->ES->createBareJITDylib("<main>")) {
     MainJD.addGenerator(
         cantFail(DynamicLibrarySearchGenerator::GetForCurrentProcess(
-            DL.getGlobalPrefix())));
+            DL.getGlobalPrefix(), DL.doNotMangleLeadingQuestionMark())));
     if (JTMB.getTargetTriple().isOSBinFormatCOFF()) {
       ObjectLayer.setOverrideObjectFlagsWithResponsibilityFlags(true);
       ObjectLayer.setAutoClaimResponsibilityForObjectSymbols(true);
     }
   }
 
   ~KaleidoscopeJIT() {
     if (auto Err = ES->endSession())

llvm/examples/OrcV2Examples/LLJITWithGDBRegistrationListener/LLJITWithGDBRegistrationListener.cpp

auto J =
                     .create());
 
   // Make sure that our process symbols are visible to JIT'd code.
   {
     MangleAndInterner Mangle(J->getExecutionSession(), J->getDataLayout());
     J->getMainJITDylib().addGenerator(
         ExitOnErr(orc::DynamicLibrarySearchGenerator::GetForCurrentProcess(
             J->getDataLayout().getGlobalPrefix(),
+            J->getDataLayout().doNotMangleLeadingQuestionMark(),
             [MainName = Mangle("main")](const orc::SymbolStringPtr &Name) {
               return Name != MainName;
             })));
   }
 
   // Load the input modules.
   for (auto &InputFile : InputFiles) {
     auto Ctx = std::make_unique<LLVMContext>();

llvm/examples/OrcV2Examples/LLJITWithObjectLinkingLayerPlugin/LLJITWithObjectLinkingLayerPlugin.cpp

auto J = ExitOnErr(
           .create());
 
   if (!InputObjects.empty()) {
 
     // If we have input objects then reflect process symbols so the input
     // objects can do interesting things, like call printf.
     J->getMainJITDylib().addGenerator(
         ExitOnErr(DynamicLibrarySearchGenerator::GetForCurrentProcess(
-            J->getDataLayout().getGlobalPrefix())));
+            J->getDataLayout().getGlobalPrefix(),
+            J->getDataLayout().doNotMangleLeadingQuestionMark())));
 
     // Load the input objects.
     for (auto InputObject : InputObjects) {
       auto ObjBuffer =
           ExitOnErr(errorOrToExpected(MemoryBuffer::getFile(InputObject)));
       ExitOnErr(J->addObjectFile(std::move(ObjBuffer)));
     }
   } else {

llvm/examples/SpeculativeJIT/SpeculativeJIT.cpp

static Expected<std::unique_ptr<SpeculativeJIT>> Create() {
     auto ISMBuilder =
         createLocalIndirectStubsManagerBuilder(JTMB->getTargetTriple());
     if (!ISMBuilder)
       return make_error<StringError>("No indirect stubs manager for target",
                                      inconvertibleErrorCode());
 
     auto ProcessSymbolsSearchGenerator =
         DynamicLibrarySearchGenerator::GetForCurrentProcess(
-            DL->getGlobalPrefix());
+            DL->getGlobalPrefix(), DL->doNotMangleLeadingQuestionMark());
     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(ISMBuilder), std::move(*ProcessSymbolsSearchGenerator)));
     return std::move(SJ);
   }

llvm/include/llvm/ExecutionEngine/Orc/ExecutionUtils.h

public:
 
   /// Create a DynamicLibrarySearchGenerator that searches for symbols in the
   /// given sys::DynamicLibrary.
   ///
   /// If the Allow predicate is given then only symbols matching the predicate
   /// will be searched for. If the predicate is not given then all symbols will
   /// be searched for.
   DynamicLibrarySearchGenerator(sys::DynamicLibrary Dylib, char GlobalPrefix,
+                                bool DoNotMangleLeadingQuestionMark = false,
                                 SymbolPredicate Allow = SymbolPredicate());
 
   /// Permanently loads the library at the given path and, on success, returns
   /// a DynamicLibrarySearchGenerator that will search it for symbol definitions
   /// in the library. On failure returns the reason the library failed to load.
   static Expected<std::unique_ptr<DynamicLibrarySearchGenerator>>
   Load(const char *FileName, char GlobalPrefix,
+       bool DoNotMangleLeadingQuestionMark = false,
        SymbolPredicate Allow = SymbolPredicate());
 
   /// Creates a DynamicLibrarySearchGenerator that searches for symbols in
   /// the current process.
   static Expected<std::unique_ptr<DynamicLibrarySearchGenerator>>
   GetForCurrentProcess(char GlobalPrefix,
+                       bool DoNotMangleLeadingQuestionMark = false,
                        SymbolPredicate Allow = SymbolPredicate()) {
-    return Load(nullptr, GlobalPrefix, std::move(Allow));
+    return Load(nullptr, GlobalPrefix, DoNotMangleLeadingQuestionMark,
+                std::move(Allow));
   }
 
   Error tryToGenerate(LookupState &LS, LookupKind K, JITDylib &JD,
                       JITDylibLookupFlags JDLookupFlags,
                       const SymbolLookupSet &Symbols) override;
 
 private:
   sys::DynamicLibrary Dylib;
   SymbolPredicate Allow;
   char GlobalPrefix;
+  bool DoNotMangleLeadingQuestionMark;
 };
 
 /// A utility class to expose symbols from a static library.
 ///
 /// If an instance of this class is attached to a JITDylib as a fallback
 /// definition generator, then any symbol found in the archive will result in
 /// the containing object being added to the JITDylib.
 class StaticLibraryDefinitionGenerator : public DefinitionGenerator {

llvm/lib/ExecutionEngine/Orc/ExecutionUtils.cpp

void ItaniumCXAAtExitSupport::runAtExits(void *DSOHandle) {
 
   while (!AtExitsToRun.empty()) {
     AtExitsToRun.back().F(AtExitsToRun.back().Ctx);
     AtExitsToRun.pop_back();
   }
 }
 
 DynamicLibrarySearchGenerator::DynamicLibrarySearchGenerator(
-    sys::DynamicLibrary Dylib, char GlobalPrefix, SymbolPredicate Allow)
+    sys::DynamicLibrary Dylib, char GlobalPrefix,
+    bool DoNotMangleLeadingQuestionMark, SymbolPredicate Allow)
     : Dylib(std::move(Dylib)), Allow(std::move(Allow)),
-      GlobalPrefix(GlobalPrefix) {}
+      GlobalPrefix(GlobalPrefix),
+      DoNotMangleLeadingQuestionMark(DoNotMangleLeadingQuestionMark) {}
 
 Expected<std::unique_ptr<DynamicLibrarySearchGenerator>>
 DynamicLibrarySearchGenerator::Load(const char *FileName, char GlobalPrefix,
+                                    bool DoNotMangleLeadingQuestionMark,
                                     SymbolPredicate Allow) {
   std::string ErrMsg;
   auto Lib = sys::DynamicLibrary::getPermanentLibrary(FileName, &ErrMsg);
   if (!Lib.isValid())
     return make_error<StringError>(std::move(ErrMsg), inconvertibleErrorCode());
   return std::make_unique<DynamicLibrarySearchGenerator>(
-      std::move(Lib), GlobalPrefix, std::move(Allow));
+      std::move(Lib), GlobalPrefix, DoNotMangleLeadingQuestionMark,
+      std::move(Allow));
 }
 
 Error DynamicLibrarySearchGenerator::tryToGenerate(
     LookupState &LS, LookupKind K, JITDylib &JD,
     JITDylibLookupFlags JDLookupFlags, const SymbolLookupSet &Symbols) {
   orc::SymbolMap NewSymbols;
 
   bool HasGlobalPrefix = (GlobalPrefix != '\0');
 
   for (auto &KV : Symbols) {
     auto &Name = KV.first;
 
     if ((*Name).empty())
       continue;
 
     if (Allow && !Allow(Name))
       continue;
 
-    if (HasGlobalPrefix && (*Name).front() != GlobalPrefix)
+    bool StripFirstCharacter = HasGlobalPrefix;
+    char FirstCharacter = (*Name).front();
+    if (FirstCharacter == '?' && DoNotMangleLeadingQuestionMark) {
+      // Continue without stripping the first character; it is ok that the
+      // mangled name does not start with GlobalPrefix (if there is one).
+      StripFirstCharacter = false;
+    } else if (HasGlobalPrefix && FirstCharacter != GlobalPrefix) {
+      // The mangled name does not start with GlobalPrefix, skip.
       continue;
+    }
 
-    std::string Tmp((*Name).data() + HasGlobalPrefix,
-                    (*Name).size() - HasGlobalPrefix);
+    std::string Tmp((*Name).data() + StripFirstCharacter,
+                    (*Name).size() - StripFirstCharacter);
     if (void *Addr = Dylib.getAddressOfSymbol(Tmp.c_str())) {
       NewSymbols[Name] = JITEvaluatedSymbol(
           static_cast<JITTargetAddress>(reinterpret_cast<uintptr_t>(Addr)),
           JITSymbolFlags::Exported);
     }
   }
 
   if (NewSymbols.empty())

llvm/lib/ExecutionEngine/Orc/OrcV2CBindings.cpp

void LLVMOrcLookupStateContinueLookup(LLVMOrcLookupStateRef S,
                                       LLVMErrorRef Err) {
   LookupState LS;
   OrcV2CAPIHelper::resetLookupState(LS, ::unwrap(S));
   LS.continueLookup(unwrap(Err));
 }
 
 LLVMErrorRef LLVMOrcCreateDynamicLibrarySearchGeneratorForProcess(
     LLVMOrcDefinitionGeneratorRef *Result, char GlobalPrefix,
-    LLVMOrcSymbolPredicate Filter, void *FilterCtx) {
+    bool DoNotMangleLeadingQuestionMark, LLVMOrcSymbolPredicate Filter,
+    void *FilterCtx) {
   assert(Result && "Result can not be null");
   assert((Filter || !FilterCtx) &&
          "if Filter is null then FilterCtx must also be null");
 
   DynamicLibrarySearchGenerator::SymbolPredicate Pred;
   if (Filter)
     Pred = [=](const SymbolStringPtr &Name) -> bool {
       return Filter(FilterCtx, wrap(OrcV2CAPIHelper::getRawPoolEntryPtr(Name)));
     };
 
   auto ProcessSymsGenerator =
-      DynamicLibrarySearchGenerator::GetForCurrentProcess(GlobalPrefix, Pred);
+      DynamicLibrarySearchGenerator::GetForCurrentProcess(
+          GlobalPrefix, DoNotMangleLeadingQuestionMark, Pred);
 
   if (!ProcessSymsGenerator) {
     *Result = nullptr;
     return wrap(ProcessSymsGenerator.takeError());
   }
 
   *Result = wrap(ProcessSymsGenerator->release());
   return LLVMErrorSuccess;
 }
 
 LLVMErrorRef LLVMOrcCreateDynamicLibrarySearchGeneratorForPath(
     LLVMOrcDefinitionGeneratorRef *Result, const char *FileName,
-    char GlobalPrefix, LLVMOrcSymbolPredicate Filter, void *FilterCtx) {
+    char GlobalPrefix, bool DoNotMangleLeadingQuestionMark,
+    LLVMOrcSymbolPredicate Filter, void *FilterCtx) {
   assert(Result && "Result can not be null");
   assert(FileName && "FileName can not be null");
   assert((Filter || !FilterCtx) &&
          "if Filter is null then FilterCtx must also be null");
 
   DynamicLibrarySearchGenerator::SymbolPredicate Pred;
   if (Filter)
     Pred = [=](const SymbolStringPtr &Name) -> bool {
       return Filter(FilterCtx, wrap(OrcV2CAPIHelper::getRawPoolEntryPtr(Name)));
     };
 
-  auto LibrarySymsGenerator =
-      DynamicLibrarySearchGenerator::Load(FileName, GlobalPrefix, Pred);
+  auto LibrarySymsGenerator = DynamicLibrarySearchGenerator::Load(
+      FileName, GlobalPrefix, DoNotMangleLeadingQuestionMark, Pred);
 
   if (!LibrarySymsGenerator) {
     *Result = nullptr;
     return wrap(LibrarySymsGenerator.takeError());
   }
 
   *Result = wrap(LibrarySymsGenerator->release());
   return LLVMErrorSuccess;

llvm/tools/lli/lli.cpp

int runOrcJIT(const char *ProgName) {
   orc::MangleAndInterner Mangle(J->getExecutionSession(), J->getDataLayout());
 
   // Unless they've been explicitly disabled, make process symbols available to
   // JIT'd code.
   if (!NoProcessSymbols)
     J->getMainJITDylib().addGenerator(
         ExitOnErr(orc::DynamicLibrarySearchGenerator::GetForCurrentProcess(
             J->getDataLayout().getGlobalPrefix(),
+            J->getDataLayout().doNotMangleLeadingQuestionMark(),
             [MainName = Mangle("main")](const orc::SymbolStringPtr &Name) {
               return Name != MainName;
             })));
 
   if (GenerateBuiltinFunctions.size() > 0)
     J->getMainJITDylib().addGenerator(
         std::make_unique<LLIBuiltinFunctionGenerator>(GenerateBuiltinFunctions,
                                                       Mangle));

mlir/lib/ExecutionEngine/ExecutionEngine.cpp

cantFail(tsm.withModuleDo(
         [&](llvm::Module &module) { return options.transformer(&module); }));
   cantFail(jit->addIRModule(std::move(tsm)));
   engine->jit = std::move(jit);
 
   // Resolve symbols that are statically linked in the current process.
   llvm::orc::JITDylib &mainJD = engine->jit->getMainJITDylib();
   mainJD.addGenerator(
       cantFail(DynamicLibrarySearchGenerator::GetForCurrentProcess(
-          dataLayout.getGlobalPrefix())));
+          dataLayout.getGlobalPrefix(),
+          dataLayout.doNotMangleLeadingQuestionMark())));
 
   return std::move(engine);
 }
 
 Expected<void (*)(void **)>
 ExecutionEngine::lookupPacked(StringRef name) const {
   auto result = lookup(makePackedFunctionName(name));
   if (!result)