Changes to use a string pool for symbols

[sgraenitz]

Hi Jared, thanks for working on this! Your patch looks really good. Two minor comments inline.

llvm/include/llvm/ExecutionEngine/JITLink/JITLink.h

428–429

Is there a special reason for these methods to take RValue references? Otherwise, these look like classical sink arguments that should be moved in and taken by value (just remove the &&).

1038

Do we have a definition for the dtor here?

[jaredwy]

llvm/include/llvm/ExecutionEngine/JITLink/JITLink.h

428–429

No not really and in fact started life that way, just was looking to avoid the overhead of the add/decrement of the ownership counter when I noticed every usage was taking ownership, will remove :)

1038

Sorry don't follow the question? Implementation is further down if that's what you meant? Did you want me to move it inline here?

[dblaikie]

llvm/include/llvm/ExecutionEngine/JITLink/JITLink.h

428–429

If you std::move at the caller and in the callee, you shouldn't need to add/decrement ownership counters even when passing by value. (it'll add an extra move, but no copies - copies are what cause add/decrement), so this should be good

[lhames]

Dave's suggestion about pass-by-value should be implemented, but otherwise LGTM. Thanks Jared!

There's a part 2 to this bug, which I thought was mentioned in http://llvm.org/PR55533, but I now realize is not: We want to change the interface of LinkGraph and associated classes to use SymbolStringPtr rather than StringRef. That will make it cheap to transfer/copy/compare strings between the current link and the surrounding ORC session, which is something that plugins (and the ObjectLinkingLayer) do quite a lot.

Jared -- do you want to tackle that under http://llvm.org/PR55533? Otherwise we can close that (once you land this patch) and file a follow-up issue.

llvm/include/llvm/ExecutionEngine/JITLink/JITLink.h

428–429

Yep -- the various rvalue reference arguments should all be changed to pass-by-value with the caller using std::move.

1026–1032

What happens if you ditch this overload and require a SymbolStringPool for construction? Does it break many uses (outside the unit tests)?

I guess it's just the jitlink::link API (and various implementations of that) that we'd need to update?

[jaredwy]

Review comments addressed and also just went and removed the getName returning a stringref.

[dblaikie]

llvm/include/llvm/ExecutionEngine/JITLink/JITLink.h

516–517

This could return by const-ref (the same way a large member like a std::vector would return from an accessor by const ref) & then isNamed could be removed & the usage code kept the same? (I assume isNamed was added to avoid the cost of copying the SymbolStringPtr - and if it returns by const ref there's no added cost? Oh, I guess callers still have to add the * in to dereference? yeah, but still maybe better than adding this isNamed function that's a bit quirky - since it only allows the one operation (equality) without the SymbolStringPtr copy, which is a bit niche/special case/inflexible)

519–521

I think this can be removed now?

[jaredwy]

llvm/include/llvm/ExecutionEngine/JITLink/JITLink.h

516–517

It was mostly added to aid in readability of the code and avoiding the unnecessary copy but I am not attached to it, I am new to these lands so if it is not the LLVM way to add utility functions i can remove

519–521

It could.

[jaredwy]

Removing an uncessary if statement

[dblaikie]

llvm/include/llvm/ExecutionEngine/JITLink/JITLink.h

516–517

Could you show/compare the readability issues you had in mind?

Would getName returning by const-ref address the unnecessary copy concerns?

[sgraenitz]

llvm/include/llvm/ExecutionEngine/JITLink/JITLink.h

1038

Ah you are right, sorry missed that.

[jaredwy]

Removing a isNamed in favour of just using the comparisons

[lhames]

I love seeing all that BlockDependenciesMap code disappearing as a result of this change. :D

Lots of minor changes, but the broad direction of this is _great_! Once this patch lands the next big target should be LinkGraph::LookupMap -- we should be able to ditch the StringRefs and pass the SymbolStringPtrs right through to the context. That'll avoid a tonne of re-interning on the ObjectLinkingLayer side.

Very cool work!

llvm/include/llvm/ExecutionEngine/JITLink/JITLink.h

516–517

I'd be in favor of having getName() return by const-ref and dropping isNamed -- this would be consistent with the existing getters/setters.

1232–1233

This and the other "add" methods can take SymbolStringPtrs now, rather than StringRefs.

This is a place where I wouldn't mind a convenience overload for the StringRef though. I.e.:

Symbol &addExternalSymbol(SymbolStringPtr Name, orc::ExecutorAddrDiff Size, Linkage L) {
  assert(llvm::count(ExternalSymbols, Name) == 0 && "Duplicate external symbol");
    auto &Sym = Symbol::constructExternal(
        Allocator, createAddressable(orc::ExecutorAddr(), false),
        std::move(Name), Size, L);
    ExternalSymbols.insert(&Sym);
    return Sym;
}

Symbol &addExternalSymbol(StringRef Name, orc::ExecutorAddrDiff Size, Linkage L) {
  return addExternalSymbol(SSP->intern(Name), Size, L);
}

llvm/include/llvm/ExecutionEngine/JITLink/TableManager.h

42

Are the parens needed here? I think * binds tight enough that you can omit them.

llvm/lib/ExecutionEngine/JITLink/COFFLinkGraphBuilder.cpp

244–245

I'd include intern convenience methods on both the LinkGraph and the builder, and then use them to avoid naming SymbolStringPtrs that only have one use. I.e.

Gym = &createDLLImportEntry(intern(SymbolName), *ExternalSym);

OTOH it's always worth naming a SymbolStringPtr that gets used more than once (otherwise you'd have to intern it more than once).

llvm/lib/ExecutionEngine/JITLink/EHFrameSupport.cpp

377

I think you can drop the outer parens here.

530

I think you can drop them outer parens here too.

llvm/lib/ExecutionEngine/JITLink/ELF_x86_64.cpp

257–258

Could lazily intern ELFGOTSymbolName into an ELFJITLinker_x86_64 member variable to speed up repeat comparisons?

No need to do that for this patch, but maybe add a FIXME to follow up on the idea?

llvm/lib/ExecutionEngine/JITLink/JITLinkGeneric.cpp

202–203

I think you can now just assert(Sym->getName() && "Externals must be named").

207

We should key UnresolvedExternals on the SymbolStringPtr now, rather than the StringRef.

llvm/lib/ExecutionEngine/JITLink/PerGraphGOTAndPLTStubsBuilder.h

73

I think GOTEntries should be able to be keyed on the SymbolStringPtr too.

95

PLTStubs should likewise be keyed on the SymbolStringPtr.

llvm/lib/ExecutionEngine/Orc/COFFPlatform.cpp

68

We need to use the ExecutionSession's SymbolStringPool here. I'd update this to take the ExecutionSession& -- COFFPlatform has an ES member handy that you can pass in.

807

Once everyone's sharing the same pool this can be a direct SymbolStringPtr value comparison.

llvm/lib/ExecutionEngine/Orc/ELFNixPlatform.cpp

655

Can be a SSP comparison once the pool is shared.

803–811

These tls symbol strings should be interned and stored in the plugin -- that'll save re-interning them for each graph.

llvm/lib/ExecutionEngine/Orc/ExecutionUtils.cpp

577–580

We shouldn't need to allocate a string on the LinkGraph for this any more. Instead, you should just be able to say:

Ptr.setName(G->intern(getImplPrefix() + *KV.first));

llvm/lib/ExecutionEngine/Orc/MachOPlatform.cpp

885

Can compare SSP values once the pool is shared.

1061–1065

We should intern these tlv strings and store them as members in the plugin to avoid redundant interning.

1340–1343

More strings to be interned and stored in the plugin.

llvm/lib/ExecutionEngine/Orc/ObjectLinkingLayer.cpp

233–240

Once Symbol::getName() returns by const-ref I think you can replace InternedName with Sym->getName() everywhere here.

245–246

Ditto here.

431–435

I'd drop Name and just use Sym->getName() here.

486–490

Drop SymName and just use Sym->getName().

llvm/unittests/ExecutionEngine/JITLink/LinkGraphTests.cpp

77–91

Once you drop the convenience method this shouldn't be needed.

847

Missing newline. :)

[jaredwy]

This further uses symbol ptrs across jitlink, i think in most places now we use it for the symbol name, there is some clean up to go, but this is a good starting point

[lhames]

Re-reviewing, since I know you're working on a rebase at the moment. Mostly cosmetic comments, but a handful of functional ones too.

llvm/include/llvm/ExecutionEngine/Orc/Layer.h

169 ↗

(On Diff #523650)

This shouldn't be needed: Clients can access getExecutionSession instead.

llvm/lib/ExecutionEngine/JITLink/COFFLinkGraphBuilder.cpp

305–308

Variable names should start with uppercase (according to LLVM coding standards).

You'll have to copy the SymbolStringPtr either way, so you can just drop the move down to the point where you use it as a map key:

auto InternedName = G->intern(S);
auto Symbol = &G->addExternalSymbol(InternedName, 0, false);
Symbol->setLive(true);
ExternalSymbols[std::move(InternedName)] = Symbol;

362–363

This should probably be done before the patch lands.

368–369

You can std::move these map keys to save a ref-count. :)

378–386

sym should be capitalized to Sym.

llvm/lib/ExecutionEngine/JITLink/COFF_x86_64.cpp

197

imageBaseName should be capitalized to ImageBaseName.

llvm/lib/ExecutionEngine/JITLink/ELF_i386.cpp

86

What about

if (Sym->hasName() *Sym->getName() == ELFGOTSymbolName)

?

llvm/lib/ExecutionEngine/JITLink/ELF_x86_64.cpp

257–259

This could be if (Sym.hasName() && *Sym.getName() == ELFGOTSymbolName) too.

284

if (Sym.hasName() && *Sym.getName() == ELFGOTSymbolName) could be used here too.

llvm/lib/ExecutionEngine/JITLink/JITLinkGeneric.cpp

203

Better yet, assert(Sym->hasName() && "Externals must be named"). Sorry I didn't spot that earlier.

llvm/lib/ExecutionEngine/Orc/ExecutionUtils.cpp

578–580

Twine::getSingleStringRef is only valid if the twine is actually representing a single StringRef, but here it's a concatenation.

I think you want to replace:

auto name = getImpPrefix() + *KV.first;
Ptr.setName(G->intern(name.getSingleStringRef()));

with

Ptr.setName(G->intern((getImpPrefix() + *KV.first).str()));

[jaredwy]

Responding to review comments

llvm/include/llvm/ExecutionEngine/JITLink/COFF.h

 namespace jitlink {
 
 /// Create a LinkGraph from an COFF relocatable object.
 ///
 /// Note: The graph does not take ownership of the underlying buffer, nor copy
 /// its contents. The caller is responsible for ensuring that the object buffer
 /// outlives the graph.
 Expected<std::unique_ptr<LinkGraph>>
-createLinkGraphFromCOFFObject(MemoryBufferRef ObjectBuffer);
+createLinkGraphFromCOFFObject(MemoryBufferRef ObjectBuffer,
+                              std::shared_ptr<orc::SymbolStringPool> SSP);
 
 /// Link the given graph.
 ///
 /// Uses conservative defaults for GOT and stub handling based on the target
 /// platform.
 void link_COFF(std::unique_ptr<LinkGraph> G,
                std::unique_ptr<JITLinkContext> Ctx);
 
 } // end namespace jitlink
 } // end namespace llvm
 
 #endif // LLVM_EXECUTIONENGINE_JITLINK_COFF_H

llvm/include/llvm/ExecutionEngine/JITLink/COFF_x86_64.h

 namespace llvm {
 namespace jitlink {
 
 /// Create a LinkGraph from an COFF/x86-64 relocatable object.
 ///
 /// Note: The graph does not take ownership of the underlying buffer, nor copy
 /// its contents. The caller is responsible for ensuring that the object buffer
 /// outlives the graph.
-Expected<std::unique_ptr<LinkGraph>>
-createLinkGraphFromCOFFObject_x86_64(MemoryBufferRef ObjectBuffer);
+Expected<std::unique_ptr<LinkGraph>> createLinkGraphFromCOFFObject_x86_64(
+    MemoryBufferRef ObjectBuffer, std::shared_ptr<orc::SymbolStringPool> SSP);
 
 /// jit-link the given object buffer, which must be a COFF x86-64 object file.
 void link_COFF_x86_64(std::unique_ptr<LinkGraph> G,
                       std::unique_ptr<JITLinkContext> Ctx);
 
 /// Return the string name of the given COFF x86-64 edge kind.
 const char *getCOFFX86RelocationKindName(Edge::Kind R);
 } // end namespace jitlink
 } // end namespace llvm
 
 #endif // LLVM_EXECUTIONENGINE_JITLINK_COFF_X86_64_H

llvm/include/llvm/ExecutionEngine/JITLink/ELF.h

 namespace jitlink {
 
 /// Create a LinkGraph from an ELF relocatable object.
 ///
 /// Note: The graph does not take ownership of the underlying buffer, nor copy
 /// its contents. The caller is responsible for ensuring that the object buffer
 /// outlives the graph.
 Expected<std::unique_ptr<LinkGraph>>
-createLinkGraphFromELFObject(MemoryBufferRef ObjectBuffer);
+createLinkGraphFromELFObject(MemoryBufferRef ObjectBuffer,
+                             std::shared_ptr<orc::SymbolStringPool> SSP);
 
 /// Link the given graph.
 ///
 /// Uses conservative defaults for GOT and stub handling based on the target
 /// platform.
 void link_ELF(std::unique_ptr<LinkGraph> G,
               std::unique_ptr<JITLinkContext> Ctx);
 
 } // end namespace jitlink
 } // end namespace llvm
 
 #endif // LLVM_EXECUTIONENGINE_JITLINK_ELF_H

llvm/include/llvm/ExecutionEngine/JITLink/ELF_aarch32.h

 namespace llvm {
 namespace jitlink {
 
 /// Create a LinkGraph from an ELF/arm relocatable object
 ///
 /// Note: The graph does not take ownership of the underlying buffer, nor copy
 /// its contents. The caller is responsible for ensuring that the object buffer
 /// outlives the graph.
-Expected<std::unique_ptr<LinkGraph>>
-createLinkGraphFromELFObject_aarch32(MemoryBufferRef ObjectBuffer);
+Expected<std::unique_ptr<LinkGraph>> createLinkGraphFromELFObject_aarch32(
+    MemoryBufferRef ObjectBuffer, std::shared_ptr<orc::SymbolStringPool> SSP);
 
 /// jit-link the given object buffer, which must be an ELF arm/thumb object
 /// file.
 void link_ELF_aarch32(std::unique_ptr<LinkGraph> G,
                       std::unique_ptr<JITLinkContext> Ctx);
 
 } // end namespace jitlink
 } // end namespace llvm
 
 #endif // LLVM_EXECUTIONENGINE_JITLINK_ELF_AARCH32

llvm/include/llvm/ExecutionEngine/JITLink/ELF_aarch64.h

 namespace llvm {
 namespace jitlink {
 
 /// Create a LinkGraph from an ELF/aarch64 relocatable object
 ///
 /// Note: The graph does not take ownership of the underlying buffer, nor copy
 /// its contents. The caller is responsible for ensuring that the object buffer
 /// outlives the graph.
-Expected<std::unique_ptr<LinkGraph>>
-createLinkGraphFromELFObject_aarch64(MemoryBufferRef ObjectBuffer);
+Expected<std::unique_ptr<LinkGraph>> createLinkGraphFromELFObject_aarch64(
+    MemoryBufferRef ObjectBuffer, std::shared_ptr<orc::SymbolStringPool> SSP);
 
 /// jit-link the given object buffer, which must be a ELF aarch64 relocatable
 /// object file.
 void link_ELF_aarch64(std::unique_ptr<LinkGraph> G,
                       std::unique_ptr<JITLinkContext> Ctx);
 
 } // end namespace jitlink
 } // end namespace llvm
 
 #endif // LLVM_EXECUTIONENGINE_JITLINK_ELF_AARCH64_H

llvm/include/llvm/ExecutionEngine/JITLink/ELF_i386.h

 namespace jitlink {
 
 /// Create a LinkGraph from an ELF/i386 relocatable object
 ///
 /// Note: The graph does not take ownership of the underlying buffer, nor copy
 /// its contents. The caller is responsible for ensuring that the object buffer
 /// outlives the graph.
 Expected<std::unique_ptr<LinkGraph>>
-createLinkGraphFromELFObject_i386(MemoryBufferRef ObjectBuffer);
+createLinkGraphFromELFObject_i386(MemoryBufferRef ObjectBuffer,
+                                  std::shared_ptr<orc::SymbolStringPool> SSP);
 
 /// jit-link the given object buffer, which must be a ELF i386 relocatable
 /// object file.
 void link_ELF_i386(std::unique_ptr<LinkGraph> G,
                    std::unique_ptr<JITLinkContext> Ctx);
 
 } // end namespace jitlink
 } // end namespace llvm
 
 #endif // LLVM_EXECUTIONENGINE_JITLINK_ELF_I386_H

llvm/include/llvm/ExecutionEngine/JITLink/ELF_loongarch.h

 namespace llvm {
 namespace jitlink {
 
 /// Create a LinkGraph from an ELF/loongarch relocatable object
 ///
 /// Note: The graph does not take ownership of the underlying buffer, nor copy
 /// its contents. The caller is responsible for ensuring that the object buffer
 /// outlives the graph.
-Expected<std::unique_ptr<LinkGraph>>
-createLinkGraphFromELFObject_loongarch(MemoryBufferRef ObjectBuffer);
+Expected<std::unique_ptr<LinkGraph>> createLinkGraphFromELFObject_loongarch(
+    MemoryBufferRef ObjectBuffer, std::shared_ptr<orc::SymbolStringPool> SSP);
 
 /// jit-link the given object buffer, which must be an ELF loongarch object
 /// file.
 void link_ELF_loongarch(std::unique_ptr<LinkGraph> G,
                         std::unique_ptr<JITLinkContext> Ctx);
 
 } // end namespace jitlink
 } // end namespace llvm
 
 #endif // LLVM_EXECUTIONENGINE_JITLINK_ELF_LOONGARCH_H

llvm/include/llvm/ExecutionEngine/JITLink/ELF_ppc64.h

 /// Create a LinkGraph from an ELF/ppc64 relocatable object.
 ///
 /// Note: The graph does not take ownership of the underlying buffer, nor copy
 /// its contents. The caller is responsible for ensuring that the object buffer
 /// outlives the graph.
 ///
 /// WARNING: The big-endian backend has not been tested yet.
 Expected<std::unique_ptr<LinkGraph>>
-createLinkGraphFromELFObject_ppc64(MemoryBufferRef ObjectBuffer);
+createLinkGraphFromELFObject_ppc64(MemoryBufferRef ObjectBuffer,
+                                   std::shared_ptr<orc::SymbolStringPool> SSP);
 
 /// Create a LinkGraph from an ELF/ppc64le relocatable object.
 ///
 /// Note: The graph does not take ownership of the underlying buffer, nor copy
 /// its contents. The caller is responsible for ensuring that the object buffer
 /// outlives the graph.
-Expected<std::unique_ptr<LinkGraph>>
-createLinkGraphFromELFObject_ppc64le(MemoryBufferRef ObjectBuffer);
+Expected<std::unique_ptr<LinkGraph>> createLinkGraphFromELFObject_ppc64le(
+    MemoryBufferRef ObjectBuffer, std::shared_ptr<orc::SymbolStringPool> SSP);
 
 /// jit-link the given object buffer, which must be a ELF ppc64le object file.
 ///
 /// WARNING: The big-endian backend has not been tested yet.
 void link_ELF_ppc64(std::unique_ptr<LinkGraph> G,
                     std::unique_ptr<JITLinkContext> Ctx);
 
 /// jit-link the given object buffer, which must be a ELF ppc64le object file.
 void link_ELF_ppc64le(std::unique_ptr<LinkGraph> G,
                       std::unique_ptr<JITLinkContext> Ctx);
 
 } // end namespace llvm::jitlink
 
 #endif // LLVM_EXECUTIONENGINE_JITLINK_ELF_PPC64_H

llvm/include/llvm/ExecutionEngine/JITLink/ELF_riscv.h

 namespace jitlink {
 
 /// Create a LinkGraph from an ELF/riscv relocatable object
 ///
 /// Note: The graph does not take ownership of the underlying buffer, nor copy
 /// its contents. The caller is responsible for ensuring that the object buffer
 /// outlives the graph.
 Expected<std::unique_ptr<LinkGraph>>
-createLinkGraphFromELFObject_riscv(MemoryBufferRef ObjectBuffer);
+createLinkGraphFromELFObject_riscv(MemoryBufferRef ObjectBuffer,
+                                   std::shared_ptr<orc::SymbolStringPool> SSP);
 
 /// jit-link the given object buffer, which must be a ELF riscv object file.
 void link_ELF_riscv(std::unique_ptr<LinkGraph> G,
                     std::unique_ptr<JITLinkContext> Ctx);
 
 /// Returns a pass that performs linker relaxation. Should be added to
 /// PostAllocationPasses.
 LinkGraphPassFunction createRelaxationPass_ELF_riscv();
 
 } // end namespace jitlink
 } // end namespace llvm
 
 #endif // LLVM_EXECUTIONENGINE_JITLINK_ELF_RISCV_H

llvm/include/llvm/ExecutionEngine/JITLink/ELF_x86_64.h

 namespace jitlink {
 
 /// Create a LinkGraph from an ELF/x86-64 relocatable object.
 ///
 /// Note: The graph does not take ownership of the underlying buffer, nor copy
 /// its contents. The caller is responsible for ensuring that the object buffer
 /// outlives the graph.
 Expected<std::unique_ptr<LinkGraph>>
-createLinkGraphFromELFObject_x86_64(MemoryBufferRef ObjectBuffer);
+createLinkGraphFromELFObject_x86_64(MemoryBufferRef ObjectBuffe,
+                                    std::shared_ptr<orc::SymbolStringPool> SSP);
 
 /// jit-link the given object buffer, which must be a ELF x86-64 object file.
 void link_ELF_x86_64(std::unique_ptr<LinkGraph> G,
                      std::unique_ptr<JITLinkContext> Ctx);
 
 } // end namespace jitlink
 } // end namespace llvm
 
 #endif // LLVM_EXECUTIONENGINE_JITLINK_ELF_X86_64_H

llvm/include/llvm/ExecutionEngine/JITLink/JITLink.h

 #include "llvm/ADT/DenseSet.h"
 #include "llvm/ADT/FunctionExtras.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ExecutionEngine/JITLink/JITLinkMemoryManager.h"
 #include "llvm/ExecutionEngine/JITSymbol.h"
 #include "llvm/ExecutionEngine/Orc/Shared/ExecutorAddress.h"
 #include "llvm/ExecutionEngine/Orc/Shared/ExecutorSymbolDef.h"
 #include "llvm/ExecutionEngine/Orc/Shared/MemoryFlags.h"
+#include "llvm/ExecutionEngine/Orc/SymbolStringPool.h"
 #include "llvm/Support/Allocator.h"
 #include "llvm/Support/BinaryStreamReader.h"
 #include "llvm/Support/BinaryStreamWriter.h"
 #include "llvm/Support/Endian.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Support/FormatVariadic.h"
 #include "llvm/Support/MathExtras.h"
 #include "llvm/Support/MemoryBuffer.h"

 ///   - Common: Has both linkage and visibility, points to a null Addressable.
 ///   - External: Has neither linkage nor visibility, points to an external
 ///     Addressable.
 ///
 class Symbol {
   friend class LinkGraph;
 
 private:
-  Symbol(Addressable &Base, orc::ExecutorAddrDiff Offset, StringRef Name,
-         orc::ExecutorAddrDiff Size, Linkage L, Scope S, bool IsLive,
-         bool IsCallable)
-      : Name(Name), Base(&Base), Offset(Offset), WeakRef(0), Size(Size) {
+  Symbol(Addressable &Base, orc::ExecutorAddrDiff Offset,
+         orc::SymbolStringPtr &&Name, orc::ExecutorAddrDiff Size, Linkage L,
+         Scope S, bool IsLive, bool IsCallable)
+      : Name(std::move(Name)), Base(&Base), Offset(Offset), WeakRef(0),
+        Size(Size) {
     assert(Offset <= MaxOffset && "Offset out of range");
     setLinkage(L);
     setScope(S);
     setLive(IsLive);
     setCallable(IsCallable);
     setTargetFlags(TargetFlagsType{});
   }
 
+  static Symbol &constructCommon(BumpPtrAllocator &Allocator, Block &Base,
+                                 orc::SymbolStringPtr &&Name,
+                                 orc::ExecutorAddrDiff Size, Scope S,
+                                 bool IsLive) {
+    assert(Name && "Common symbol name cannot be empty");
+    assert(Base.isDefined() &&
+           "Cannot create common symbol from undefined block");
+    assert(static_cast<Block &>(Base).getSize() == Size &&
+           "Common symbol size should match underlying block size");
+    auto *Sym = Allocator.Allocate<Symbol>();
+    new (Sym)
+        Symbol(Base, 0, std::move(Name), Size, Linkage::Weak, S, IsLive, false);
+    return *Sym;
+  }
+
   static Symbol &constructExternal(BumpPtrAllocator &Allocator,
-                                   Addressable &Base, StringRef Name,
+                                   Addressable &Base,
+                                   orc::SymbolStringPtr &&Name,
                                    orc::ExecutorAddrDiff Size, Linkage L,
                                    bool WeaklyReferenced) {
     assert(!Base.isDefined() &&
            "Cannot create external symbol from defined block");
-    assert(!Name.empty() && "External symbol name cannot be empty");
+    assert(Name && "External symbol name cannot be empty");
     auto *Sym = Allocator.Allocate<Symbol>();
-    new (Sym) Symbol(Base, 0, Name, Size, L, Scope::Default, false, false);
+    new (Sym)
+        Symbol(Base, 0, std::move(Name), Size, L, Scope::Default, false, false);
     Sym->setWeaklyReferenced(WeaklyReferenced);
     return *Sym;
   }
 
   static Symbol &constructAbsolute(BumpPtrAllocator &Allocator,
-                                   Addressable &Base, StringRef Name,
+                                   Addressable &Base,
+                                   orc::SymbolStringPtr &&Name,
                                    orc::ExecutorAddrDiff Size, Linkage L,
                                    Scope S, bool IsLive) {
     assert(!Base.isDefined() &&
            "Cannot create absolute symbol from a defined block");
     auto *Sym = Allocator.Allocate<Symbol>();
-    new (Sym) Symbol(Base, 0, Name, Size, L, S, IsLive, false);
+    new (Sym) Symbol(Base, 0, std::move(Name), Size, L, S, IsLive, false);
     return *Sym;
   }
 
   static Symbol &constructAnonDef(BumpPtrAllocator &Allocator, Block &Base,
                                   orc::ExecutorAddrDiff Offset,
                                   orc::ExecutorAddrDiff Size, bool IsCallable,
                                   bool IsLive) {
     assert((Offset + Size) <= Base.getSize() &&
            "Symbol extends past end of block");
     auto *Sym = Allocator.Allocate<Symbol>();
-    new (Sym) Symbol(Base, Offset, StringRef(), Size, Linkage::Strong,
-                     Scope::Local, IsLive, IsCallable);
+    new (Sym) Symbol(Base, Offset, orc::SymbolStringPtr(nullptr), Size,
+                     Linkage::Strong, Scope::Local, IsLive, IsCallable);
     return *Sym;
   }
 
   static Symbol &constructNamedDef(BumpPtrAllocator &Allocator, Block &Base,
-                                   orc::ExecutorAddrDiff Offset, StringRef Name,
+                                   orc::ExecutorAddrDiff Offset,
+                                   orc::SymbolStringPtr Name,
                                    orc::ExecutorAddrDiff Size, Linkage L,
                                    Scope S, bool IsLive, bool IsCallable) {
     assert((Offset + Size) <= Base.getSize() &&
            "Symbol extends past end of block");
-    assert(!Name.empty() && "Name cannot be empty");
+    assert(Name && "Name cannot be empty");
     auto *Sym = Allocator.Allocate<Symbol>();
-    new (Sym) Symbol(Base, Offset, Name, Size, L, S, IsLive, IsCallable);
+    new (Sym)
+        Symbol(Base, Offset, std::move(Name), Size, L, S, IsLive, IsCallable);
     return *Sym;
   }
 
 public:
   /// Create a null Symbol. This allows Symbols to be default initialized for
   /// use in containers (e.g. as map values). Null symbols are only useful for
   /// assigning to.
   Symbol() = default;
 
   // Symbols are not movable or copyable.
   Symbol(const Symbol &) = delete;
   Symbol &operator=(const Symbol &) = delete;
   Symbol(Symbol &&) = delete;
   Symbol &operator=(Symbol &&) = delete;
 
   /// Returns true if this symbol has a name.
-  bool hasName() const { return !Name.empty(); }
+  bool hasName() const { return Name != nullptr; }
 
   /// Returns the name of this symbol (empty if the symbol is anonymous).
-  StringRef getName() const {
-    assert((!Name.empty() || getScope() == Scope::Local) &&
+  const orc::SymbolStringPtr &getName() const {
+    assert((Name || getScope() == Scope::Local) &&
            "Anonymous symbol has non-local scope");
+
     return Name;
   }
 
   /// Rename this symbol. The client is responsible for updating scope and
   /// linkage if this name-change requires it.
-  void setName(StringRef Name) { this->Name = Name; }
+  void setName(orc::SymbolStringPtr &&Name) { this->Name = std::move(Name); }
 
   /// Returns true if this Symbol has content (potentially) defined within this
   /// object file (i.e. is anything but an external or absolute symbol).
   bool isDefined() const {
     assert(Base && "Attempt to access null symbol");
     return Base->isDefined();
   }
 
ArrayRef<char> getSymbolContent() const {
     return getBlock().getContent().slice(Offset, Size);
   }
 
   /// Get the linkage for this Symbol.
   Linkage getLinkage() const { return static_cast<Linkage>(L); }
 
   /// Set the linkage for this Symbol.
   void setLinkage(Linkage L) {
-    assert((L == Linkage::Strong || (!Base->isAbsolute() && !Name.empty())) &&
+    assert((L == Linkage::Strong || (!Base->isAbsolute() && Name)) &&
            "Linkage can only be applied to defined named symbols");
     this->L = static_cast<uint8_t>(L);
   }
 
   /// Get the visibility for this Symbol.
   Scope getScope() const { return static_cast<Scope>(S); }
 
   /// Set the visibility for this Symbol.
   void setScope(Scope S) {
-    assert((!Name.empty() || S == Scope::Local) &&
+    assert((Name || S == Scope::Local) &&
            "Can not set anonymous symbol to non-local scope");
     assert((S != Scope::Local || Base->isDefined() || Base->isAbsolute()) &&
            "Invalid visibility for symbol type");
     this->S = static_cast<uint8_t>(S);
   }
 
   /// Get the target flags of this Symbol.
   TargetFlagsType getTargetFlags() const { return TargetFlags; }
void makeAbsolute(Addressable &A) {
     Base = &A;
     Offset = 0;
   }
 
   void setBlock(Block &B) { Base = &B; }
 
   static constexpr uint64_t MaxOffset = (1ULL << 59) - 1;
 
-  // FIXME: A char* or SymbolStringPtr may pack better.
-  StringRef Name;
+  orc::SymbolStringPtr Name;
   Addressable *Base = nullptr;
   uint64_t Offset : 57;
   uint64_t L : 1;
   uint64_t S : 2;
   uint64_t IsLive : 1;
   uint64_t IsCallable : 1;
   uint64_t WeakRef : 1;
   uint64_t TargetFlags : 1;
public:
 
   using const_block_iterator =
       nested_collection_iterator<const_section_iterator,
                                  Section::const_block_iterator, const Block *,
                                  getSectionConstBlocks>;
 
   using GetEdgeKindNameFunction = const char *(*)(Edge::Kind);
 
-  LinkGraph(std::string Name, const Triple &TT, SubtargetFeatures Features,
+  LinkGraph(std::string Name,  std::shared_ptr<orc::SymbolStringPool> SSP, const Triple &TT, SubtargetFeatures Features,
             unsigned PointerSize, llvm::endianness Endianness,
             GetEdgeKindNameFunction GetEdgeKindName)
-      : Name(std::move(Name)), TT(TT), Features(std::move(Features)),
+      : Name(std::move(Name)), SSP(SSP), TT(TT), Features(std::move(Features)),
         PointerSize(PointerSize), Endianness(Endianness),
         GetEdgeKindName(std::move(GetEdgeKindName)) {}
 
-  LinkGraph(std::string Name, const Triple &TT, unsigned PointerSize,
+  LinkGraph(std::string Name,
+            std::shared_ptr<orc::SymbolStringPool> SSP,
+            const Triple &TT, unsigned PointerSize,
             llvm::endianness Endianness,
             GetEdgeKindNameFunction GetEdgeKindName)
-      : LinkGraph(std::move(Name), TT, SubtargetFeatures(), PointerSize,
+      : LinkGraph(std::move(Name), SSP, TT, SubtargetFeatures(), PointerSize,
                   Endianness, GetEdgeKindName) {}
 
   LinkGraph(const LinkGraph &) = delete;
   LinkGraph &operator=(const LinkGraph &) = delete;
   LinkGraph(LinkGraph &&) = delete;
   LinkGraph &operator=(LinkGraph &&) = delete;
+  ~LinkGraph();
 
   /// Returns the name of this graph (usually the name of the original
   /// underlying MemoryBuffer).
   const std::string &getName() const { return Name; }
 
   /// Returns the target triple for this Graph.
   const Triple &getTargetTriple() const { return TT; }
 
   /// Return the subtarget features for this Graph.
   const SubtargetFeatures &getFeatures() const { return Features; }
 
   /// Returns the pointer size for use in this graph.
   unsigned getPointerSize() const { return PointerSize; }
 
   /// Returns the endianness of content in this graph.
   llvm::endianness getEndianness() const { return Endianness; }
 
   const char *getEdgeKindName(Edge::Kind K) const { return GetEdgeKindName(K); }
 
+  std::shared_ptr<orc::SymbolStringPool> getSymbolStringPool() { return SSP; }
+
   /// Allocate a mutable buffer of the given size using the LinkGraph's
   /// allocator.
   MutableArrayRef<char> allocateBuffer(size_t Size) {
     return {Allocator.Allocate<char>(Size), Size};
   }
 
   /// Allocate a copy of the given string using the LinkGraph's allocator.
   /// This can be useful when renaming symbols or adding new content to the
public:
   /// 3. The cache is not automatically updated if new symbols are introduced
   ///    between calls to splitBlock. Any newly introduced symbols may be
   ///    added to the cache manually (descending offset order must be
   ///    preserved), or the cache can be set to None and rebuilt by
   ///    splitBlock on the next call.
   Block &splitBlock(Block &B, size_t SplitIndex,
                     SplitBlockCache *Cache = nullptr);
 
+  //
+  orc::SymbolStringPtr intern(StringRef SymbolName) {
+    return SSP->intern(SymbolName);
+  }
   /// Add an external symbol.
   /// Some formats (e.g. ELF) allow Symbols to have sizes. For Symbols whose
   /// size is not known, you should substitute '0'.
   /// The IsWeaklyReferenced argument determines whether the symbol must be
   /// present during lookup: Externals that are strongly referenced must be
   /// found or an error will be emitted. Externals that are weakly referenced
   /// are permitted to be undefined, in which case they are assigned an address
   /// of 0.
-  Symbol &addExternalSymbol(StringRef Name, orc::ExecutorAddrDiff Size,
+  Symbol &addExternalSymbol(orc::SymbolStringPtr &&Name,
+                            orc::ExecutorAddrDiff Size,
                             bool IsWeaklyReferenced) {
-    assert(!ExternalSymbols.contains(Name) && "Duplicate external symbol");
+    assert(!ExternalSymbols.contains(*Name) && "Duplicate external symbol");
     auto &Sym = Symbol::constructExternal(
-        Allocator, createAddressable(orc::ExecutorAddr(), false), Name, Size,
+        Allocator, createAddressable(orc::ExecutorAddr(), false), 
+        std::move(Name), Size,
         Linkage::Strong, IsWeaklyReferenced);
-    ExternalSymbols.insert({Sym.getName(), &Sym});
+    ExternalSymbols.insert({*Sym.getName(), &Sym});
     return Sym;
   }
 
+  Symbol &addExternalSymbol(StringRef Name, orc::ExecutorAddrDiff Size,
+                            bool IsWeaklyReferenced) {
+    return addExternalSymbol(SSP->intern(Name), Size, IsWeaklyReferenced);
+  }
+
   /// Add an absolute symbol.
-  Symbol &addAbsoluteSymbol(StringRef Name, orc::ExecutorAddr Address,
+  Symbol &addAbsoluteSymbol(orc::SymbolStringPtr Name,
+                            orc::ExecutorAddr Address,
                             orc::ExecutorAddrDiff Size, Linkage L, Scope S,
                             bool IsLive) {
     assert((S == Scope::Local || llvm::count_if(AbsoluteSymbols,
                                                [&](const Symbol *Sym) {
                                                  return Sym->getName() == Name;
                                                }) == 0) &&
                                     "Duplicate absolute symbol");
     auto &Sym = Symbol::constructAbsolute(Allocator, createAddressable(Address),
-                                          Name, Size, L, S, IsLive);
+                                          std::move(Name), Size, L, S, IsLive);
     AbsoluteSymbols.insert(&Sym);
     return Sym;
   }
 
+  Symbol &addAbsoluteSymbol(StringRef Name, orc::ExecutorAddr Address,
+                            orc::ExecutorAddrDiff Size, Linkage L, Scope S,
+                            bool IsLive) {
+
+    return addAbsoluteSymbol(SSP->intern(Name), Address, Size, L, S, IsLive);
+  }
+
   /// Add an anonymous symbol.
   Symbol &addAnonymousSymbol(Block &Content, orc::ExecutorAddrDiff Offset,
                              orc::ExecutorAddrDiff Size, bool IsCallable,
                              bool IsLive) {
     auto &Sym = Symbol::constructAnonDef(Allocator, Content, Offset, Size,
                                          IsCallable, IsLive);
     Content.getSection().addSymbol(Sym);
     return Sym;
   }
 
   /// Add a named symbol.
   Symbol &addDefinedSymbol(Block &Content, orc::ExecutorAddrDiff Offset,
                            StringRef Name, orc::ExecutorAddrDiff Size,
                            Linkage L, Scope S, bool IsCallable, bool IsLive) {
+    return addDefinedSymbol(Content, Offset, SSP->intern(Name), Size, L, S,
+                            IsCallable, IsLive);
+  }
+
+  Symbol &addDefinedSymbol(Block &Content, orc::ExecutorAddrDiff Offset,
+                           orc::SymbolStringPtr Name,
+                           orc::ExecutorAddrDiff Size, Linkage L, Scope S,
+                           bool IsCallable, bool IsLive) {
     assert((S == Scope::Local || llvm::count_if(defined_symbols(),
                                                 [&](const Symbol *Sym) {
                                                   return Sym->getName() == Name;
                                                 }) == 0) &&
            "Duplicate defined symbol");
-    auto &Sym = Symbol::constructNamedDef(Allocator, Content, Offset, Name,
-                                          Size, L, S, IsLive, IsCallable);
+    auto &Sym =
+        Symbol::constructNamedDef(Allocator, Content, Offset, std::move(Name),
     Content.getSection().addSymbol(Sym);
     return Sym;
   }
 
   iterator_range<section_iterator> sections() {
     return make_range(
         section_iterator(Sections.begin(), GetSectionMapEntryValue()),
         section_iterator(Sections.end(), GetSectionMapEntryValue()));
if (Sym.isAbsolute()) {
       A.setAbsolute(false);
       A.setAddress(orc::ExecutorAddr());
     } else {
       assert(Sym.isDefined() && "Sym is not a defined symbol");
       Section &Sec = Sym.getBlock().getSection();
       Sec.removeSymbol(Sym);
       Sym.makeExternal(createAddressable(orc::ExecutorAddr(), false));
     }
-    ExternalSymbols.insert({Sym.getName(), &Sym});
+    ExternalSymbols.insert({*Sym.getName(), &Sym});
   }
 
   /// Make the given symbol an absolute with the given address (must not already
   /// be absolute).
   ///
   /// The symbol's size, linkage, and callability, and liveness will be left
   /// unchanged, and its offset will be reset to 0.
   ///
   /// If the symbol was external then its scope will be set to local, otherwise
   /// it will be left unchanged.
   void makeAbsolute(Symbol &Sym, orc::ExecutorAddr Address) {
     assert(!Sym.isAbsolute() && "Symbol is already absolute");
     if (Sym.isExternal()) {
-      assert(ExternalSymbols.contains(Sym.getName()) &&
+      assert(ExternalSymbols.contains(*Sym.getName()) &&
              "Sym is not in the absolute symbols set");
       assert(Sym.getOffset() == 0 && "External is not at offset 0");
-      ExternalSymbols.erase(Sym.getName());
+      ExternalSymbols.erase(*Sym.getName());
       auto &A = Sym.getAddressable();
       A.setAbsolute(true);
       A.setAddress(Address);
       Sym.setScope(Scope::Local);
     } else {
       assert(Sym.isDefined() && "Sym is not a defined symbol");
       Section &Sec = Sym.getBlock().getSection();
       Sec.removeSymbol(Sym);
       Sym.makeAbsolute(createAddressable(Address));
     }
     AbsoluteSymbols.insert(&Sym);
   }
 
   /// Turn an absolute or external symbol into a defined one by attaching it to
   /// a block. Symbol must not already be defined.
   void makeDefined(Symbol &Sym, Block &Content, orc::ExecutorAddrDiff Offset,
                    orc::ExecutorAddrDiff Size, Linkage L, Scope S,
                    bool IsLive) {
     assert(!Sym.isDefined() && "Sym is already a defined symbol");
     if (Sym.isAbsolute()) {
       assert(AbsoluteSymbols.count(&Sym) &&
              "Symbol is not in the absolutes set");
       AbsoluteSymbols.erase(&Sym);
     } else {
-      assert(ExternalSymbols.contains(Sym.getName()) &&
+      assert(ExternalSymbols.contains(*Sym.getName()) &&
              "Symbol is not in the externals set");
-      ExternalSymbols.erase(Sym.getName());
+      ExternalSymbols.erase(*Sym.getName());
     }
     Addressable &OldBase = *Sym.Base;
     Sym.setBlock(Content);
     Sym.setOffset(Offset);
     Sym.setSize(Size);
     Sym.setLinkage(L);
     Sym.setScope(S);
     Sym.setLive(IsLive);
void mergeSections(Section &DstSection, Section &SrcSection,
     if (!PreserveSrcSection)
       removeSection(SrcSection);
   }
 
   /// Removes an external symbol. Also removes the underlying Addressable.
   void removeExternalSymbol(Symbol &Sym) {
     assert(!Sym.isDefined() && !Sym.isAbsolute() &&
            "Sym is not an external symbol");
-    assert(ExternalSymbols.contains(Sym.getName()) &&
+    assert(ExternalSymbols.contains(*Sym.getName()) &&
            "Symbol is not in the externals set");
-    ExternalSymbols.erase(Sym.getName());
+    ExternalSymbols.erase(*Sym.getName());
     Addressable &Base = *Sym.Base;
     assert(llvm::none_of(external_symbols(),
                          [&](Symbol *AS) { return AS->Base == &Base; }) &&
            "Base addressable still in use");
     destroySymbol(Sym);
     destroyAddressable(Base);
   }
 
public:
   void dump(raw_ostream &OS);
 
 private:
   // Put the BumpPtrAllocator first so that we don't free any of the underlying
   // memory until the Symbol/Addressable destructors have been run.
   BumpPtrAllocator Allocator;
 
   std::string Name;
+  std::shared_ptr<orc::SymbolStringPool> SSP;
   Triple TT;
   SubtargetFeatures Features;
   unsigned PointerSize;
   llvm::endianness Endianness;
   GetEdgeKindNameFunction GetEdgeKindName = nullptr;
   DenseMap<StringRef, std::unique_ptr<Section>> Sections;
   ExternalSymbolMap ExternalSymbols;
   AbsoluteSymbolSet AbsoluteSymbols;

 ///
 /// FIXME: These basically duplicate orc::SymbolLookupFlags -- We should merge
 ///        the two types once we have an OrcSupport library.
 enum class SymbolLookupFlags { RequiredSymbol, WeaklyReferencedSymbol };
 
 raw_ostream &operator<<(raw_ostream &OS, const SymbolLookupFlags &LF);
 
 /// A map of symbol names to resolved addresses.
-using AsyncLookupResult = DenseMap<StringRef, orc::ExecutorSymbolDef>;
+using AsyncLookupResult =
+    DenseMap<orc::SymbolStringPtr, orc::ExecutorSymbolDef>;
 
 /// A function object to call with a resolved symbol map (See AsyncLookupResult)
 /// or an error if resolution failed.
 class JITLinkAsyncLookupContinuation {
 public:
   virtual ~JITLinkAsyncLookupContinuation() = default;
   virtual void run(Expected<AsyncLookupResult> LR) = 0;
 
createLookupContinuation(Continuation Cont) {
   };
 
   return std::make_unique<Impl>(std::move(Cont));
 }
 
 /// Holds context for a single jitLink invocation.
 class JITLinkContext {
 public:
-  using LookupMap = DenseMap<StringRef, SymbolLookupFlags>;
+  using LookupMap = DenseMap<orc::SymbolStringPtr, SymbolLookupFlags>;
 
   /// Create a JITLinkContext.
   JITLinkContext(const JITLinkDylib *JD) : JD(JD) {}
 
   /// Destroy a JITLinkContext.
   virtual ~JITLinkContext();
 
   /// Return the JITLinkDylib that this link is targeting, if any.

 }
 
 /// Create a LinkGraph from the given object buffer.
 ///
 /// Note: The graph does not take ownership of the underlying buffer, nor copy
 /// its contents. The caller is responsible for ensuring that the object buffer
 /// outlives the graph.
 Expected<std::unique_ptr<LinkGraph>>
-createLinkGraphFromObject(MemoryBufferRef ObjectBuffer);
+createLinkGraphFromObject(MemoryBufferRef ObjectBuffer,
+                          std::shared_ptr<orc::SymbolStringPool> SSP);
 
 /// Link the given graph.
 void link(std::unique_ptr<LinkGraph> G, std::unique_ptr<JITLinkContext> Ctx);
 
 } // end namespace jitlink
 } // end namespace llvm
 
 #endif // LLVM_EXECUTIONENGINE_JITLINK_JITLINK_H

llvm/include/llvm/ExecutionEngine/JITLink/MachO.h

 namespace jitlink {
 
 /// Create a LinkGraph from a MachO relocatable object.
 ///
 /// Note: The graph does not take ownership of the underlying buffer, nor copy
 /// its contents. The caller is responsible for ensuring that the object buffer
 /// outlives the graph.
 Expected<std::unique_ptr<LinkGraph>>
-createLinkGraphFromMachOObject(MemoryBufferRef ObjectBuffer);
+createLinkGraphFromMachOObject(MemoryBufferRef ObjectBuffer,
+                               std::shared_ptr<orc::SymbolStringPool> SSP);
 
 /// jit-link the given ObjBuffer, which must be a MachO object file.
 ///
 /// Uses conservative defaults for GOT and stub handling based on the target
 /// platform.
 void link_MachO(std::unique_ptr<LinkGraph> G,
                 std::unique_ptr<JITLinkContext> Ctx);
 
 } // end namespace jitlink
 } // end namespace llvm
 
 #endif // LLVM_EXECUTIONENGINE_JITLINK_MACHO_H

llvm/include/llvm/ExecutionEngine/JITLink/MachO_arm64.h

 namespace llvm {
 namespace jitlink {
 
 /// Create a LinkGraph from a MachO/arm64 relocatable object.
 ///
 /// Note: The graph does not take ownership of the underlying buffer, nor copy
 /// its contents. The caller is responsible for ensuring that the object buffer
 /// outlives the graph.
-Expected<std::unique_ptr<LinkGraph>>
-createLinkGraphFromMachOObject_arm64(MemoryBufferRef ObjectBuffer);
+Expected<std::unique_ptr<LinkGraph>> createLinkGraphFromMachOObject_arm64(
+    MemoryBufferRef ObjectBuffer, std::shared_ptr<orc::SymbolStringPool> SSP);
 
 /// jit-link the given object buffer, which must be a MachO arm64 object file.
 ///
 /// If PrePrunePasses is empty then a default mark-live pass will be inserted
 /// that will mark all exported atoms live. If PrePrunePasses is not empty, the
 /// caller is responsible for including a pass to mark atoms as live.
 ///
 /// If PostPrunePasses is empty then a default GOT-and-stubs insertion pass will

llvm/include/llvm/ExecutionEngine/JITLink/MachO_x86_64.h

 namespace llvm {
 namespace jitlink {
 
 /// Create a LinkGraph from a MachO/x86-64 relocatable object.
 ///
 /// Note: The graph does not take ownership of the underlying buffer, nor copy
 /// its contents. The caller is responsible for ensuring that the object buffer
 /// outlives the graph.
-Expected<std::unique_ptr<LinkGraph>>
-createLinkGraphFromMachOObject_x86_64(MemoryBufferRef ObjectBuffer);
+Expected<std::unique_ptr<LinkGraph>> createLinkGraphFromMachOObject_x86_64(
+    MemoryBufferRef ObjectBuffer, std::shared_ptr<orc::SymbolStringPool> SSP);
 
 /// jit-link the given LinkGraph.
 ///
 /// If PrePrunePasses is empty then a default mark-live pass will be inserted
 /// that will mark all exported atoms live. If PrePrunePasses is not empty, the
 /// caller is responsible for including a pass to mark atoms as live.
 ///
 /// If PostPrunePasses is empty then a default GOT-and-stubs insertion pass will

llvm/include/llvm/ExecutionEngine/JITLink/TableManager.h

Symbol &getEntryForTarget(LinkGraph &G, Symbol &Target) {
 
     auto EntryI = Entries.find(Target.getName());
 
     // Build the entry if it doesn't exist.
     if (EntryI == Entries.end()) {
       auto &Entry = impl().createEntry(G, Target);
       DEBUG_WITH_TYPE("jitlink", {
         dbgs() << "    Created " << impl().getSectionName() << " entry for "
-               << Target.getName() << ": " << Entry << "\n";
+               << *Target.getName() << ": " << Entry << "\n";
       });
       EntryI = Entries.insert(std::make_pair(Target.getName(), &Entry)).first;
     }
 
     assert(EntryI != Entries.end() && "Could not get entry symbol");
     DEBUG_WITH_TYPE("jitlink", {
       dbgs() << "    Using " << impl().getSectionName() << " entry "
              << *EntryI->second << "\n";
auto Res = Entries.insert({
         Target.getName(),
         &Entry,
     });
     return Res.second;
   }
 
 private:
   TableManagerImplT &impl() { return static_cast<TableManagerImplT &>(*this); }
-  DenseMap<StringRef, Symbol *> Entries;
+  DenseMap<orc::SymbolStringPtr, Symbol *> Entries;
 };
 
 } // namespace jitlink
 } // namespace llvm
 
 #endif

llvm/lib/ExecutionEngine/JITLink/COFF.cpp

static StringRef getMachineName(uint16_t Machine) {
   case COFF::IMAGE_FILE_MACHINE_ARM64:
     return "ARM64";
   default:
     return "unknown";
   }
 }
 
 Expected<std::unique_ptr<LinkGraph>>
-createLinkGraphFromCOFFObject(MemoryBufferRef ObjectBuffer) {
+createLinkGraphFromCOFFObject(MemoryBufferRef ObjectBuffer,
+                              std::shared_ptr<orc::SymbolStringPool> SSP) {
   StringRef Data = ObjectBuffer.getBuffer();
 
   // Check magic
   auto Magic = identify_magic(ObjectBuffer.getBuffer());
   if (Magic != file_magic::coff_object)
     return make_error<JITLinkError>("Invalid COFF buffer");
 
   if (Data.size() < sizeof(object::coff_file_header))
LLVM_DEBUG({
     dbgs() << "jitLink_COFF: PE = " << (IsPE ? "yes" : "no")
            << ", bigobj = " << (COFFBigObjHeader ? "yes" : "no")
            << ", identifier = \"" << ObjectBuffer.getBufferIdentifier() << "\" "
            << "machine = " << getMachineName(Machine) << "\n";
   });
 
   switch (Machine) {
   case COFF::IMAGE_FILE_MACHINE_AMD64:
-    return createLinkGraphFromCOFFObject_x86_64(ObjectBuffer);
+    return createLinkGraphFromCOFFObject_x86_64(ObjectBuffer, SSP);
   default:
     return make_error<JITLinkError>(
         "Unsupported target machine architecture in COFF object " +
         ObjectBuffer.getBufferIdentifier() + ": " + getMachineName(Machine));
   }
 }
 
 void link_COFF(std::unique_ptr<LinkGraph> G,

llvm/lib/ExecutionEngine/JITLink/COFFLinkGraphBuilder.h

 public:
   virtual ~COFFLinkGraphBuilder();
   Expected<std::unique_ptr<LinkGraph>> buildGraph();
 
 protected:
   using COFFSectionIndex = int32_t;
   using COFFSymbolIndex = int32_t;
 
-  COFFLinkGraphBuilder(const object::COFFObjectFile &Obj, Triple TT,
+  COFFLinkGraphBuilder(const object::COFFObjectFile &Obj,
+                       std::shared_ptr<orc::SymbolStringPool> SSP, Triple TT,
                        SubtargetFeatures Features,
                        LinkGraph::GetEdgeKindNameFunction GetEdgeKindName);
 
   LinkGraph &getGraph() const { return *G; }
 
   const object::COFFObjectFile &getObject() const { return Obj; }
 
   virtual Error addRelocations() = 0;
private:
 
   // Per COFF section jitlink symbol set sorted by offset.
   // Used for calculating implicit size of defined symbols.
   using SymbolSet = std::set<std::pair<orc::ExecutorAddrDiff, Symbol *>>;
   std::vector<SymbolSet> SymbolSets;
 
   Section &getCommonSection();
 
-  Symbol *createExternalSymbol(COFFSymbolIndex SymIndex, StringRef SymbolName,
+  Symbol *createExternalSymbol(COFFSymbolIndex SymIndex,
+                               orc::SymbolStringPtr SymbolName,
                                object::COFFSymbolRef Symbol,
                                const object::coff_section *Section);
-  Expected<Symbol *> createAliasSymbol(StringRef SymbolName, Linkage L, Scope S,
-                                       Symbol &Target);
+  Expected<Symbol *> createAliasSymbol(orc::SymbolStringPtr SymbolName,
+                                       Linkage L, Scope S, Symbol &Target);
   Expected<Symbol *> createDefinedSymbol(COFFSymbolIndex SymIndex,
-                                         StringRef SymbolName,
+                                         orc::SymbolStringPtr SymbolName,
                                          object::COFFSymbolRef Symbol,
                                          const object::coff_section *Section);
   Expected<Symbol *> createCOMDATExportRequest(
       COFFSymbolIndex SymIndex, object::COFFSymbolRef Symbol,
       const object::coff_aux_section_definition *Definition);
   Expected<Symbol *> exportCOMDATSymbol(COFFSymbolIndex SymIndex,
-                                        StringRef SymbolName,
+                                        orc::SymbolStringPtr SymbolName,
                                         object::COFFSymbolRef Symbol);
 
   Error handleDirectiveSection(StringRef Str);
   Error flushWeakAliasRequests();
   Error handleAlternateNames();
   Error calculateImplicitSizeOfSymbols();
 
   static uint64_t getSectionAddress(const object::COFFObjectFile &Obj,
private:
   const object::COFFObjectFile &Obj;
   std::unique_ptr<LinkGraph> G;
   COFFDirectiveParser DirectiveParser;
 
   Section *CommonSection = nullptr;
   std::vector<Block *> GraphBlocks;
   std::vector<Symbol *> GraphSymbols;
 
-  DenseMap<StringRef, StringRef> AlternateNames;
-  DenseMap<StringRef, Symbol *> ExternalSymbols;
-  DenseMap<StringRef, Symbol *> DefinedSymbols;
+  DenseMap<orc::SymbolStringPtr, orc::SymbolStringPtr> AlternateNames;
+  DenseMap<orc::SymbolStringPtr, Symbol *> ExternalSymbols;
+  DenseMap<orc::SymbolStringPtr, Symbol *> DefinedSymbols;
 };
 
 template <typename RelocHandlerFunction>
 Error COFFLinkGraphBuilder::forEachRelocation(const object::SectionRef &RelSec,
                                               RelocHandlerFunction &&Func,
                                               bool ProcessDebugSections) {
 
   auto COFFRelSect = Obj.getCOFFSection(RelSec);

llvm/lib/ExecutionEngine/JITLink/COFFLinkGraphBuilder.cpp

 //=--------- COFFLinkGraphBuilder.cpp - COFF LinkGraph builder ----------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // Generic COFF LinkGraph building code.
 //
 //===----------------------------------------------------------------------===//
 #include "COFFLinkGraphBuilder.h"
 
+#include <memory>
+
 #define DEBUG_TYPE "jitlink"
 
 static const char *CommonSectionName = "__common";
 
 namespace llvm {
 namespace jitlink {
 
 static Triple createTripleWithCOFFFormat(Triple T) {
   T.setObjectFormat(Triple::COFF);
   return T;
 }
 
 COFFLinkGraphBuilder::COFFLinkGraphBuilder(
-    const object::COFFObjectFile &Obj, Triple TT, SubtargetFeatures Features,
+    const object::COFFObjectFile &Obj,
+    std::shared_ptr<orc::SymbolStringPool> SSP,
+    Triple TT, SubtargetFeatures Features,
     LinkGraph::GetEdgeKindNameFunction GetEdgeKindName)
     : Obj(Obj), G(std::make_unique<LinkGraph>(
-                    Obj.getFileName().str(), createTripleWithCOFFFormat(TT),
+                    Obj.getFileName().str(), SSP,createTripleWithCOFFFormat(TT),
                     std::move(Features), getPointerSize(Obj),
-                    getEndianness(Obj), std::move(GetEdgeKindName))) {
+                    getEndianness(Obj), std::move(GetEdgeKindName))) {    
   LLVM_DEBUG({
     dbgs() << "Created COFFLinkGraphBuilder for \"" << Obj.getFileName()
            << "\"\n";
   });
 }
 
 COFFLinkGraphBuilder::~COFFLinkGraphBuilder() = default;
 
for (COFFSymbolIndex SymIndex = 0;
     if (!COFF::isReservedSectionNumber(SectionIndex)) {
       auto SecOrErr = Obj.getSection(SectionIndex);
       if (!SecOrErr)
         return make_error<JITLinkError>(
             "Invalid COFF section number:" + formatv("{0:d}: ", SectionIndex) +
             " (" + toString(SecOrErr.takeError()) + ")");
       Sec = *SecOrErr;
     }
+    auto InternedSymbolName = G->intern(std::move(SymbolName));
 
     // Create jitlink symbol
     jitlink::Symbol *GSym = nullptr;
     if (Sym->isFileRecord())
       LLVM_DEBUG({
         dbgs() << "    " << SymIndex << ": Skipping FileRecord symbol \""
-               << SymbolName << "\" in "
+               << *InternedSymbolName << "\" in "
                << getCOFFSectionName(SectionIndex, Sec, *Sym)
                << " (index: " << SectionIndex << ") \n";
       });
     else if (Sym->isUndefined()) {
-      GSym = createExternalSymbol(SymIndex, SymbolName, *Sym, Sec);
+      GSym = createExternalSymbol(SymIndex, InternedSymbolName, *Sym, Sec);
     } else if (Sym->isWeakExternal()) {
       auto *WeakExternal = Sym->getAux<object::coff_aux_weak_external>();
       COFFSymbolIndex TagIndex = WeakExternal->TagIndex;
       uint32_t Characteristics = WeakExternal->Characteristics;
       WeakExternalRequests.push_back(
           {SymIndex, TagIndex, Characteristics, SymbolName});
     } else {
       Expected<jitlink::Symbol *> NewGSym =
-          createDefinedSymbol(SymIndex, SymbolName, *Sym, Sec);
+          createDefinedSymbol(SymIndex, InternedSymbolName, *Sym, Sec);
       if (!NewGSym)
         return NewGSym.takeError();
       GSym = *NewGSym;
       if (GSym) {
         LLVM_DEBUG({
           dbgs() << "    " << SymIndex
                  << ": Creating defined graph symbol for COFF symbol \""
-                 << SymbolName << "\" in "
+                 << *InternedSymbolName << "\" in "
                  << getCOFFSectionName(SectionIndex, Sec, *Sym)
                  << " (index: " << SectionIndex << ") \n";
           dbgs() << "      " << *GSym << "\n";
         });
       }
     }
 
     // Register the symbol
for (auto *Arg : *Parsed) {
     StringRef S = Arg->getValue();
     switch (Arg->getOption().getID()) {
     case COFF_OPT_alternatename: {
       StringRef From, To;
       std::tie(From, To) = S.split('=');
       if (From.empty() || To.empty())
         return make_error<JITLinkError>(
             "Invalid COFF /alternatename directive");
-      AlternateNames[From] = To;
+      AlternateNames[G->intern(From)] =  G->intern(To);
       break;
     }
     case COFF_OPT_incl: {
-      auto DataCopy = G->allocateContent(S);
-      StringRef StrCopy(DataCopy.data(), DataCopy.size());
-      ExternalSymbols[StrCopy] = &G->addExternalSymbol(StrCopy, 0, false);
-      ExternalSymbols[StrCopy]->setLive(true);
+      auto Symbol = &G->addExternalSymbol(S, 0, false);
+      Symbol->setLive(true);
+      ExternalSymbols[Symbol->getName()] = Symbol;
       break;
     }
     case COFF_OPT_export:
       break;
     default: {
       LLVM_DEBUG({
         dbgs() << "Unknown coff directive: " << Arg->getSpelling() << "\n";
       });
       break;
if (auto *Target = getGraphSymbol(WeakExternal.Target)) {
 
       // FIXME: IMAGE_WEAK_EXTERN_SEARCH_NOLIBRARY and
       // IMAGE_WEAK_EXTERN_SEARCH_LIBRARY are handled in the same way.
       Scope S =
           WeakExternal.Characteristics == COFF::IMAGE_WEAK_EXTERN_SEARCH_ALIAS
               ? Scope::Default
               : Scope::Local;
 
-      auto NewSymbol =
-          createAliasSymbol(WeakExternal.SymbolName, Linkage::Weak, S, *Target);
+      auto NewSymbol = createAliasSymbol(G->intern(WeakExternal.SymbolName),
+                                         Linkage::Weak, S, *Target);
       if (!NewSymbol)
         return NewSymbol.takeError();
       setGraphSymbol(AliasSymbol->getSectionNumber(), WeakExternal.Alias,
                      **NewSymbol);
       LLVM_DEBUG({
         dbgs() << "    " << WeakExternal.Alias
                << ": Creating weak external symbol for COFF symbol \""
                << WeakExternal.SymbolName << "\" in section "
                << AliasSymbol->getSectionNumber() << "\n";
         dbgs() << "      " << **NewSymbol << "\n";
       });
     } else
       return make_error<JITLinkError>("Weak symbol alias requested but actual "
                                       "symbol not found for symbol " +
                                       formatv("{0:d}", WeakExternal.Alias));
   }
   return Error::success();
 }
 
 Error COFFLinkGraphBuilder::handleAlternateNames() {
-  for (auto &KeyValue : AlternateNames)
-    if (DefinedSymbols.count(KeyValue.second) &&
-        ExternalSymbols.count(KeyValue.first)) {
-      auto *Target = DefinedSymbols[KeyValue.second];
-      auto *Alias = ExternalSymbols[KeyValue.first];
+  for (auto &KeyValue : AlternateNames) {
+    auto DefinedSymbolName = KeyValue.second;
+    auto ExternalSymbolsName = KeyValue.first;
+    if (DefinedSymbols.count(DefinedSymbolName) &&
+        ExternalSymbols.count(ExternalSymbolsName)) {
+      auto *Target = DefinedSymbols[DefinedSymbolName];
+      auto *Alias = ExternalSymbols[ExternalSymbolsName];
       G->makeDefined(*Alias, Target->getBlock(), Target->getOffset(),
                      Target->getSize(), Linkage::Weak, Scope::Local, false);
     }
+  }
   return Error::success();
 }
 
 Symbol *COFFLinkGraphBuilder::createExternalSymbol(
-    COFFSymbolIndex SymIndex, StringRef SymbolName,
+    COFFSymbolIndex SymIndex, orc::SymbolStringPtr SymbolName,
     object::COFFSymbolRef Symbol, const object::coff_section *Section) {
-  if (!ExternalSymbols.count(SymbolName))
-    ExternalSymbols[SymbolName] =
-        &G->addExternalSymbol(SymbolName, Symbol.getValue(), false);
+  llvm::jitlink::Symbol *sym = nullptr;
+  if (!ExternalSymbols.count(SymbolName)) {
+    sym =
+        &G->addExternalSymbol(*SymbolName, Symbol.getValue(), false);
+    ExternalSymbols[sym->getName()] = sym;
+  } else {
+    sym = ExternalSymbols[SymbolName];
+  }
 
   LLVM_DEBUG({
     dbgs() << "    " << SymIndex
            << ": Creating external graph symbol for COFF symbol \""
-           << SymbolName << "\" in "
+           << *sym->getName() << "\" in "
            << getCOFFSectionName(Symbol.getSectionNumber(), Section, Symbol)
            << " (index: " << Symbol.getSectionNumber() << ") \n";
   });
-  return ExternalSymbols[SymbolName];
+  return sym;
 }
 
-Expected<Symbol *> COFFLinkGraphBuilder::createAliasSymbol(StringRef SymbolName,
-                                                           Linkage L, Scope S,
-                                                           Symbol &Target) {
+Expected<Symbol *>
+COFFLinkGraphBuilder::createAliasSymbol(orc::SymbolStringPtr SymbolName,
+                                        Linkage L, Scope S, Symbol &Target) {
   if (!Target.isDefined()) {
     // FIXME: Support this when there's a way to handle this.
     return make_error<JITLinkError>("Weak external symbol with external "
                                     "symbol as alternative not supported.");
   }
   return &G->addDefinedSymbol(Target.getBlock(), Target.getOffset(), SymbolName,
                               Target.getSize(), L, S, Target.isCallable(),
                               false);
for (auto It = SymbolSet.rbegin(); It != SymbolSet.rend(); It++) {
 
       Symbol->setSize(CandSize);
     }
   }
   return Error::success();
 }
 
 Expected<Symbol *> COFFLinkGraphBuilder::createDefinedSymbol(
-    COFFSymbolIndex SymIndex, StringRef SymbolName,
+    COFFSymbolIndex SymIndex, orc::SymbolStringPtr SymbolName,
     object::COFFSymbolRef Symbol, const object::coff_section *Section) {
+
   if (Symbol.isCommon()) {
     // FIXME: correct alignment
     return &G->addDefinedSymbol(
         G->createZeroFillBlock(getCommonSection(), Symbol.getValue(),
                                orc::ExecutorAddr(), Symbol.getValue(), 0),
         0, SymbolName, Symbol.getValue(), Linkage::Strong, Scope::Default,
         false, false);
   }
+
   if (Symbol.isAbsolute())
     return &G->addAbsoluteSymbol(SymbolName,
                                  orc::ExecutorAddr(Symbol.getValue()), 0,
                                  Linkage::Strong, Scope::Local, false);
 
   if (llvm::COFF::isReservedSectionNumber(Symbol.getSectionNumber()))
     return make_error<JITLinkError>(
         "Reserved section number used in regular symbol " +
         formatv("{0:d}", SymIndex));
 
   Block *B = getGraphBlock(Symbol.getSectionNumber());
   if (!B) {
     LLVM_DEBUG({
       dbgs() << "    " << SymIndex
              << ": Skipping graph symbol since section was not created for "
                 "COFF symbol \""
-             << SymbolName << "\" in section " << Symbol.getSectionNumber()
+             << *SymbolName << "\" in section " << Symbol.getSectionNumber()
              << "\n";
     });
     return nullptr;
   }
 
   if (Symbol.isExternal()) {
     // This is not a comdat sequence, export the symbol as it is
     if (!isComdatSection(Section)) {
Expected<Symbol *> COFFLinkGraphBuilder::createCOMDATExportRequest(
   PendingComdatExports[Symbol.getSectionNumber()] = {SymIndex, L,
                                                      Definition->Length};
   return nullptr;
 }
 
 // Process the second symbol of COMDAT sequence.
 Expected<Symbol *>
 COFFLinkGraphBuilder::exportCOMDATSymbol(COFFSymbolIndex SymIndex,
-                                         StringRef SymbolName,
+                                         orc::SymbolStringPtr SymbolName,
                                          object::COFFSymbolRef Symbol) {
   Block *B = getGraphBlock(Symbol.getSectionNumber());
   auto &PendingComdatExport = PendingComdatExports[Symbol.getSectionNumber()];
   // NOTE: ComdatDef->Length is the size of "section" not size of symbol.
   // We use zero symbol size to not reach out of bound of block when symbol
   // offset is non-zero.
   auto GSym = &G->addDefinedSymbol(
       *B, Symbol.getValue(), SymbolName, 0, PendingComdatExport->Linkage,
       Scope::Default, Symbol.getComplexType() == COFF::IMAGE_SYM_DTYPE_FUNCTION,
       false);
   LLVM_DEBUG({
     dbgs() << "    " << SymIndex
-           << ": Exporting COMDAT graph symbol for COFF symbol \"" << SymbolName
-           << "\" in section " << Symbol.getSectionNumber() << "\n";
+           << ": Exporting COMDAT graph symbol for COFF symbol \""
+           << *SymbolName << "\" in section " << Symbol.getSectionNumber()
+           << "\n";
     dbgs() << "      " << *GSym << "\n";
   });
   setGraphSymbol(Symbol.getSectionNumber(), PendingComdatExport->SymbolIndex,
                  *GSym);
   DefinedSymbols[SymbolName] = GSym;
   PendingComdatExport = std::nullopt;
   return GSym;
 }
 
 } // namespace jitlink
 } // namespace llvm

llvm/lib/ExecutionEngine/JITLink/COFF_x86_64.cpp

Error addSingleRelocation(const object::RelocationRef &Rel,
     case COFF::RelocationTypeAMD64::IMAGE_REL_AMD64_SECTION: {
       Kind = EdgeKind_coff_x86_64::SectionIdx16;
       Addend = *reinterpret_cast<const support::little16_t *>(FixupPtr);
       uint64_t SectionIdx = 0;
       if (COFFSymbol.isAbsolute())
         SectionIdx = getObject().getNumberOfSections() + 1;
       else
         SectionIdx = COFFSymbol.getSectionNumber();
+
       auto *AbsSym = &getGraph().addAbsoluteSymbol(
           "secidx", orc::ExecutorAddr(SectionIdx), 2, Linkage::Strong,
           Scope::Local, false);
       GraphSymbol = AbsSym;
       break;
     }
     case COFF::RelocationTypeAMD64::IMAGE_REL_AMD64_SECREL: {
       // FIXME: SECREL to external symbol should be handled
Error addSingleRelocation(const object::RelocationRef &Rel,
     });
 
     BlockToFix.addEdge(std::move(GE));
 
     return Error::success();
   }
 
 public:
-  COFFLinkGraphBuilder_x86_64(const object::COFFObjectFile &Obj, const Triple T,
+  COFFLinkGraphBuilder_x86_64(const object::COFFObjectFile &Obj, 
+                              std::shared_ptr<orc::SymbolStringPool> SSP,
+                              const Triple T,
                               const SubtargetFeatures Features)
-      : COFFLinkGraphBuilder(Obj, std::move(T), std::move(Features),
+      : COFFLinkGraphBuilder(Obj, std::move(SSP), std::move(T), std::move(Features),
                              getCOFFX86RelocationKindName) {}
 };
 
 class COFFLinkGraphLowering_x86_64 {
 public:
+  COFFLinkGraphLowering_x86_64(std::shared_ptr<orc::SymbolStringPool> SSP)
+      : SSP(SSP) {
+    imageBaseName = SSP->intern("__ImageBase");
+  }
   // Lowers COFF x86_64 specific edges to generic x86_64 edges.
   Error lowerCOFFRelocationEdges(LinkGraph &G, JITLinkContext &Ctx) {
     for (auto *B : G.blocks()) {
       for (auto &E : B->edges()) {
         switch (E.getKind()) {
         case EdgeKind_coff_x86_64::Pointer32NB: {
           auto ImageBase = getImageBaseAddress(G, Ctx);
           if (!ImageBase)
for (auto *B : G.blocks()) {
           break;
         }
       }
     }
     return Error::success();
   }
 
 private:
-  static StringRef getImageBaseSymbolName() { return "__ImageBase"; }
-
+  orc::SymbolStringPtr getImageBaseSymbolName() { return this->imageBaseName; }
   orc::ExecutorAddr getSectionStart(Section &Sec) {
     if (!SectionStartCache.count(&Sec)) {
       SectionRange Range(Sec);
       SectionStartCache[&Sec] = Range.getStart();
     }
     return SectionStartCache[&Sec];
   }
 
Expected<orc::ExecutorAddr> getImageBaseAddress(LinkGraph &G,
     if (Err)
       return std::move(Err);
     this->ImageBase = ImageBase;
     return ImageBase;
   }
 
   DenseMap<Section *, orc::ExecutorAddr> SectionStartCache;
   orc::ExecutorAddr ImageBase;
+  std::shared_ptr<orc::SymbolStringPool> SSP;
+  orc::SymbolStringPtr imageBaseName = nullptr;
 };
 
 Error lowerEdges_COFF_x86_64(LinkGraph &G, JITLinkContext *Ctx) {
   LLVM_DEBUG(dbgs() << "Lowering COFF x86_64 edges:\n");
-  COFFLinkGraphLowering_x86_64 GraphLowering;
-
+  COFFLinkGraphLowering_x86_64 GraphLowering(G.getSymbolStringPool());
   if (auto Err = GraphLowering.lowerCOFFRelocationEdges(G, *Ctx))
     return Err;
 
   return Error::success();
 }
 } // namespace
 
 namespace llvm {
case SectionIdx16:
     return "SectionIdx16";
   case SecRel32:
     return "SecRel32";
   default:
     return x86_64::getEdgeKindName(R);
   }
 }
 
-Expected<std::unique_ptr<LinkGraph>>
-createLinkGraphFromCOFFObject_x86_64(MemoryBufferRef ObjectBuffer) {
+Expected<std::unique_ptr<LinkGraph>> createLinkGraphFromCOFFObject_x86_64(
+    MemoryBufferRef ObjectBuffer, std::shared_ptr<orc::SymbolStringPool> SSP) {
   LLVM_DEBUG({
     dbgs() << "Building jitlink graph for new input "
            << ObjectBuffer.getBufferIdentifier() << "...\n";
   });
 
   auto COFFObj = object::ObjectFile::createCOFFObjectFile(ObjectBuffer);
   if (!COFFObj)
     return COFFObj.takeError();
     
   auto Features = (*COFFObj)->getFeatures();
   if (!Features)
     return Features.takeError();
 
-  return COFFLinkGraphBuilder_x86_64(**COFFObj, (*COFFObj)->makeTriple(),
+  return COFFLinkGraphBuilder_x86_64(**COFFObj, SSP, (*COFFObj)->makeTriple(),
                                      std::move(*Features))
       .buildGraph();
 }
 
 void link_COFF_x86_64(std::unique_ptr<LinkGraph> G,
                       std::unique_ptr<JITLinkContext> Ctx) {
   PassConfiguration Config;
   const Triple &TT = G->getTargetTriple();

llvm/lib/ExecutionEngine/JITLink/EHFrameSupport.cpp

if ((*PCBegin)->isDefined()) {
                << RecordAddress << "\n";
       });
       (*PCBegin)->getBlock().addEdge(Edge::KeepAlive, 0, FDESymbol, 0);
     } else {
       LLVM_DEBUG({
         dbgs() << "      WARNING: Not adding keep-alive edge to FDE at "
                << RecordAddress << ", which points to "
                << ((*PCBegin)->isExternal() ? "external" : "absolute")
-               << " symbol \"" << (*PCBegin)->getName()
+               << " symbol \"" << *(*PCBegin)->getName()
                << "\" -- FDE must be kept alive manually or it will be "
                << "dead stripped.\n";
       });
     }
   } else
     return PCBegin.takeError();
 
   // Skip over the PC range size field.
Expected<Symbol *> EHFrameEdgeFixer::getOrCreateEncodedPointerEdge(
   {
     auto EdgeI = BlockEdges.TargetMap.find(PointerFieldOffset);
     if (EdgeI != BlockEdges.TargetMap.end()) {
       LLVM_DEBUG({
         dbgs() << "      Existing edge at "
                << (BlockToFix.getAddress() + PointerFieldOffset) << " to "
                << FieldName << " at " << EdgeI->second.Target->getAddress();
         if (EdgeI->second.Target->hasName())
-          dbgs() << " (" << EdgeI->second.Target->getName() << ")";
+          dbgs() << " (" << *EdgeI->second.Target->getName() << ")";
         dbgs() << "\n";
       });
       if (auto Err = skipEncodedPointer(PointerEncoding, RecordReader))
         return std::move(Err);
       return EdgeI->second.Target;
     }
 
     if (BlockEdges.Multiple.contains(PointerFieldOffset))
if (!TargetSym)
     return TargetSym.takeError();
   BlockToFix.addEdge(PtrEdgeKind, PointerFieldOffset, *TargetSym, 0);
 
   LLVM_DEBUG({
     dbgs() << "      Adding edge at "
            << (BlockToFix.getAddress() + PointerFieldOffset) << " to "
            << FieldName << " at " << TargetSym->getAddress();
     if (TargetSym->hasName())
-      dbgs() << " (" << TargetSym->getName() << ")";
+      dbgs() << " (" << *TargetSym->getName() << ")";
     dbgs() << "\n";
   });
 
   return &*TargetSym;
 }
 
 Expected<Symbol &> EHFrameEdgeFixer::getOrCreateSymbol(ParseContext &PC,
                                                        orc::ExecutorAddr Addr) {

llvm/lib/ExecutionEngine/JITLink/ELF.cpp

if (Data[ELF::EI_CLASS] == ELF::ELFCLASS64) {
       }
     }
   }
 
   return ELF::EM_NONE;
 }
 
 Expected<std::unique_ptr<LinkGraph>>
-createLinkGraphFromELFObject(MemoryBufferRef ObjectBuffer) {
+createLinkGraphFromELFObject(MemoryBufferRef ObjectBuffer,
+                             std::shared_ptr<orc::SymbolStringPool> SSP) {
   StringRef Buffer = ObjectBuffer.getBuffer();
   if (Buffer.size() < ELF::EI_NIDENT)
     return make_error<JITLinkError>("Truncated ELF buffer");
 
   if (memcmp(Buffer.data(), ELF::ElfMagic, strlen(ELF::ElfMagic)) != 0)
     return make_error<JITLinkError>("ELF magic not valid");
 
   uint8_t DataEncoding = Buffer.data()[ELF::EI_DATA];
   Expected<uint16_t> TargetMachineArch = readTargetMachineArch(Buffer);
   if (!TargetMachineArch)
     return TargetMachineArch.takeError();
 
   switch (*TargetMachineArch) {
   case ELF::EM_AARCH64:
-    return createLinkGraphFromELFObject_aarch64(ObjectBuffer);
+    return createLinkGraphFromELFObject_aarch64(ObjectBuffer, SSP);
   case ELF::EM_ARM:
-    return createLinkGraphFromELFObject_aarch32(ObjectBuffer);
-  case ELF::EM_LOONGARCH:
-    return createLinkGraphFromELFObject_loongarch(ObjectBuffer);
+    return createLinkGraphFromELFObject_aarch32(ObjectBuffer, SSP);
   case ELF::EM_PPC64: {
     if (DataEncoding == ELF::ELFDATA2LSB)
-      return createLinkGraphFromELFObject_ppc64le(ObjectBuffer);
+      return createLinkGraphFromELFObject_ppc64le(ObjectBuffer, SSP);
     else
-      return createLinkGraphFromELFObject_ppc64(ObjectBuffer);
+      return createLinkGraphFromELFObject_ppc64(ObjectBuffer, SSP);
   }
+  case ELF::EM_LOONGARCH:
+    return createLinkGraphFromELFObject_loongarch(ObjectBuffer, SSP);
   case ELF::EM_RISCV:
-    return createLinkGraphFromELFObject_riscv(ObjectBuffer);
+    return createLinkGraphFromELFObject_riscv(ObjectBuffer, SSP);
   case ELF::EM_X86_64:
-    return createLinkGraphFromELFObject_x86_64(ObjectBuffer);
+    return createLinkGraphFromELFObject_x86_64(ObjectBuffer, SSP);
   case ELF::EM_386:
-    return createLinkGraphFromELFObject_i386(ObjectBuffer);
+    return createLinkGraphFromELFObject_i386(ObjectBuffer, SSP);
   default:
     return make_error<JITLinkError>(
         "Unsupported target machine architecture in ELF object " +
         ObjectBuffer.getBufferIdentifier());
   }
 }
 
 void link_ELF(std::unique_ptr<LinkGraph> G,

llvm/lib/ExecutionEngine/JITLink/ELFLinkGraphBuilder.h

 
 /// LinkGraph building code that's specific to the given ELFT, but common
 /// across all architectures.
 template <typename ELFT>
 class ELFLinkGraphBuilder : public ELFLinkGraphBuilderBase {
   using ELFFile = object::ELFFile<ELFT>;
 
 public:
-  ELFLinkGraphBuilder(const object::ELFFile<ELFT> &Obj, Triple TT,
+  ELFLinkGraphBuilder(const object::ELFFile<ELFT> &Obj,
+                      std::shared_ptr<orc::SymbolStringPool> SSP, Triple TT,
                       SubtargetFeatures Features, StringRef FileName,
                       LinkGraph::GetEdgeKindNameFunction GetEdgeKindName);
 
   /// Debug sections are included in the graph by default. Use
   /// setProcessDebugSections(false) to ignore them if debug info is not
   /// needed.
   ELFLinkGraphBuilder &setProcessDebugSections(bool ProcessDebugSections) {
     this->ProcessDebugSections = ProcessDebugSections;
protected:
   DenseMap<ELFSymbolIndex, Symbol *> GraphSymbols;
   DenseMap<const typename ELFFile::Elf_Shdr *,
            ArrayRef<typename ELFFile::Elf_Word>>
       ShndxTables;
 };
 
 template <typename ELFT>
 ELFLinkGraphBuilder<ELFT>::ELFLinkGraphBuilder(
-    const ELFFile &Obj, Triple TT, SubtargetFeatures Features,
+    const ELFFile &Obj, 
+    std::shared_ptr<orc::SymbolStringPool> SSP , Triple TT,
+    SubtargetFeatures Features,
     StringRef FileName, LinkGraph::GetEdgeKindNameFunction GetEdgeKindName)
     : ELFLinkGraphBuilderBase(std::make_unique<LinkGraph>(
-          FileName.str(), Triple(std::move(TT)), std::move(Features),
+          FileName.str(), std::move(SSP), Triple(std::move(TT)), std::move(Features),
           ELFT::Is64Bits ? 8 : 4, llvm::endianness(ELFT::TargetEndianness),
           std::move(GetEdgeKindName))),
       Obj(Obj) {
   LLVM_DEBUG(
       { dbgs() << "Created ELFLinkGraphBuilder for \"" << FileName << "\""; });
 }
 
 template <typename ELFT>

llvm/lib/ExecutionEngine/JITLink/ELF_aarch32.cpp

orc::ExecutorAddrDiff getRawOffset(const typename ELFT::Sym &Sym,
                                      TargetFlagsType Flags) override {
     assert((makeTargetFlags(Sym) & Flags) == Flags);
     static constexpr uint64_t ThumbBit = 0x01;
     return Sym.getValue() & ~ThumbBit;
   }
 
 public:
   ELFLinkGraphBuilder_aarch32(StringRef FileName,
-                              const llvm::object::ELFFile<ELFT> &Obj, Triple TT,
+                              const llvm::object::ELFFile<ELFT> &Obj,
+                              std::shared_ptr<orc::SymbolStringPool> SSP, 
+                              Triple TT,
                               SubtargetFeatures Features,
                               aarch32::ArmConfig ArmCfg)
-      : ELFLinkGraphBuilder<ELFT>(Obj, std::move(TT), std::move(Features),
+      : ELFLinkGraphBuilder<ELFT>(Obj, SSP, std::move(TT), std::move(Features),
                                   FileName, getELFAArch32EdgeKindName),
                                   ArmCfg(std::move(ArmCfg)) {}
 };
 
 template <aarch32::StubsFlavor Flavor>
 Error buildTables_ELF_aarch32(LinkGraph &G) {
   LLVM_DEBUG(dbgs() << "Visiting edges in graph:\n");
 
   aarch32::StubsManager<Flavor> PLT;
   visitExistingEdges(G, PLT);
   return Error::success();
 }
 
-Expected<std::unique_ptr<LinkGraph>>
-createLinkGraphFromELFObject_aarch32(MemoryBufferRef ObjectBuffer) {
+Expected<std::unique_ptr<LinkGraph>> createLinkGraphFromELFObject_aarch32(
+    MemoryBufferRef ObjectBuffer, std::shared_ptr<orc::SymbolStringPool> SSP) {
   LLVM_DEBUG({
     dbgs() << "Building jitlink graph for new input "
            << ObjectBuffer.getBufferIdentifier() << "...\n";
   });
 
   auto ELFObj = ObjectFile::createELFObjectFile(ObjectBuffer);
   if (!ELFObj)
     return ELFObj.takeError();
Expected<std::unique_ptr<LinkGraph>> createLinkGraphFromELFObject_aarch32(
   }
 
   // Populate the link-graph.
   switch (TT.getArch()) {
   case Triple::arm:
   case Triple::thumb: {
     auto &ELFFile = cast<ELFObjectFile<ELF32LE>>(**ELFObj).getELFFile();
     return ELFLinkGraphBuilder_aarch32<llvm::endianness::little>(
-               (*ELFObj)->getFileName(), ELFFile, TT, std::move(*Features),
+               (*ELFObj)->getFileName(), ELFFile, SSP, TT, std::move(*Features),
                ArmCfg)
         .buildGraph();
   }
   case Triple::armeb:
   case Triple::thumbeb: {
     auto &ELFFile = cast<ELFObjectFile<ELF32BE>>(**ELFObj).getELFFile();
     return ELFLinkGraphBuilder_aarch32<llvm::endianness::big>(
-               (*ELFObj)->getFileName(), ELFFile, TT, std::move(*Features),
+               (*ELFObj)->getFileName(), ELFFile, SSP, TT, std::move(*Features),
                ArmCfg)
         .buildGraph();
   }
   default:
     return make_error<JITLinkError>(
         "Failed to build ELF/aarch32 link graph: Invalid target triple " +
         TT.getTriple());
   }

llvm/lib/ExecutionEngine/JITLink/ELF_aarch64.cpp

case ELFTLSDescCall:
       return "ELFTLSDescCall";
     default:
       return getGenericEdgeKindName(static_cast<Edge::Kind>(R));
     }
   }
 
 public:
   ELFLinkGraphBuilder_aarch64(StringRef FileName,
-                              const object::ELFFile<ELFT> &Obj, Triple TT,
-                              SubtargetFeatures Features)
-      : ELFLinkGraphBuilder<ELFT>(Obj, std::move(TT), std::move(Features),
+                              const object::ELFFile<ELFT> &Obj, 
+                              std::shared_ptr<orc::SymbolStringPool> SSP,
+                              Triple TT, SubtargetFeatures Features)
+
+
+
+
+      : ELFLinkGraphBuilder<ELFT>(Obj, SSP, std::move(TT), std::move(Features),
                                   FileName, aarch64::getEdgeKindName) {}
 };
 
 // TLS Info Builder.
 class TLSInfoTableManager_ELF_aarch64
     : public TableManager<TLSInfoTableManager_ELF_aarch64> {
 public:
   static StringRef getSectionName() { return "$__TLSINFO"; }
Error buildTables_ELF_aarch64(LinkGraph &G) {
   return Error::success();
 }
 
 } // namespace
 
 namespace llvm {
 namespace jitlink {
 
-Expected<std::unique_ptr<LinkGraph>>
-createLinkGraphFromELFObject_aarch64(MemoryBufferRef ObjectBuffer) {
+Expected<std::unique_ptr<LinkGraph>> createLinkGraphFromELFObject_aarch64(
+    MemoryBufferRef ObjectBuffer, std::shared_ptr<orc::SymbolStringPool> SSP) {
   LLVM_DEBUG({
     dbgs() << "Building jitlink graph for new input "
            << ObjectBuffer.getBufferIdentifier() << "...\n";
   });
 
   auto ELFObj = object::ObjectFile::createELFObjectFile(ObjectBuffer);
   if (!ELFObj)
     return ELFObj.takeError();
 
   auto Features = (*ELFObj)->getFeatures();
   if (!Features)
     return Features.takeError();
 
   assert((*ELFObj)->getArch() == Triple::aarch64 &&
          "Only AArch64 (little endian) is supported for now");
 
   auto &ELFObjFile = cast<object::ELFObjectFile<object::ELF64LE>>(**ELFObj);
   return ELFLinkGraphBuilder_aarch64<object::ELF64LE>(
              (*ELFObj)->getFileName(), ELFObjFile.getELFFile(),
-             (*ELFObj)->makeTriple(), std::move(*Features))
+             SSP, (*ELFObj)->makeTriple(), std::move(*Features))
       .buildGraph();
 }
 
 void link_ELF_aarch64(std::unique_ptr<LinkGraph> G,
                       std::unique_ptr<JITLinkContext> Ctx) {
   PassConfiguration Config;
   const Triple &TT = G->getTargetTriple();
   if (Ctx->shouldAddDefaultTargetPasses(TT)) {

llvm/lib/ExecutionEngine/JITLink/ELF_i386.cpp

 
 private:
   Symbol *GOTSymbol = nullptr;
 
   Error getOrCreateGOTSymbol(LinkGraph &G) {
     auto DefineExternalGOTSymbolIfPresent =
         createDefineExternalSectionStartAndEndSymbolsPass(
             [&](LinkGraph &LG, Symbol &Sym) -> SectionRangeSymbolDesc {
-              if (Sym.getName() == ELFGOTSymbolName)
+              if (Sym.getName() != nullptr &&
+                  *Sym.getName() == ELFGOTSymbolName)
                 if (auto *GOTSection = G.findSectionByName(
                         i386::GOTTableManager::getSectionName())) {
                   GOTSymbol = &Sym;
                   return {*GOTSection, true};
                 }
               return {};
             });
 
Error getOrCreateGOTSymbol(LinkGraph &G) {
     // Otherwise look for a GOT section: If it already has a start symbol we'll
     // record it, otherwise we'll create our own.
     // If there's a GOT section but we didn't find an external GOT symbol...
     if (auto *GOTSection =
             G.findSectionByName(i386::GOTTableManager::getSectionName())) {
 
       // Check for an existing defined symbol.
       for (auto *Sym : GOTSection->symbols())
-        if (Sym->getName() == ELFGOTSymbolName) {
+        if (Sym->getName() != nullptr && *Sym->getName() == ELFGOTSymbolName) {
           GOTSymbol = Sym;
           return Error::success();
         }
 
       // If there's no defined symbol then create one.
       SectionRange SR(*GOTSection);
 
       if (SR.empty()) {
Error addSingleRelocation(const typename ELFT::Rel &Rel,
     });
 
     BlockToFix.addEdge(std::move(GE));
     return Error::success();
   }
 
 public:
   ELFLinkGraphBuilder_i386(StringRef FileName, const object::ELFFile<ELFT> &Obj,
+                           std::shared_ptr<orc::SymbolStringPool> SSP,
                            Triple TT, SubtargetFeatures Features)
-      : ELFLinkGraphBuilder<ELFT>(Obj, std::move(TT), std::move(Features),
+      : ELFLinkGraphBuilder<ELFT>(Obj, SSP, std::move(TT), std::move(Features),
                                   FileName, i386::getEdgeKindName) {}
 };
 
 Expected<std::unique_ptr<LinkGraph>>
-createLinkGraphFromELFObject_i386(MemoryBufferRef ObjectBuffer) {
+createLinkGraphFromELFObject_i386(MemoryBufferRef ObjectBuffer,
+                                  std::shared_ptr<orc::SymbolStringPool> SSP) {
   LLVM_DEBUG({
     dbgs() << "Building jitlink graph for new input "
            << ObjectBuffer.getBufferIdentifier() << "...\n";
   });
 
   auto ELFObj = object::ObjectFile::createELFObjectFile(ObjectBuffer);
   if (!ELFObj)
     return ELFObj.takeError();
 
   auto Features = (*ELFObj)->getFeatures();
   if (!Features)
     return Features.takeError();
 
   assert((*ELFObj)->getArch() == Triple::x86 &&
          "Only i386 (little endian) is supported for now");
 
   auto &ELFObjFile = cast<object::ELFObjectFile<object::ELF32LE>>(**ELFObj);
+
   return ELFLinkGraphBuilder_i386<object::ELF32LE>(
-             (*ELFObj)->getFileName(), ELFObjFile.getELFFile(),
+             (*ELFObj)->getFileName(), ELFObjFile.getELFFile(), SSP,
              (*ELFObj)->makeTriple(), std::move(*Features))
       .buildGraph();
 }
 
 void link_ELF_i386(std::unique_ptr<LinkGraph> G,
                    std::unique_ptr<JITLinkContext> Ctx) {
   PassConfiguration Config;
   const Triple &TT = G->getTargetTriple();

llvm/lib/ExecutionEngine/JITLink/ELF_loongarch.cpp

Error addSingleRelocation(const typename ELFT::Rela &Rel,
 
     BlockToFix.addEdge(std::move(GE));
 
     return Error::success();
   }
 
 public:
   ELFLinkGraphBuilder_loongarch(StringRef FileName,
-                                const object::ELFFile<ELFT> &Obj, Triple TT,
-                                SubtargetFeatures Features)
-      : ELFLinkGraphBuilder<ELFT>(Obj, std::move(TT), std::move(Features),
-                                  FileName, loongarch::getEdgeKindName) {}
+                                const object::ELFFile<ELFT> &Obj,
+                                std::shared_ptr<orc::SymbolStringPool> SSP,
+                                Triple TT, SubtargetFeatures Features)
+      : ELFLinkGraphBuilder<ELFT>(Obj, std::move(SSP), std::move(TT),
+                                  std::move(Features), FileName,
+                                  loongarch::getEdgeKindName) {}
 };
 
 Error buildTables_ELF_loongarch(LinkGraph &G) {
   LLVM_DEBUG(dbgs() << "Visiting edges in graph:\n");
 
   GOTTableManager GOT;
   PLTTableManager PLT(GOT);
   visitExistingEdges(G, GOT, PLT);
   return Error::success();
 }
 
 } // namespace
 
 namespace llvm {
 namespace jitlink {
 
-Expected<std::unique_ptr<LinkGraph>>
-createLinkGraphFromELFObject_loongarch(MemoryBufferRef ObjectBuffer) {
+Expected<std::unique_ptr<LinkGraph>> createLinkGraphFromELFObject_loongarch(
+    MemoryBufferRef ObjectBuffer, std::shared_ptr<orc::SymbolStringPool> SSP) {
   LLVM_DEBUG({
     dbgs() << "Building jitlink graph for new input "
            << ObjectBuffer.getBufferIdentifier() << "...\n";
   });
 
   auto ELFObj = object::ObjectFile::createELFObjectFile(ObjectBuffer);
   if (!ELFObj)
     return ELFObj.takeError();
 
   auto Features = (*ELFObj)->getFeatures();
   if (!Features)
     return Features.takeError();
 
   if ((*ELFObj)->getArch() == Triple::loongarch64) {
     auto &ELFObjFile = cast<object::ELFObjectFile<object::ELF64LE>>(**ELFObj);
     return ELFLinkGraphBuilder_loongarch<object::ELF64LE>(
-               (*ELFObj)->getFileName(), ELFObjFile.getELFFile(),
+               (*ELFObj)->getFileName(), ELFObjFile.getELFFile(), SSP,
                (*ELFObj)->makeTriple(), std::move(*Features))
         .buildGraph();
   }
 
   assert((*ELFObj)->getArch() == Triple::loongarch32 &&
          "Invalid triple for LoongArch ELF object file");
   auto &ELFObjFile = cast<object::ELFObjectFile<object::ELF32LE>>(**ELFObj);
   return ELFLinkGraphBuilder_loongarch<object::ELF32LE>(
-             (*ELFObj)->getFileName(), ELFObjFile.getELFFile(),
+             (*ELFObj)->getFileName(), ELFObjFile.getELFFile(), SSP,
              (*ELFObj)->makeTriple(), std::move(*Features))
       .buildGraph();
 }
 
 void link_ELF_loongarch(std::unique_ptr<LinkGraph> G,
                         std::unique_ptr<JITLinkContext> Ctx) {
   PassConfiguration Config;
   const Triple &TT = G->getTargetTriple();

llvm/lib/ExecutionEngine/JITLink/ELF_ppc64.cpp

 };
 
 template <llvm::endianness Endianness>
 Symbol &createELFGOTHeader(LinkGraph &G,
                            ppc64::TOCTableManager<Endianness> &TOC) {
   Symbol *TOCSymbol = nullptr;
 
   for (Symbol *Sym : G.defined_symbols())
-    if (LLVM_UNLIKELY(Sym->getName() == ELFTOCSymbolName)) {
+    if (LLVM_UNLIKELY(Sym->hasName() && *Sym->getName() == ELFTOCSymbolName)) {
       TOCSymbol = Sym;
       break;
     }
 
   if (LLVM_LIKELY(TOCSymbol == nullptr)) {
     for (Symbol *Sym : G.external_symbols())
-      if (Sym->getName() == ELFTOCSymbolName) {
+      if (Sym->hasName() && *Sym->getName() == ELFTOCSymbolName) {
         TOCSymbol = Sym;
         break;
       }
   }
 
   if (!TOCSymbol)
     TOCSymbol = &G.addExternalSymbol(ELFTOCSymbolName, 0, false);
 
Error addSingleRelocation(const typename ELFT::Rela &Rel,
 
     Edge GE(Kind, Offset, *GraphSymbol, Addend);
     BlockToFix.addEdge(std::move(GE));
     return Error::success();
   }
 
 public:
   ELFLinkGraphBuilder_ppc64(StringRef FileName,
-                            const object::ELFFile<ELFT> &Obj, Triple TT,
-                            SubtargetFeatures Features)
-      : ELFLinkGraphBuilder<ELFT>(Obj, std::move(TT), std::move(Features),
+                            const object::ELFFile<ELFT> &Obj, 
+                            std::shared_ptr<orc::SymbolStringPool> SSP,
+                            Triple TT, SubtargetFeatures Features)
+      : ELFLinkGraphBuilder<ELFT>(Obj, std::move(SSP), std::move(TT), std::move(Features),
                                   FileName, ppc64::getEdgeKindName) {}
 };
 
 template <llvm::endianness Endianness>
 class ELFJITLinker_ppc64 : public JITLinker<ELFJITLinker_ppc64<Endianness>> {
   using JITLinkerBase = JITLinker<ELFJITLinker_ppc64<Endianness>>;
   friend JITLinkerBase;
 
 public:
   ELFJITLinker_ppc64(std::unique_ptr<JITLinkContext> Ctx,
                      std::unique_ptr<LinkGraph> G, PassConfiguration PassConfig)
       : JITLinkerBase(std::move(Ctx), std::move(G), std::move(PassConfig)) {
     JITLinkerBase::getPassConfig().PostAllocationPasses.push_back(
         [this](LinkGraph &G) { return defineTOCBase(G); });
   }
 
 private:
   Symbol *TOCSymbol = nullptr;
 
   Error defineTOCBase(LinkGraph &G) {
     for (Symbol *Sym : G.defined_symbols()) {
-      if (LLVM_UNLIKELY(Sym->getName() == ELFTOCSymbolName)) {
+      if (LLVM_UNLIKELY(Sym->hasName() && *Sym->getName() == ELFTOCSymbolName)) {
         TOCSymbol = Sym;
         return Error::success();
       }
     }
 
     assert(TOCSymbol == nullptr &&
            "TOCSymbol should not be defined at this point");
 
     for (Symbol *Sym : G.external_symbols()) {
-      if (Sym->getName() == ELFTOCSymbolName) {
+      if (Sym->hasName() && *Sym->getName() == ELFTOCSymbolName) {
         TOCSymbol = Sym;
         break;
       }
     }
 
     if (Section *TOCSection = G.findSectionByName(
             ppc64::TOCTableManager<Endianness>::getSectionName())) {
       assert(!TOCSection->empty() && "TOC section should have reserved an "
private:
 
   Error applyFixup(LinkGraph &G, Block &B, const Edge &E) const {
     return ppc64::applyFixup<Endianness>(G, B, E, TOCSymbol);
   }
 };
 
 template <llvm::endianness Endianness>
 Expected<std::unique_ptr<LinkGraph>>
-createLinkGraphFromELFObject_ppc64(MemoryBufferRef ObjectBuffer) {
+createLinkGraphFromELFObject_ppc64(MemoryBufferRef ObjectBuffer, 
+                                  std::shared_ptr<orc::SymbolStringPool> SSP) {
   LLVM_DEBUG({
     dbgs() << "Building jitlink graph for new input "
            << ObjectBuffer.getBufferIdentifier() << "...\n";
   });
 
   auto ELFObj = object::ObjectFile::createELFObjectFile(ObjectBuffer);
   if (!ELFObj)
     return ELFObj.takeError();
 
   auto Features = (*ELFObj)->getFeatures();
   if (!Features)
     return Features.takeError();
 
   using ELFT = object::ELFType<Endianness, true>;
   auto &ELFObjFile = cast<object::ELFObjectFile<ELFT>>(**ELFObj);
   return ELFLinkGraphBuilder_ppc64<Endianness>(
              (*ELFObj)->getFileName(), ELFObjFile.getELFFile(),
+             SSP,
              (*ELFObj)->makeTriple(), std::move(*Features))
       .buildGraph();
 }
 
 template <llvm::endianness Endianness>
 void link_ELF_ppc64(std::unique_ptr<LinkGraph> G,
                     std::unique_ptr<JITLinkContext> Ctx) {
   PassConfiguration Config;
void link_ELF_ppc64(std::unique_ptr<LinkGraph> G,
   if (auto Err = Ctx->modifyPassConfig(*G, Config))
     return Ctx->notifyFailed(std::move(Err));
 
   ELFJITLinker_ppc64<Endianness>::link(std::move(Ctx), std::move(G),
                                        std::move(Config));
 }
 
 Expected<std::unique_ptr<LinkGraph>>
-createLinkGraphFromELFObject_ppc64(MemoryBufferRef ObjectBuffer) {
+createLinkGraphFromELFObject_ppc64(MemoryBufferRef ObjectBuffer, 
+                                  std::shared_ptr<orc::SymbolStringPool> SSP) {
   return createLinkGraphFromELFObject_ppc64<llvm::endianness::big>(
-      std::move(ObjectBuffer));
+      std::move(ObjectBuffer), SSP);
 }
 
 Expected<std::unique_ptr<LinkGraph>>
-createLinkGraphFromELFObject_ppc64le(MemoryBufferRef ObjectBuffer) {
+createLinkGraphFromELFObject_ppc64le(MemoryBufferRef ObjectBuffer, 
+                                    std::shared_ptr<orc::SymbolStringPool> SSP) {
   return createLinkGraphFromELFObject_ppc64<llvm::endianness::little>(
-      std::move(ObjectBuffer));
+      std::move(ObjectBuffer), SSP);
 }
 
 /// jit-link the given object buffer, which must be a ELF ppc64 object file.
 void link_ELF_ppc64(std::unique_ptr<LinkGraph> G,
                     std::unique_ptr<JITLinkContext> Ctx) {
   return link_ELF_ppc64<llvm::endianness::big>(std::move(G), std::move(Ctx));
 }
 
 /// jit-link the given object buffer, which must be a ELF ppc64le object file.
 void link_ELF_ppc64le(std::unique_ptr<LinkGraph> G,
                       std::unique_ptr<JITLinkContext> Ctx) {
   return link_ELF_ppc64<llvm::endianness::little>(std::move(G), std::move(Ctx));
 }
 
 } // end namespace llvm::jitlink

llvm/lib/ExecutionEngine/JITLink/ELF_riscv.cpp

Error addSingleRelocation(const typename ELFT::Rela &Rel,
     });
 
     BlockToFix.addEdge(std::move(GE));
     return Error::success();
   }
 
 public:
   ELFLinkGraphBuilder_riscv(StringRef FileName,
-                            const object::ELFFile<ELFT> &Obj, Triple TT,
-                            SubtargetFeatures Features)
-      : ELFLinkGraphBuilder<ELFT>(Obj, std::move(TT), std::move(Features),
+                            const object::ELFFile<ELFT> &Obj, 
+                            std::shared_ptr<orc::SymbolStringPool> SSP,
+                            Triple TT, SubtargetFeatures Features)
+      : ELFLinkGraphBuilder<ELFT>(Obj,SSP, std::move(TT), std::move(Features),
                                   FileName, riscv::getEdgeKindName) {}
 };
 
 Expected<std::unique_ptr<LinkGraph>>
-createLinkGraphFromELFObject_riscv(MemoryBufferRef ObjectBuffer) {
+createLinkGraphFromELFObject_riscv(MemoryBufferRef ObjectBuffer,
+                                   std::shared_ptr<orc::SymbolStringPool> SSP) {
   LLVM_DEBUG({
     dbgs() << "Building jitlink graph for new input "
            << ObjectBuffer.getBufferIdentifier() << "...\n";
   });
 
   auto ELFObj = object::ObjectFile::createELFObjectFile(ObjectBuffer);
   if (!ELFObj)
     return ELFObj.takeError();
 
   auto Features = (*ELFObj)->getFeatures();
   if (!Features)
     return Features.takeError();
 
   if ((*ELFObj)->getArch() == Triple::riscv64) {
     auto &ELFObjFile = cast<object::ELFObjectFile<object::ELF64LE>>(**ELFObj);
     return ELFLinkGraphBuilder_riscv<object::ELF64LE>(
                (*ELFObj)->getFileName(), ELFObjFile.getELFFile(),
-               (*ELFObj)->makeTriple(), std::move(*Features))
+               SSP, (*ELFObj)->makeTriple(), std::move(*Features))
         .buildGraph();
   } else {
     assert((*ELFObj)->getArch() == Triple::riscv32 &&
            "Invalid triple for RISCV ELF object file");
     auto &ELFObjFile = cast<object::ELFObjectFile<object::ELF32LE>>(**ELFObj);
     return ELFLinkGraphBuilder_riscv<object::ELF32LE>(
                (*ELFObj)->getFileName(), ELFObjFile.getELFFile(),
-               (*ELFObj)->makeTriple(), std::move(*Features))
+               SSP, (*ELFObj)->makeTriple(), std::move(*Features))
         .buildGraph();
   }
 }
 
 void link_ELF_riscv(std::unique_ptr<LinkGraph> G,
                     std::unique_ptr<JITLinkContext> Ctx) {
   PassConfiguration Config;
   const Triple &TT = G->getTargetTriple();

llvm/lib/ExecutionEngine/JITLink/ELF_x86_64.cpp

Error addSingleRelocation(const typename ELFT::Rela &Rel,
     });
 
     BlockToFix.addEdge(std::move(GE));
     return Error::success();
   }
 
 public:
   ELFLinkGraphBuilder_x86_64(StringRef FileName,
-                             const object::ELFFile<object::ELF64LE> &Obj,
+                            std::shared_ptr<orc::SymbolStringPool> SSP,
                              SubtargetFeatures Features)
-      : ELFLinkGraphBuilder(Obj, Triple("x86_64-unknown-linux"),
+      : ELFLinkGraphBuilder(Obj, SSP, Triple("x86_64-unknown-linux"),
                             std::move(Features), FileName,
                             x86_64::getEdgeKindName) {}
 };
 
 class ELFJITLinker_x86_64 : public JITLinker<ELFJITLinker_x86_64> {
   friend class JITLinker<ELFJITLinker_x86_64>;
 
 public:
   ELFJITLinker_x86_64(std::unique_ptr<JITLinkContext> Ctx,
                       std::unique_ptr<LinkGraph> G,
                       PassConfiguration PassConfig)
       : JITLinker(std::move(Ctx), std::move(G), std::move(PassConfig)) {
 
     if (shouldAddDefaultTargetPasses(getGraph().getTargetTriple()))
       getPassConfig().PostAllocationPasses.push_back(
           [this](LinkGraph &G) { return getOrCreateGOTSymbol(G); });
   }
 
 private:
   Symbol *GOTSymbol = nullptr;
-
   Error getOrCreateGOTSymbol(LinkGraph &G) {
     auto DefineExternalGOTSymbolIfPresent =
         createDefineExternalSectionStartAndEndSymbolsPass(
             [&](LinkGraph &LG, Symbol &Sym) -> SectionRangeSymbolDesc {
-              if (Sym.getName() == ELFGOTSymbolName)
+              if (Sym.getName() != nullptr &&
+                  *Sym.getName() == ELFGOTSymbolName)
                 if (auto *GOTSection = G.findSectionByName(
                         x86_64::GOTTableManager::getSectionName())) {
                   GOTSymbol = &Sym;
                   return {*GOTSection, true};
                 }
               return {};
             });
 
     // Try to attach _GLOBAL_OFFSET_TABLE_ to the GOT if it's defined as an
     // external.
     if (auto Err = DefineExternalGOTSymbolIfPresent(G))
       return Err;
 
     // If we succeeded then we're done.
     if (GOTSymbol)
       return Error::success();
 
     // Otherwise look for a GOT section: If it already has a start symbol we'll
     // record it, otherwise we'll create our own.
     // If there's a GOT section but we didn't find an external GOT symbol...
     if (auto *GOTSection =
             G.findSectionByName(x86_64::GOTTableManager::getSectionName())) {
 
       // Check for an existing defined symbol.
       for (auto *Sym : GOTSection->symbols())
-        if (Sym->getName() == ELFGOTSymbolName) {
+        if (Sym->getName() != nullptr && *Sym->getName() == ELFGOTSymbolName) {
           GOTSymbol = Sym;
           return Error::success();
         }
 
       // If there's no defined symbol then create one.
       SectionRange SR(*GOTSection);
       if (SR.empty())
         GOTSymbol =
             &G.addAbsoluteSymbol(ELFGOTSymbolName, orc::ExecutorAddr(), 0,
                                  Linkage::Strong, Scope::Local, true);
       else
         GOTSymbol =
             &G.addDefinedSymbol(*SR.getFirstBlock(), 0, ELFGOTSymbolName, 0,
                                 Linkage::Strong, Scope::Local, false, true);
     }
 
     // If we still haven't found a GOT symbol then double check the externals.
     // We may have a GOT-relative reference but no GOT section, in which case
     // we just need to point the GOT symbol at some address in this graph.
     if (!GOTSymbol) {
       for (auto *Sym : G.external_symbols()) {
-        if (Sym->getName() == ELFGOTSymbolName) {
+        if (*Sym->getName() == ELFGOTSymbolName) {
           auto Blocks = G.blocks();
           if (!Blocks.empty()) {
             G.makeAbsolute(*Sym, (*Blocks.begin())->getAddress());
             GOTSymbol = Sym;
             break;
           }
         }
       }
     }
 
     return Error::success();
   }
 
   Error applyFixup(LinkGraph &G, Block &B, const Edge &E) const {
     return x86_64::applyFixup(G, B, E, GOTSymbol);
   }
 };
 
-Expected<std::unique_ptr<LinkGraph>>
-createLinkGraphFromELFObject_x86_64(MemoryBufferRef ObjectBuffer) {
+Expected<std::unique_ptr<LinkGraph>> createLinkGraphFromELFObject_x86_64(
+    MemoryBufferRef ObjectBuffer, std::shared_ptr<orc::SymbolStringPool> SSP) {
   LLVM_DEBUG({
     dbgs() << "Building jitlink graph for new input "
            << ObjectBuffer.getBufferIdentifier() << "...\n";
   });
 
   auto ELFObj = object::ObjectFile::createELFObjectFile(ObjectBuffer);
   if (!ELFObj)
     return ELFObj.takeError();
 
   auto Features = (*ELFObj)->getFeatures();
   if (!Features)
     return Features.takeError();
 
   auto &ELFObjFile = cast<object::ELFObjectFile<object::ELF64LE>>(**ELFObj);
   return ELFLinkGraphBuilder_x86_64((*ELFObj)->getFileName(),
-                                    ELFObjFile.getELFFile(),
+                                    SSP, ELFObjFile.getELFFile(),
                                     std::move(*Features))
       .buildGraph();
 }
 
 static SectionRangeSymbolDesc
 identifyELFSectionStartAndEndSymbols(LinkGraph &G, Symbol &Sym) {
   constexpr StringRef StartSymbolPrefix = "__start";
   constexpr StringRef EndSymbolPrefix = "__end";
 
-  auto SymName = Sym.getName();
+  auto SymName = *Sym.getName();
   if (SymName.startswith(StartSymbolPrefix)) {
     if (auto *Sec =
             G.findSectionByName(SymName.drop_front(StartSymbolPrefix.size())))
       return {*Sec, true};
   } else if (SymName.startswith(EndSymbolPrefix)) {
     if (auto *Sec =
             G.findSectionByName(SymName.drop_front(EndSymbolPrefix.size())))
       return {*Sec, false};

llvm/lib/ExecutionEngine/JITLink/JITLink.cpp

 
 raw_ostream &operator<<(raw_ostream &OS, const Symbol &Sym) {
   OS << Sym.getAddress() << " (" << (Sym.isDefined() ? "block" : "addressable")
      << " + " << formatv("{0:x8}", Sym.getOffset())
      << "): size: " << formatv("{0:x8}", Sym.getSize())
      << ", linkage: " << formatv("{0:6}", getLinkageName(Sym.getLinkage()))
      << ", scope: " << formatv("{0:8}", getScopeName(Sym.getScope())) << ", "
      << (Sym.isLive() ? "live" : "dead") << "  -   "
-     << (Sym.hasName() ? Sym.getName() : "<anonymous symbol>");
+     << (Sym.hasName() ? *Sym.getName() : "<anonymous symbol>");
   return OS;
 }
 
 void printEdge(raw_ostream &OS, const Block &B, const Edge &E,
                StringRef EdgeKindName) {
   OS << "edge@" << B.getAddress() + E.getOffset() << ": " << B.getAddress()
      << " + " << formatv("{0:x}", E.getOffset()) << " -- " << EdgeKindName
      << " -> ";
 
   auto &TargetSym = E.getTarget();
   if (TargetSym.hasName())
-    OS << TargetSym.getName();
+    OS << *TargetSym.getName();
   else {
     auto &TargetBlock = TargetSym.getBlock();
     auto &TargetSec = TargetBlock.getSection();
     orc::ExecutorAddr SecAddress(~uint64_t(0));
     for (auto *B : TargetSec.blocks())
       if (B->getAddress() < SecAddress)
         SecAddress = B->getAddress();
 

 
 Section::~Section() {
   for (auto *Sym : Symbols)
     Sym->~Symbol();
   for (auto *B : Blocks)
     B->~Block();
 }
 
+LinkGraph::~LinkGraph() {
+  for (auto *Sym : AbsoluteSymbols) {
+    Sym->~Symbol();
+  }
+  for (auto *Sym: external_symbols()) {
+    Sym->~Symbol();
+  }
+  ExternalSymbols.clear();
+}
+
 Block &LinkGraph::splitBlock(Block &B, size_t SplitIndex,
                              SplitBlockCache *Cache) {
 
   assert(SplitIndex > 0 && "splitBlock can not be called with SplitIndex == 0");
 
   // If the split point covers all of B then just return B.
   if (SplitIndex == B.getSize())
     return B;
for (auto *B : SortedBlocks) {
           OS << "      " << B->getFixupAddress(E) << " (block + "
              << formatv("{0:x8}", E.getOffset()) << "), addend = ";
           if (E.getAddend() >= 0)
             OS << formatv("+{0:x8}", E.getAddend());
           else
             OS << formatv("-{0:x8}", -E.getAddend());
           OS << ", kind = " << getEdgeKindName(E.getKind()) << ", target = ";
           if (E.getTarget().hasName())
-            OS << E.getTarget().getName();
+            OS << *E.getTarget().getName();
           else
             OS << "addressable@"
                << formatv("{0:x16}", E.getTarget().getAddress()) << "+"
                << formatv("{0:x8}", E.getTarget().getOffset());
           OS << "\n";
         }
       } else
         OS << "    no edges\n";
Error makeTargetOutOfRangeError(const LinkGraph &G, const Block &B,
                                 const Edge &E) {
   std::string ErrMsg;
   {
     raw_string_ostream ErrStream(ErrMsg);
     Section &Sec = B.getSection();
     ErrStream << "In graph " << G.getName() << ", section " << Sec.getName()
               << ": relocation target ";
     if (E.getTarget().hasName()) {
-      ErrStream << "\"" << E.getTarget().getName() << "\"";
+      ErrStream << "\"" << *E.getTarget().getName() << "\"";
     } else
       ErrStream << E.getTarget().getBlock().getSection().getName() << " + "
                 << formatv("{0:x}", E.getOffset());
     ErrStream << " at address " << formatv("{0:x}", E.getTarget().getAddress())
               << " is out of range of " << G.getEdgeKindName(E.getKind())
               << " fixup at " << formatv("{0:x}", B.getFixupAddress(E)) << " (";
 
     Symbol *BestSymbolForBlock = nullptr;
     for (auto *Sym : Sec.symbols())
       if (&Sym->getBlock() == &B && Sym->hasName() && Sym->getOffset() == 0 &&
           (!BestSymbolForBlock ||
            Sym->getScope() < BestSymbolForBlock->getScope() ||
            Sym->getLinkage() < BestSymbolForBlock->getLinkage()))
         BestSymbolForBlock = Sym;
 
     if (BestSymbolForBlock)
-      ErrStream << BestSymbolForBlock->getName() << ", ";
+      ErrStream << *BestSymbolForBlock->getName() << ", ";
     else
       ErrStream << "<anonymous block> @ ";
 
     ErrStream << formatv("{0:x}", B.getAddress()) << " + "
               << formatv("{0:x}", E.getOffset()) << ")";
   }
   return make_error<JITLinkError>(std::move(ErrMsg));
 }
PointerJumpStubCreator getPointerJumpStubCreator(const Triple &TT) {
   case Triple::loongarch64:
     return loongarch::createAnonymousPointerJumpStub;
   default:
     return nullptr;
   }
 }
 
 Expected<std::unique_ptr<LinkGraph>>
-createLinkGraphFromObject(MemoryBufferRef ObjectBuffer) {
+createLinkGraphFromObject(MemoryBufferRef ObjectBuffer,
+                          std::shared_ptr<orc::SymbolStringPool> SSP) {
   auto Magic = identify_magic(ObjectBuffer.getBuffer());
   switch (Magic) {
   case file_magic::macho_object:
-    return createLinkGraphFromMachOObject(ObjectBuffer);
+    return createLinkGraphFromMachOObject(ObjectBuffer, SSP);
   case file_magic::elf_relocatable:
-    return createLinkGraphFromELFObject(ObjectBuffer);
+    return createLinkGraphFromELFObject(ObjectBuffer, SSP);
   case file_magic::coff_object:
-    return createLinkGraphFromCOFFObject(ObjectBuffer);
+    return createLinkGraphFromCOFFObject(ObjectBuffer, SSP);
   default:
     return make_error<JITLinkError>("Unsupported file format");
   };
 }
 
 void link(std::unique_ptr<LinkGraph> G, std::unique_ptr<JITLinkContext> Ctx) {
   switch (G->getTargetTriple().getObjectFormat()) {
   case Triple::MachO:

llvm/lib/ExecutionEngine/JITLink/JITLinkGeneric.cpp

Error JITLinkerBase::runPasses(LinkGraphPassList &Passes) {
   return Error::success();
 }
 
 JITLinkContext::LookupMap JITLinkerBase::getExternalSymbolNames() const {
   // Identify unresolved external symbols.
   JITLinkContext::LookupMap UnresolvedExternals;
   for (auto *Sym : G->external_symbols()) {
     assert(!Sym->getAddress() &&
            "External has already been assigned an address");
-    assert(Sym->getName() != StringRef() && Sym->getName() != "" &&
-           "Externals must be named");
+    assert(Sym->hasName() && "Externals must be named");
     SymbolLookupFlags LookupFlags =
         Sym->isWeaklyReferenced() ? SymbolLookupFlags::WeaklyReferencedSymbol
                                   : SymbolLookupFlags::RequiredSymbol;
     UnresolvedExternals[Sym->getName()] = LookupFlags;
   }
   return UnresolvedExternals;
 }
 
 void JITLinkerBase::applyLookupResult(AsyncLookupResult Result) {
   for (auto *Sym : G->external_symbols()) {
     assert(Sym->getOffset() == 0 &&
            "External symbol is not at the start of its addressable block");
for (auto *Sym : G->external_symbols()) {
     } else
       assert(Sym->isWeaklyReferenced() &&
              "Failed to resolve non-weak reference");
   }
 
   LLVM_DEBUG({
     dbgs() << "Externals after applying lookup result:\n";
     for (auto *Sym : G->external_symbols()) {
-      dbgs() << "  " << Sym->getName() << ": "
+      dbgs() << "  " << *Sym->getName() << ": "
              << formatv("{0:x16}", Sym->getAddress().getValue());
       switch (Sym->getLinkage()) {
       case Linkage::Strong:
         break;
       case Linkage::Weak:
         dbgs() << " (weak)";
         break;
       }

llvm/lib/ExecutionEngine/JITLink/JITLinkMemoryManager.cpp

void SimpleSegmentAlloc::Create(JITLinkMemoryManager &MemMgr,
   static_assert(orc::AllocGroup::NumGroups == 32,
                 "AllocGroup has changed. Section names below must be updated");
   StringRef AGSectionNames[] = {
       "__---.standard", "__R--.standard", "__-W-.standard", "__RW-.standard",
       "__--X.standard", "__R-X.standard", "__-WX.standard", "__RWX.standard",
       "__---.finalize", "__R--.finalize", "__-W-.finalize", "__RW-.finalize",
       "__--X.finalize", "__R-X.finalize", "__-WX.finalize", "__RWX.finalize"};
 
-  auto G = std::make_unique<LinkGraph>("", Triple(), 0,
+  auto G = std::make_unique<LinkGraph>("", std::shared_ptr<orc::SymbolStringPool>(), Triple(), 0,
                                        llvm::endianness::native, nullptr);
   orc::AllocGroupSmallMap<Block *> ContentBlocks;
 
   orc::ExecutorAddr NextAddr(0x100000);
   for (auto &KV : Segments) {
     auto &AG = KV.first;
     auto &Seg = KV.second;
 

llvm/lib/ExecutionEngine/JITLink/MachO.cpp

 using namespace llvm;
 
 #define DEBUG_TYPE "jitlink"
 
 namespace llvm {
 namespace jitlink {
 
 Expected<std::unique_ptr<LinkGraph>>
-createLinkGraphFromMachOObject(MemoryBufferRef ObjectBuffer) {
+createLinkGraphFromMachOObject(MemoryBufferRef ObjectBuffer,
+                               std::shared_ptr<orc::SymbolStringPool> SSP) {
   StringRef Data = ObjectBuffer.getBuffer();
   if (Data.size() < 4)
     return make_error<JITLinkError>("Truncated MachO buffer \"" +
                                     ObjectBuffer.getBufferIdentifier() + "\"");
 
   uint32_t Magic;
   memcpy(&Magic, Data.data(), sizeof(uint32_t));
   LLVM_DEBUG({
else if (Magic == MachO::MH_MAGIC_64 || Magic == MachO::MH_CIGAM_64) {
 
     LLVM_DEBUG({
       dbgs() << "jitLink_MachO: cputype = " << format("0x%08" PRIx32, CPUType)
              << "\n";
     });
 
     switch (CPUType) {
     case MachO::CPU_TYPE_ARM64:
-      return createLinkGraphFromMachOObject_arm64(ObjectBuffer);
+      return createLinkGraphFromMachOObject_arm64(ObjectBuffer, SSP);
     case MachO::CPU_TYPE_X86_64:
-      return createLinkGraphFromMachOObject_x86_64(ObjectBuffer);
+      return createLinkGraphFromMachOObject_x86_64(ObjectBuffer, SSP);
     }
     return make_error<JITLinkError>("MachO-64 CPU type not valid");
   } else
     return make_error<JITLinkError>("Unrecognized MachO magic value");
 }
 
 void link_MachO(std::unique_ptr<LinkGraph> G,
                 std::unique_ptr<JITLinkContext> Ctx) {

llvm/lib/ExecutionEngine/JITLink/MachOLinkGraphBuilder.h

 public:
   virtual ~MachOLinkGraphBuilder();
   Expected<std::unique_ptr<LinkGraph>> buildGraph();
 
 protected:
 
   struct NormalizedSymbol {
     friend class MachOLinkGraphBuilder;
-
-  private:
     NormalizedSymbol(std::optional<StringRef> Name, uint64_t Value,
                      uint8_t Type, uint8_t Sect, uint16_t Desc, Linkage L,
                      Scope S)
         : Name(Name), Value(Value), Type(Type), Sect(Sect), Desc(Desc), L(L),
           S(S) {
       assert((!Name || !Name->empty()) && "Name must be none or non-empty");
     }
 
+  private:
   public:
     NormalizedSymbol(const NormalizedSymbol &) = delete;
     NormalizedSymbol &operator=(const NormalizedSymbol &) = delete;
     NormalizedSymbol(NormalizedSymbol &&) = delete;
     NormalizedSymbol &operator=(NormalizedSymbol &&) = delete;
 
     std::optional<StringRef> Name;
     uint64_t Value = 0;
public:
     uint32_t Flags = 0;
     const char *Data = nullptr;
     Section *GraphSection = nullptr;
     std::map<orc::ExecutorAddr, Symbol *> CanonicalSymbols;
   };
 
   using SectionParserFunction = std::function<Error(NormalizedSection &S)>;
 
-  MachOLinkGraphBuilder(const object::MachOObjectFile &Obj, Triple TT,
+  MachOLinkGraphBuilder(const object::MachOObjectFile &Obj,
+                        std::shared_ptr<orc::SymbolStringPool> SSP, Triple TT,
                         SubtargetFeatures Features,
                         LinkGraph::GetEdgeKindNameFunction GetEdgeKindName);
-
   LinkGraph &getGraph() const { return *G; }
 
   const object::MachOObjectFile &getObject() const { return Obj; }
 
   void addCustomSectionParser(StringRef SectionName,
                               SectionParserFunction Parse);
 
   virtual Error addRelocations() = 0;

llvm/lib/ExecutionEngine/JITLink/MachOLinkGraphBuilder.cpp

Expected<std::unique_ptr<LinkGraph>> MachOLinkGraphBuilder::buildGraph() {
 
   if (auto Err = addRelocations())
     return std::move(Err);
 
   return std::move(G);
 }
 
 MachOLinkGraphBuilder::MachOLinkGraphBuilder(
-    const object::MachOObjectFile &Obj, Triple TT, SubtargetFeatures Features,
+    const object::MachOObjectFile &Obj,
+        std::shared_ptr<orc::SymbolStringPool> SSP,
+        Triple TT, SubtargetFeatures Features,
     LinkGraph::GetEdgeKindNameFunction GetEdgeKindName)
     : Obj(Obj),
       G(std::make_unique<LinkGraph>(std::string(Obj.getFileName()),
+                                    SSP,
                                     std::move(TT), std::move(Features),
                                     getPointerSize(Obj), getEndianness(Obj),
-                                    std::move(GetEdgeKindName))) {
+                                    std::move(GetEdgeKindName)))
+  {
   auto &MachHeader = Obj.getHeader64();
   SubsectionsViaSymbols = MachHeader.flags & MachO::MH_SUBSECTIONS_VIA_SYMBOLS;
 }
 
 void MachOLinkGraphBuilder::addCustomSectionParser(
     StringRef SectionName, SectionParserFunction Parser) {
   assert(!CustomSectionParserFunctions.count(SectionName) &&
          "Custom parser for this section already exists");
if (Sect != 0) {
           dbgs() << "  Skipping: Symbol is in section " << NSec->SegName << "/"
                  << NSec->SectName
                  << " which has no associated graph section.\n";
         });
         continue;
       }
     }
 
-    IndexToSymbol[SymbolIndex] =
-        &createNormalizedSymbol(*Name, Value, Type, Sect, Desc,
-                                getLinkage(Desc), getScope(*Name, Type));
+    IndexToSymbol[SymbolIndex] = &createNormalizedSymbol(
+        Name, Value, Type, Sect, Desc, getLinkage(Desc), getScope(*Name, Type));
   }
 
   return Error::success();
 }
 
 void MachOLinkGraphBuilder::addSectionStartSymAndBlock(
     unsigned SecIndex, Section &GraphSec, orc::ExecutorAddr Address,
     const char *Data, orc::ExecutorAddrDiff Size, uint32_t Alignment,
Symbol &MachOLinkGraphBuilder::createStandardGraphSymbol(NormalizedSymbol &NSym,
                                                          bool IsCanonical) {
 
   LLVM_DEBUG({
     dbgs() << "      " << formatv("{0:x16}", NSym.Value) << " -- "
            << formatv("{0:x16}", NSym.Value + Size) << ": ";
     if (!NSym.Name)
       dbgs() << "<anonymous symbol>";
     else
-      dbgs() << NSym.Name;
+      dbgs() << *NSym.Name;
     if (IsText)
       dbgs() << " [text]";
     if (IsNoDeadStrip)
       dbgs() << " [no-dead-strip]";
     if (!IsCanonical)
       dbgs() << " [non-canonical]";
     dbgs() << "\n";
   });
if (NSec.Data[I] == '\0') {
         }
 
         auto &Sym = createStandardGraphSymbol(NSym, B, SymSize, SectionIsText,
                                               SymLive, IsCanonical);
         (void)Sym;
         LLVM_DEBUG({
           dbgs() << "      Adding symbol for c-string block " << B.getRange()
                  << ": "
-                 << (Sym.hasName() ? Sym.getName() : "<anonymous symbol>")
+                 << (Sym.hasName() ? *Sym.getName() : "<anonymous symbol>")
                  << " at offset " << formatv("{0:x}", Sym.getOffset()) << "\n";
         });
 
         NSyms.pop_back();
       }
 
       BlockStart += BlockSize;
     }
for (unsigned I = 0; I != NumBlocks; ++I) {
       auto &CURec = G.splitBlock(*B, CURecordSize, &C);
       bool AddedKeepAlive = false;
 
       for (auto &E : CURec.edges()) {
         if (E.getOffset() == 0) {
           LLVM_DEBUG({
             dbgs() << "    Updating compact unwind record at "
                    << formatv("{0:x16}", CURec.getAddress()) << " to point to "
-                   << (E.getTarget().hasName() ? E.getTarget().getName()
+                   << (E.getTarget().hasName() ? *E.getTarget().getName()
                                                : StringRef())
                    << " (at " << formatv("{0:x16}", E.getTarget().getAddress())
                    << ")\n";
           });
 
           if (E.getTarget().isExternal())
             return make_error<JITLinkError>(
                 "Error adding keep-alive edge for compact unwind record at " +
                 formatv("{0:x}", CURec.getAddress()) + ": target " +
-                E.getTarget().getName() + " is an external symbol");
+                *E.getTarget().getName() + " is an external symbol");
           auto &TgtBlock = E.getTarget().getBlock();
           auto &CURecSym =
               G.addAnonymousSymbol(CURec, 0, CURecordSize, false, false);
           TgtBlock.addEdge(Edge::KeepAlive, 0, CURecSym, 0);
           AddedKeepAlive = true;
         } else if (E.getOffset() != PersonalityEdgeOffset &&
                    E.getOffset() != LSDAEdgeOffset)
           return make_error<JITLinkError>("Unexpected edge at offset " +

llvm/lib/ExecutionEngine/JITLink/MachO_arm64.cpp

 
 #include "MachOLinkGraphBuilder.h"
 
 #define DEBUG_TYPE "jitlink"
 
 using namespace llvm;
 using namespace llvm::jitlink;
 
-namespace {
+namespace { 
 
 class MachOLinkGraphBuilder_arm64 : public MachOLinkGraphBuilder {
 public:
   MachOLinkGraphBuilder_arm64(const object::MachOObjectFile &Obj,
+                             std::shared_ptr<orc::SymbolStringPool> SSP, 
                               SubtargetFeatures Features)
-      : MachOLinkGraphBuilder(Obj, Triple("arm64-apple-darwin"),
+      : MachOLinkGraphBuilder(Obj, SSP,
+                              Triple("arm64-apple-darwin"),
                               std::move(Features), aarch64::getEdgeKindName),
         NumSymbols(Obj.getSymtabLoadCommand().nsyms) {}
 
 private:
   enum MachOARM64RelocationKind : Edge::Kind {
     MachOBranch26 = Edge::FirstRelocation,
     MachOPointer32,
     MachOPointer64,

 private:
   Error applyFixup(LinkGraph &G, Block &B, const Edge &E) const {
     return aarch64::applyFixup(G, B, E);
   }
 
   uint64_t NullValue = 0;
 };
 
-Expected<std::unique_ptr<LinkGraph>>
-createLinkGraphFromMachOObject_arm64(MemoryBufferRef ObjectBuffer) {
+Expected<std::unique_ptr<LinkGraph>> createLinkGraphFromMachOObject_arm64(
+    MemoryBufferRef ObjectBuffer, std::shared_ptr<orc::SymbolStringPool> SSP) {
   auto MachOObj = object::ObjectFile::createMachOObjectFile(ObjectBuffer);
   if (!MachOObj)
     return MachOObj.takeError();
 
   auto Features = (*MachOObj)->getFeatures();
   if (!Features)
     return Features.takeError();
 
-  return MachOLinkGraphBuilder_arm64(**MachOObj, std::move(*Features))
+  return MachOLinkGraphBuilder_arm64(**MachOObj, SSP,  std::move(*Features))
       .buildGraph();
 }
 
 void link_MachO_arm64(std::unique_ptr<LinkGraph> G,
                       std::unique_ptr<JITLinkContext> Ctx) {
 
   PassConfiguration Config;
 
   if (Ctx->shouldAddDefaultTargetPasses(G->getTargetTriple())) {
     // Add a mark-live pass.
     if (auto MarkLive = Ctx->getMarkLivePass(G->getTargetTriple()))
       Config.PrePrunePasses.push_back(std::move(MarkLive));
     else
       Config.PrePrunePasses.push_back(markAllSymbolsLive);
 
     // Add compact unwind splitter pass.
     Config.PrePrunePasses.push_back(
         CompactUnwindSplitter("__LD,__compact_unwind"));
 
-    // Add eh-frame passes.
+    // Add eh-frame passses.
     // FIXME: Prune eh-frames for which compact-unwind is available once
     // we support compact-unwind registration with libunwind.
     Config.PrePrunePasses.push_back(createEHFrameSplitterPass_MachO_arm64());
     Config.PrePrunePasses.push_back(createEHFrameEdgeFixerPass_MachO_arm64());
 
     // Add an in-place GOT/Stubs pass.
     Config.PostPrunePasses.push_back(buildTables_MachO_arm64);
   }

llvm/lib/ExecutionEngine/JITLink/MachO_x86_64.cpp

 using namespace llvm;
 using namespace llvm::jitlink;
 
 namespace {
 
 class MachOLinkGraphBuilder_x86_64 : public MachOLinkGraphBuilder {
 public:
   MachOLinkGraphBuilder_x86_64(const object::MachOObjectFile &Obj,
+                              std::shared_ptr<orc::SymbolStringPool> SSP,
                                SubtargetFeatures Features)
-      : MachOLinkGraphBuilder(Obj, Triple("x86_64-apple-darwin"),
+      : MachOLinkGraphBuilder(Obj, SSP, Triple("x86_64-apple-darwin"),
                               std::move(Features), x86_64::getEdgeKindName) {}
 
 private:
   enum MachONormalizedRelocationType : unsigned {
     MachOBranch32,
     MachOPointer32,
     MachOPointer64,
     MachOPointer64Anon,
MachOJITLinker_x86_64(std::unique_ptr<JITLinkContext> Ctx,
       : JITLinker(std::move(Ctx), std::move(G), std::move(PassConfig)) {}
 
 private:
   Error applyFixup(LinkGraph &G, Block &B, const Edge &E) const {
     return x86_64::applyFixup(G, B, E, nullptr);
   }
 };
 
-Expected<std::unique_ptr<LinkGraph>>
-createLinkGraphFromMachOObject_x86_64(MemoryBufferRef ObjectBuffer) {
+Expected<std::unique_ptr<LinkGraph>> createLinkGraphFromMachOObject_x86_64(
+    MemoryBufferRef ObjectBuffer, std::shared_ptr<orc::SymbolStringPool> SSP) {
   auto MachOObj = object::ObjectFile::createMachOObjectFile(ObjectBuffer);
   if (!MachOObj)
     return MachOObj.takeError();
 
   auto Features = (*MachOObj)->getFeatures();
   if (!Features)
     return Features.takeError();
 
-  return MachOLinkGraphBuilder_x86_64(**MachOObj, std::move(*Features))
+  return MachOLinkGraphBuilder_x86_64(**MachOObj, SSP, std::move(*Features))
       .buildGraph();
 }
 
 void link_MachO_x86_64(std::unique_ptr<LinkGraph> G,
                        std::unique_ptr<JITLinkContext> Ctx) {
 
   PassConfiguration Config;
 

llvm/lib/ExecutionEngine/JITLink/PerGraphGOTAndPLTStubsBuilder.h

Error run() {
 
     return Error::success();
   }
 
 protected:
   Symbol &getGOTEntry(Symbol &Target) {
     assert(Target.hasName() && "GOT edge cannot point to anonymous target");
 
     auto GOTEntryI = GOTEntries.find(Target.getName());
 
     // Build the entry if it doesn't exist.
     if (GOTEntryI == GOTEntries.end()) {
       auto &GOTEntry = impl().createGOTEntry(Target);
       LLVM_DEBUG({
-        dbgs() << "    Created GOT entry for " << Target.getName() << ": "
+        dbgs() << "    Created GOT entry for " << *Target.getName() << ": "
                << GOTEntry << "\n";
       });
       GOTEntryI =
           GOTEntries.insert(std::make_pair(Target.getName(), &GOTEntry)).first;
     }
 
     assert(GOTEntryI != GOTEntries.end() && "Could not get GOT entry symbol");
     LLVM_DEBUG(
         { dbgs() << "    Using GOT entry " << *GOTEntryI->second << "\n"; });
     return *GOTEntryI->second;
   }
 
   Symbol &getPLTStub(Symbol &Target) {
     assert(Target.hasName() &&
            "External branch edge can not point to an anonymous target");
     auto StubI = PLTStubs.find(Target.getName());
 
     if (StubI == PLTStubs.end()) {
       auto &StubSymbol = impl().createPLTStub(Target);
       LLVM_DEBUG({
-        dbgs() << "    Created PLT stub for " << Target.getName() << ": "
+        dbgs() << "    Created PLT stub for " << *Target.getName() << ": "
                << StubSymbol << "\n";
       });
       StubI =
           PLTStubs.insert(std::make_pair(Target.getName(), &StubSymbol)).first;
     }
 
     assert(StubI != PLTStubs.end() && "Count not get stub symbol");
     LLVM_DEBUG({ dbgs() << "    Using PLT stub " << *StubI->second << "\n"; });
     return *StubI->second;
   }
 
   LinkGraph &G;
 
 private:
   BuilderImplT &impl() { return static_cast<BuilderImplT &>(*this); }
 
-  DenseMap<StringRef, Symbol *> GOTEntries;
-  DenseMap<StringRef, Symbol *> PLTStubs;
+  DenseMap<orc::SymbolStringPtr, Symbol *> GOTEntries;
+  DenseMap<orc::SymbolStringPtr, Symbol *> PLTStubs;
 };
 
 } // end namespace jitlink
 } // end namespace llvm
 
 #undef DEBUG_TYPE
 
 #endif // LLVM_EXECUTIONENGINE_JITLINK_PERGRAPHGOTANDPLTSTUBSBUILDER_H

llvm/lib/ExecutionEngine/Orc/COFFPlatform.cpp

void materialize(std::unique_ptr<MaterializationResponsibility> R) override {
     switch (TT.getArch()) {
     case Triple::x86_64:
       PointerSize = 8;
       Endianness = llvm::endianness::little;
       break;
     default:
       llvm_unreachable("Unrecognized architecture");
     }
 
     auto G = std::make_unique<jitlink::LinkGraph>(
-        "<COFFHeaderMU>", TT, PointerSize, Endianness,
-        jitlink::getGenericEdgeKindName);
+        "<COFFHeaderMU>", CP.getExecutionSession().getSymbolStringPool(), TT,
+        PointerSize, Endianness, jitlink::getGenericEdgeKindName);
     auto &HeaderSection = G->createSection("__header", MemProt::Read);
     auto &HeaderBlock = createHeaderBlock(*G, HeaderSection);
 
     // Init symbol is __ImageBase symbol.
     auto &ImageBaseSymbol = G->addDefinedSymbol(
         HeaderBlock, 0, *R->getInitializerSymbol(), HeaderBlock.getSize(),
         jitlink::Linkage::Strong, jitlink::Scope::Default, false, true);
 
COFFPlatform::COFFPlatformPlugin::getSyntheticSymbolDependencies(
   }
   return SyntheticSymbolDependenciesMap();
 }
 
 Error COFFPlatform::COFFPlatformPlugin::associateJITDylibHeaderSymbol(
     jitlink::LinkGraph &G, MaterializationResponsibility &MR,
     bool IsBootstraping) {
   auto I = llvm::find_if(G.defined_symbols(), [this](jitlink::Symbol *Sym) {
-    return Sym->getName() == *CP.COFFHeaderStartSymbol;
+    return *Sym->getName() == *CP.COFFHeaderStartSymbol;
   });
   assert(I != G.defined_symbols().end() && "Missing COFF header start symbol");
 
   auto &JD = MR.getTargetJITDylib();
   std::lock_guard<std::mutex> Lock(CP.PlatformMutex);
   auto HeaderAddr = (*I)->getAddress();
   CP.JITDylibToHeaderAddr[&JD] = HeaderAddr;
   CP.HeaderAddrToJITDylib[HeaderAddr] = &JD;

llvm/lib/ExecutionEngine/Orc/Debugging/DebuggerSupportPlugin.cpp

for (auto &NDSP : NonDebugSections) {
         // Skip anonymous symbols.
         if (!Sym->hasName())
           continue;
 
         uint8_t SymType = Sym->isCallable() ? MachO::N_FUN : MachO::N_GSYM;
 
         Builder.addSymbol("", MachO::N_BNSYM, 1, 0, 0);
         StabSymbols.push_back(
-            {*Sym, Builder.addSymbol(Sym->getName(), SymType, 1, 0, 0),
-             Builder.addSymbol(Sym->getName(), SymType, 0, 0, 0)});
+            {*Sym, Builder.addSymbol(*Sym->getName(), SymType, 1, 0, 0),
+             Builder.addSymbol(*Sym->getName(), SymType, 0, 0, 0)});
         Builder.addSymbol("", MachO::N_ENSYM, 1, 0, 0);
       }
     }
 
     Builder.addSymbol("", MachO::N_SO, 1, 0, 0);
 
     // Lay out the debug object, create a section and block for it.
     size_t DebugObjectSize = Builder.layout();

llvm/lib/ExecutionEngine/Orc/Debugging/PerfSupportPlugin.cpp

 constexpr StringRef RegisterPerfEndSymbolName =
     "llvm_orc_registerJITLoaderPerfEnd";
 constexpr StringRef RegisterPerfImplSymbolName =
     "llvm_orc_registerJITLoaderPerfImpl";
 
 static PerfJITCodeLoadRecord
 getCodeLoadRecord(const Symbol &Sym, std::atomic<uint64_t> &CodeIndex) {
   PerfJITCodeLoadRecord Record;
-  auto Name = Sym.getName();
+  auto Name = *Sym.getName();
   auto Addr = Sym.getAddress();
   auto Size = Sym.getSize();
   Record.Prefix.Id = PerfJITRecordType::JIT_CODE_LOAD;
   // Runtime sets PID
   Record.Pid = 0;
   // Runtime sets TID
   Record.Tid = 0;
   Record.Vma = Addr.getValue();

 }
 
 static std::optional<PerfJITDebugInfoRecord>
 getDebugInfoRecord(const Symbol &Sym, DWARFContext &DC) {
   auto &Section = Sym.getBlock().getSection();
   auto Addr = Sym.getAddress();
   auto Size = Sym.getSize();
   auto SAddr = object::SectionedAddress{Addr.getValue(), Section.getOrdinal()};
-  LLVM_DEBUG(dbgs() << "Getting debug info for symbol " << Sym.getName()
+  LLVM_DEBUG(dbgs() << "Getting debug info for symbol " << *Sym.getName()
                     << " at address " << Addr.getValue() << " with size "
                     << Size << "\n"
                     << "Section ordinal: " << Section.getOrdinal() << "\n");
   auto LInfo = DC.getLineInfoForAddressRange(
       SAddr, Size, DILineInfoSpecifier::FileLineInfoKind::AbsoluteFilePath);
   if (LInfo.empty()) {
     // No line info available
     LLVM_DEBUG(dbgs() << "No line info available\n");

llvm/lib/ExecutionEngine/Orc/ELFNixPlatform.cpp

case Triple::ppc64le:
       EdgeKind = jitlink::ppc64::Pointer64;
       break;
     default:
       llvm_unreachable("Unrecognized architecture");
     }
 
     // void *__dso_handle = &__dso_handle;
     auto G = std::make_unique<jitlink::LinkGraph>(
-        "<DSOHandleMU>", TT, PointerSize, Endianness,
-        jitlink::getGenericEdgeKindName);
+        "<DSOHandleMU>", ENP.getExecutionSession().getSymbolStringPool(), TT,
+        PointerSize, Endianness, jitlink::getGenericEdgeKindName);
     auto &DSOHandleSection =
         G->createSection(".data.__dso_handle", MemProt::Read);
     auto &DSOHandleBlock = G->createContentBlock(
         DSOHandleSection, getDSOHandleContent(PointerSize), orc::ExecutorAddr(),
         8, 0);
     auto &DSOHandleSymbol = G->addDefinedSymbol(
         DSOHandleBlock, 0, *R->getInitializerSymbol(), DSOHandleBlock.getSize(),
         jitlink::Linkage::Strong, jitlink::Scope::Default, false, true);

 }
 
 void ELFNixPlatform::ELFNixPlatformPlugin::addDSOHandleSupportPasses(
     MaterializationResponsibility &MR, jitlink::PassConfiguration &Config) {
 
   Config.PostAllocationPasses.push_back([this, &JD = MR.getTargetJITDylib()](
                                             jitlink::LinkGraph &G) -> Error {
     auto I = llvm::find_if(G.defined_symbols(), [this](jitlink::Symbol *Sym) {
-      return Sym->getName() == *MP.DSOHandleSymbol;
+      return Sym->getName() == MP.DSOHandleSymbol;
     });
     assert(I != G.defined_symbols().end() && "Missing DSO handle symbol");
     {
       std::lock_guard<std::mutex> Lock(MP.PlatformMutex);
       auto HandleAddr = (*I)->getAddress();
       MP.HandleAddrToJITDylib[HandleAddr] = &JD;
       assert(!MP.InitSeqs.count(&JD) && "InitSeq entry for JD already exists");
       MP.InitSeqs.insert(std::make_pair(
LLVM_DEBUG({
     }
   });
 
   return MP.registerInitInfo(JD, InitSections);
 }
 
 Error ELFNixPlatform::ELFNixPlatformPlugin::fixTLVSectionsAndEdges(
     jitlink::LinkGraph &G, JITDylib &JD) {
-
+  auto TLSGetAddrSymbolName = G.intern("__tls_get_addr");
+  auto TLSDescResolveSymbolName = G.intern("__tlsdesc_resolver");
   for (auto *Sym : G.external_symbols()) {
-    if (Sym->getName() == "__tls_get_addr") {
-      Sym->setName("___orc_rt_elfnix_tls_get_addr");
-    } else if (Sym->getName() == "__tlsdesc_resolver") {
-      Sym->setName("___orc_rt_elfnix_tlsdesc_resolver");
+    if (Sym->getName() == TLSGetAddrSymbolName) {
+      auto TLSGetAddr =
+          MP.getExecutionSession().intern("___orc_rt_elfnix_tls_get_addr");
+      Sym->setName(std::move(TLSGetAddr));
+    } else if (Sym->getName() == TLSDescResolveSymbolName) {
+      auto TLSGetAddr =
+          MP.getExecutionSession().intern("___orc_rt_elfnix_tlsdesc_resolver");
+      Sym->setName(std::move(TLSGetAddr));
     }
   }
 
   auto *TLSInfoEntrySection = G.findSectionByName("$__TLSINFO");
 
   if (TLSInfoEntrySection) {
     std::optional<uint64_t> Key;
     {
       std::lock_guard<std::mutex> Lock(MP.PlatformMutex);

llvm/lib/ExecutionEngine/Orc/ExecutionUtils.cpp

 //===---- ExecutionUtils.cpp - Utilities for executing functions in Orc ---===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/ExecutionEngine/Orc/ExecutionUtils.h"
 #include "llvm/ExecutionEngine/JITLink/x86_64.h"
 #include "llvm/ExecutionEngine/Orc/Layer.h"
 #include "llvm/ExecutionEngine/Orc/ObjectFileInterface.h"
+#include "llvm/ExecutionEngine/Orc/SymbolStringPool.h"
 #include "llvm/IR/Constants.h"
 #include "llvm/IR/Function.h"
 #include "llvm/IR/GlobalVariable.h"
 #include "llvm/IR/Module.h"
 #include "llvm/MC/TargetRegistry.h"
 #include "llvm/Object/MachOUniversal.h"
 #include "llvm/Support/FormatVariadic.h"
 #include "llvm/Target/TargetMachine.h"
DLLImportDefinitionGenerator::createStubsGraph(const SymbolMap &Resolved) {
   auto PointerSize = getTargetPointerSize(TT);
   if (!PointerSize)
     return PointerSize.takeError();
   auto Endianness = getTargetEndianness(TT);
   if (!Endianness)
     return Endianness.takeError();
 
   auto G = std::make_unique<jitlink::LinkGraph>(
-      "<DLLIMPORT_STUBS>", TT, *PointerSize, *Endianness,
-      jitlink::getGenericEdgeKindName);
+      "<DLLIMPORT_STUBS>", ES.getSymbolStringPool(), TT, *PointerSize,
+      *Endianness, jitlink::getGenericEdgeKindName);
   jitlink::Section &Sec =
       G->createSection(getSectionName(), MemProt::Read | MemProt::Exec);
 
   for (auto &KV : Resolved) {
     jitlink::Symbol &Target = G->addAbsoluteSymbol(
         *KV.first, KV.second.getAddress(), *PointerSize,
         jitlink::Linkage::Strong, jitlink::Scope::Local, false);
 
     // Create __imp_ symbol
     jitlink::Symbol &Ptr =
         jitlink::x86_64::createAnonymousPointer(*G, Sec, &Target);
-    auto NameCopy = G->allocateContent(Twine(getImpPrefix()) + *KV.first);
-    StringRef NameCopyRef = StringRef(NameCopy.data(), NameCopy.size());
-    Ptr.setName(NameCopyRef);
+    auto name = getImpPrefix() + *KV.first;
+    Ptr.setName(G->intern(name.getSingleStringRef()));
     Ptr.setLinkage(jitlink::Linkage::Strong);
     Ptr.setScope(jitlink::Scope::Default);
 
     // Create PLT stub
     // FIXME: check PLT stub of data symbol is not accessed
     jitlink::Block &StubBlock =
         jitlink::x86_64::createPointerJumpStubBlock(*G, Sec, Ptr);
     G->addDefinedSymbol(StubBlock, 0, *KV.first, StubBlock.getSize(),
                         jitlink::Linkage::Strong, jitlink::Scope::Default, true,
                         false);
   }
 
   return std::move(G);
 }
 
 } // End namespace orc.
 } // End namespace llvm.

llvm/lib/ExecutionEngine/Orc/IndirectionUtils.cpp

Error addFunctionPointerRelocationsToCurrentSymbol(jitlink::Symbol &Sym,
   auto &B = Sym.getBlock();
   assert(!B.isZeroFill() && "expected content block");
   auto SymAddress = Sym.getAddress();
   auto SymStartInBlock =
       (const uint8_t *)B.getContent().data() + Sym.getOffset();
   auto SymSize = Sym.getSize() ? Sym.getSize() : B.getSize() - Sym.getOffset();
   auto Content = ArrayRef(SymStartInBlock, SymSize);
 
-  LLVM_DEBUG(dbgs() << "Adding self-relocations to " << Sym.getName() << "\n");
+  LLVM_DEBUG(dbgs() << "Adding self-relocations to " << *Sym.getName() << "\n");
 
   SmallDenseSet<uintptr_t, 8> ExistingRelocations;
   for (auto &E : B.edges()) {
     if (E.isRelocation())
       ExistingRelocations.insert(E.getOffset());
   }
 
   size_t I = 0;

llvm/lib/ExecutionEngine/Orc/MachOPlatform.cpp

std::unique_ptr<jitlink::LinkGraph> createPlatformGraph(MachOPlatform &MOP,
   case Triple::x86_64:
     PointerSize = 8;
     Endianness = llvm::endianness::little;
     break;
   default:
     llvm_unreachable("Unrecognized architecture");
   }
 
-  return std::make_unique<jitlink::LinkGraph>(std::move(Name), TT, PointerSize,
-                                              Endianness,
-                                              jitlink::getGenericEdgeKindName);
+  return std::make_unique<jitlink::LinkGraph>(
+      std::move(Name), MOP.getExecutionSession().getSymbolStringPool(), TT,
+      PointerSize, Endianness, jitlink::getGenericEdgeKindName);
 }
 
 // Generates a MachO header.
 class MachOHeaderMaterializationUnit : public MaterializationUnit {
 public:
   MachOHeaderMaterializationUnit(MachOPlatform &MOP,
                                  const SymbolStringPtr &HeaderStartSymbol)
       : MaterializationUnit(createHeaderInterface(MOP, HeaderStartSymbol)),
std::pair<StringRef, ExecutorAddr *> RuntimeSymbols[] = {
       {*MP.RegisterObjCRuntimeObject.Name, &MP.RegisterObjCRuntimeObject.Addr},
       {*MP.DeregisterObjCRuntimeObject.Name,
        &MP.DeregisterObjCRuntimeObject.Addr}};
 
   bool RegisterMachOHeader = false;
 
   for (auto *Sym : G.defined_symbols()) {
     for (auto &RTSym : RuntimeSymbols) {
-      if (Sym->hasName() && Sym->getName() == RTSym.first) {
+      if (Sym->hasName() && *Sym->getName() == RTSym.first) {
         if (*RTSym.second)
           return make_error<StringError>(
               "Duplicate " + RTSym.first +
                   " detected during MachOPlatform bootstrap",
               inconvertibleErrorCode());
 
-        if (Sym->getName() == *MP.MachOHeaderStartSymbol)
+        if (Sym->getName() == MP.MachOHeaderStartSymbol)
           RegisterMachOHeader = true;
 
         *RTSym.second = Sym->getAddress();
       }
     }
   }
 
   if (RegisterMachOHeader) {
Error MachOPlatform::MachOPlatformPlugin::bootstrapPipelineEnd(
   if (MP.Bootstrap.load()->ActiveGraphs == 0)
     MP.Bootstrap.load()->CV.notify_all();
   return Error::success();
 }
 
 Error MachOPlatform::MachOPlatformPlugin::associateJITDylibHeaderSymbol(
     jitlink::LinkGraph &G, MaterializationResponsibility &MR) {
   auto I = llvm::find_if(G.defined_symbols(), [this](jitlink::Symbol *Sym) {
-    return Sym->getName() == *MP.MachOHeaderStartSymbol;
+    return Sym->getName() == MP.MachOHeaderStartSymbol;
   });
   assert(I != G.defined_symbols().end() && "Missing MachO header start symbol");
 
   auto &JD = MR.getTargetJITDylib();
   std::lock_guard<std::mutex> Lock(MP.PlatformMutex);
   auto HeaderAddr = (*I)->getAddress();
   MP.JITDylibToHeaderAddr[&JD] = HeaderAddr;
   MP.HeaderAddrToJITDylib[HeaderAddr] = &JD;
if (ObjCImageInfoItr != ObjCImageInfos.end()) {
     ObjCImageInfos[&MR.getTargetJITDylib()] = {Version, Flags};
   }
 
   return Error::success();
 }
 
 Error MachOPlatform::MachOPlatformPlugin::fixTLVSectionsAndEdges(
     jitlink::LinkGraph &G, JITDylib &JD) {
-
+  auto TLVBootStrapSymbolName = G.intern("__tlv_bootstrap");
   // Rename external references to __tlv_bootstrap to ___orc_rt_tlv_get_addr.
   for (auto *Sym : G.external_symbols())
-    if (Sym->getName() == "__tlv_bootstrap") {
-      Sym->setName("___orc_rt_macho_tlv_get_addr");
+    if (Sym->getName() == TLVBootStrapSymbolName) {
+      auto TLSGetADDR =
+          MP.getExecutionSession().intern("___orc_rt_macho_tlv_get_addr");
+      Sym->setName(std::move(TLSGetADDR));
       break;
     }
 
   // Store key in __thread_vars struct fields.
   if (auto *ThreadDataSec = G.findSectionByName(MachOThreadVarsSectionName)) {
     std::optional<uint64_t> Key;
     {
       std::lock_guard<std::mutex> Lock(MP.PlatformMutex);
       auto I = MP.JITDylibToPThreadKey.find(&JD);
Error MachOPlatform::MachOPlatformPlugin::populateObjCRuntimeObject(
     jitlink::LinkGraph &G, MaterializationResponsibility &MR) {
 
   auto *ObjCRuntimeObjectSec =
       G.findSectionByName(ObjCRuntimeObjectSectionName);
 
   if (!ObjCRuntimeObjectSec)
     return Error::success();
 
   switch (G.getTargetTriple().getArch()) {
   case Triple::aarch64:
   case Triple::x86_64:
     // Supported.
     break;
   default:
     return make_error<StringError>("Unrecognized MachO arch in triple " +
                                        G.getTargetTriple().str(),
                                    inconvertibleErrorCode());
   }
 
   auto &SecBlock = **ObjCRuntimeObjectSec->blocks().begin();
SD.AddFixups = [&](size_t RecordOffset) {
         break;
       default:
         llvm_unreachable("Unsupported architecture");
       }
 
       // Look for an existing __objc_imageinfo symbol.
       jitlink::Symbol *ObjCImageInfoSym = nullptr;
       for (auto *Sym : G.external_symbols())
-        if (Sym->getName() == ObjCImageInfoSymbolName) {
+        if (Sym->hasName() && *Sym->getName() == ObjCImageInfoSymbolName) {
           ObjCImageInfoSym = Sym;
           break;
         }
       if (!ObjCImageInfoSym)
         for (auto *Sym : G.absolute_symbols())
-          if (Sym->getName() == ObjCImageInfoSymbolName) {
+          if (Sym->hasName() && *Sym->getName() == ObjCImageInfoSymbolName) {
             ObjCImageInfoSym = Sym;
             break;
           }
       if (!ObjCImageInfoSym)
         for (auto *Sym : G.defined_symbols())
-          if (Sym->hasName() && Sym->getName() == ObjCImageInfoSymbolName) {
+          if (Sym->hasName() && *Sym->getName() == ObjCImageInfoSymbolName) {
             ObjCImageInfoSym = Sym;
             break;
           }
       if (!ObjCImageInfoSym)
         ObjCImageInfoSym =
             &G.addExternalSymbol(ObjCImageInfoSymbolName, 8, false);
 
       SecBlock.addEdge(PointerEdge,

llvm/lib/ExecutionEngine/Orc/ObjectFileInterface.cpp

for (auto &Sym : Obj.symbols()) {
     auto SymFlags = JITSymbolFlags::fromObjectSymbol(Sym);
     if (!SymFlags)
       return SymFlags.takeError();
 
     // ELF STB_GNU_UNIQUE should map to Weak for ORC.
     if (Sym.getBinding() == ELF::STB_GNU_UNIQUE)
       *SymFlags |= JITSymbolFlags::Weak;
 
-    I.SymbolFlags[ES.intern(*Name)] = std::move(*SymFlags);
+    I.SymbolFlags[ES.intern(std::move(*Name))] = std::move(*SymFlags);
   }
 
   SymbolStringPtr InitSymbol;
   for (auto &Sec : Obj.sections()) {
     if (auto SecName = Sec.getName()) {
       if (isELFInitializerSection(*SecName)) {
         addInitSymbol(I, ES, Obj.getFileName());
         break;

llvm/lib/ExecutionEngine/Orc/ObjectLinkingLayer.cpp

static Interface scanLinkGraph(ExecutionSession &ES, LinkGraph &G) {
     Interface LGI;
 
     for (auto *Sym : G.defined_symbols()) {
       // Skip local symbols.
       if (Sym->getScope() == Scope::Local)
         continue;
       assert(Sym->hasName() && "Anonymous non-local symbol?");
 
-      LGI.SymbolFlags[ES.intern(Sym->getName())] =
-          getJITSymbolFlagsForSymbol(*Sym);
+      LGI.SymbolFlags[Sym->getName()] = getJITSymbolFlagsForSymbol(*Sym);
     }
 
     if (hasInitializerSection(G))
       LGI.InitSymbol = makeInitSymbol(ES, G);
 
     return LGI;
   }
 
   static SymbolStringPtr makeInitSymbol(ExecutionSession &ES, LinkGraph &G) {
     std::string InitSymString;
     raw_string_ostream(InitSymString)
         << "$." << G.getName() << ".__inits" << Counter++;
     return ES.intern(InitSymString);
   }
 
   LinkGraphMaterializationUnit(ObjectLinkingLayer &ObjLinkingLayer,
                                std::unique_ptr<LinkGraph> G, Interface LGI)
       : MaterializationUnit(std::move(LGI)), ObjLinkingLayer(ObjLinkingLayer),
         G(std::move(G)) {}
 
   void discard(const JITDylib &JD, const SymbolStringPtr &Name) override {
     for (auto *Sym : G->defined_symbols())
-      if (Sym->getName() == *Name) {
+      if (Sym->getName() == Name) {
         assert(Sym->getLinkage() == Linkage::Weak &&
                "Discarding non-weak definition");
         G->makeExternal(*Sym);
         break;
       }
   }
 
   ObjectLinkingLayer &ObjLinkingLayer;
for (auto &KV : Symbols) {
       switch (KV.second) {
       case jitlink::SymbolLookupFlags::RequiredSymbol:
         LookupFlags = orc::SymbolLookupFlags::RequiredSymbol;
         break;
       case jitlink::SymbolLookupFlags::WeaklyReferencedSymbol:
         LookupFlags = orc::SymbolLookupFlags::WeaklyReferencedSymbol;
         break;
       }
-      LookupSet.add(ES.intern(KV.first), LookupFlags);
+      LookupSet.add(KV.first, LookupFlags);
     }
 
     // OnResolve -- De-intern the symbols and pass the result to the linker.
     auto OnResolve = [LookupContinuation =
                           std::move(LC)](Expected<SymbolMap> Result) mutable {
       if (!Result)
         LookupContinuation->run(Result.takeError());
       else {
         AsyncLookupResult LR;
         for (auto &KV : *Result)
-          LR[*KV.first] = KV.second;
+          LR[KV.first] = KV.second;
         LookupContinuation->run(std::move(LR));
       }
     };
 
     for (auto &KV : InternalNamedSymbolDeps) {
       SymbolDependenceMap InternalDeps;
       InternalDeps[&MR->getTargetJITDylib()] = std::move(KV.second);
       MR->addDependencies(KV.first, InternalDeps);
     }
 
     ES.lookup(LookupKind::Static, LinkOrder, std::move(LookupSet),
               SymbolState::Resolved, std::move(OnResolve),
               [this](const SymbolDependenceMap &Deps) {
                 registerDependencies(Deps);
               });
   }
 
   Error notifyResolved(LinkGraph &G) override {
-    auto &ES = Layer.getExecutionSession();
 
     SymbolFlagsMap ExtraSymbolsToClaim;
     bool AutoClaim = Layer.AutoClaimObjectSymbols;
 
     SymbolMap InternedResult;
     for (auto *Sym : G.defined_symbols())
       if (Sym->hasName() && Sym->getScope() != Scope::Local) {
-        auto InternedName = ES.intern(Sym->getName());
         auto Ptr = getJITSymbolPtrForSymbol(*Sym, G.getTargetTriple());
         auto Flags = getJITSymbolFlagsForSymbol(*Sym);
-        InternedResult[InternedName] = {Ptr, Flags};
-        if (AutoClaim && !MR->getSymbols().count(InternedName)) {
-          assert(!ExtraSymbolsToClaim.count(InternedName) &&
+        InternedResult[Sym->getName()] = {Ptr, Flags};
+        if (AutoClaim && !MR->getSymbols().count(Sym->getName())) {
+          assert(!ExtraSymbolsToClaim.count(Sym->getName()) &&
                  "Duplicate symbol to claim?");
-          ExtraSymbolsToClaim[InternedName] = Flags;
+          ExtraSymbolsToClaim[Sym->getName()] = Flags;
         }
       }
 
     for (auto *Sym : G.absolute_symbols())
       if (Sym->hasName() && Sym->getScope() != Scope::Local) {
-        auto InternedName = ES.intern(Sym->getName());
         auto Ptr = getJITSymbolPtrForSymbol(*Sym, G.getTargetTriple());
         auto Flags = getJITSymbolFlagsForSymbol(*Sym);
-        InternedResult[InternedName] = {Ptr, Flags};
-        if (AutoClaim && !MR->getSymbols().count(InternedName)) {
-          assert(!ExtraSymbolsToClaim.count(InternedName) &&
+        InternedResult[Sym->getName()] = {Ptr, Flags};
+        if (AutoClaim && !MR->getSymbols().count(Sym->getName())) {
+          assert(!ExtraSymbolsToClaim.count(Sym->getName()) &&
                  "Duplicate symbol to claim?");
-          ExtraSymbolsToClaim[InternedName] = Flags;
+          ExtraSymbolsToClaim[Sym->getName()] = Flags;
         }
       }
 
     if (!ExtraSymbolsToClaim.empty())
       if (auto Err = MR->defineMaterializing(ExtraSymbolsToClaim))
         return Err;
 
     {
struct BlockSymbolDependencies {
     SymbolNameSet Internal, External;
   };
 
   // Lazily populated map of blocks to BlockSymbolDependencies values.
   class BlockDependenciesMap {
   public:
     BlockDependenciesMap(ExecutionSession &ES,
                          DenseMap<const Block *, DenseSet<Block *>> BlockDeps)
-        : ES(ES), BlockDeps(std::move(BlockDeps)) {}
+        : BlockDeps(std::move(BlockDeps)) {}
 
     const BlockSymbolDependencies &operator[](const Block &B) {
       // Check the cache first.
       auto I = BlockTransitiveDepsCache.find(&B);
       if (I != BlockTransitiveDepsCache.end())
         return I->second;
 
       // No value. Populate the cache.
const BlockSymbolDependencies &operator[](const Block &B) {
           .first->second;
     }
 
     SymbolStringPtr &getInternedName(Symbol &Sym) {
       auto I = NameCache.find(&Sym);
       if (I != NameCache.end())
         return I->second;
 
-      return NameCache.insert(std::make_pair(&Sym, ES.intern(Sym.getName())))
+      return NameCache.insert(std::make_pair(&Sym, Sym.getName()))
           .first->second;
     }
 
   private:
     BlockSymbolDependencies &getBlockImmediateDeps(Block &B) {
       // Check the cache first.
       auto I = BlockImmediateDepsCache.find(&B);
       if (I != BlockImmediateDepsCache.end())
BlockSymbolDependencies &getBlockImmediateDeps(Block &B) {
         }
       }
 
       return BlockImmediateDepsCache
           .insert(std::make_pair(&B, std::move(BIDCacheVal)))
           .first->second;
     }
 
-    ExecutionSession &ES;
     DenseMap<const Block *, DenseSet<Block *>> BlockDeps;
     DenseMap<const Symbol *, SymbolStringPtr> NameCache;
     DenseMap<const Block *, BlockSymbolDependencies> BlockImmediateDepsCache;
     DenseMap<const Block *, BlockSymbolDependencies> BlockTransitiveDepsCache;
   };
 
   Error claimOrExternalizeWeakAndCommonSymbols(LinkGraph &G) {
-    auto &ES = Layer.getExecutionSession();
-
     SymbolFlagsMap NewSymbolsToClaim;
     std::vector<std::pair<SymbolStringPtr, Symbol *>> NameToSym;
 
     auto ProcessSymbol = [&](Symbol *Sym) {
       if (Sym->hasName() && Sym->getLinkage() == Linkage::Weak &&
           Sym->getScope() != Scope::Local) {
-        auto Name = ES.intern(Sym->getName());
-        if (!MR->getSymbols().count(ES.intern(Sym->getName()))) {
-          NewSymbolsToClaim[Name] =
+        if (!MR->getSymbols().count(Sym->getName())) {
+          NewSymbolsToClaim[Sym->getName()] =
               getJITSymbolFlagsForSymbol(*Sym) | JITSymbolFlags::Weak;
-          NameToSym.push_back(std::make_pair(std::move(Name), Sym));
+          NameToSym.push_back(std::make_pair(Sym->getName(), Sym));
         }
       }
     };
 
     for (auto *Sym : G.defined_symbols())
       ProcessSymbol(Sym);
     for (auto *Sym : G.absolute_symbols())
       ProcessSymbol(Sym);
for (auto &KV : NameToSym) {
       else
         G.makeExternal(*KV.second);
     }
 
     return Error::success();
   }
 
   Error markResponsibilitySymbolsLive(LinkGraph &G) const {
-    auto &ES = Layer.getExecutionSession();
     for (auto *Sym : G.defined_symbols())
-      if (Sym->hasName() && MR->getSymbols().count(ES.intern(Sym->getName())))
+      if (Sym->hasName() && MR->getSymbols().count(Sym->getName()))
         Sym->setLive(true);
     return Error::success();
   }
 
   Error computeNamedSymbolDependencies(LinkGraph &G) {
-    auto &ES = MR->getTargetJITDylib().getExecutionSession();
     auto BlockDeps = computeBlockNonLocalDeps(G);
 
     // Compute dependencies for symbols defined in the JITLink graph.
     for (auto *Sym : G.defined_symbols()) {
 
       // Skip local symbols: we do not track dependencies for these.
       if (Sym->getScope() == Scope::Local)
         continue;
       assert(Sym->hasName() &&
              "Defined non-local jitlink::Symbol should have a name");
 
       auto &SymDeps = BlockDeps[Sym->getBlock()];
       if (SymDeps.External.empty() && SymDeps.Internal.empty())
         continue;
 
-      auto SymName = ES.intern(Sym->getName());
+      auto SymName = Sym->getName();
       if (!SymDeps.External.empty())
         ExternalNamedSymbolDeps[SymName] = SymDeps.External;
       if (!SymDeps.Internal.empty())
         InternalNamedSymbolDeps[SymName] = SymDeps.Internal;
     }
 
     for (auto &P : Layer.Plugins) {
       auto SynthDeps = P->getSyntheticSymbolDependencies(*MR);
       if (SynthDeps.empty())
         continue;
 
       DenseSet<Block *> BlockVisited;

 
 void ObjectLinkingLayer::emit(std::unique_ptr<MaterializationResponsibility> R,
                               std::unique_ptr<MemoryBuffer> O) {
   assert(O && "Object must not be null");
   MemoryBufferRef ObjBuffer = O->getMemBufferRef();
 
   auto Ctx = std::make_unique<ObjectLinkingLayerJITLinkContext>(
       *this, std::move(R), std::move(O));
-  if (auto G = createLinkGraphFromObject(ObjBuffer)) {
+  if (auto G = createLinkGraphFromObject(ObjBuffer, getExecutionSession().getSymbolStringPool())) {
     Ctx->notifyMaterializing(**G);
     link(std::move(*G), std::move(Ctx));
   } else {
     Ctx->notifyFailed(G.takeError());
   }
 }
 
 void ObjectLinkingLayer::emit(std::unique_ptr<MaterializationResponsibility> R,

llvm/tools/llvm-jitlink/llvm-jitlink-coff.cpp

for (auto *Sym : Sec.symbols()) {
         if (Sym->isSymbolZeroFill())
           return make_error<StringError>("zero-fill atom in GOT section",
                                          inconvertibleErrorCode());
 
         // If this is a GOT symbol with size (i.e. not the GOT start symbol)
         // then add it to the GOT entry info table.
         if (Sym->getSize() != 0) {
           if (auto TS = getCOFFGOTTarget(G, Sym->getBlock()))
-            FileInfo.GOTEntryInfos[TS->getName()] = {
+            FileInfo.GOTEntryInfos[*TS->getName()] = {
                 Sym->getSymbolContent(), Sym->getAddress().getValue(),
                 Sym->getTargetFlags()};
           else
             return TS.takeError();
         }
         SectionContainsContent = true;
       } else if (isStubsSection) {
         if (Sym->isSymbolZeroFill())
           return make_error<StringError>("zero-fill atom in Stub section",
                                          inconvertibleErrorCode());
 
         if (auto TS = getCOFFStubTarget(G, Sym->getBlock()))
-          FileInfo.StubInfos[TS->getName()] = {Sym->getSymbolContent(),
+          FileInfo.StubInfos[*TS->getName()] = {Sym->getSymbolContent(),
                                                 Sym->getAddress().getValue(),
                                                 Sym->getTargetFlags()};
         else
           return TS.takeError();
         SectionContainsContent = true;
       }
 
       if (Sym->hasName()) {
         if (Sym->isSymbolZeroFill()) {
-          S.SymbolInfos[Sym->getName()] = {Sym->getSize(),
+          S.SymbolInfos[*Sym->getName()] = {Sym->getSize(),
                                             Sym->getAddress().getValue()};
           SectionContainsZeroFill = true;
         } else {
-          S.SymbolInfos[Sym->getName()] = {Sym->getSymbolContent(),
+          S.SymbolInfos[*Sym->getName()] = {Sym->getSymbolContent(),
                                             Sym->getAddress().getValue(),
                                             Sym->getTargetFlags()};
           SectionContainsContent = true;
         }
       }
     }
 
     auto SecAddr = FirstSym->getAddress();
     auto SecSize =
         (LastSym->getBlock().getAddress() + LastSym->getBlock().getSize()) -

llvm/tools/llvm-jitlink/llvm-jitlink-elf.cpp

for (auto *Sym : Sec.symbols()) {
         if (Sym->isSymbolZeroFill())
           return make_error<StringError>("zero-fill atom in GOT section",
                                          inconvertibleErrorCode());
 
         // If this is a GOT symbol with size (i.e. not the GOT start symbol)
         // then add it to the GOT entry info table.
         if (Sym->getSize() != 0) {
           if (auto TS = getELFGOTTarget(G, Sym->getBlock()))
-            FileInfo.GOTEntryInfos[TS->getName()] = {
+            FileInfo.GOTEntryInfos[*TS->getName()] = {
                 Sym->getSymbolContent(), Sym->getAddress().getValue(),
                 Sym->getTargetFlags()};
           else
             return TS.takeError();
         }
         SectionContainsContent = true;
       } else if (isStubsSection) {
         if (Sym->isSymbolZeroFill())
           return make_error<StringError>("zero-fill atom in Stub section",
                                          inconvertibleErrorCode());
 
         if (auto TS = getELFStubTarget(G, Sym->getBlock()))
-          FileInfo.StubInfos[TS->getName()] = {Sym->getSymbolContent(),
+          FileInfo.StubInfos[*TS->getName()] = {Sym->getSymbolContent(),
                                                 Sym->getAddress().getValue(),
                                                 Sym->getTargetFlags()};
         else
           return TS.takeError();
         SectionContainsContent = true;
       }
 
       if (Sym->hasName()) {
         if (Sym->isSymbolZeroFill()) {
-          S.SymbolInfos[Sym->getName()] = {Sym->getSize(),
+          S.SymbolInfos[*Sym->getName()] = {Sym->getSize(),
                                             Sym->getAddress().getValue()};
           SectionContainsZeroFill = true;
         } else {
-          S.SymbolInfos[Sym->getName()] = {Sym->getSymbolContent(),
+          S.SymbolInfos[*Sym->getName()] = {Sym->getSymbolContent(),
                                             Sym->getAddress().getValue(),
                                             Sym->getTargetFlags()};
           SectionContainsContent = true;
         }
       }
     }
 
     // Add symbol info for absolute symbols.
     for (auto *Sym : G.absolute_symbols())
-      S.SymbolInfos[Sym->getName()] = {Sym->getSize(),
+      S.SymbolInfos[*Sym->getName()] = {Sym->getSize(),
                                         Sym->getAddress().getValue()};
 
     auto SecAddr = FirstSym->getAddress();
     auto SecSize =
         (LastSym->getBlock().getAddress() + LastSym->getBlock().getSize()) -
         SecAddr;
 
     if (SectionContainsZeroFill && SectionContainsContent)
       return make_error<StringError>("Mixed zero-fill and content sections not "

llvm/tools/llvm-jitlink/llvm-jitlink-macho.cpp

for (auto *Sym : Sec.symbols()) {
       if (Sym->getAddress() > LastSym->getAddress())
         LastSym = Sym;
       if (isGOTSection) {
         if (Sym->isSymbolZeroFill())
           return make_error<StringError>("zero-fill atom in GOT section",
                                          inconvertibleErrorCode());
 
         if (auto TS = getMachOGOTTarget(G, Sym->getBlock()))
-          FileInfo.GOTEntryInfos[TS->getName()] = {Sym->getSymbolContent(),
-                                                   Sym->getAddress().getValue(),
-                                                   Sym->getTargetFlags()};
+          FileInfo.GOTEntryInfos[*TS->getName()] = {
+              Sym->getSymbolContent(), Sym->getAddress().getValue(),
         else
           return TS.takeError();
         SectionContainsContent = true;
       } else if (isStubsSection) {
         if (Sym->isSymbolZeroFill())
           return make_error<StringError>("zero-fill atom in Stub section",
                                          inconvertibleErrorCode());
 
         if (auto TS = getMachOStubTarget(G, Sym->getBlock()))
-          FileInfo.StubInfos[TS->getName()] = {Sym->getSymbolContent(),
+          FileInfo.StubInfos[*TS->getName()] = {Sym->getSymbolContent(),
                                                 Sym->getAddress().getValue(),
                                                 Sym->getTargetFlags()};
         else
           return TS.takeError();
         SectionContainsContent = true;
       } else if (Sym->hasName()) {
         if (Sym->isSymbolZeroFill()) {
-          S.SymbolInfos[Sym->getName()] = {Sym->getSize(),
+          S.SymbolInfos[*Sym->getName()] = {Sym->getSize(),
                                             Sym->getAddress().getValue()};
           SectionContainsZeroFill = true;
         } else {
-          S.SymbolInfos[Sym->getName()] = {Sym->getSymbolContent(),
+          S.SymbolInfos[*Sym->getName()] = {Sym->getSymbolContent(),
                                             Sym->getAddress().getValue(),
                                             Sym->getTargetFlags()};
           SectionContainsContent = true;
         }
       }
     }
 
     auto SecAddr = FirstSym->getAddress();
     auto SecSize =
         (LastSym->getBlock().getAddress() + LastSym->getBlock().getSize()) -

llvm/tools/llvm-jitlink/llvm-jitlink.cpp

static Error applyHarnessPromotions(Session &S, LinkGraph &G) {
   // definitions.
   std::vector<Symbol *> DefinitionsToRemove;
   for (auto *Sym : G.defined_symbols()) {
 
     if (!Sym->hasName())
       continue;
 
     if (Sym->getLinkage() == Linkage::Weak) {
-      if (!S.CanonicalWeakDefs.count(Sym->getName()) ||
-          S.CanonicalWeakDefs[Sym->getName()] != G.getName()) {
+      if (!S.CanonicalWeakDefs.count(*Sym->getName()) ||
+          S.CanonicalWeakDefs[*Sym->getName()] != G.getName()) {
         LLVM_DEBUG({
-          dbgs() << "  Externalizing weak symbol " << Sym->getName() << "\n";
+          dbgs() << "  Externalizing weak symbol " << *Sym->getName() << "\n";
         });
         DefinitionsToRemove.push_back(Sym);
       } else {
         LLVM_DEBUG({
-          dbgs() << "  Making weak symbol " << Sym->getName() << " strong\n";
+          dbgs() << "  Making weak symbol " << *Sym->getName() << " strong\n";
         });
-        if (S.HarnessExternals.count(Sym->getName()))
+        if (S.HarnessExternals.count(*Sym->getName()))
           Sym->setScope(Scope::Default);
         else
           Sym->setScope(Scope::Hidden);
         Sym->setLinkage(Linkage::Strong);
       }
-    } else if (S.HarnessExternals.count(Sym->getName())) {
-      LLVM_DEBUG(dbgs() << "  Promoting " << Sym->getName() << "\n");
+    } else if (S.HarnessExternals.count(*Sym->getName())) {
+      LLVM_DEBUG(dbgs() << "  Promoting " << *Sym->getName() << "\n");
       Sym->setScope(Scope::Default);
       Sym->setLive(true);
       continue;
-    } else if (S.HarnessDefinitions.count(Sym->getName())) {
-      LLVM_DEBUG(dbgs() << "  Externalizing " << Sym->getName() << "\n");
+    } else if (S.HarnessDefinitions.count(*Sym->getName())) {
+      LLVM_DEBUG(dbgs() << "  Externalizing " << *Sym->getName() << "\n");
       DefinitionsToRemove.push_back(Sym);
     }
   }
 
   for (auto *Sym : DefinitionsToRemove)
     G.makeExternal(*Sym);
 
   return Error::success();

llvm/unittests/ExecutionEngine/JITLink/EHFrameSupportTests.cpp

TEST(EHFrameCFIBlockInspector, BasicSuccessCase) {
   // Create a LinkGraph from the test object above and verify that
   // (1) There are two CIEs -- one with a personality function and one
   //     without.
   // (2) There are three FDEs -- two attached to the CIE with no
   //     personality, one attached to the CIE with a personality.
   // (3) Each FDE has an edge pointing to the CIE at the correct offset.
   // (4) Each function has exactly one FDE pointing at it.
 
-  auto G = cantFail(createLinkGraphFromMachOObject_arm64(TestObject));
+  auto G = cantFail(createLinkGraphFromMachOObject_arm64(TestObject,
+                    std::make_shared<orc::SymbolStringPool>()));
   cantFail(createEHFrameSplitterPass_MachO_arm64()(*G));
   cantFail(createEHFrameEdgeFixerPass_MachO_arm64()(*G));
 
   auto *EHFrame = G->findSectionByName("__TEXT,__eh_frame");
   assert(EHFrame && "eh-frame missing?");
 
   SmallVector<Block *, 2> CIEs;
   for (auto *B : EHFrame->blocks()) {
if (CFIBI.isFDE()) {
       ASSERT_TRUE(!!CFIBI.getCIEEdge());
       ASSERT_TRUE(CFIBI.getCIEEdge()->getTarget().isDefined());
       auto &CIE = CFIBI.getCIEEdge()->getTarget().getBlock();
       ASSERT_TRUE(&CIE == CIEs[0] || &CIE == CIEs[1]);
 
       ASSERT_TRUE(!!CFIBI.getPCBeginEdge());
       auto &PCBeginTarget = CFIBI.getPCBeginEdge()->getTarget();
       ASSERT_TRUE(PCBeginTarget.hasName());
-      Targets.insert(PCBeginTarget.getName());
+      Targets.insert(*PCBeginTarget.getName());
 
       // If the FDE points at CIEs[0] (the CIE without a personality) then it
       // should not have an LSDA. If it points to CIEs[1] then it should have
       // an LSDA.
       if (&CIE == CIEs[0])
         EXPECT_EQ(CFIBI.getLSDAEdge(), nullptr);
       else
         EXPECT_NE(CFIBI.getLSDAEdge(), nullptr);
     }
   }
 
   EXPECT_EQ(Targets.size(), 3U) << "Unexpected number of FDEs";
   EXPECT_EQ(Targets.count("_a"), 1U);
   EXPECT_EQ(Targets.count("_b"), 1U);
   EXPECT_EQ(Targets.count("_c"), 1U);
 }
 
 TEST(EHFrameCFIBlockInspector, ExternalPCBegin) {
   // Check that we don't crash if we transform the target of an FDE into an
   // external symbol before running edge-fixing.
-  auto G = cantFail(createLinkGraphFromMachOObject_arm64(TestObject));
+  auto G = cantFail(createLinkGraphFromMachOObject_arm64(TestObject,
+                    std::make_shared<orc::SymbolStringPool>()));
 
   // Make '_a' external.
   for (auto *Sym : G->defined_symbols())
-    if (Sym->hasName() && Sym->getName() == "_a") {
+    if (Sym->hasName() && *Sym->getName() == "_a") {
       G->makeExternal(*Sym);
       break;
     }
 
   // Run the splitter and edge-fixer passes.
   cantFail(createEHFrameSplitterPass_MachO_arm64()(*G));
   cantFail(createEHFrameEdgeFixerPass_MachO_arm64()(*G));
 }

llvm/unittests/ExecutionEngine/JITLink/JITLinkMocks.cpp

 }
 
 void defaultMemMgrSetup(MockJITLinkMemoryManager &) {}
 void defaultCtxSetup(MockJITLinkContext &) {}
 
 TEST(JITLinkMocks, SmokeTest) {
   // Check that the testing infrastructure defaults can "link" a graph
   // successfully.
-  auto G = std::make_unique<LinkGraph>("foo", Triple("x86_64-apple-darwin"), 8,
-                                       llvm::endianness::little,
-                                       getGenericEdgeKindName);
+  auto G = std::make_unique<LinkGraph>(
+      "foo", std::make_shared<orc::SymbolStringPool>(),
+      Triple("x86_64-apple-darwin"), 8, llvm::endianness::little,
 
   ArrayRef<char> Content = "hello, world!";
   auto &Sec =
       G->createSection("__data", orc::MemProt::Read | orc::MemProt::Write);
   orc::ExecutorAddr B1Addr(0x1000);
   auto &B = G->createContentBlock(Sec, Content, B1Addr, 8, 0);
   G->addDefinedSymbol(B, 4, "S", 4, Linkage::Strong, Scope::Default, false,
                       false);

llvm/unittests/ExecutionEngine/JITLink/LinkGraphTests.cpp

 //===------ LinkGraphTests.cpp - Unit tests for core JITLink classes ------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ExecutionEngine/JITLink/JITLink.h"
 #include "llvm/ExecutionEngine/Orc/ObjectFileInterface.h"
+#include "llvm/ExecutionEngine/Orc/SymbolStringPool.h"
 #include "llvm/Support/Endian.h"
 #include "llvm/Support/Memory.h"
 
 #include "llvm/Testing/Support/Error.h"
 #include "gtest/gtest.h"
 
 using namespace llvm;
 using namespace llvm::jitlink;
static const char BlockContentBytes[] = {
     0x72, 0x73, 0x65, 0x20, 0x73, 0x6e, 0x75, 0x66, 0x66, 0x73, 0x20, 0x74,
     0x68, 0x65, 0x20, 0x62, 0x61, 0x74, 0x74, 0x6c, 0x65, 0x20, 0x77, 0x69,
     0x74, 0x68, 0x20, 0x64, 0x65, 0x6c, 0x69, 0x67, 0x68, 0x74, 0x2e, 0x00};
 
 static ArrayRef<char> BlockContent(BlockContentBytes);
 
 TEST(LinkGraphTest, Construction) {
   // Check that LinkGraph construction works as expected.
-  LinkGraph G("foo", Triple("x86_64-apple-darwin"), 8, llvm::endianness::little,
+  LinkGraph G("foo", 
+              std::make_shared<orc::SymbolStringPool>(),
+              Triple("x86_64-apple-darwin"), 8, 
+              llvm::endianness::little,
               getGenericEdgeKindName);
   EXPECT_EQ(G.getName(), "foo");
   EXPECT_EQ(G.getTargetTriple().str(), "x86_64-apple-darwin");
   EXPECT_EQ(G.getPointerSize(), 8U);
   EXPECT_EQ(G.getEndianness(), llvm::endianness::little);
   EXPECT_TRUE(G.external_symbols().empty());
   EXPECT_TRUE(G.absolute_symbols().empty());
   EXPECT_TRUE(G.defined_symbols().empty());
   EXPECT_TRUE(G.blocks().empty());
 }
 
 TEST(LinkGraphTest, AddressAccess) {
   // Check that we can get addresses for blocks, symbols, and edges.
-  LinkGraph G("foo", Triple("x86_64-apple-darwin"), 8, llvm::endianness::little,
+  LinkGraph G("foo", std::make_shared<orc::SymbolStringPool>(), 
+              Triple("x86_64-apple-darwin"), 8, 
+              llvm::endianness::little,
               getGenericEdgeKindName);
 
   auto &Sec1 =
       G.createSection("__data.1", orc::MemProt::Read | orc::MemProt::Write);
   orc::ExecutorAddr B1Addr(0x1000);
   auto &B1 = G.createContentBlock(Sec1, BlockContent, B1Addr, 8, 0);
   auto &S1 = G.addDefinedSymbol(B1, 4, "S1", 4, Linkage::Strong, Scope::Default,
                                 false, false);
   B1.addEdge(Edge::FirstRelocation, 8, S1, 0);
   auto &E1 = *B1.edges().begin();
 
   EXPECT_EQ(B1.getAddress(), B1Addr) << "Incorrect block address";
   EXPECT_EQ(S1.getAddress(), B1Addr + 4) << "Incorrect symbol address";
   EXPECT_EQ(B1.getFixupAddress(E1), B1Addr + 8) << "Incorrect fixup address";
 }
 
 TEST(LinkGraphTest, SectionEmpty) {
   // Check that Section::empty behaves as expected.
-  LinkGraph G("foo", Triple("x86_64-apple-darwin"), 8, llvm::endianness::little,
-              getGenericEdgeKindName);
+  LinkGraph G("foo", 
+            std::make_shared<orc::SymbolStringPool>(),
+            Triple("x86_64-apple-darwin"), 8, llvm::endianness::little,
   auto &Sec1 =
       G.createSection("__data.1", orc::MemProt::Read | orc::MemProt::Write);
   auto &B =
       G.createContentBlock(Sec1, BlockContent, orc::ExecutorAddr(0x1000), 8, 0);
   G.addDefinedSymbol(B, 0, "S", 4, Linkage::Strong, Scope::Default, false,
                      false);
 
   auto &Sec2 =
       G.createSection("__data.2", orc::MemProt::Read | orc::MemProt::Write);
 
   EXPECT_FALSE(Sec1.empty());
   EXPECT_TRUE(Sec2.empty());
 }
 
 TEST(LinkGraphTest, BlockAndSymbolIteration) {
   // Check that we can iterate over blocks within Sections and across sections.
-  LinkGraph G("foo", Triple("x86_64-apple-darwin"), 8, llvm::endianness::little,
+  LinkGraph G("foo", std::make_shared<orc::SymbolStringPool>(), 
+              Triple("x86_64-apple-darwin"), 8, 
+              llvm::endianness::little,
               getGenericEdgeKindName);
   auto &Sec1 =
       G.createSection("__data.1", orc::MemProt::Read | orc::MemProt::Write);
   orc::ExecutorAddr B1Addr(0x1000);
   auto &B1 = G.createContentBlock(Sec1, BlockContent, B1Addr, 8, 0);
   orc::ExecutorAddr B2Addr(0x2000);
   auto &B2 = G.createContentBlock(Sec1, BlockContent, B2Addr, 8, 0);
   auto &S1 = G.addDefinedSymbol(B1, 0, "S1", 4, Linkage::Strong, Scope::Default,
TEST(LinkGraphTest, BlockAndSymbolIteration) {
   EXPECT_TRUE(llvm::count(G.defined_symbols(), &S1));
   EXPECT_TRUE(llvm::count(G.defined_symbols(), &S2));
   EXPECT_TRUE(llvm::count(G.defined_symbols(), &S3));
   EXPECT_TRUE(llvm::count(G.defined_symbols(), &S4));
 }
 
 TEST(LinkGraphTest, ContentAccessAndUpdate) {
   // Check that we can make a defined symbol external.
-  LinkGraph G("foo", Triple("x86_64-apple-darwin"), 8, llvm::endianness::little,
+  LinkGraph G("foo", std::make_shared<orc::SymbolStringPool>(), 
+              Triple("x86_64-apple-darwin"), 8, 
+              llvm::endianness::little,
               getGenericEdgeKindName);
   auto &Sec =
       G.createSection("__data", orc::MemProt::Read | orc::MemProt::Write);
 
   // Create an initial block.
   orc::ExecutorAddr BAddr(0x1000);
   auto &B = G.createContentBlock(Sec, BlockContent, BAddr, 8, 0);
 
#endif
   EXPECT_TRUE(B3.isContentMutable()) << "Expected B2 content to be mutable";
   EXPECT_EQ(B3.getSize(), 16U);
   EXPECT_TRUE(llvm::all_of(B3.getAlreadyMutableContent(),
                            [](char C) { return C == 0; }));
 }
 
 TEST(LinkGraphTest, MakeExternal) {
   // Check that we can make defined and absolute symbols external.
-  LinkGraph G("foo", Triple("x86_64-apple-darwin"), 8, llvm::endianness::little,
+  LinkGraph G("foo", std::make_shared<orc::SymbolStringPool>(), 
+              Triple("x86_64-apple-darwin"), 8, 
+              llvm::endianness::little,
               getGenericEdgeKindName);
   auto &Sec =
       G.createSection("__data", orc::MemProt::Read | orc::MemProt::Write);
 
   // Create an initial block.
   auto &B1 =
       G.createContentBlock(Sec, BlockContent, orc::ExecutorAddr(0x1000), 8, 0);
 
TEST(LinkGraphTest, MakeExternal) {
   EXPECT_EQ(
       std::distance(G.absolute_symbols().begin(), G.absolute_symbols().end()),
       0U)
       << "Unexpected number of external symbols";
 }
 
 TEST(LinkGraphTest, MakeAbsolute) {
   // Check that we can make defined and external symbols absolute.
-  LinkGraph G("foo", Triple("x86_64-apple-darwin"), 8, llvm::endianness::little,
+  LinkGraph G("foo", std::make_shared<orc::SymbolStringPool>(), 
+              Triple("x86_64-apple-darwin"), 8, 
+              llvm::endianness::little,
               getGenericEdgeKindName);
   auto &Sec =
       G.createSection("__data", orc::MemProt::Read | orc::MemProt::Write);
 
   // Create an initial block.
   auto &B1 =
       G.createContentBlock(Sec, BlockContent, orc::ExecutorAddr(0x1000), 8, 0);
 
TEST(LinkGraphTest, MakeAbsolute) {
   EXPECT_EQ(
       std::distance(G.absolute_symbols().begin(), G.absolute_symbols().end()),
       2U)
       << "Unexpected number of external symbols";
 }
 
 TEST(LinkGraphTest, MakeDefined) {
   // Check that we can make an external symbol defined.
-  LinkGraph G("foo", Triple("x86_64-apple-darwin"), 8, llvm::endianness::little,
+  LinkGraph G("foo", std::make_shared<orc::SymbolStringPool>(), 
+              Triple("x86_64-apple-darwin"), 8, 
+              llvm::endianness::little,
               getGenericEdgeKindName);
   auto &Sec =
       G.createSection("__data", orc::MemProt::Read | orc::MemProt::Write);
 
   // Create an initial block.
   orc::ExecutorAddr B1Addr(0x1000);
   auto &B1 = G.createContentBlock(Sec, BlockContent, B1Addr, 8, 0);
 
TEST(LinkGraphTest, MakeDefined) {
   EXPECT_EQ(
       std::distance(G.external_symbols().begin(), G.external_symbols().end()),
       0U)
       << "Unexpected number of external symbols";
 }
 
 TEST(LinkGraphTest, TransferDefinedSymbol) {
   // Check that we can transfer a defined symbol from one block to another.
-  LinkGraph G("foo", Triple("x86_64-apple-darwin"), 8, llvm::endianness::little,
+  LinkGraph G("foo", std::make_shared<orc::SymbolStringPool>(), 
+              Triple("x86_64-apple-darwin"), 8, 
+              llvm::endianness::little,
               getGenericEdgeKindName);
   auto &Sec =
       G.createSection("__data", orc::MemProt::Read | orc::MemProt::Write);
 
   // Create initial blocks.
   orc::ExecutorAddr B1Addr(0x1000);
   auto &B1 = G.createContentBlock(Sec, BlockContent, B1Addr, 8, 0);
   orc::ExecutorAddr B2Addr(0x2000);
TEST(LinkGraphTest, TransferDefinedSymbol) {
   EXPECT_EQ(&S1.getBlock(), &B3) << "Block was not updated";
   EXPECT_EQ(S1.getOffset(), 16U) << "Offset was not updated";
   EXPECT_EQ(S1.getSize(), 16U) << "Size was not updated";
 }
 
 TEST(LinkGraphTest, TransferDefinedSymbolAcrossSections) {
   // Check that we can transfer a defined symbol from an existing block in one
   // section to another.
-  LinkGraph G("foo", Triple("x86_64-apple-darwin"), 8, llvm::endianness::little,
+  LinkGraph G("foo", std::make_shared<orc::SymbolStringPool>(), 
+              Triple("x86_64-apple-darwin"), 8, 
+              llvm::endianness::little,
               getGenericEdgeKindName);
   auto &Sec1 =
       G.createSection("__data.1", orc::MemProt::Read | orc::MemProt::Write);
   auto &Sec2 =
       G.createSection("__data.2", orc::MemProt::Read | orc::MemProt::Write);
 
   // Create blocks in each section.
   orc::ExecutorAddr B1Addr(0x1000);
TEST(LinkGraphTest, TransferDefinedSymbolAcrossSections) {
   if (Sec2.symbols_size() == 1) {
     EXPECT_EQ(*Sec2.symbols().begin(), &S1) << "Unexpected symbol";
   }
 }
 
 TEST(LinkGraphTest, TransferBlock) {
   // Check that we can transfer a block (and all associated symbols) from one
   // section to another.
-  LinkGraph G("foo", Triple("x86_64-apple-darwin"), 8, llvm::endianness::little,
+  LinkGraph G("foo", std::make_shared<orc::SymbolStringPool>(), 
+              Triple("x86_64-apple-darwin"), 8, 
+              llvm::endianness::little,
               getGenericEdgeKindName);
   auto &Sec1 =
       G.createSection("__data.1", orc::MemProt::Read | orc::MemProt::Write);
   auto &Sec2 =
       G.createSection("__data.2", orc::MemProt::Read | orc::MemProt::Write);
 
   // Create an initial block.
   orc::ExecutorAddr B1Addr(0x1000);
EXPECT_EQ(Sec2.blocks_size(), 1U)
       << "Expected one blocks in Sec2 after transfer";
   EXPECT_EQ(Sec2.symbols_size(), 2U)
       << "Expected two symbols in Sec2 after transfer";
 }
 
 TEST(LinkGraphTest, MergeSections) {
   // Check that we can transfer a block (and all associated symbols) from one
   // section to another.
-  LinkGraph G("foo", Triple("x86_64-apple-darwin"), 8, llvm::endianness::little,
+  LinkGraph G("foo", std::make_shared<orc::SymbolStringPool>(), 
+              Triple("x86_64-apple-darwin"), 8, 
+              llvm::endianness::little,
               getGenericEdgeKindName);
   auto &Sec1 =
       G.createSection("__data.1", orc::MemProt::Read | orc::MemProt::Write);
   auto &Sec2 =
       G.createSection("__data.2", orc::MemProt::Read | orc::MemProt::Write);
   auto &Sec3 =
       G.createSection("__data.3", orc::MemProt::Read | orc::MemProt::Write);
 
TEST(LinkGraphTest, MergeSections) {
   EXPECT_EQ(Sec3.blocks_size(), 0U)
       << "Expected one block in Sec3 after third merge";
   EXPECT_EQ(Sec3.symbols_size(), 0U)
       << "Expected one symbol in Sec3 after third merge";
 }
 
 TEST(LinkGraphTest, SplitBlock) {
   // Check that the LinkGraph::splitBlock test works as expected.
-  LinkGraph G("foo", Triple("x86_64-apple-darwin"), 8, llvm::endianness::little,
+  LinkGraph G("foo", std::make_shared<orc::SymbolStringPool>(), 
+              Triple("x86_64-apple-darwin"), 8, 
+              llvm::endianness::little,
               getGenericEdgeKindName);
   auto &Sec =
       G.createSection("__data", orc::MemProt::Read | orc::MemProt::Write);
 
   // Create the block to split.
   orc::ExecutorAddr B1Addr(0x1000);
   auto &B1 = G.createContentBlock(Sec, BlockContent, B1Addr, 8, 0);
 
if (size(B2.edges()) == 2) {
     if (E2->getOffset() < E1->getOffset())
       std::swap(E1, E2);
     EXPECT_EQ(E1->getOffset(), 0U);
     EXPECT_EQ(E2->getOffset(), 4U);
   }
 }
 
 TEST(LinkGraphTest, GraphAllocationMethods) {
-  LinkGraph G("foo", Triple("x86_64-apple-darwin"), 8, llvm::endianness::little,
+  LinkGraph G("foo", std::make_shared<orc::SymbolStringPool>(), 
+              Triple("x86_64-apple-darwin"), 8, 
+              llvm::endianness::little,
               getGenericEdgeKindName);
 
   // Test allocation of sized, uninitialized buffer.
   auto Buf1 = G.allocateBuffer(10);
   EXPECT_EQ(Buf1.size(), 10U);
 
   // Test allocation of content-backed buffer.
   char Buf2Src[] = {1, static_cast<char>(-1), 0, 42};
   auto Buf2 = G.allocateContent(ArrayRef<char>(Buf2Src));
   EXPECT_EQ(Buf2, ArrayRef<char>(Buf2Src));
 
   // Test c-string allocation from StringRef.
   StringRef Buf3Src = "hello";
   auto Buf3 = G.allocateCString(Buf3Src);
   EXPECT_TRUE(llvm::equal(Buf3.drop_back(1), Buf3Src));
   EXPECT_EQ(Buf3.back(), '\0');
 }
 
 TEST(LinkGraphTest, IsCStringBlockTest) {
   // Check that the LinkGraph::splitBlock test works as expected.
-  LinkGraph G("foo", Triple("x86_64-apple-darwin"), 8, llvm::endianness::little,
+  LinkGraph G("foo", std::make_shared<orc::SymbolStringPool>(), 
+              Triple("x86_64-apple-darwin"), 8, 
+              llvm::endianness::little,
               getGenericEdgeKindName);
   auto &Sec =
       G.createSection("__data", orc::MemProt::Read | orc::MemProt::Write);
 
   char CString[] = "hello, world!";
   char NotACString[] = {0, 1, 0, 1, 0};
 
   auto &CStringBlock =
       G.createContentBlock(Sec, CString, orc::ExecutorAddr(), 1, 0);
   auto &NotACStringBlock =
       G.createContentBlock(Sec, NotACString, orc::ExecutorAddr(), 1, 0);
   auto &SizeOneZeroFillBlock =
       G.createZeroFillBlock(Sec, 1, orc::ExecutorAddr(), 1, 0);
   auto &LargerZeroFillBlock =
       G.createZeroFillBlock(Sec, 2, orc::ExecutorAddr(), 1, 0);
 
   EXPECT_TRUE(isCStringBlock(CStringBlock));
   EXPECT_FALSE(isCStringBlock(NotACStringBlock));
   EXPECT_TRUE(isCStringBlock(SizeOneZeroFillBlock));
   EXPECT_FALSE(isCStringBlock(LargerZeroFillBlock));
 }
 
 TEST(LinkGraphTest, BasicLayoutHonorsNoAlloc) {
-  // Check that BasicLayout honors NoAlloc.
-  LinkGraph G("foo", Triple("x86_64-apple-darwin"), 8, llvm::endianness::little,
+  LinkGraph G("foo", std::make_shared<orc::SymbolStringPool>(), 
+              Triple("x86_64-apple-darwin"), 8, 
+              llvm::endianness::little,
               getGenericEdgeKindName);
 
   // Create a regular section and block.
   auto &Sec1 =
       G.createSection("__data", orc::MemProt::Read | orc::MemProt::Write);
   G.createContentBlock(Sec1, BlockContent.slice(0, 8), orc::ExecutorAddr(), 8,
                        0);
 
   // Create a NoAlloc section and block.
   auto &Sec2 =
       G.createSection("__metadata", orc::MemProt::Read | orc::MemProt::Write);
   Sec2.setMemLifetime(orc::MemLifetime::NoAlloc);
   G.createContentBlock(Sec2, BlockContent.slice(0, 8), orc::ExecutorAddr(), 8,
                        0);
 
   BasicLayout BL(G);
 
   EXPECT_EQ(std::distance(BL.segments().begin(), BL.segments().end()), 1U);
   EXPECT_EQ(BL.segments().begin()->first,
             orc::MemProt::Read | orc::MemProt::Write);
   auto &SegInfo = BL.segments().begin()->second;
   EXPECT_EQ(SegInfo.Alignment, 8U);
   EXPECT_EQ(SegInfo.ContentSize, 8U);
 }

llvm/unittests/ExecutionEngine/JITLink/MemoryManagerErrorTests.cpp

 #include "gtest/gtest.h"
 
 using namespace llvm;
 using namespace llvm::orc;
 using namespace llvm::jitlink;
 
 TEST(MemoryManagerErrorTest, ErrorOnFirstAllocate) {
   // Check that we can get addresses for blocks, symbols, and edges.
-  auto G = std::make_unique<LinkGraph>("foo", Triple("x86_64-apple-darwin"), 8,
-                                       llvm::endianness::little,
-                                       getGenericEdgeKindName);
+  auto G = std::make_unique<LinkGraph>(
+      "foo", std::make_shared<orc::SymbolStringPool>(),
+      Triple("x86_64-apple-darwin"), 8, llvm::endianness::little,
 
   ArrayRef<char> Content = "hello, world!";
   auto &Sec =
       G->createSection("__data", orc::MemProt::Read | orc::MemProt::Write);
   orc::ExecutorAddr B1Addr(0x1000);
   auto &B = G->createContentBlock(Sec, Content, B1Addr, 8, 0);
   G->addDefinedSymbol(B, 4, "S", 4, Linkage::Strong, Scope::Default, false,
                       false);

llvm/unittests/ExecutionEngine/JITLink/StubsTests.cpp

GenerateStub(LinkGraph &G, size_t PointerSize, Edge::Kind PointerEdgeKind) {
   auto StubSym = PtrJumpStubCreator(G, StubsSec, *PointerSym);
   EXPECT_FALSE(errorToBool(StubSym.takeError()));
   return {*PointerSym, *StubSym};
 }
 
 TEST(StubsTest, StubsGeneration_x86_64) {
   const char PointerJumpStubContent[6] = {
       static_cast<char>(0xFFu), 0x25, 0x00, 0x00, 0x00, 0x00};
-  LinkGraph G("foo", Triple("x86_64-apple-darwin"), 8, llvm::endianness::little,
+  LinkGraph G("foo", std::make_shared<orc::SymbolStringPool>(),
+              Triple("x86_64-apple-darwin"), 8, llvm::endianness::little,
               getGenericEdgeKindName);
   auto [PointerSym, StubSym] = GenerateStub(G, 8U, x86_64::Pointer64);
 
   EXPECT_EQ(std::distance(StubSym.getBlock().edges().begin(),
                           StubSym.getBlock().edges().end()),
             1U);
   auto &JumpEdge = *StubSym.getBlock().edges().begin();
   EXPECT_EQ(JumpEdge.getKind(), x86_64::BranchPCRel32);
   EXPECT_EQ(&JumpEdge.getTarget(), &PointerSym);
   EXPECT_EQ(StubSym.getBlock().getContent(),
             ArrayRef<char>(PointerJumpStubContent));
 }
 
 TEST(StubsTest, StubsGeneration_aarch64) {
   const char PointerJumpStubContent[12] = {
       0x10, 0x00, 0x00, (char)0x90u, // ADRP x16, <imm>@page21
       0x10, 0x02, 0x40, (char)0xf9u, // LDR x16, [x16, <imm>@pageoff12]
       0x00, 0x02, 0x1f, (char)0xd6u  // BR  x16
   };
-  LinkGraph G("foo", Triple("aarch64-linux-gnu"), 8, llvm::endianness::little,
+  LinkGraph G("foo", std::make_shared<orc::SymbolStringPool>(),
+              Triple("aarch64-linux-gnu"), 8, llvm::endianness::little,
               getGenericEdgeKindName);
   auto [PointerSym, StubSym] = GenerateStub(G, 8U, aarch64::Pointer64);
 
   EXPECT_EQ(std::distance(StubSym.getBlock().edges().begin(),
                           StubSym.getBlock().edges().end()),
             2U);
   auto &AdrpHighEdge = *StubSym.getBlock().edges().begin();
   auto &LdrEdge = *++StubSym.getBlock().edges().begin();
   EXPECT_EQ(AdrpHighEdge.getKind(), aarch64::Page21);
   EXPECT_EQ(&AdrpHighEdge.getTarget(), &PointerSym);
   EXPECT_EQ(LdrEdge.getKind(), aarch64::PageOffset12);
   EXPECT_EQ(&LdrEdge.getTarget(), &PointerSym);
   EXPECT_EQ(StubSym.getBlock().getContent(),
             ArrayRef<char>(PointerJumpStubContent));
 }
 
 TEST(StubsTest, StubsGeneration_i386) {
   const char PointerJumpStubContent[6] = {
       static_cast<char>(0xFFu), 0x25, 0x00, 0x00, 0x00, 0x00};
-  LinkGraph G("foo", Triple("i386-unknown-linux-gnu"), 4,
-              llvm::endianness::little, getGenericEdgeKindName);
+  LinkGraph G("foo", std::make_shared<orc::SymbolStringPool>(),
+              Triple("i386-unknown-linux-gnu"), 8, llvm::endianness::little,
+              getGenericEdgeKindName);
   auto [PointerSym, StubSym] = GenerateStub(G, 4U, i386::Pointer32);
 
   EXPECT_EQ(std::distance(StubSym.getBlock().edges().begin(),
                           StubSym.getBlock().edges().end()),
             1U);
   auto &JumpEdge = *StubSym.getBlock().edges().begin();
   EXPECT_EQ(JumpEdge.getKind(), i386::Pointer32);
   EXPECT_EQ(&JumpEdge.getTarget(), &PointerSym);
const char PointerJumpStubContent[12] = {
       0x02,
       static_cast<char>(0x80),
       0x28, // ld.d $t8, $t8, %pageoff12(imm)
       static_cast<char>(0x80),
       0x02,
       0x00,
       0x4c // jr $t8
   };
-  LinkGraph G("foo", Triple("loongarch32"), 4, llvm::endianness::little,
+  LinkGraph G("foo", std::make_shared<orc::SymbolStringPool>(),
+              Triple("loongarch32"), 4, llvm::endianness::little,
               getGenericEdgeKindName);
   auto [PointerSym, StubSym] = GenerateStub(G, 4U, loongarch::Pointer32);
 
   EXPECT_EQ(std::distance(StubSym.getBlock().edges().begin(),
                           StubSym.getBlock().edges().end()),
             2U);
   auto &PageHighEdge = *StubSym.getBlock().edges().begin();
   auto &PageLowEdge = *++StubSym.getBlock().edges().begin();
const char PointerJumpStubContent[12] = {
       0x02,
       static_cast<char>(0xc0),
       0x28, // ld.d $t8, $t8, %pageoff12(imm)
       static_cast<char>(0x80),
       0x02,
       0x00,
       0x4c // jr $t8
   };
-  LinkGraph G("foo", Triple("loongarch64"), 8, llvm::endianness::little,
+  LinkGraph G("foo", std::make_shared<orc::SymbolStringPool>(),
+              Triple("loongarch64"), 8, llvm::endianness::little,
               getGenericEdgeKindName);
   auto [PointerSym, StubSym] = GenerateStub(G, 8U, loongarch::Pointer64);
 
   EXPECT_EQ(std::distance(StubSym.getBlock().edges().begin(),
                           StubSym.getBlock().edges().end()),
             2U);
   auto &PageHighEdge = *StubSym.getBlock().edges().begin();
   auto &PageLowEdge = *++StubSym.getBlock().edges().begin();
   EXPECT_EQ(PageHighEdge.getKind(), loongarch::Page20);
   EXPECT_EQ(&PageHighEdge.getTarget(), &PointerSym);
   EXPECT_EQ(PageLowEdge.getKind(), loongarch::PageOffset12);
   EXPECT_EQ(&PageLowEdge.getTarget(), &PointerSym);
   EXPECT_EQ(StubSym.getBlock().getContent(),
             ArrayRef<char>(PointerJumpStubContent));
 }

llvm/unittests/ExecutionEngine/Orc/ObjectLinkingLayerTest.cpp

 protected:
   ExecutionSession ES{std::make_unique<UnsupportedExecutorProcessControl>()};
   JITDylib &JD = ES.createBareJITDylib("main");
   ObjectLinkingLayer ObjLinkingLayer{
       ES, std::make_unique<InProcessMemoryManager>(4096)};
 };
 
 TEST_F(ObjectLinkingLayerTest, AddLinkGraph) {
-  auto G = std::make_unique<LinkGraph>("foo", Triple("x86_64-apple-darwin"), 8,
-                                       llvm::endianness::little,
-                                       x86_64::getEdgeKindName);
+  auto G = std::make_unique<LinkGraph>(
+      "foo", std::make_shared<orc::SymbolStringPool>(),
+      Triple("x86_64-apple-darwin"), 8, llvm::endianness::little,
 
   auto &Sec1 = G->createSection("__data", MemProt::Read | MemProt::Write);
   auto &B1 = G->createContentBlock(Sec1, BlockContent,
                                    orc::ExecutorAddr(0x1000), 8, 0);
   G->addDefinedSymbol(B1, 4, "_X", 4, Linkage::Strong, Scope::Default, false,
                       false);
   G->addDefinedSymbol(B1, 4, "_Y", 4, Linkage::Weak, Scope::Default, false,
                       false);
public:
     void notifyTransferringResources(JITDylib &JD, ResourceKey DstKey,
                                      ResourceKey SrcKey) override {
       llvm_unreachable("unexpected resource transfer");
     }
   };
 
   ObjLinkingLayer.addPlugin(std::make_unique<TestPlugin>());
 
-  auto G = std::make_unique<LinkGraph>("foo", Triple("x86_64-apple-darwin"), 8,
-                                       llvm::endianness::little,
-                                       x86_64::getEdgeKindName);
+  auto G = std::make_unique<LinkGraph>(
+      "foo", std::make_shared<orc::SymbolStringPool>(),
+      Triple("x86_64-apple-darwin"), 8, llvm::endianness::little,
+      getGenericEdgeKindName);
 
   auto &DataSec = G->createSection("__data", MemProt::Read | MemProt::Write);
   auto &DataBlock = G->createContentBlock(DataSec, BlockContent,
                                           orc::ExecutorAddr(0x1000), 8, 0);
   G->addDefinedSymbol(DataBlock, 4, "_anchor", 4, Linkage::Weak, Scope::Default,
                       false, true);
 
   EXPECT_THAT_ERROR(ObjLinkingLayer.add(JD, std::move(G)), Succeeded());
TEST_F(ObjectLinkingLayerTest, HandleErrorDuringPostAllocationPass) {
   };
 
   // We expect this test to generate errors. Consume them so that we don't
   // add noise to the test logs.
   ES.setErrorReporter(consumeError);
 
   ObjLinkingLayer.addPlugin(std::make_unique<TestPlugin>());
 
-  auto G = std::make_unique<LinkGraph>("foo", Triple("x86_64-apple-darwin"), 8,
-                                       llvm::endianness::little,
-                                       x86_64::getEdgeKindName);
+  auto G = std::make_unique<LinkGraph>(
+      "foo", std::make_shared<orc::SymbolStringPool>(),
+      Triple("x86_64-apple-darwin"), 8, llvm::endianness::little,
+      getGenericEdgeKindName);
 
   auto &DataSec = G->createSection("__data", MemProt::Read | MemProt::Write);
   auto &DataBlock = G->createContentBlock(DataSec, BlockContent,
                                           orc::ExecutorAddr(0x1000), 8, 0);
   G->addDefinedSymbol(DataBlock, 4, "_anchor", 4, Linkage::Weak, Scope::Default,
                       false, true);
 
   EXPECT_THAT_ERROR(ObjLinkingLayer.add(JD, std::move(G)), Succeeded());
 
   EXPECT_THAT_EXPECTED(ES.lookup(&JD, "_anchor"), Failed());
 }
 
 } // end anonymous namespace