[ORC] Make mangling convenience methods part of the public API of LLJIT.

This saves clients from having to manually construct a MangleAndInterner.

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

@@ -107,7 +107,14 @@ public:
   /// Look up a symbol in JITDylib JD by the symbol's linker-mangled name (to
   /// look up symbols based on their IR name use the lookup function instead).
   Expected<JITEvaluatedSymbol> lookupLinkerMangled(JITDylib &JD,
-                                                   StringRef Name);
+                                                   SymbolStringPtr Name);
+
+  /// Look up a symbol in JITDylib JD by the symbol's linker-mangled name (to
+  /// look up symbols based on their IR name use the lookup function instead).
+  Expected<JITEvaluatedSymbol> lookupLinkerMangled(JITDylib &JD,
+                                                   StringRef Name) {
+    return lookupLinkerMangled(JD, ES->intern(Name));
+  }
 
   /// Look up a symbol in the main JITDylib by the symbol's linker-mangled name
   /// (to look up symbols based on their IR name use the lookup function
@@ -166,6 +173,14 @@ public:
   /// Returns a reference to the IR compile layer.
   IRCompileLayer &getIRCompileLayer() { return *CompileLayer; }
 
+  /// Returns a linker-mangled version of UnmangledName.
+  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>
   createObjectLinkingLayer(LLJITBuilderState &S, ExecutionSession &ES);
@@ -176,8 +191,6 @@ protected:
   /// Create an LLJIT instance with a single compile thread.
   LLJIT(LLJITBuilderState &S, Error &Err);
 
-  std::string mangle(StringRef UnmangledName);
-
   Error applyDataLayout(Module &M);
 
   void recordCtorDtors(Module &M);

llvm/lib/ExecutionEngine/Orc/LLJIT.cpp

@@ -122,23 +122,22 @@ private:
 class GenericLLVMIRPlatformSupport : public LLJIT::PlatformSupport {
 public:
   // GenericLLVMIRPlatform &P) : P(P) {
-  GenericLLVMIRPlatformSupport(LLJIT &J) : J(J) {
+  GenericLLVMIRPlatformSupport(LLJIT &J)
-
+      : J(J), InitFunctionPrefix(J.mangle("__orc_init_func.")) {
-    MangleAndInterner Mangle(getExecutionSession(), J.getDataLayout());
-    InitFunctionPrefix = Mangle("__orc_init_func.");
 
     getExecutionSession().setPlatform(
         std::make_unique<GenericLLVMIRPlatform>(*this));
 
-    setInitTransform(J, GlobalCtorDtorScraper(*this, *InitFunctionPrefix));
+    setInitTransform(J, GlobalCtorDtorScraper(*this, InitFunctionPrefix));
 
     SymbolMap StdInterposes;
 
-    StdInterposes[Mangle("__lljit.platform_support_instance")] =
+    StdInterposes[J.mangleAndIntern("__lljit.platform_support_instance")] =
         JITEvaluatedSymbol(pointerToJITTargetAddress(this),
                            JITSymbolFlags::Exported);
-    StdInterposes[Mangle("__lljit.cxa_atexit_helper")] = JITEvaluatedSymbol(
+    StdInterposes[J.mangleAndIntern("__lljit.cxa_atexit_helper")] =
-        pointerToJITTargetAddress(registerAtExitHelper), JITSymbolFlags());
+        JITEvaluatedSymbol(pointerToJITTargetAddress(registerAtExitHelper),
+                           JITSymbolFlags());
 
     cantFail(
         J.getMainJITDylib().define(absoluteSymbols(std::move(StdInterposes))));
@@ -152,10 +151,10 @@ public:
   Error setupJITDylib(JITDylib &JD) {
 
     // Add per-jitdylib standard interposes.
-    MangleAndInterner Mangle(getExecutionSession(), J.getDataLayout());
     SymbolMap PerJDInterposes;
-    PerJDInterposes[Mangle("__lljit.run_atexits_helper")] = JITEvaluatedSymbol(
+    PerJDInterposes[J.mangleAndIntern("__lljit.run_atexits_helper")] =
-        pointerToJITTargetAddress(runAtExitsHelper), JITSymbolFlags());
+        JITEvaluatedSymbol(pointerToJITTargetAddress(runAtExitsHelper),
+                           JITSymbolFlags());
     cantFail(JD.define(absoluteSymbols(std::move(PerJDInterposes))));
 
     auto Ctx = std::make_unique<LLVMContext>();
@@ -197,7 +196,7 @@ public:
       // will trigger a lookup to materialize the module) and the InitFunctions
       // map (which holds the names of the symbols to execute).
       for (auto &KV : MU.getSymbols())
-        if ((*KV.first).startswith(*InitFunctionPrefix)) {
+        if ((*KV.first).startswith(InitFunctionPrefix)) {
           InitSymbols[&JD].add(KV.first,
                                SymbolLookupFlags::WeaklyReferencedSymbol);
           InitFunctions[&JD].add(KV.first);
@@ -308,8 +307,7 @@ private:
   Expected<std::vector<JITTargetAddress>> getDeinitializers(JITDylib &JD) {
     auto &ES = getExecutionSession();
 
-    MangleAndInterner Mangle(getExecutionSession(), J.getDataLayout());
+    auto LLJITRunAtExits = J.mangleAndIntern("__lljit_run_atexits");
-    auto LLJITRunAtExits = Mangle("__lljit_run_atexits");
 
     DenseMap<JITDylib *, SymbolLookupSet> LookupSymbols;
     std::vector<JITDylib *> DFSLinkOrder;
@@ -459,7 +457,7 @@ private:
   }
 
   LLJIT &J;
-  SymbolStringPtr InitFunctionPrefix;
+  std::string InitFunctionPrefix;
   DenseMap<JITDylib *, SymbolLookupSet> InitSymbols;
   DenseMap<JITDylib *, SymbolLookupSet> InitFunctions;
   DenseMap<JITDylib *, SymbolLookupSet> DeInitFunctions;
@@ -653,26 +651,31 @@ private:
   MachOPlatformSupport(LLJIT &J, JITDylib &PlatformJITDylib, DlFcnValues DlFcn)
       : J(J), MP(setupPlatform(J)), DlFcn(std::move(DlFcn)) {
 
-    MangleAndInterner Mangle(J.getExecutionSession(), J.getDataLayout());
     SymbolMap HelperSymbols;
 
     // platform and atexit helpers.
-    HelperSymbols[Mangle("__lljit.platform_support_instance")] =
+    HelperSymbols[J.mangleAndIntern("__lljit.platform_support_instance")] =
         JITEvaluatedSymbol(pointerToJITTargetAddress(this), JITSymbolFlags());
-    HelperSymbols[Mangle("__lljit.cxa_atexit_helper")] = JITEvaluatedSymbol(
+    HelperSymbols[J.mangleAndIntern("__lljit.cxa_atexit_helper")] =
-        pointerToJITTargetAddress(registerAtExitHelper), JITSymbolFlags());
+        JITEvaluatedSymbol(pointerToJITTargetAddress(registerAtExitHelper),
-    HelperSymbols[Mangle("__lljit.run_atexits_helper")] = JITEvaluatedSymbol(
+                           JITSymbolFlags());
-        pointerToJITTargetAddress(runAtExitsHelper), JITSymbolFlags());
+    HelperSymbols[J.mangleAndIntern("__lljit.run_atexits_helper")] =
+        JITEvaluatedSymbol(pointerToJITTargetAddress(runAtExitsHelper),
+                           JITSymbolFlags());
 
     // dlfcn helpers.
-    HelperSymbols[Mangle("__lljit.dlopen_helper")] = JITEvaluatedSymbol(
+    HelperSymbols[J.mangleAndIntern("__lljit.dlopen_helper")] =
-        pointerToJITTargetAddress(dlopenHelper), JITSymbolFlags());
+        JITEvaluatedSymbol(pointerToJITTargetAddress(dlopenHelper),
-    HelperSymbols[Mangle("__lljit.dlclose_helper")] = JITEvaluatedSymbol(
+                           JITSymbolFlags());
-        pointerToJITTargetAddress(dlcloseHelper), JITSymbolFlags());
+    HelperSymbols[J.mangleAndIntern("__lljit.dlclose_helper")] =
-    HelperSymbols[Mangle("__lljit.dlsym_helper")] = JITEvaluatedSymbol(
+        JITEvaluatedSymbol(pointerToJITTargetAddress(dlcloseHelper),
-        pointerToJITTargetAddress(dlsymHelper), JITSymbolFlags());
+                           JITSymbolFlags());
-    HelperSymbols[Mangle("__lljit.dlerror_helper")] = JITEvaluatedSymbol(
+    HelperSymbols[J.mangleAndIntern("__lljit.dlsym_helper")] =
-        pointerToJITTargetAddress(dlerrorHelper), JITSymbolFlags());
+        JITEvaluatedSymbol(pointerToJITTargetAddress(dlsymHelper),
+                           JITSymbolFlags());
+    HelperSymbols[J.mangleAndIntern("__lljit.dlerror_helper")] =
+        JITEvaluatedSymbol(pointerToJITTargetAddress(dlerrorHelper),
+                           JITSymbolFlags());
 
     cantFail(
         PlatformJITDylib.define(absoluteSymbols(std::move(HelperSymbols))));
@@ -859,8 +862,7 @@ private:
     }
 
     if (!JITSymSearchOrder.empty()) {
-      MangleAndInterner Mangle(J.getExecutionSession(), J.getDataLayout());
+      auto MangledName = J.mangleAndIntern(Name);
-      auto MangledName = Mangle(Name);
       SymbolLookupSet Syms(MangledName,
                            SymbolLookupFlags::WeaklyReferencedSymbol);
       if (auto Result = J.getExecutionSession().lookup(JITSymSearchOrder, Syms,
@@ -987,10 +989,9 @@ Error LLJIT::addObjectFile(JITDylib &JD, std::unique_ptr<MemoryBuffer> Obj) {
 }
 
 Expected<JITEvaluatedSymbol> LLJIT::lookupLinkerMangled(JITDylib &JD,
-                                                        StringRef Name) {
+                                                        SymbolStringPtr Name) {
   return ES->lookup(
-      makeJITDylibSearchOrder(&JD, JITDylibLookupFlags::MatchAllSymbols),
+      makeJITDylibSearchOrder(&JD, JITDylibLookupFlags::MatchAllSymbols), Name);
-      ES->intern(Name));
 }
 
 std::unique_ptr<ObjectLayer>
@@ -1093,7 +1094,7 @@ LLJIT::LLJIT(LLJITBuilderState &S, Error &Err)
     setUpGenericLLVMIRPlatform(*this);
 }
 
-std::string LLJIT::mangle(StringRef UnmangledName) {
+std::string LLJIT::mangle(StringRef UnmangledName) const {
   std::string MangledName;
   {
     raw_string_ostream MangledNameStream(MangledName);