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

418–421

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 &&).

972

Do we have a definition for the dtor here?

[jaredwy]

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

418–421

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 :)

972

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

418–421

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

418–421

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

953–966

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

500–501

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)

503–505

I think this can be removed now?

[jaredwy]

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

500–501

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

503–505

It could.

[jaredwy]

Removing an uncessary if statement

[dblaikie]

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

500–501

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

972

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

500–501

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

1103

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

238–240

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

388

I think you can drop the outer parens here.

541

I think you can drop them outer parens here too.

llvm/lib/ExecutionEngine/JITLink/ELF_x86_64.cpp

280

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

203

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

209

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

67

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.

733

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

llvm/lib/ExecutionEngine/Orc/ELFNixPlatform.cpp

693

Can be a SSP comparison once the pool is shared.

843–851

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

532–536

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

676

Can compare SSP values once the pool is shared.

814–818

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

994–997

More strings to be interned and stored in the plugin.

llvm/lib/ExecutionEngine/Orc/ObjectLinkingLayer.cpp

212–225

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

231

Ditto here.

414–420

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

465–469

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

llvm/unittests/ExecutionEngine/JITLink/LinkGraphTests.cpp

75–89

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

717

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–306

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;

364–365

This should probably be done before the patch lands.

370–371

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

375–376

sym should be capitalized to Sym.

llvm/lib/ExecutionEngine/JITLink/COFF_x86_64.cpp

201

imageBaseName should be capitalized to ImageBaseName.

llvm/lib/ExecutionEngine/JITLink/ELF_i386.cpp

86 ↗

(On Diff #523650)

What about

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

?

llvm/lib/ExecutionEngine/JITLink/ELF_x86_64.cpp

280–281

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

306

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

llvm/lib/ExecutionEngine/JITLink/JITLinkGeneric.cpp

204

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

llvm/lib/ExecutionEngine/Orc/ExecutionUtils.cpp

534–536

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/JITLink.h

 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/DenseSet.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/Triple.h"
 #include "llvm/ExecutionEngine/JITLink/JITLinkMemoryManager.h"
 #include "llvm/ExecutionEngine/JITLink/MemoryFlags.h"
 #include "llvm/ExecutionEngine/JITSymbol.h"
+#include "llvm/ExecutionEngine/Orc/SymbolStringPool.h"
 #include "llvm/Support/Allocator.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"
 
 #include <map>

 ///   - 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), 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), Size(Size) {
     assert(Offset <= MaxOffset && "Offset out of range");
     setLinkage(L);
     setScope(S);
     setLive(IsLive);
     setCallable(IsCallable);
   }
 
   static Symbol &constructCommon(BumpPtrAllocator &Allocator, Block &Base,
-                                 StringRef Name, orc::ExecutorAddrDiff Size,
-                                 Scope S, bool IsLive) {
-    assert(!Name.empty() && "Common symbol name cannot be empty");
+                                 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, Name, Size, Linkage::Weak, S, IsLive, false);
+    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) {
     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);
     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 true if this symbol matches the name.
+  bool isNamed(const char *Name) const { return *(this->Name) == Name; }
 
   /// Returns the name of this symbol (empty if the symbol is anonymous).
-  StringRef getName() const {
-    assert((!Name.empty() || getScope() == Scope::Local) &&
+  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::Default || Base->isDefined() || Base->isAbsolute()) &&
            "Invalid visibility for symbol type");
     this->S = static_cast<uint8_t>(S);
   }
 
 private:
   void makeExternal(Addressable &A) {
private:
 
   void setOffset(orc::ExecutorAddrDiff NewOffset) {
     assert(NewOffset <= MaxOffset && "Offset out of range");
     Offset = NewOffset;
   }
 
   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 : 59;
   uint64_t L : 1;
   uint64_t S : 2;
   uint64_t IsLive : 1;
   uint64_t IsCallable : 1;
   size_t Size = 0;
 };
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, unsigned PointerSize,
             support::endianness Endianness,
             GetEdgeKindNameFunction GetEdgeKindName)
       : Name(std::move(Name)), TT(TT), PointerSize(PointerSize),
+        Endianness(Endianness), GetEdgeKindName(std::move(GetEdgeKindName)) {
+    SSP = std::make_shared<orc::SymbolStringPool>();
+  }
+
+  LinkGraph(std::string Name, std::shared_ptr<orc::SymbolStringPool> SSP,
+            const Triple &TT, unsigned PointerSize,
+            support::endianness Endianness,
+            GetEdgeKindNameFunction GetEdgeKindName)
+      : Name(std::move(Name)), SSP(SSP), TT(TT), PointerSize(PointerSize),
         Endianness(Endianness), GetEdgeKindName(std::move(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; }
 
   /// Returns the pointer size for use in this graph.
   unsigned getPointerSize() const { return PointerSize; }
 
   /// Returns the endianness of content in this graph.
   support::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:
 
   /// 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'.
   /// For external symbols Linkage determines whether the symbol must be
   /// present during lookup: Externals with strong linkage must be found or
   /// an error will be emitted. Externals with weak linkage are permitted to
   /// be undefined, in which case they are assigned a value of 0.
   Symbol &addExternalSymbol(StringRef Name, orc::ExecutorAddrDiff Size,
                             Linkage L) {
     assert(llvm::count_if(ExternalSymbols,
                           [&](const Symbol *Sym) {
-                            return Sym->getName() == Name;
+                            return *(Sym->getName()) == Name;
                           }) == 0 &&
            "Duplicate external symbol");
+    auto SSPName = SSP->intern(Name);
     auto &Sym = Symbol::constructExternal(
-        Allocator, createAddressable(orc::ExecutorAddr(), false), Name, Size,
-        L);
+        Allocator, createAddressable(orc::ExecutorAddr(), false),
+        std::move(SSPName), Size, L);
     ExternalSymbols.insert(&Sym);
     return Sym;
   }
 
   /// Add an absolute symbol.
   Symbol &addAbsoluteSymbol(StringRef 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;
+                                                  return *(Sym->getName()) ==
+                                                         Name;
                                                 }) == 0) &&
-                                    "Duplicate absolute symbol");
-    auto &Sym = Symbol::constructAbsolute(Allocator, createAddressable(Address),
-                                          Name, Size, L, S, IsLive);
+    auto SSPName = SSP->intern(Name);
+    auto &Sym =
+        Symbol::constructAbsolute(Allocator, createAddressable(Address),
+                                  std::move(SSPName), Size, L, S, IsLive);
     AbsoluteSymbols.insert(&Sym);
     return Sym;
   }
 
   /// Convenience method for adding a weak zero-fill symbol.
   Symbol &addCommonSymbol(StringRef Name, Scope S, Section &Section,
                           orc::ExecutorAddr Address, orc::ExecutorAddrDiff Size,
                           uint64_t Alignment, bool IsLive) {
     assert(llvm::count_if(defined_symbols(),
                           [&](const Symbol *Sym) {
-                            return Sym->getName() == Name;
+                            return *(Sym->getName()) == Name;
                           }) == 0 &&
            "Duplicate defined symbol");
+    auto SSPName = SSP->intern(Name);
     auto &Sym = Symbol::constructCommon(
-        Allocator, createBlock(Section, Size, Address, Alignment, 0), Name,
-        Size, S, IsLive);
+        Allocator, createBlock(Section, Size, Address, Alignment, 0),
+        std::move(SSPName), Size, S, IsLive);
     Section.addSymbol(Sym);
     return Sym;
   }
 
   /// 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) {
+    auto SSPName = SSP->intern(Name);
     assert((S == Scope::Local || llvm::count_if(defined_symbols(),
                                                 [&](const Symbol *Sym) {
-                                                  return Sym->getName() == Name;
+                                                  return *(Sym->getName()) ==
+                                                         *SSPName;
                                                 }) == 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(SSPName), Size, L, S,
+                                          IsLive, IsCallable);
     Content.getSection().addSymbol(Sym);
     return Sym;
   }
 
   iterator_range<section_iterator> sections() {
     return make_range(section_iterator(Sections.begin()),
                       section_iterator(Sections.end()));
   }
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;
   unsigned PointerSize;
   support::endianness Endianness;
   GetEdgeKindNameFunction GetEdgeKindName = nullptr;
   SectionList Sections;
   ExternalSymbolSet ExternalSymbols;
   ExternalSymbolSet AbsoluteSymbols;
   orc::shared::AllocActions AAs;

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";
     });
     return *EntryI->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/COFFLinkGraphBuilder.h

protected:
   COFFLinkGraphBuilder(const object::COFFObjectFile &Obj, Triple TT,
                        LinkGraph::GetEdgeKindNameFunction GetEdgeKindName);
 
   LinkGraph &getGraph() const { return *G; }
 
   const object::COFFObjectFile &getObject() const { return Obj; }
 
   virtual Error addRelocations() = 0;
-  virtual Symbol &createDLLImportEntry(StringRef StubName, Symbol &Target) = 0;
+  virtual Symbol &createDLLImportEntry(orc::SymbolStringPtr StubName,
+                                       Symbol &Target) = 0;
 
   Error graphifySections();
   Error graphifySymbols();
 
   void setGraphSymbol(COFFSectionIndex SecIndex, COFFSymbolIndex SymIndex,
                       Symbol &Sym) {
     assert(!GraphSymbols[SymIndex] && "Duplicate symbol at index");
     GraphSymbols[SymIndex] = &Sym;

llvm/lib/ExecutionEngine/JITLink/COFFLinkGraphBuilder.cpp

else if (Sym->isUndefined()) {
       if (SymbolName.startswith(getDLLImportStubPrefix())) {
         if (Sym->getValue() != 0)
           return make_error<JITLinkError>(
               "DLL import symbol has non-zero offset");
 
         auto ExternalSym = createExternalSymbol(
             SymIndex, SymbolName.drop_front(getDLLImportStubPrefix().size()),
             *Sym, Sec);
-        GSym = &createDLLImportEntry(SymbolName, *ExternalSym);
+        auto SSPName = G->getSymbolStringPool()->intern(SymbolName);
+        GSym = &createDLLImportEntry(SSPName, *ExternalSym);
       } else
         GSym = createExternalSymbol(SymIndex, SymbolName, *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 {
case COFF_OPT_alternatename: {
       AlternateNames[From] = To;
       break;
     }
     case COFF_OPT_incl: {
       auto DataCopy = G->allocateString(S);
       StringRef StrCopy(DataCopy.data(), DataCopy.size());
       ExternalSymbols[StrCopy] =
           &G->addExternalSymbol(StrCopy, 0, Linkage::Strong);
       ExternalSymbols[StrCopy]->setLive(true);
       break;
     }
     case COFF_OPT_export:
       break;
     default: {
       LLVM_DEBUG({
         dbgs() << "Unknown coff directive: " << Arg->getSpelling() << "\n";
       });
       break;

 }
 
 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];
       G->makeDefined(*Alias, Target->getBlock(), Target->getOffset(),
                      Target->getSize(), Linkage::Weak, Scope::Local, false);
     }
   return Error::success();
 }
 
 Symbol *COFFLinkGraphBuilder::createExternalSymbol(
     COFFSymbolIndex SymIndex, StringRef SymbolName,
     object::COFFSymbolRef Symbol, const object::coff_section *Section) {
   if (!ExternalSymbols.count(SymbolName))
     ExternalSymbols[SymbolName] =
         &G->addExternalSymbol(SymbolName, Symbol.getValue(), Linkage::Strong);
 
   LLVM_DEBUG({
     dbgs() << "    " << SymIndex
            << ": Creating external graph symbol for COFF symbol \""
            << SymbolName << "\" in "
            << getCOFFSectionName(Symbol.getSectionNumber(), Section, Symbol)
            << " (index: " << Symbol.getSectionNumber() << ") \n";
   });
   return ExternalSymbols[SymbolName];

llvm/lib/ExecutionEngine/JITLink/COFF_x86_64.cpp

Error addRelocations() override {
     for (const auto &RelSect : sections())
       if (Error Err = COFFLinkGraphBuilder::forEachRelocation(
               RelSect, this, &COFFLinkGraphBuilder_x86_64::addSingleRelocation))
         return Err;
 
     return Error::success();
   }
 
-  Symbol &createDLLImportEntry(StringRef StubName, Symbol &Target) override {
+  Symbol &createDLLImportEntry(orc::SymbolStringPtr StubName,
+                               Symbol &Target) override {
     auto &Sym = DLLImportTable.getEntryForTarget(getGraph(), Target);
-    Sym.setName(StubName);
+    Sym.setName(std::move(StubName));
     return Sym;
   }
 
   Error addSingleRelocation(const object::RelocationRef &Rel,
                             const object::SectionRef &FixupSect,
                             Block &BlockToFix) {
     const object::coff_relocation *COFFRel = getObject().getCOFFRelocation(Rel);
     auto SymbolIt = Rel.getSymbol();
public:
   COFFLinkGraphBuilder_x86_64(const object::COFFObjectFile &Obj, const Triple T)
       : COFFLinkGraphBuilder(Obj, std::move(T), getCOFFX86RelocationKindName) {}
 };
 
 class COFFLinkGraphLowering_x86_64 {
 public:
   // 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)
             return ImageBase.takeError();
           E.setAddend(E.getAddend() - *ImageBase);
           E.setKind(x86_64::Pointer32);
orc::ExecutorAddr getSectionStart(Section &Sec) {
     return SectionStartCache[&Sec];
   }
 
   Expected<JITTargetAddress> getImageBaseAddress(LinkGraph &G,
                                                  JITLinkContext &Ctx) {
     if (this->ImageBase)
       return this->ImageBase;
     for (auto *S : G.defined_symbols())
-      if (S->getName() == getImageBaseSymbolName()) {
+      if (*S->getName() == getImageBaseSymbolName()) {
         this->ImageBase = S->getAddress().getValue();
         return this->ImageBase;
       }
 
     JITLinkContext::LookupMap Symbols;
     Symbols[getImageBaseSymbolName()] = SymbolLookupFlags::RequiredSymbol;
     JITTargetAddress ImageBase;
     Error Err = Error::success();

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.find(PointerFieldOffset);
     if (EdgeI != BlockEdges.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 (!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_x86_64.cpp

 
 private:
   Symbol *GOTSymbol = nullptr;
 
   Error getOrCreateGOTSymbol(LinkGraph &G) {
     auto DefineExternalGOTSymbolIfPresent =
         createDefineExternalSectionStartAndEndSymbolsPass(
             [&](LinkGraph &LG, Symbol &Sym) -> SectionRangeSymbolDesc {
-              if (Sym.getName() == ELFGOTSymbolName)
+              if (*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() == ELFGOTSymbolName) {
           GOTSymbol = Sym;
           return Error::success();
         }
 
       // If there's no defined symbol then create one.
       SectionRange SR(*GOTSection);
       if (SR.empty())
         GOTSymbol =
return ELFLinkGraphBuilder_x86_64((*ELFObj)->getFileName(),
       .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 : ExternalSymbols) {
+    Sym->~Symbol();
+  }
+  for (auto *Sym : AbsoluteSymbols) {
+    Sym->~Symbol();
+  }
+}
+
 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));
 }

llvm/lib/ExecutionEngine/JITLink/JITLinkGeneric.cpp

 }
 
 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() != "" &&
+    assert(Sym->hasName() && *Sym->getName() != "" &&
            "Externals must be named");
     SymbolLookupFlags LookupFlags =
         Sym->getLinkage() == Linkage::Weak
             ? SymbolLookupFlags::WeaklyReferencedSymbol
             : SymbolLookupFlags::RequiredSymbol;
-    UnresolvedExternals[Sym->getName()] = LookupFlags;
+    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");
     assert(!Sym->getAddress() && "Symbol already resolved");
     assert(!Sym->isDefined() && "Symbol being resolved is already defined");
-    auto ResultI = Result.find(Sym->getName());
+    auto ResultI = Result.find(*Sym->getName());
     if (ResultI != Result.end())
       Sym->getAddressable().setAddress(
           orc::ExecutorAddr(ResultI->second.getAddress()));
     else
       assert(Sym->getLinkage() == Linkage::Weak &&
              "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()) << "\n";
   });
 }
 
 void JITLinkerBase::abandonAllocAndBailOut(std::unique_ptr<JITLinkerBase> Self,
                                            Error Err) {
   assert(Err && "Should not be bailing out on success value");
   assert(Alloc && "can not call abandonAllocAndBailOut before allocation");

llvm/lib/ExecutionEngine/JITLink/MachOLinkGraphBuilder.cpp

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/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());
+    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;
+          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());
+    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;
+          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;

llvm/lib/ExecutionEngine/Orc/COFFPlatform.cpp

void materialize(std::unique_ptr<MaterializationResponsibility> R) override {
     switch (TT.getArch()) {
     case Triple::x86_64:
       PointerSize = 8;
       Endianness = support::endianness::little;
       break;
     default:
       llvm_unreachable("Unrecognized architecture");
     }
-
+    auto SSP = CP.getExecutionSession().getSymbolStringPool();
     auto G = std::make_unique<jitlink::LinkGraph>(
-        "<COFFHeaderMU>", TT, PointerSize, Endianness,
+        "<COFFHeaderMU>", SSP, TT, PointerSize, Endianness,
         jitlink::getGenericEdgeKindName);
     auto &HeaderSection = G->createSection("__header", jitlink::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/ELFNixPlatform.cpp

case Triple::aarch64:
       EdgeKind = jitlink::aarch64::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", jitlink::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(
Error ELFNixPlatform::ELFNixPlatformPlugin::registerInitSections(
 
   return MP.registerInitInfo(JD, InitSections);
 }
 
 Error ELFNixPlatform::ELFNixPlatformPlugin::fixTLVSectionsAndEdges(
     jitlink::LinkGraph &G, JITDylib &JD) {
 
   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() == "__tls_get_addr") {
+      auto TLSGetAddr =
+          MP.getExecutionSession().intern("___orc_rt_elfnix_tls_get_addr");
+      Sym->setName(std::move(TLSGetAddr));
+    } else if (*Sym->getName() == "__tlsdesc_resolver") {
+      auto TLSGetAddr =
+          MP.getExecutionSession().intern("___orc_rt_elfnix_tlsdesc_resolver");
+      Sym->setName(std::move(TLSGetAddr));
     }
   }
 
   auto *TLSInfoEntrySection = G.findSectionByName("$__TLSINFO");
 
   if (TLSInfoEntrySection) {
     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) {
   for (auto &KV : Resolved) {
     jitlink::Symbol &Target = G->addAbsoluteSymbol(
         *KV.first, ExecutorAddr(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->allocateString(Twine(getImpPrefix()) + *KV.first);
     StringRef NameCopyRef = StringRef(NameCopy.data(), NameCopy.size());
-    Ptr.setName(NameCopyRef);
+    auto SymbolName = G->getSymbolStringPool()->intern(NameCopyRef);
+    Ptr.setName(std::move(SymbolName));
     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 = makeArrayRef(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

case Triple::x86_64:
       PointerSize = 8;
       Endianness = support::endianness::little;
       break;
     default:
       llvm_unreachable("Unrecognized architecture");
     }
 
     auto G = std::make_unique<jitlink::LinkGraph>(
-        "<MachOHeaderMU>", TT, PointerSize, Endianness,
-        jitlink::getGenericEdgeKindName);
+        "<MachOHeaderMU>", MOP.getExecutionSession().getSymbolStringPool(), TT,
+        PointerSize, Endianness, jitlink::getGenericEdgeKindName);
     auto &HeaderSection = G->createSection("__header", jitlink::MemProt::Read);
     auto &HeaderBlock = createHeaderBlock(*G, HeaderSection);
 
     // Init symbol is header-start symbol.
     G->addDefinedSymbol(HeaderBlock, 0, *R->getInitializerSymbol(),
                         HeaderBlock.getSize(), jitlink::Linkage::Strong,
                         jitlink::Scope::Default, false, true);
     for (auto &HS : AdditionalHeaderSymbols)
if (I != InitSymbolDeps.end()) {
     return Result;
   }
   return SyntheticSymbolDependenciesMap();
 }
 
 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;
Error MachOPlatform::MachOPlatformPlugin::processObjCImageInfo(
   return Error::success();
 }
 
 Error MachOPlatform::MachOPlatformPlugin::fixTLVSectionsAndEdges(
     jitlink::LinkGraph &G, JITDylib &JD) {
 
   // 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->isNamed("__tlv_bootstrap")) {
+      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(ThreadVarsSectionName)) {
     Optional<uint64_t> Key;
     {
       std::lock_guard<std::mutex> Lock(MP.PlatformMutex);
       auto I = MP.JITDylibToPThreadKey.find(&JD);
Error MachOPlatform::MachOPlatformPlugin::registerEHSectionsPhase1(
   // Since we're linking the object containing the registration code now the
   // addresses won't be ready in the platform. We'll have to find them in this
   // graph instead.
   ExecutorAddr orc_rt_macho_register_ehframe_section;
   ExecutorAddr orc_rt_macho_deregister_ehframe_section;
   for (auto *Sym : G.defined_symbols()) {
     if (!Sym->hasName())
       continue;
-    if (Sym->getName() == "___orc_rt_macho_register_ehframe_section")
+    if (Sym->isNamed("___orc_rt_macho_register_ehframe_section"))
       orc_rt_macho_register_ehframe_section = ExecutorAddr(Sym->getAddress());
-    else if (Sym->getName() == "___orc_rt_macho_deregister_ehframe_section")
+    else if (Sym->isNamed("___orc_rt_macho_deregister_ehframe_section"))
       orc_rt_macho_deregister_ehframe_section = ExecutorAddr(Sym->getAddress());
 
     if (orc_rt_macho_register_ehframe_section &&
         orc_rt_macho_deregister_ehframe_section)
       break;
   }
 
   // If we failed to find the required functions then bail out.
   if (!orc_rt_macho_register_ehframe_section ||
       !orc_rt_macho_deregister_ehframe_section)

llvm/lib/ExecutionEngine/Orc/ObjectLinkingLayer.cpp

for (auto *Sym : G.defined_symbols()) {
 
       JITSymbolFlags Flags;
       if (Sym->getScope() == Scope::Default)
         Flags |= JITSymbolFlags::Exported;
 
       if (Sym->isCallable())
         Flags |= JITSymbolFlags::Callable;
 
-      LGI.SymbolFlags[ES.intern(Sym->getName())] = Flags;
+      LGI.SymbolFlags[Sym->getName()] = Flags;
     }
 
     if ((G.getTargetTriple().isOSBinFormatMachO() && hasMachOInitSection(G)) ||
         (G.getTargetTriple().isOSBinFormatELF() && hasELFInitSection(G)))
       LGI.InitSymbol = makeInitSymbol(ES, G);
 
     return LGI;
   }
private:
 
   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;
void lookup(const LookupMap &Symbols,
     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 InternedName = Sym->getName();
         JITSymbolFlags Flags;
 
         if (Sym->isCallable())
           Flags |= JITSymbolFlags::Callable;
         if (Sym->getScope() == Scope::Default)
           Flags |= JITSymbolFlags::Exported;
 
         InternedResult[InternedName] =
             JITEvaluatedSymbol(Sym->getAddress().getValue(), Flags);
         if (AutoClaim && !MR->getSymbols().count(InternedName)) {
           assert(!ExtraSymbolsToClaim.count(InternedName) &&
                  "Duplicate symbol to claim?");
           ExtraSymbolsToClaim[InternedName] = Flags;
         }
       }
 
     for (auto *Sym : G.absolute_symbols())
       if (Sym->hasName() && Sym->getScope() != Scope::Local) {
-        auto InternedName = ES.intern(Sym->getName());
+        auto InternedName = Sym->getName();
         JITSymbolFlags Flags;
         if (Sym->isCallable())
           Flags |= JITSymbolFlags::Callable;
         if (Sym->getScope() == Scope::Default)
           Flags |= JITSymbolFlags::Exported;
         if (Sym->getLinkage() == Linkage::Weak)
           Flags |= JITSymbolFlags::Weak;
         InternedResult[InternedName] =
private:
   // External: Defined externally.
   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)) {}
+    BlockDependenciesMap(DenseMap<const Block *, DenseSet<Block *>> 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) {
           BTDCacheVal.Internal.insert(InternalDep);
       }
 
       return BlockTransitiveDepsCache
           .insert(std::make_pair(&B, std::move(BTDCacheVal)))
           .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())))
-          .first->second;
-    }
-
   private:
     BlockSymbolDependencies &getBlockImmediateDeps(Block &B) {
       // Check the cache first.
       auto I = BlockImmediateDepsCache.find(&B);
       if (I != BlockImmediateDepsCache.end())
         return I->second;
 
       BlockSymbolDependencies BIDCacheVal;
       for (auto &E : B.edges()) {
         auto &Tgt = E.getTarget();
         if (Tgt.getScope() != Scope::Local) {
           if (Tgt.isExternal())
-            BIDCacheVal.External.insert(getInternedName(Tgt));
+            BIDCacheVal.External.insert(Tgt.getName());
           else
-            BIDCacheVal.Internal.insert(getInternedName(Tgt));
+            BIDCacheVal.Internal.insert(Tgt.getName());
         }
       }
 
       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()))) {
+        auto Name = Sym->getName();
+        if (!MR->getSymbols().count(Name)) {
           JITSymbolFlags SF = JITSymbolFlags::Weak;
           if (Sym->getScope() == Scope::Default)
             SF |= JITSymbolFlags::Exported;
           NewSymbolsToClaim[Name] = SF;
           NameToSym.push_back(std::make_pair(std::move(Name), Sym));
         }
       }
     };
 
     for (auto *Sym : G.defined_symbols())
       ProcessSymbol(Sym);
     for (auto *Sym : G.absolute_symbols())
       ProcessSymbol(Sym);
 
     // Attempt to claim all weak defs that we're not already responsible for.
     // This cannot fail -- any clashes will just result in rejection of our
     // claim, at which point we'll externalize that symbol.
     cantFail(MR->defineMaterializing(std::move(NewSymbolsToClaim)));
 
     for (auto &KV : NameToSym)
       if (!MR->getSymbols().count(KV.first))
         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;
       for (auto &KV : SynthDeps) {
         auto &Name = KV.first;
         auto &DepsForName = KV.second;
         for (auto *Sym : DepsForName) {
           if (Sym->getScope() == Scope::Local) {
             auto &BDeps = BlockDeps[Sym->getBlock()];
             for (auto &S : BDeps.Internal)
               InternalNamedSymbolDeps[Name].insert(S);
             for (auto &S : BDeps.External)
               ExternalNamedSymbolDeps[Name].insert(S);
           } else {
             if (Sym->isExternal())
-              ExternalNamedSymbolDeps[Name].insert(
-                  BlockDeps.getInternedName(*Sym));
+              ExternalNamedSymbolDeps[Name].insert(Sym->getName());
             else
-              InternalNamedSymbolDeps[Name].insert(
-                  BlockDeps.getInternedName(*Sym));
+              InternalNamedSymbolDeps[Name].insert(Sym->getName());
           }
         }
       }
     }
 
     return Error::success();
   }
 
while (!WorkList.empty()) {
         }
       }
     }
 
     DenseMap<const Block *, DenseSet<Block *>> BlockDeps;
     for (auto &KV : BlockInfos)
       BlockDeps[KV.first] = std::move(KV.second.Dependencies);
 
-    return BlockDependenciesMap(Layer.getExecutionSession(),
-                                std::move(BlockDeps));
+    return BlockDependenciesMap(std::move(BlockDeps));
   }
 
   void registerDependencies(const SymbolDependenceMap &QueryDeps) {
     for (auto &NamedDepsEntry : ExternalNamedSymbolDeps) {
       auto &Name = NamedDepsEntry.first;
       auto &NameDeps = NamedDepsEntry.second;
       SymbolDependenceMap SymbolDeps;
 

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()};
           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()};
         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()};
           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()};
           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()};
         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()};
           SectionContainsContent = true;
         }
       }
     }
 
     auto SecAddr = FirstSym->getAddress();
     auto SecSize =
         (LastSym->getBlock().getAddress() + LastSym->getBlock().getSize()) -

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()] = {
+          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()};
         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()};
           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) {
   // the harness to default scope, remove all symbols that clash with harness
   // definitions.
   std::vector<Symbol *> DefinitionsToRemove;
   for (auto *Sym : G.defined_symbols()) {
 
     if (!Sym->hasName())
       continue;
 
+    auto SymName = *(Sym->getName());
+
     if (Sym->getLinkage() == Linkage::Weak) {
-      if (!S.CanonicalWeakDefs.count(Sym->getName()) ||
-          S.CanonicalWeakDefs[Sym->getName()] != G.getName()) {
-        LLVM_DEBUG({
-          dbgs() << "  Externalizing weak symbol " << Sym->getName() << "\n";
-        });
+      if (!S.CanonicalWeakDefs.count(SymName) ||
+          S.CanonicalWeakDefs[SymName] != G.getName()) {
+        LLVM_DEBUG(
+            { dbgs() << "  Externalizing weak symbol " << SymName << "\n"; });
         DefinitionsToRemove.push_back(Sym);
       } else {
-        LLVM_DEBUG({
-          dbgs() << "  Making weak symbol " << Sym->getName() << " strong\n";
-        });
-        if (S.HarnessExternals.count(Sym->getName()))
+        LLVM_DEBUG(
+            { dbgs() << "  Making weak symbol " << SymName << " strong\n"; });
+        if (S.HarnessExternals.count(SymName))
           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(SymName)) {
+      LLVM_DEBUG(dbgs() << "  Promoting " << SymName << "\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(SymName)) {
+      LLVM_DEBUG(dbgs() << "  Externalizing " << SymName << "\n");
       DefinitionsToRemove.push_back(Sym);
     }
   }
 
   for (auto *Sym : DefinitionsToRemove)
     G.makeExternal(*Sym);
 
   return Error::success();

llvm/unittests/ExecutionEngine/JITLink/EHFrameSupportTests.cpp

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));
 
   // 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/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/SymbolStringPool.h"
 #include "llvm/Support/Endian.h"
 #include "llvm/Support/Memory.h"
 #include "gtest/gtest.h"
 
 using namespace llvm;
 using namespace llvm::jitlink;
 
 static const char BlockContentBytes[] = {
TEST(LinkGraphTest, Construction) {
   EXPECT_EQ(G.getName(), "foo");
   EXPECT_EQ(G.getTargetTriple().str(), "x86_64-apple-darwin");
   EXPECT_EQ(G.getPointerSize(), 8U);
   EXPECT_EQ(G.getEndianness(), support::little);
   EXPECT_TRUE(llvm::empty(G.external_symbols()));
   EXPECT_TRUE(llvm::empty(G.absolute_symbols()));
   EXPECT_TRUE(llvm::empty(G.defined_symbols()));
   EXPECT_TRUE(llvm::empty(G.blocks()));
+  EXPECT_TRUE(G.getSymbolStringPool());
+}
+
+TEST(LinkGraphTest, ConstructionWithPool) {
+  auto SSP = std::make_shared<orc::SymbolStringPool>();
+  // Check that LinkGraph construction works as expected.
+  LinkGraph G("foo", SSP, Triple("x86_64-apple-darwin"), 8, support::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(), support::little);
+  EXPECT_TRUE(llvm::empty(G.external_symbols()));
+  EXPECT_TRUE(llvm::empty(G.absolute_symbols()));
+  EXPECT_TRUE(llvm::empty(G.defined_symbols()));
+  EXPECT_TRUE(llvm::empty(G.blocks()));
+  EXPECT_EQ(&*G.getSymbolStringPool(), &*SSP);
 }
 
 TEST(LinkGraphTest, AddressAccess) {
   // Check that we can get addresses for blocks, symbols, and edges.
   LinkGraph G("foo", Triple("x86_64-apple-darwin"), 8, support::little,
               getGenericEdgeKindName);
 
   auto &Sec1 = G.createSection("__data.1", MemProt::Read | MemProt::Write);
   orc::ExecutorAddr B1Addr(0x1000);
if (size(B2.edges()) == 2) {
     auto *E1 = &*B2.edges().begin();
     auto *E2 = &*(B2.edges().begin() + 1);
     if (E2->getOffset() < E1->getOffset())
       std::swap(E1, E2);
     EXPECT_EQ(E1->getOffset(), 0U);
     EXPECT_EQ(E2->getOffset(), 4U);
   }
 }
+
+TEST(LinkGraphTest, SymbolPoolSupport) {
+  // Check that we can get addresses for blocks, symbols, and edges.
+  LinkGraph G("foo", Triple("x86_64-apple-darwin"), 8, support::little,
+              getGenericEdgeKindName);
+
+  auto &Sec1 = G.createSection("__data.1", MemProt::Read | 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);
+  auto SN1 = G.getSymbolStringPool()->intern("S1");
+  ASSERT_EQ(S1.getName(), SN1);
+}
 No newline at end of file