[cling] JIT: find existing weak symbol without materializer:

m_JIT.getSymbolAddress() invokes the symbol materializers, which compile (which
is sort of okay) but also try autoloading (which totally is not okay).

Instead, implement a function to search existing JIT symbols.

This can be accelerated by looking up the whole set of symbols, instead of doing it
symbol by symbol. I leave that refactoring for later...

Author: Axel-Naumann

interpreter/cling/lib/Interpreter/BackendPasses.cpp

@@ -267,9 +267,17 @@ namespace {
       if (!GV.isDiscardableIfUnused(LT) || !GV.isWeakForLinker(LT))
         return false;
 
-      // Find the symbol as existing, previously compiled symbol in the JIT,
-      // or in shared libraries (without auto-loading).
-      return (m_JIT.getSymbolAddress(GV.getName(), /*IncludeHostSyms*/ true));
+      // Find the symbol as existing, previously compiled symbol in the JIT...
+      if (m_JIT.lookupExistingSymbol(GV.getName()))
+        return true;
+
+      // ...or in shared libraries (without auto-loading).
+      std::string Name = GV.getName().str();
+#if !defined(_WIN32)
+        return llvm::sys::DynamicLibrary::SearchForAddressOfSymbol(Name);
+#else
+        return platform::DLSym(Name);
+#endif
     }
 
     bool runOnVar(GlobalVariable& GV) {
@@ -310,6 +318,7 @@ namespace {
 
     bool runOnModule(Module &M) override {
       bool ret = false;
+      // FIXME: use SymbolLookupSet, rather than looking up symbol by symbol.
       for (auto &&F: M)
         ret |= runOnFunc(F);
       for (auto &&G: M.globals())

interpreter/cling/lib/Interpreter/IncrementalJIT.cpp

@@ -577,4 +577,22 @@ void* IncrementalJIT::getSymbolAddress(StringRef Name, bool IncludeHostSymbols)
   return jitTargetAddressToPointer<void*>(Symbol->getAddress());
 }
 
+void *IncrementalJIT::lookupExistingSymbol(StringRef UnmangledName) {
+  auto &ES = Jit->getExecutionSession();
+  auto &JD = Jit->getMainJITDylib();
+  SymbolLookupSet Names({ES.intern(Jit->mangle(UnmangledName))});
+  if (auto ResultMap = ES.lookup(llvm::orc::makeJITDylibSearchOrder(&JD,
+                JITDylibLookupFlags::MatchAllSymbols),
+                std::move(Names),
+                LookupKind::DLSym)) {
+    assert(ResultMap->size() == 1 && "Unexpected number of results");
+    assert(ResultMap->count(jit->mangle(UnmangledName)) && "Missing result for symbol");
+    return jitTargetAddressToPointer<void*>(ResultMap->begin()->second.getAddress());
+  } else {
+    consumeError(ResultMap.takeError());
+    return nullptr;
+  }
+}
+
+
 } // namespace cling

interpreter/cling/lib/Interpreter/IncrementalJIT.h

@@ -78,6 +78,10 @@ class IncrementalJIT {
   /// should include symbols from the host process (via dlsym) or not.
   void* getSymbolAddress(llvm::StringRef Name, bool IncludeHostSymbols);
 
+  /// @brief Lookup existing symbols in the set of JIT emitted symbols,
+  /// based on its IR name (as coming from clang's mangler).
+  void *lookupExistingSymbol(llvm::StringRef UnmangledName);
+
   /// Inject a symbol with a known address. Name is not linker mangled, i.e.
   /// as known by the IR.
   llvm::JITTargetAddress addOrReplaceDefinition(llvm::StringRef Name,