diff --git a/llvm/include/llvm/ExecutionEngine/JITLink/COFF.h b/llvm/include/llvm/ExecutionEngine/JITLink/COFF.h --- a/llvm/include/llvm/ExecutionEngine/JITLink/COFF.h +++ b/llvm/include/llvm/ExecutionEngine/JITLink/COFF.h @@ -24,7 +24,8 @@ /// its contents. The caller is responsible for ensuring that the object buffer /// outlives the graph. Expected> -createLinkGraphFromCOFFObject(MemoryBufferRef ObjectBuffer); +createLinkGraphFromCOFFObject(MemoryBufferRef ObjectBuffer, + std::shared_ptr SSP); /// Link the given graph. /// diff --git a/llvm/include/llvm/ExecutionEngine/JITLink/COFF_x86_64.h b/llvm/include/llvm/ExecutionEngine/JITLink/COFF_x86_64.h --- a/llvm/include/llvm/ExecutionEngine/JITLink/COFF_x86_64.h +++ b/llvm/include/llvm/ExecutionEngine/JITLink/COFF_x86_64.h @@ -23,8 +23,8 @@ /// 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> -createLinkGraphFromCOFFObject_x86_64(MemoryBufferRef ObjectBuffer); +Expected> createLinkGraphFromCOFFObject_x86_64( + MemoryBufferRef ObjectBuffer, std::shared_ptr SSP); /// jit-link the given object buffer, which must be a COFF x86-64 object file. void link_COFF_x86_64(std::unique_ptr G, diff --git a/llvm/include/llvm/ExecutionEngine/JITLink/ELF.h b/llvm/include/llvm/ExecutionEngine/JITLink/ELF.h --- a/llvm/include/llvm/ExecutionEngine/JITLink/ELF.h +++ b/llvm/include/llvm/ExecutionEngine/JITLink/ELF.h @@ -24,7 +24,8 @@ /// its contents. The caller is responsible for ensuring that the object buffer /// outlives the graph. Expected> -createLinkGraphFromELFObject(MemoryBufferRef ObjectBuffer); +createLinkGraphFromELFObject(MemoryBufferRef ObjectBuffer, + std::shared_ptr SSP); /// Link the given graph. /// diff --git a/llvm/include/llvm/ExecutionEngine/JITLink/ELF_aarch32.h b/llvm/include/llvm/ExecutionEngine/JITLink/ELF_aarch32.h --- a/llvm/include/llvm/ExecutionEngine/JITLink/ELF_aarch32.h +++ b/llvm/include/llvm/ExecutionEngine/JITLink/ELF_aarch32.h @@ -24,8 +24,8 @@ /// 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> -createLinkGraphFromELFObject_aarch32(MemoryBufferRef ObjectBuffer); +Expected> createLinkGraphFromELFObject_aarch32( + MemoryBufferRef ObjectBuffer, std::shared_ptr SSP); /// jit-link the given object buffer, which must be an ELF arm/thumb object /// file. diff --git a/llvm/include/llvm/ExecutionEngine/JITLink/ELF_aarch64.h b/llvm/include/llvm/ExecutionEngine/JITLink/ELF_aarch64.h --- a/llvm/include/llvm/ExecutionEngine/JITLink/ELF_aarch64.h +++ b/llvm/include/llvm/ExecutionEngine/JITLink/ELF_aarch64.h @@ -25,8 +25,8 @@ /// 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> -createLinkGraphFromELFObject_aarch64(MemoryBufferRef ObjectBuffer); +Expected> createLinkGraphFromELFObject_aarch64( + MemoryBufferRef ObjectBuffer, std::shared_ptr SSP); /// jit-link the given object buffer, which must be a ELF aarch64 relocatable /// object file. diff --git a/llvm/include/llvm/ExecutionEngine/JITLink/ELF_i386.h b/llvm/include/llvm/ExecutionEngine/JITLink/ELF_i386.h --- a/llvm/include/llvm/ExecutionEngine/JITLink/ELF_i386.h +++ b/llvm/include/llvm/ExecutionEngine/JITLink/ELF_i386.h @@ -26,7 +26,8 @@ /// its contents. The caller is responsible for ensuring that the object buffer /// outlives the graph. Expected> -createLinkGraphFromELFObject_i386(MemoryBufferRef ObjectBuffer); +createLinkGraphFromELFObject_i386(MemoryBufferRef ObjectBuffer, + std::shared_ptr SSP); /// jit-link the given object buffer, which must be a ELF i386 relocatable /// object file. diff --git a/llvm/include/llvm/ExecutionEngine/JITLink/ELF_loongarch.h b/llvm/include/llvm/ExecutionEngine/JITLink/ELF_loongarch.h --- a/llvm/include/llvm/ExecutionEngine/JITLink/ELF_loongarch.h +++ b/llvm/include/llvm/ExecutionEngine/JITLink/ELF_loongarch.h @@ -25,8 +25,8 @@ /// 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> -createLinkGraphFromELFObject_loongarch(MemoryBufferRef ObjectBuffer); +Expected> createLinkGraphFromELFObject_loongarch( + MemoryBufferRef ObjectBuffer, std::shared_ptr SSP); /// jit-link the given object buffer, which must be an ELF loongarch object /// file. diff --git a/llvm/include/llvm/ExecutionEngine/JITLink/ELF_ppc64.h b/llvm/include/llvm/ExecutionEngine/JITLink/ELF_ppc64.h --- a/llvm/include/llvm/ExecutionEngine/JITLink/ELF_ppc64.h +++ b/llvm/include/llvm/ExecutionEngine/JITLink/ELF_ppc64.h @@ -25,15 +25,16 @@ /// /// WARNING: The big-endian backend has not been tested yet. Expected> -createLinkGraphFromELFObject_ppc64(MemoryBufferRef ObjectBuffer); +createLinkGraphFromELFObject_ppc64(MemoryBufferRef ObjectBuffer, + std::shared_ptr 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> -createLinkGraphFromELFObject_ppc64le(MemoryBufferRef ObjectBuffer); +Expected> createLinkGraphFromELFObject_ppc64le( + MemoryBufferRef ObjectBuffer, std::shared_ptr SSP); /// jit-link the given object buffer, which must be a ELF ppc64le object file. /// diff --git a/llvm/include/llvm/ExecutionEngine/JITLink/ELF_riscv.h b/llvm/include/llvm/ExecutionEngine/JITLink/ELF_riscv.h --- a/llvm/include/llvm/ExecutionEngine/JITLink/ELF_riscv.h +++ b/llvm/include/llvm/ExecutionEngine/JITLink/ELF_riscv.h @@ -26,7 +26,8 @@ /// its contents. The caller is responsible for ensuring that the object buffer /// outlives the graph. Expected> -createLinkGraphFromELFObject_riscv(MemoryBufferRef ObjectBuffer); +createLinkGraphFromELFObject_riscv(MemoryBufferRef ObjectBuffer, + std::shared_ptr SSP); /// jit-link the given object buffer, which must be a ELF riscv object file. void link_ELF_riscv(std::unique_ptr G, diff --git a/llvm/include/llvm/ExecutionEngine/JITLink/ELF_x86_64.h b/llvm/include/llvm/ExecutionEngine/JITLink/ELF_x86_64.h --- a/llvm/include/llvm/ExecutionEngine/JITLink/ELF_x86_64.h +++ b/llvm/include/llvm/ExecutionEngine/JITLink/ELF_x86_64.h @@ -24,7 +24,8 @@ /// its contents. The caller is responsible for ensuring that the object buffer /// outlives the graph. Expected> -createLinkGraphFromELFObject_x86_64(MemoryBufferRef ObjectBuffer); +createLinkGraphFromELFObject_x86_64(MemoryBufferRef ObjectBuffe, + std::shared_ptr SSP); /// jit-link the given object buffer, which must be a ELF x86-64 object file. void link_ELF_x86_64(std::unique_ptr G, diff --git a/llvm/include/llvm/ExecutionEngine/JITLink/JITLink.h b/llvm/include/llvm/ExecutionEngine/JITLink/JITLink.h --- a/llvm/include/llvm/ExecutionEngine/JITLink/JITLink.h +++ b/llvm/include/llvm/ExecutionEngine/JITLink/JITLink.h @@ -22,6 +22,7 @@ #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" @@ -415,10 +416,11 @@ 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); @@ -427,27 +429,45 @@ 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(Base).getSize() == Size && + "Common symbol size should match underlying block size"); + auto *Sym = Allocator.Allocate(); + 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(); - 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(); - 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; } @@ -458,20 +478,22 @@ assert((Offset + Size) <= Base.getSize() && "Symbol extends past end of block"); auto *Sym = Allocator.Allocate(); - 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(); - 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; } @@ -488,18 +510,19 @@ 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). @@ -606,7 +629,7 @@ /// 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(L); } @@ -616,7 +639,7 @@ /// 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"); @@ -668,8 +691,7 @@ 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; @@ -994,23 +1016,26 @@ using GetEdgeKindNameFunction = const char *(*)(Edge::Kind); - LinkGraph(std::string Name, const Triple &TT, SubtargetFeatures Features, + LinkGraph(std::string Name, std::shared_ptr 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 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). @@ -1030,6 +1055,8 @@ const char *getEdgeKindName(Edge::Kind K) const { return GetEdgeKindName(K); } + std::shared_ptr getSymbolStringPool() { return SSP; } + /// Allocate a mutable buffer of the given size using the LinkGraph's /// allocator. MutableArrayRef allocateBuffer(size_t Size) { @@ -1190,6 +1217,10 @@ 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'. @@ -1198,18 +1229,26 @@ /// 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, @@ -1218,11 +1257,18 @@ }) == 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, @@ -1237,13 +1283,22 @@ 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), + Size, L, S, IsLive, IsCallable); Content.getSection().addSymbol(Sym); return Sym; } @@ -1328,7 +1383,7 @@ 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 @@ -1342,10 +1397,10 @@ 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); @@ -1370,9 +1425,9 @@ "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); @@ -1457,9 +1512,9 @@ 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; }) && @@ -1527,6 +1582,7 @@ BumpPtrAllocator Allocator; std::string Name; + std::shared_ptr SSP; Triple TT; SubtargetFeatures Features; unsigned PointerSize; @@ -1755,7 +1811,8 @@ raw_ostream &operator<<(raw_ostream &OS, const SymbolLookupFlags &LF); /// A map of symbol names to resolved addresses. -using AsyncLookupResult = DenseMap; +using AsyncLookupResult = + DenseMap; /// A function object to call with a resolved symbol map (See AsyncLookupResult) /// or an error if resolution failed. @@ -1788,7 +1845,7 @@ /// Holds context for a single jitLink invocation. class JITLinkContext { public: - using LookupMap = DenseMap; + using LookupMap = DenseMap; /// Create a JITLinkContext. JITLinkContext(const JITLinkDylib *JD) : JD(JD) {} @@ -1921,7 +1978,8 @@ /// its contents. The caller is responsible for ensuring that the object buffer /// outlives the graph. Expected> -createLinkGraphFromObject(MemoryBufferRef ObjectBuffer); +createLinkGraphFromObject(MemoryBufferRef ObjectBuffer, + std::shared_ptr SSP); /// Link the given graph. void link(std::unique_ptr G, std::unique_ptr Ctx); diff --git a/llvm/include/llvm/ExecutionEngine/JITLink/MachO.h b/llvm/include/llvm/ExecutionEngine/JITLink/MachO.h --- a/llvm/include/llvm/ExecutionEngine/JITLink/MachO.h +++ b/llvm/include/llvm/ExecutionEngine/JITLink/MachO.h @@ -24,7 +24,8 @@ /// its contents. The caller is responsible for ensuring that the object buffer /// outlives the graph. Expected> -createLinkGraphFromMachOObject(MemoryBufferRef ObjectBuffer); +createLinkGraphFromMachOObject(MemoryBufferRef ObjectBuffer, + std::shared_ptr SSP); /// jit-link the given ObjBuffer, which must be a MachO object file. /// diff --git a/llvm/include/llvm/ExecutionEngine/JITLink/MachO_arm64.h b/llvm/include/llvm/ExecutionEngine/JITLink/MachO_arm64.h --- a/llvm/include/llvm/ExecutionEngine/JITLink/MachO_arm64.h +++ b/llvm/include/llvm/ExecutionEngine/JITLink/MachO_arm64.h @@ -23,8 +23,8 @@ /// 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> -createLinkGraphFromMachOObject_arm64(MemoryBufferRef ObjectBuffer); +Expected> createLinkGraphFromMachOObject_arm64( + MemoryBufferRef ObjectBuffer, std::shared_ptr SSP); /// jit-link the given object buffer, which must be a MachO arm64 object file. /// diff --git a/llvm/include/llvm/ExecutionEngine/JITLink/MachO_x86_64.h b/llvm/include/llvm/ExecutionEngine/JITLink/MachO_x86_64.h --- a/llvm/include/llvm/ExecutionEngine/JITLink/MachO_x86_64.h +++ b/llvm/include/llvm/ExecutionEngine/JITLink/MachO_x86_64.h @@ -23,8 +23,8 @@ /// 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> -createLinkGraphFromMachOObject_x86_64(MemoryBufferRef ObjectBuffer); +Expected> createLinkGraphFromMachOObject_x86_64( + MemoryBufferRef ObjectBuffer, std::shared_ptr SSP); /// jit-link the given LinkGraph. /// diff --git a/llvm/include/llvm/ExecutionEngine/JITLink/TableManager.h b/llvm/include/llvm/ExecutionEngine/JITLink/TableManager.h --- a/llvm/include/llvm/ExecutionEngine/JITLink/TableManager.h +++ b/llvm/include/llvm/ExecutionEngine/JITLink/TableManager.h @@ -39,7 +39,7 @@ 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; } @@ -69,7 +69,7 @@ private: TableManagerImplT &impl() { return static_cast(*this); } - DenseMap Entries; + DenseMap Entries; }; } // namespace jitlink diff --git a/llvm/lib/ExecutionEngine/JITLink/COFF.cpp b/llvm/lib/ExecutionEngine/JITLink/COFF.cpp --- a/llvm/lib/ExecutionEngine/JITLink/COFF.cpp +++ b/llvm/lib/ExecutionEngine/JITLink/COFF.cpp @@ -42,7 +42,8 @@ } Expected> -createLinkGraphFromCOFFObject(MemoryBufferRef ObjectBuffer) { +createLinkGraphFromCOFFObject(MemoryBufferRef ObjectBuffer, + std::shared_ptr SSP) { StringRef Data = ObjectBuffer.getBuffer(); // Check magic @@ -110,7 +111,7 @@ switch (Machine) { case COFF::IMAGE_FILE_MACHINE_AMD64: - return createLinkGraphFromCOFFObject_x86_64(ObjectBuffer); + return createLinkGraphFromCOFFObject_x86_64(ObjectBuffer, SSP); default: return make_error( "Unsupported target machine architecture in COFF object " + diff --git a/llvm/lib/ExecutionEngine/JITLink/COFFLinkGraphBuilder.h b/llvm/lib/ExecutionEngine/JITLink/COFFLinkGraphBuilder.h --- a/llvm/lib/ExecutionEngine/JITLink/COFFLinkGraphBuilder.h +++ b/llvm/lib/ExecutionEngine/JITLink/COFFLinkGraphBuilder.h @@ -37,7 +37,8 @@ using COFFSectionIndex = int32_t; using COFFSymbolIndex = int32_t; - COFFLinkGraphBuilder(const object::COFFObjectFile &Obj, Triple TT, + COFFLinkGraphBuilder(const object::COFFObjectFile &Obj, + std::shared_ptr SSP, Triple TT, SubtargetFeatures Features, LinkGraph::GetEdgeKindNameFunction GetEdgeKindName); @@ -134,20 +135,21 @@ Section &getCommonSection(); - Symbol *createExternalSymbol(COFFSymbolIndex SymIndex, StringRef SymbolName, + Symbol *createExternalSymbol(COFFSymbolIndex SymIndex, + orc::SymbolStringPtr SymbolName, object::COFFSymbolRef Symbol, const object::coff_section *Section); - Expected createAliasSymbol(StringRef SymbolName, Linkage L, Scope S, - Symbol &Target); + Expected createAliasSymbol(orc::SymbolStringPtr SymbolName, + Linkage L, Scope S, Symbol &Target); Expected createDefinedSymbol(COFFSymbolIndex SymIndex, - StringRef SymbolName, + orc::SymbolStringPtr SymbolName, object::COFFSymbolRef Symbol, const object::coff_section *Section); Expected createCOMDATExportRequest( COFFSymbolIndex SymIndex, object::COFFSymbolRef Symbol, const object::coff_aux_section_definition *Definition); Expected exportCOMDATSymbol(COFFSymbolIndex SymIndex, - StringRef SymbolName, + orc::SymbolStringPtr SymbolName, object::COFFSymbolRef Symbol); Error handleDirectiveSection(StringRef Str); @@ -176,9 +178,9 @@ std::vector GraphBlocks; std::vector GraphSymbols; - DenseMap AlternateNames; - DenseMap ExternalSymbols; - DenseMap DefinedSymbols; + DenseMap AlternateNames; + DenseMap ExternalSymbols; + DenseMap DefinedSymbols; }; template diff --git a/llvm/lib/ExecutionEngine/JITLink/COFFLinkGraphBuilder.cpp b/llvm/lib/ExecutionEngine/JITLink/COFFLinkGraphBuilder.cpp --- a/llvm/lib/ExecutionEngine/JITLink/COFFLinkGraphBuilder.cpp +++ b/llvm/lib/ExecutionEngine/JITLink/COFFLinkGraphBuilder.cpp @@ -11,6 +11,8 @@ //===----------------------------------------------------------------------===// #include "COFFLinkGraphBuilder.h" +#include + #define DEBUG_TYPE "jitlink" static const char *CommonSectionName = "__common"; @@ -24,12 +26,14 @@ } COFFLinkGraphBuilder::COFFLinkGraphBuilder( - const object::COFFObjectFile &Obj, Triple TT, SubtargetFeatures Features, + const object::COFFObjectFile &Obj, + std::shared_ptr SSP, + Triple TT, SubtargetFeatures Features, LinkGraph::GetEdgeKindNameFunction GetEdgeKindName) : Obj(Obj), G(std::make_unique( - 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"; @@ -226,18 +230,19 @@ " (" + 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(); COFFSymbolIndex TagIndex = WeakExternal->TagIndex; @@ -246,7 +251,7 @@ {SymIndex, TagIndex, Characteristics, SymbolName}); } else { Expected NewGSym = - createDefinedSymbol(SymIndex, SymbolName, *Sym, Sec); + createDefinedSymbol(SymIndex, InternedSymbolName, *Sym, Sec); if (!NewGSym) return NewGSym.takeError(); GSym = *NewGSym; @@ -254,7 +259,7 @@ 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"; @@ -293,14 +298,13 @@ if (From.empty() || To.empty()) return make_error( "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: @@ -332,8 +336,8 @@ ? 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, @@ -354,37 +358,45 @@ } 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 COFFLinkGraphBuilder::createAliasSymbol(StringRef SymbolName, - Linkage L, Scope S, - Symbol &Target) { +Expected +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("Weak external symbol with external " @@ -460,8 +472,9 @@ } Expected 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( @@ -470,6 +483,7 @@ 0, SymbolName, Symbol.getValue(), Linkage::Strong, Scope::Default, false, false); } + if (Symbol.isAbsolute()) return &G->addAbsoluteSymbol(SymbolName, orc::ExecutorAddr(Symbol.getValue()), 0, @@ -486,7 +500,7 @@ 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; @@ -603,7 +617,7 @@ // Process the second symbol of COMDAT sequence. Expected COFFLinkGraphBuilder::exportCOMDATSymbol(COFFSymbolIndex SymIndex, - StringRef SymbolName, + orc::SymbolStringPtr SymbolName, object::COFFSymbolRef Symbol) { Block *B = getGraphBlock(Symbol.getSectionNumber()); auto &PendingComdatExport = PendingComdatExports[Symbol.getSectionNumber()]; @@ -616,8 +630,9 @@ 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, diff --git a/llvm/lib/ExecutionEngine/JITLink/COFF_x86_64.cpp b/llvm/lib/ExecutionEngine/JITLink/COFF_x86_64.cpp --- a/llvm/lib/ExecutionEngine/JITLink/COFF_x86_64.cpp +++ b/llvm/lib/ExecutionEngine/JITLink/COFF_x86_64.cpp @@ -148,6 +148,7 @@ SectionIdx = getObject().getNumberOfSections() + 1; else SectionIdx = COFFSymbol.getSectionNumber(); + auto *AbsSym = &getGraph().addAbsoluteSymbol( "secidx", orc::ExecutorAddr(SectionIdx), 2, Linkage::Strong, Scope::Local, false); @@ -181,14 +182,20 @@ } public: - COFFLinkGraphBuilder_x86_64(const object::COFFObjectFile &Obj, const Triple T, + COFFLinkGraphBuilder_x86_64(const object::COFFObjectFile &Obj, + std::shared_ptr 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 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()) { @@ -230,8 +237,7 @@ } private: - static StringRef getImageBaseSymbolName() { return "__ImageBase"; } - + orc::SymbolStringPtr getImageBaseSymbolName() { return this->imageBaseName; } orc::ExecutorAddr getSectionStart(Section &Sec) { if (!SectionStartCache.count(&Sec)) { SectionRange Range(Sec); @@ -271,12 +277,13 @@ DenseMap
SectionStartCache; orc::ExecutorAddr ImageBase; + std::shared_ptr 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; @@ -305,8 +312,8 @@ } } -Expected> -createLinkGraphFromCOFFObject_x86_64(MemoryBufferRef ObjectBuffer) { +Expected> createLinkGraphFromCOFFObject_x86_64( + MemoryBufferRef ObjectBuffer, std::shared_ptr SSP) { LLVM_DEBUG({ dbgs() << "Building jitlink graph for new input " << ObjectBuffer.getBufferIdentifier() << "...\n"; @@ -315,12 +322,12 @@ 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(); } diff --git a/llvm/lib/ExecutionEngine/JITLink/EHFrameSupport.cpp b/llvm/lib/ExecutionEngine/JITLink/EHFrameSupport.cpp --- a/llvm/lib/ExecutionEngine/JITLink/EHFrameSupport.cpp +++ b/llvm/lib/ExecutionEngine/JITLink/EHFrameSupport.cpp @@ -374,7 +374,7 @@ 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"; }); @@ -527,7 +527,7 @@ << (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)) @@ -593,7 +593,7 @@ << (BlockToFix.getAddress() + PointerFieldOffset) << " to " << FieldName << " at " << TargetSym->getAddress(); if (TargetSym->hasName()) - dbgs() << " (" << TargetSym->getName() << ")"; + dbgs() << " (" << *TargetSym->getName() << ")"; dbgs() << "\n"; }); diff --git a/llvm/lib/ExecutionEngine/JITLink/ELF.cpp b/llvm/lib/ExecutionEngine/JITLink/ELF.cpp --- a/llvm/lib/ExecutionEngine/JITLink/ELF.cpp +++ b/llvm/lib/ExecutionEngine/JITLink/ELF.cpp @@ -71,7 +71,8 @@ } Expected> -createLinkGraphFromELFObject(MemoryBufferRef ObjectBuffer) { +createLinkGraphFromELFObject(MemoryBufferRef ObjectBuffer, + std::shared_ptr SSP) { StringRef Buffer = ObjectBuffer.getBuffer(); if (Buffer.size() < ELF::EI_NIDENT) return make_error("Truncated ELF buffer"); @@ -86,23 +87,23 @@ 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( "Unsupported target machine architecture in ELF object " + diff --git a/llvm/lib/ExecutionEngine/JITLink/ELFLinkGraphBuilder.h b/llvm/lib/ExecutionEngine/JITLink/ELFLinkGraphBuilder.h --- a/llvm/lib/ExecutionEngine/JITLink/ELFLinkGraphBuilder.h +++ b/llvm/lib/ExecutionEngine/JITLink/ELFLinkGraphBuilder.h @@ -58,7 +58,8 @@ using ELFFile = object::ELFFile; public: - ELFLinkGraphBuilder(const object::ELFFile &Obj, Triple TT, + ELFLinkGraphBuilder(const object::ELFFile &Obj, + std::shared_ptr SSP, Triple TT, SubtargetFeatures Features, StringRef FileName, LinkGraph::GetEdgeKindNameFunction GetEdgeKindName); @@ -189,10 +190,12 @@ template ELFLinkGraphBuilder::ELFLinkGraphBuilder( - const ELFFile &Obj, Triple TT, SubtargetFeatures Features, + const ELFFile &Obj, + std::shared_ptr SSP , Triple TT, + SubtargetFeatures Features, StringRef FileName, LinkGraph::GetEdgeKindNameFunction GetEdgeKindName) : ELFLinkGraphBuilderBase(std::make_unique( - 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) { diff --git a/llvm/lib/ExecutionEngine/JITLink/ELF_aarch32.cpp b/llvm/lib/ExecutionEngine/JITLink/ELF_aarch32.cpp --- a/llvm/lib/ExecutionEngine/JITLink/ELF_aarch32.cpp +++ b/llvm/lib/ExecutionEngine/JITLink/ELF_aarch32.cpp @@ -202,12 +202,14 @@ public: ELFLinkGraphBuilder_aarch32(StringRef FileName, - const llvm::object::ELFFile &Obj, Triple TT, + const llvm::object::ELFFile &Obj, + std::shared_ptr SSP, + Triple TT, SubtargetFeatures Features, aarch32::ArmConfig ArmCfg) - : ELFLinkGraphBuilder(Obj, std::move(TT), std::move(Features), + : ELFLinkGraphBuilder(Obj, SSP, std::move(TT), std::move(Features), FileName, getELFAArch32EdgeKindName), - ArmCfg(std::move(ArmCfg)) {} + ArmCfg(std::move(ArmCfg)) {} }; template @@ -219,8 +221,8 @@ return Error::success(); } -Expected> -createLinkGraphFromELFObject_aarch32(MemoryBufferRef ObjectBuffer) { +Expected> createLinkGraphFromELFObject_aarch32( + MemoryBufferRef ObjectBuffer, std::shared_ptr SSP) { LLVM_DEBUG({ dbgs() << "Building jitlink graph for new input " << ObjectBuffer.getBufferIdentifier() << "...\n"; @@ -266,7 +268,7 @@ case Triple::thumb: { auto &ELFFile = cast>(**ELFObj).getELFFile(); return ELFLinkGraphBuilder_aarch32( - (*ELFObj)->getFileName(), ELFFile, TT, std::move(*Features), + (*ELFObj)->getFileName(), ELFFile, SSP, TT, std::move(*Features), ArmCfg) .buildGraph(); } @@ -274,7 +276,7 @@ case Triple::thumbeb: { auto &ELFFile = cast>(**ELFObj).getELFFile(); return ELFLinkGraphBuilder_aarch32( - (*ELFObj)->getFileName(), ELFFile, TT, std::move(*Features), + (*ELFObj)->getFileName(), ELFFile, SSP, TT, std::move(*Features), ArmCfg) .buildGraph(); } diff --git a/llvm/lib/ExecutionEngine/JITLink/ELF_aarch64.cpp b/llvm/lib/ExecutionEngine/JITLink/ELF_aarch64.cpp --- a/llvm/lib/ExecutionEngine/JITLink/ELF_aarch64.cpp +++ b/llvm/lib/ExecutionEngine/JITLink/ELF_aarch64.cpp @@ -428,9 +428,14 @@ public: ELFLinkGraphBuilder_aarch64(StringRef FileName, - const object::ELFFile &Obj, Triple TT, - SubtargetFeatures Features) - : ELFLinkGraphBuilder(Obj, std::move(TT), std::move(Features), + const object::ELFFile &Obj, + std::shared_ptr SSP, + Triple TT, SubtargetFeatures Features) + + + + + : ELFLinkGraphBuilder(Obj, SSP, std::move(TT), std::move(Features), FileName, aarch64::getEdgeKindName) {} }; @@ -568,8 +573,8 @@ namespace llvm { namespace jitlink { -Expected> -createLinkGraphFromELFObject_aarch64(MemoryBufferRef ObjectBuffer) { +Expected> createLinkGraphFromELFObject_aarch64( + MemoryBufferRef ObjectBuffer, std::shared_ptr SSP) { LLVM_DEBUG({ dbgs() << "Building jitlink graph for new input " << ObjectBuffer.getBufferIdentifier() << "...\n"; @@ -589,7 +594,7 @@ auto &ELFObjFile = cast>(**ELFObj); return ELFLinkGraphBuilder_aarch64( (*ELFObj)->getFileName(), ELFObjFile.getELFFile(), - (*ELFObj)->makeTriple(), std::move(*Features)) + SSP, (*ELFObj)->makeTriple(), std::move(*Features)) .buildGraph(); } diff --git a/llvm/lib/ExecutionEngine/JITLink/ELF_i386.cpp b/llvm/lib/ExecutionEngine/JITLink/ELF_i386.cpp --- a/llvm/lib/ExecutionEngine/JITLink/ELF_i386.cpp +++ b/llvm/lib/ExecutionEngine/JITLink/ELF_i386.cpp @@ -56,7 +56,8 @@ 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; @@ -82,7 +83,7 @@ // 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(); } @@ -210,13 +211,15 @@ public: ELFLinkGraphBuilder_i386(StringRef FileName, const object::ELFFile &Obj, + std::shared_ptr SSP, Triple TT, SubtargetFeatures Features) - : ELFLinkGraphBuilder(Obj, std::move(TT), std::move(Features), + : ELFLinkGraphBuilder(Obj, SSP, std::move(TT), std::move(Features), FileName, i386::getEdgeKindName) {} }; Expected> -createLinkGraphFromELFObject_i386(MemoryBufferRef ObjectBuffer) { +createLinkGraphFromELFObject_i386(MemoryBufferRef ObjectBuffer, + std::shared_ptr SSP) { LLVM_DEBUG({ dbgs() << "Building jitlink graph for new input " << ObjectBuffer.getBufferIdentifier() << "...\n"; @@ -234,8 +237,9 @@ "Only i386 (little endian) is supported for now"); auto &ELFObjFile = cast>(**ELFObj); + return ELFLinkGraphBuilder_i386( - (*ELFObj)->getFileName(), ELFObjFile.getELFFile(), + (*ELFObj)->getFileName(), ELFObjFile.getELFFile(), SSP, (*ELFObj)->makeTriple(), std::move(*Features)) .buildGraph(); } diff --git a/llvm/lib/ExecutionEngine/JITLink/ELF_loongarch.cpp b/llvm/lib/ExecutionEngine/JITLink/ELF_loongarch.cpp --- a/llvm/lib/ExecutionEngine/JITLink/ELF_loongarch.cpp +++ b/llvm/lib/ExecutionEngine/JITLink/ELF_loongarch.cpp @@ -129,10 +129,12 @@ public: ELFLinkGraphBuilder_loongarch(StringRef FileName, - const object::ELFFile &Obj, Triple TT, - SubtargetFeatures Features) - : ELFLinkGraphBuilder(Obj, std::move(TT), std::move(Features), - FileName, loongarch::getEdgeKindName) {} + const object::ELFFile &Obj, + std::shared_ptr SSP, + Triple TT, SubtargetFeatures Features) + : ELFLinkGraphBuilder(Obj, std::move(SSP), std::move(TT), + std::move(Features), FileName, + loongarch::getEdgeKindName) {} }; Error buildTables_ELF_loongarch(LinkGraph &G) { @@ -149,8 +151,8 @@ namespace llvm { namespace jitlink { -Expected> -createLinkGraphFromELFObject_loongarch(MemoryBufferRef ObjectBuffer) { +Expected> createLinkGraphFromELFObject_loongarch( + MemoryBufferRef ObjectBuffer, std::shared_ptr SSP) { LLVM_DEBUG({ dbgs() << "Building jitlink graph for new input " << ObjectBuffer.getBufferIdentifier() << "...\n"; @@ -167,7 +169,7 @@ if ((*ELFObj)->getArch() == Triple::loongarch64) { auto &ELFObjFile = cast>(**ELFObj); return ELFLinkGraphBuilder_loongarch( - (*ELFObj)->getFileName(), ELFObjFile.getELFFile(), + (*ELFObj)->getFileName(), ELFObjFile.getELFFile(), SSP, (*ELFObj)->makeTriple(), std::move(*Features)) .buildGraph(); } @@ -176,7 +178,7 @@ "Invalid triple for LoongArch ELF object file"); auto &ELFObjFile = cast>(**ELFObj); return ELFLinkGraphBuilder_loongarch( - (*ELFObj)->getFileName(), ELFObjFile.getELFFile(), + (*ELFObj)->getFileName(), ELFObjFile.getELFFile(), SSP, (*ELFObj)->makeTriple(), std::move(*Features)) .buildGraph(); } diff --git a/llvm/lib/ExecutionEngine/JITLink/ELF_ppc64.cpp b/llvm/lib/ExecutionEngine/JITLink/ELF_ppc64.cpp --- a/llvm/lib/ExecutionEngine/JITLink/ELF_ppc64.cpp +++ b/llvm/lib/ExecutionEngine/JITLink/ELF_ppc64.cpp @@ -107,14 +107,14 @@ 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; } @@ -394,9 +394,10 @@ public: ELFLinkGraphBuilder_ppc64(StringRef FileName, - const object::ELFFile &Obj, Triple TT, - SubtargetFeatures Features) - : ELFLinkGraphBuilder(Obj, std::move(TT), std::move(Features), + const object::ELFFile &Obj, + std::shared_ptr SSP, + Triple TT, SubtargetFeatures Features) + : ELFLinkGraphBuilder(Obj, std::move(SSP), std::move(TT), std::move(Features), FileName, ppc64::getEdgeKindName) {} }; @@ -418,7 +419,7 @@ 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(); } @@ -428,7 +429,7 @@ "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; } @@ -464,7 +465,8 @@ template Expected> -createLinkGraphFromELFObject_ppc64(MemoryBufferRef ObjectBuffer) { +createLinkGraphFromELFObject_ppc64(MemoryBufferRef ObjectBuffer, + std::shared_ptr SSP) { LLVM_DEBUG({ dbgs() << "Building jitlink graph for new input " << ObjectBuffer.getBufferIdentifier() << "...\n"; @@ -482,6 +484,7 @@ auto &ELFObjFile = cast>(**ELFObj); return ELFLinkGraphBuilder_ppc64( (*ELFObj)->getFileName(), ELFObjFile.getELFFile(), + SSP, (*ELFObj)->makeTriple(), std::move(*Features)) .buildGraph(); } @@ -518,15 +521,17 @@ } Expected> -createLinkGraphFromELFObject_ppc64(MemoryBufferRef ObjectBuffer) { +createLinkGraphFromELFObject_ppc64(MemoryBufferRef ObjectBuffer, + std::shared_ptr SSP) { return createLinkGraphFromELFObject_ppc64( - std::move(ObjectBuffer)); + std::move(ObjectBuffer), SSP); } Expected> -createLinkGraphFromELFObject_ppc64le(MemoryBufferRef ObjectBuffer) { +createLinkGraphFromELFObject_ppc64le(MemoryBufferRef ObjectBuffer, + std::shared_ptr SSP) { return createLinkGraphFromELFObject_ppc64( - std::move(ObjectBuffer)); + std::move(ObjectBuffer), SSP); } /// jit-link the given object buffer, which must be a ELF ppc64 object file. diff --git a/llvm/lib/ExecutionEngine/JITLink/ELF_riscv.cpp b/llvm/lib/ExecutionEngine/JITLink/ELF_riscv.cpp --- a/llvm/lib/ExecutionEngine/JITLink/ELF_riscv.cpp +++ b/llvm/lib/ExecutionEngine/JITLink/ELF_riscv.cpp @@ -924,14 +924,16 @@ public: ELFLinkGraphBuilder_riscv(StringRef FileName, - const object::ELFFile &Obj, Triple TT, - SubtargetFeatures Features) - : ELFLinkGraphBuilder(Obj, std::move(TT), std::move(Features), + const object::ELFFile &Obj, + std::shared_ptr SSP, + Triple TT, SubtargetFeatures Features) + : ELFLinkGraphBuilder(Obj,SSP, std::move(TT), std::move(Features), FileName, riscv::getEdgeKindName) {} }; Expected> -createLinkGraphFromELFObject_riscv(MemoryBufferRef ObjectBuffer) { +createLinkGraphFromELFObject_riscv(MemoryBufferRef ObjectBuffer, + std::shared_ptr SSP) { LLVM_DEBUG({ dbgs() << "Building jitlink graph for new input " << ObjectBuffer.getBufferIdentifier() << "...\n"; @@ -949,7 +951,7 @@ auto &ELFObjFile = cast>(**ELFObj); return ELFLinkGraphBuilder_riscv( (*ELFObj)->getFileName(), ELFObjFile.getELFFile(), - (*ELFObj)->makeTriple(), std::move(*Features)) + SSP, (*ELFObj)->makeTriple(), std::move(*Features)) .buildGraph(); } else { assert((*ELFObj)->getArch() == Triple::riscv32 && @@ -957,7 +959,7 @@ auto &ELFObjFile = cast>(**ELFObj); return ELFLinkGraphBuilder_riscv( (*ELFObj)->getFileName(), ELFObjFile.getELFFile(), - (*ELFObj)->makeTriple(), std::move(*Features)) + SSP, (*ELFObj)->makeTriple(), std::move(*Features)) .buildGraph(); } } diff --git a/llvm/lib/ExecutionEngine/JITLink/ELF_x86_64.cpp b/llvm/lib/ExecutionEngine/JITLink/ELF_x86_64.cpp --- a/llvm/lib/ExecutionEngine/JITLink/ELF_x86_64.cpp +++ b/llvm/lib/ExecutionEngine/JITLink/ELF_x86_64.cpp @@ -226,9 +226,10 @@ public: ELFLinkGraphBuilder_x86_64(StringRef FileName, - const object::ELFFile &Obj, + std::shared_ptr SSP, + const object::ELFFile &Obj, SubtargetFeatures Features) - : ELFLinkGraphBuilder(Obj, Triple("x86_64-unknown-linux"), + : ELFLinkGraphBuilder(Obj, SSP, Triple("x86_64-unknown-linux"), std::move(Features), FileName, x86_64::getEdgeKindName) {} }; @@ -249,12 +250,12 @@ 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; @@ -280,7 +281,7 @@ // 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(); } @@ -302,7 +303,7 @@ // 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()); @@ -321,8 +322,8 @@ } }; -Expected> -createLinkGraphFromELFObject_x86_64(MemoryBufferRef ObjectBuffer) { +Expected> createLinkGraphFromELFObject_x86_64( + MemoryBufferRef ObjectBuffer, std::shared_ptr SSP) { LLVM_DEBUG({ dbgs() << "Building jitlink graph for new input " << ObjectBuffer.getBufferIdentifier() << "...\n"; @@ -338,7 +339,7 @@ auto &ELFObjFile = cast>(**ELFObj); return ELFLinkGraphBuilder_x86_64((*ELFObj)->getFileName(), - ELFObjFile.getELFFile(), + SSP, ELFObjFile.getELFFile(), std::move(*Features)) .buildGraph(); } @@ -348,7 +349,7 @@ 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()))) diff --git a/llvm/lib/ExecutionEngine/JITLink/JITLink.cpp b/llvm/lib/ExecutionEngine/JITLink/JITLink.cpp --- a/llvm/lib/ExecutionEngine/JITLink/JITLink.cpp +++ b/llvm/lib/ExecutionEngine/JITLink/JITLink.cpp @@ -125,7 +125,7 @@ << ", linkage: " << formatv("{0:6}", getLinkageName(Sym.getLinkage())) << ", scope: " << formatv("{0:8}", getScopeName(Sym.getScope())) << ", " << (Sym.isLive() ? "live" : "dead") << " - " - << (Sym.hasName() ? Sym.getName() : ""); + << (Sym.hasName() ? *Sym.getName() : ""); return OS; } @@ -137,7 +137,7 @@ auto &TargetSym = E.getTarget(); if (TargetSym.hasName()) - OS << TargetSym.getName(); + OS << *TargetSym.getName(); else { auto &TargetBlock = TargetSym.getBlock(); auto &TargetSec = TargetBlock.getSection(); @@ -167,6 +167,16 @@ 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) { @@ -315,7 +325,7 @@ 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()) << "+" @@ -385,7 +395,7 @@ 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()); @@ -402,7 +412,7 @@ BestSymbolForBlock = Sym; if (BestSymbolForBlock) - ErrStream << BestSymbolForBlock->getName() << ", "; + ErrStream << *BestSymbolForBlock->getName() << ", "; else ErrStream << " @ "; @@ -454,15 +464,16 @@ } Expected> -createLinkGraphFromObject(MemoryBufferRef ObjectBuffer) { +createLinkGraphFromObject(MemoryBufferRef ObjectBuffer, + std::shared_ptr 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("Unsupported file format"); }; diff --git a/llvm/lib/ExecutionEngine/JITLink/JITLinkGeneric.cpp b/llvm/lib/ExecutionEngine/JITLink/JITLinkGeneric.cpp --- a/llvm/lib/ExecutionEngine/JITLink/JITLinkGeneric.cpp +++ b/llvm/lib/ExecutionEngine/JITLink/JITLinkGeneric.cpp @@ -200,8 +200,7 @@ 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; @@ -231,7 +230,7 @@ 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: diff --git a/llvm/lib/ExecutionEngine/JITLink/JITLinkMemoryManager.cpp b/llvm/lib/ExecutionEngine/JITLink/JITLinkMemoryManager.cpp --- a/llvm/lib/ExecutionEngine/JITLink/JITLinkMemoryManager.cpp +++ b/llvm/lib/ExecutionEngine/JITLink/JITLinkMemoryManager.cpp @@ -155,7 +155,7 @@ "__---.finalize", "__R--.finalize", "__-W-.finalize", "__RW-.finalize", "__--X.finalize", "__R-X.finalize", "__-WX.finalize", "__RWX.finalize"}; - auto G = std::make_unique("", Triple(), 0, + auto G = std::make_unique("", std::shared_ptr(), Triple(), 0, llvm::endianness::native, nullptr); orc::AllocGroupSmallMap ContentBlocks; diff --git a/llvm/lib/ExecutionEngine/JITLink/MachO.cpp b/llvm/lib/ExecutionEngine/JITLink/MachO.cpp --- a/llvm/lib/ExecutionEngine/JITLink/MachO.cpp +++ b/llvm/lib/ExecutionEngine/JITLink/MachO.cpp @@ -27,7 +27,8 @@ namespace jitlink { Expected> -createLinkGraphFromMachOObject(MemoryBufferRef ObjectBuffer) { +createLinkGraphFromMachOObject(MemoryBufferRef ObjectBuffer, + std::shared_ptr SSP) { StringRef Data = ObjectBuffer.getBuffer(); if (Data.size() < 4) return make_error("Truncated MachO buffer \"" + @@ -63,9 +64,9 @@ 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("MachO-64 CPU type not valid"); } else diff --git a/llvm/lib/ExecutionEngine/JITLink/MachOLinkGraphBuilder.h b/llvm/lib/ExecutionEngine/JITLink/MachOLinkGraphBuilder.h --- a/llvm/lib/ExecutionEngine/JITLink/MachOLinkGraphBuilder.h +++ b/llvm/lib/ExecutionEngine/JITLink/MachOLinkGraphBuilder.h @@ -35,8 +35,6 @@ struct NormalizedSymbol { friend class MachOLinkGraphBuilder; - - private: NormalizedSymbol(std::optional Name, uint64_t Value, uint8_t Type, uint8_t Sect, uint16_t Desc, Linkage L, Scope S) @@ -45,6 +43,7 @@ assert((!Name || !Name->empty()) && "Name must be none or non-empty"); } + private: public: NormalizedSymbol(const NormalizedSymbol &) = delete; NormalizedSymbol &operator=(const NormalizedSymbol &) = delete; @@ -83,10 +82,10 @@ using SectionParserFunction = std::function; - MachOLinkGraphBuilder(const object::MachOObjectFile &Obj, Triple TT, + MachOLinkGraphBuilder(const object::MachOObjectFile &Obj, + std::shared_ptr SSP, Triple TT, SubtargetFeatures Features, LinkGraph::GetEdgeKindNameFunction GetEdgeKindName); - LinkGraph &getGraph() const { return *G; } const object::MachOObjectFile &getObject() const { return Obj; } diff --git a/llvm/lib/ExecutionEngine/JITLink/MachOLinkGraphBuilder.cpp b/llvm/lib/ExecutionEngine/JITLink/MachOLinkGraphBuilder.cpp --- a/llvm/lib/ExecutionEngine/JITLink/MachOLinkGraphBuilder.cpp +++ b/llvm/lib/ExecutionEngine/JITLink/MachOLinkGraphBuilder.cpp @@ -47,13 +47,17 @@ } MachOLinkGraphBuilder::MachOLinkGraphBuilder( - const object::MachOObjectFile &Obj, Triple TT, SubtargetFeatures Features, + const object::MachOObjectFile &Obj, + std::shared_ptr SSP, + Triple TT, SubtargetFeatures Features, LinkGraph::GetEdgeKindNameFunction GetEdgeKindName) : Obj(Obj), G(std::make_unique(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; } @@ -317,9 +321,8 @@ } } - 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(); @@ -585,7 +588,7 @@ if (!NSym.Name) dbgs() << ""; else - dbgs() << NSym.Name; + dbgs() << *NSym.Name; if (IsText) dbgs() << " [text]"; if (IsNoDeadStrip) @@ -724,7 +727,7 @@ LLVM_DEBUG({ dbgs() << " Adding symbol for c-string block " << B.getRange() << ": " - << (Sym.hasName() ? Sym.getName() : "") + << (Sym.hasName() ? *Sym.getName() : "") << " at offset " << formatv("{0:x}", Sym.getOffset()) << "\n"; }); @@ -822,7 +825,7 @@ 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"; @@ -832,7 +835,7 @@ return make_error( "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); diff --git a/llvm/lib/ExecutionEngine/JITLink/MachO_arm64.cpp b/llvm/lib/ExecutionEngine/JITLink/MachO_arm64.cpp --- a/llvm/lib/ExecutionEngine/JITLink/MachO_arm64.cpp +++ b/llvm/lib/ExecutionEngine/JITLink/MachO_arm64.cpp @@ -21,13 +21,15 @@ using namespace llvm; using namespace llvm::jitlink; -namespace { +namespace { class MachOLinkGraphBuilder_arm64 : public MachOLinkGraphBuilder { public: MachOLinkGraphBuilder_arm64(const object::MachOObjectFile &Obj, + std::shared_ptr 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) {} @@ -537,8 +539,8 @@ uint64_t NullValue = 0; }; -Expected> -createLinkGraphFromMachOObject_arm64(MemoryBufferRef ObjectBuffer) { +Expected> createLinkGraphFromMachOObject_arm64( + MemoryBufferRef ObjectBuffer, std::shared_ptr SSP) { auto MachOObj = object::ObjectFile::createMachOObjectFile(ObjectBuffer); if (!MachOObj) return MachOObj.takeError(); @@ -547,7 +549,7 @@ if (!Features) return Features.takeError(); - return MachOLinkGraphBuilder_arm64(**MachOObj, std::move(*Features)) + return MachOLinkGraphBuilder_arm64(**MachOObj, SSP, std::move(*Features)) .buildGraph(); } @@ -567,7 +569,7 @@ 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()); diff --git a/llvm/lib/ExecutionEngine/JITLink/MachO_x86_64.cpp b/llvm/lib/ExecutionEngine/JITLink/MachO_x86_64.cpp --- a/llvm/lib/ExecutionEngine/JITLink/MachO_x86_64.cpp +++ b/llvm/lib/ExecutionEngine/JITLink/MachO_x86_64.cpp @@ -26,8 +26,9 @@ class MachOLinkGraphBuilder_x86_64 : public MachOLinkGraphBuilder { public: MachOLinkGraphBuilder_x86_64(const object::MachOObjectFile &Obj, + std::shared_ptr 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: @@ -462,8 +463,8 @@ } }; -Expected> -createLinkGraphFromMachOObject_x86_64(MemoryBufferRef ObjectBuffer) { +Expected> createLinkGraphFromMachOObject_x86_64( + MemoryBufferRef ObjectBuffer, std::shared_ptr SSP) { auto MachOObj = object::ObjectFile::createMachOObjectFile(ObjectBuffer); if (!MachOObj) return MachOObj.takeError(); @@ -472,7 +473,7 @@ if (!Features) return Features.takeError(); - return MachOLinkGraphBuilder_x86_64(**MachOObj, std::move(*Features)) + return MachOLinkGraphBuilder_x86_64(**MachOObj, SSP, std::move(*Features)) .buildGraph(); } diff --git a/llvm/lib/ExecutionEngine/JITLink/PerGraphGOTAndPLTStubsBuilder.h b/llvm/lib/ExecutionEngine/JITLink/PerGraphGOTAndPLTStubsBuilder.h --- a/llvm/lib/ExecutionEngine/JITLink/PerGraphGOTAndPLTStubsBuilder.h +++ b/llvm/lib/ExecutionEngine/JITLink/PerGraphGOTAndPLTStubsBuilder.h @@ -76,7 +76,7 @@ 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 = @@ -97,7 +97,7 @@ 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 = @@ -114,8 +114,8 @@ private: BuilderImplT &impl() { return static_cast(*this); } - DenseMap GOTEntries; - DenseMap PLTStubs; + DenseMap GOTEntries; + DenseMap PLTStubs; }; } // end namespace jitlink diff --git a/llvm/lib/ExecutionEngine/Orc/COFFPlatform.cpp b/llvm/lib/ExecutionEngine/Orc/COFFPlatform.cpp --- a/llvm/lib/ExecutionEngine/Orc/COFFPlatform.cpp +++ b/llvm/lib/ExecutionEngine/Orc/COFFPlatform.cpp @@ -67,8 +67,8 @@ } auto G = std::make_unique( - "", TT, PointerSize, Endianness, - jitlink::getGenericEdgeKindName); + "", CP.getExecutionSession().getSymbolStringPool(), TT, + PointerSize, Endianness, jitlink::getGenericEdgeKindName); auto &HeaderSection = G->createSection("__header", MemProt::Read); auto &HeaderBlock = createHeaderBlock(*G, HeaderSection); @@ -804,7 +804,7 @@ 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"); diff --git a/llvm/lib/ExecutionEngine/Orc/Debugging/DebuggerSupportPlugin.cpp b/llvm/lib/ExecutionEngine/Orc/Debugging/DebuggerSupportPlugin.cpp --- a/llvm/lib/ExecutionEngine/Orc/Debugging/DebuggerSupportPlugin.cpp +++ b/llvm/lib/ExecutionEngine/Orc/Debugging/DebuggerSupportPlugin.cpp @@ -215,8 +215,8 @@ 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); } } diff --git a/llvm/lib/ExecutionEngine/Orc/Debugging/PerfSupportPlugin.cpp b/llvm/lib/ExecutionEngine/Orc/Debugging/PerfSupportPlugin.cpp --- a/llvm/lib/ExecutionEngine/Orc/Debugging/PerfSupportPlugin.cpp +++ b/llvm/lib/ExecutionEngine/Orc/Debugging/PerfSupportPlugin.cpp @@ -87,7 +87,7 @@ static PerfJITCodeLoadRecord getCodeLoadRecord(const Symbol &Sym, std::atomic &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; @@ -118,7 +118,7 @@ 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"); diff --git a/llvm/lib/ExecutionEngine/Orc/ELFNixPlatform.cpp b/llvm/lib/ExecutionEngine/Orc/ELFNixPlatform.cpp --- a/llvm/lib/ExecutionEngine/Orc/ELFNixPlatform.cpp +++ b/llvm/lib/ExecutionEngine/Orc/ELFNixPlatform.cpp @@ -71,8 +71,8 @@ // void *__dso_handle = &__dso_handle; auto G = std::make_unique( - "", TT, PointerSize, Endianness, - jitlink::getGenericEdgeKindName); + "", ENP.getExecutionSession().getSymbolStringPool(), TT, + PointerSize, Endianness, jitlink::getGenericEdgeKindName); auto &DSOHandleSection = G->createSection(".data.__dso_handle", MemProt::Read); auto &DSOHandleBlock = G->createContentBlock( @@ -652,7 +652,7 @@ 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"); { @@ -797,12 +797,17 @@ 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)); } } diff --git a/llvm/lib/ExecutionEngine/Orc/ExecutionUtils.cpp b/llvm/lib/ExecutionEngine/Orc/ExecutionUtils.cpp --- a/llvm/lib/ExecutionEngine/Orc/ExecutionUtils.cpp +++ b/llvm/lib/ExecutionEngine/Orc/ExecutionUtils.cpp @@ -10,6 +10,7 @@ #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" @@ -561,8 +562,8 @@ return Endianness.takeError(); auto G = std::make_unique( - "", TT, *PointerSize, *Endianness, - jitlink::getGenericEdgeKindName); + "", ES.getSymbolStringPool(), TT, *PointerSize, + *Endianness, jitlink::getGenericEdgeKindName); jitlink::Section &Sec = G->createSection(getSectionName(), MemProt::Read | MemProt::Exec); @@ -574,9 +575,8 @@ // 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); diff --git a/llvm/lib/ExecutionEngine/Orc/IndirectionUtils.cpp b/llvm/lib/ExecutionEngine/Orc/IndirectionUtils.cpp --- a/llvm/lib/ExecutionEngine/Orc/IndirectionUtils.cpp +++ b/llvm/lib/ExecutionEngine/Orc/IndirectionUtils.cpp @@ -368,7 +368,7 @@ 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 ExistingRelocations; for (auto &E : B.edges()) { diff --git a/llvm/lib/ExecutionEngine/Orc/MachOPlatform.cpp b/llvm/lib/ExecutionEngine/Orc/MachOPlatform.cpp --- a/llvm/lib/ExecutionEngine/Orc/MachOPlatform.cpp +++ b/llvm/lib/ExecutionEngine/Orc/MachOPlatform.cpp @@ -77,9 +77,9 @@ llvm_unreachable("Unrecognized architecture"); } - return std::make_unique(std::move(Name), TT, PointerSize, - Endianness, - jitlink::getGenericEdgeKindName); + return std::make_unique( + std::move(Name), MOP.getExecutionSession().getSymbolStringPool(), TT, + PointerSize, Endianness, jitlink::getGenericEdgeKindName); } // Generates a MachO header. @@ -839,14 +839,14 @@ 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( "Duplicate " + RTSym.first + " detected during MachOPlatform bootstrap", inconvertibleErrorCode()); - if (Sym->getName() == *MP.MachOHeaderStartSymbol) + if (Sym->getName() == MP.MachOHeaderStartSymbol) RegisterMachOHeader = true; *RTSym.second = Sym->getAddress(); @@ -882,7 +882,7 @@ 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"); @@ -1055,11 +1055,13 @@ 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; } @@ -1389,19 +1391,19 @@ // 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; } diff --git a/llvm/lib/ExecutionEngine/Orc/ObjectFileInterface.cpp b/llvm/lib/ExecutionEngine/Orc/ObjectFileInterface.cpp --- a/llvm/lib/ExecutionEngine/Orc/ObjectFileInterface.cpp +++ b/llvm/lib/ExecutionEngine/Orc/ObjectFileInterface.cpp @@ -133,7 +133,7 @@ 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; diff --git a/llvm/lib/ExecutionEngine/Orc/ObjectLinkingLayer.cpp b/llvm/lib/ExecutionEngine/Orc/ObjectLinkingLayer.cpp --- a/llvm/lib/ExecutionEngine/Orc/ObjectLinkingLayer.cpp +++ b/llvm/lib/ExecutionEngine/Orc/ObjectLinkingLayer.cpp @@ -99,8 +99,7 @@ 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)) @@ -123,7 +122,7 @@ 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); @@ -195,7 +194,7 @@ 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. @@ -206,7 +205,7 @@ else { AsyncLookupResult LR; for (auto &KV : *Result) - LR[*KV.first] = KV.second; + LR[KV.first] = KV.second; LookupContinuation->run(std::move(LR)); } }; @@ -225,7 +224,6 @@ } Error notifyResolved(LinkGraph &G) override { - auto &ES = Layer.getExecutionSession(); SymbolFlagsMap ExtraSymbolsToClaim; bool AutoClaim = Layer.AutoClaimObjectSymbols; @@ -233,27 +231,25 @@ 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; } } @@ -362,7 +358,7 @@ public: BlockDependenciesMap(ExecutionSession &ES, DenseMap> BlockDeps) - : ES(ES), BlockDeps(std::move(BlockDeps)) {} + : BlockDeps(std::move(BlockDeps)) {} const BlockSymbolDependencies &operator[](const Block &B) { // Check the cache first. @@ -393,7 +389,7 @@ 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; } @@ -420,7 +416,6 @@ .first->second; } - ExecutionSession &ES; DenseMap> BlockDeps; DenseMap NameCache; DenseMap BlockImmediateDepsCache; @@ -428,19 +423,16 @@ }; Error claimOrExternalizeWeakAndCommonSymbols(LinkGraph &G) { - auto &ES = Layer.getExecutionSession(); - SymbolFlagsMap NewSymbolsToClaim; std::vector> 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)); } } }; @@ -469,15 +461,13 @@ } 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. @@ -493,7 +483,7 @@ 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()) @@ -668,7 +658,7 @@ auto Ctx = std::make_unique( *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 { diff --git a/llvm/tools/llvm-jitlink/llvm-jitlink-coff.cpp b/llvm/tools/llvm-jitlink/llvm-jitlink-coff.cpp --- a/llvm/tools/llvm-jitlink/llvm-jitlink-coff.cpp +++ b/llvm/tools/llvm-jitlink/llvm-jitlink-coff.cpp @@ -117,7 +117,7 @@ // 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 @@ -130,9 +130,9 @@ inconvertibleErrorCode()); if (auto TS = getCOFFStubTarget(G, Sym->getBlock())) - FileInfo.StubInfos[TS->getName()] = {Sym->getSymbolContent(), - Sym->getAddress().getValue(), - Sym->getTargetFlags()}; + FileInfo.StubInfos[*TS->getName()] = {Sym->getSymbolContent(), + Sym->getAddress().getValue(), + Sym->getTargetFlags()}; else return TS.takeError(); SectionContainsContent = true; @@ -140,13 +140,13 @@ if (Sym->hasName()) { if (Sym->isSymbolZeroFill()) { - S.SymbolInfos[Sym->getName()] = {Sym->getSize(), - Sym->getAddress().getValue()}; + S.SymbolInfos[*Sym->getName()] = {Sym->getSize(), + Sym->getAddress().getValue()}; SectionContainsZeroFill = true; } else { - S.SymbolInfos[Sym->getName()] = {Sym->getSymbolContent(), - Sym->getAddress().getValue(), - Sym->getTargetFlags()}; + S.SymbolInfos[*Sym->getName()] = {Sym->getSymbolContent(), + Sym->getAddress().getValue(), + Sym->getTargetFlags()}; SectionContainsContent = true; } } diff --git a/llvm/tools/llvm-jitlink/llvm-jitlink-elf.cpp b/llvm/tools/llvm-jitlink/llvm-jitlink-elf.cpp --- a/llvm/tools/llvm-jitlink/llvm-jitlink-elf.cpp +++ b/llvm/tools/llvm-jitlink/llvm-jitlink-elf.cpp @@ -119,7 +119,7 @@ // 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 @@ -132,9 +132,9 @@ inconvertibleErrorCode()); if (auto TS = getELFStubTarget(G, Sym->getBlock())) - FileInfo.StubInfos[TS->getName()] = {Sym->getSymbolContent(), - Sym->getAddress().getValue(), - Sym->getTargetFlags()}; + FileInfo.StubInfos[*TS->getName()] = {Sym->getSymbolContent(), + Sym->getAddress().getValue(), + Sym->getTargetFlags()}; else return TS.takeError(); SectionContainsContent = true; @@ -142,13 +142,13 @@ if (Sym->hasName()) { if (Sym->isSymbolZeroFill()) { - S.SymbolInfos[Sym->getName()] = {Sym->getSize(), - Sym->getAddress().getValue()}; + S.SymbolInfos[*Sym->getName()] = {Sym->getSize(), + Sym->getAddress().getValue()}; SectionContainsZeroFill = true; } else { - S.SymbolInfos[Sym->getName()] = {Sym->getSymbolContent(), - Sym->getAddress().getValue(), - Sym->getTargetFlags()}; + S.SymbolInfos[*Sym->getName()] = {Sym->getSymbolContent(), + Sym->getAddress().getValue(), + Sym->getTargetFlags()}; SectionContainsContent = true; } } @@ -156,8 +156,8 @@ // Add symbol info for absolute symbols. for (auto *Sym : G.absolute_symbols()) - S.SymbolInfos[Sym->getName()] = {Sym->getSize(), - Sym->getAddress().getValue()}; + S.SymbolInfos[*Sym->getName()] = {Sym->getSize(), + Sym->getAddress().getValue()}; auto SecAddr = FirstSym->getAddress(); auto SecSize = diff --git a/llvm/tools/llvm-jitlink/llvm-jitlink-macho.cpp b/llvm/tools/llvm-jitlink/llvm-jitlink-macho.cpp --- a/llvm/tools/llvm-jitlink/llvm-jitlink-macho.cpp +++ b/llvm/tools/llvm-jitlink/llvm-jitlink-macho.cpp @@ -117,9 +117,9 @@ 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(), + Sym->getTargetFlags()}; else return TS.takeError(); SectionContainsContent = true; @@ -129,21 +129,21 @@ inconvertibleErrorCode()); if (auto TS = getMachOStubTarget(G, Sym->getBlock())) - FileInfo.StubInfos[TS->getName()] = {Sym->getSymbolContent(), - Sym->getAddress().getValue(), - Sym->getTargetFlags()}; + 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(), - Sym->getAddress().getValue()}; + S.SymbolInfos[*Sym->getName()] = {Sym->getSize(), + Sym->getAddress().getValue()}; SectionContainsZeroFill = true; } else { - S.SymbolInfos[Sym->getName()] = {Sym->getSymbolContent(), - Sym->getAddress().getValue(), - Sym->getTargetFlags()}; + S.SymbolInfos[*Sym->getName()] = {Sym->getSymbolContent(), + Sym->getAddress().getValue(), + Sym->getTargetFlags()}; SectionContainsContent = true; } } diff --git a/llvm/tools/llvm-jitlink/llvm-jitlink.cpp b/llvm/tools/llvm-jitlink/llvm-jitlink.cpp --- a/llvm/tools/llvm-jitlink/llvm-jitlink.cpp +++ b/llvm/tools/llvm-jitlink/llvm-jitlink.cpp @@ -362,29 +362,29 @@ 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); } } diff --git a/llvm/unittests/ExecutionEngine/JITLink/EHFrameSupportTests.cpp b/llvm/unittests/ExecutionEngine/JITLink/EHFrameSupportTests.cpp --- a/llvm/unittests/ExecutionEngine/JITLink/EHFrameSupportTests.cpp +++ b/llvm/unittests/ExecutionEngine/JITLink/EHFrameSupportTests.cpp @@ -172,7 +172,8 @@ // (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())); cantFail(createEHFrameSplitterPass_MachO_arm64()(*G)); cantFail(createEHFrameEdgeFixerPass_MachO_arm64()(*G)); @@ -210,7 +211,7 @@ 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 @@ -231,11 +232,12 @@ 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())); // 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; } diff --git a/llvm/unittests/ExecutionEngine/JITLink/JITLinkMocks.cpp b/llvm/unittests/ExecutionEngine/JITLink/JITLinkMocks.cpp --- a/llvm/unittests/ExecutionEngine/JITLink/JITLinkMocks.cpp +++ b/llvm/unittests/ExecutionEngine/JITLink/JITLinkMocks.cpp @@ -51,9 +51,10 @@ TEST(JITLinkMocks, SmokeTest) { // Check that the testing infrastructure defaults can "link" a graph // successfully. - auto G = std::make_unique("foo", Triple("x86_64-apple-darwin"), 8, - llvm::endianness::little, - getGenericEdgeKindName); + auto G = std::make_unique( + "foo", std::make_shared(), + Triple("x86_64-apple-darwin"), 8, llvm::endianness::little, + getGenericEdgeKindName); ArrayRef Content = "hello, world!"; auto &Sec = diff --git a/llvm/unittests/ExecutionEngine/JITLink/LinkGraphTests.cpp b/llvm/unittests/ExecutionEngine/JITLink/LinkGraphTests.cpp --- a/llvm/unittests/ExecutionEngine/JITLink/LinkGraphTests.cpp +++ b/llvm/unittests/ExecutionEngine/JITLink/LinkGraphTests.cpp @@ -9,6 +9,7 @@ #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" @@ -61,7 +62,10 @@ 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(), + Triple("x86_64-apple-darwin"), 8, + llvm::endianness::little, getGenericEdgeKindName); EXPECT_EQ(G.getName(), "foo"); EXPECT_EQ(G.getTargetTriple().str(), "x86_64-apple-darwin"); @@ -75,7 +79,9 @@ 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(), + Triple("x86_64-apple-darwin"), 8, + llvm::endianness::little, getGenericEdgeKindName); auto &Sec1 = @@ -94,8 +100,10 @@ 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(), + Triple("x86_64-apple-darwin"), 8, llvm::endianness::little, + getGenericEdgeKindName); auto &Sec1 = G.createSection("__data.1", orc::MemProt::Read | orc::MemProt::Write); auto &B = @@ -112,7 +120,9 @@ 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(), + Triple("x86_64-apple-darwin"), 8, + llvm::endianness::little, getGenericEdgeKindName); auto &Sec1 = G.createSection("__data.1", orc::MemProt::Read | orc::MemProt::Write); @@ -165,7 +175,9 @@ 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(), + Triple("x86_64-apple-darwin"), 8, + llvm::endianness::little, getGenericEdgeKindName); auto &Sec = G.createSection("__data", orc::MemProt::Read | orc::MemProt::Write); @@ -254,7 +266,9 @@ 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(), + Triple("x86_64-apple-darwin"), 8, + llvm::endianness::little, getGenericEdgeKindName); auto &Sec = G.createSection("__data", orc::MemProt::Read | orc::MemProt::Write); @@ -324,7 +338,9 @@ 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(), + Triple("x86_64-apple-darwin"), 8, + llvm::endianness::little, getGenericEdgeKindName); auto &Sec = G.createSection("__data", orc::MemProt::Read | orc::MemProt::Write); @@ -393,7 +409,9 @@ 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(), + Triple("x86_64-apple-darwin"), 8, + llvm::endianness::little, getGenericEdgeKindName); auto &Sec = G.createSection("__data", orc::MemProt::Read | orc::MemProt::Write); @@ -441,7 +459,9 @@ 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(), + Triple("x86_64-apple-darwin"), 8, + llvm::endianness::little, getGenericEdgeKindName); auto &Sec = G.createSection("__data", orc::MemProt::Read | orc::MemProt::Write); @@ -476,7 +496,9 @@ 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(), + Triple("x86_64-apple-darwin"), 8, + llvm::endianness::little, getGenericEdgeKindName); auto &Sec1 = G.createSection("__data.1", orc::MemProt::Read | orc::MemProt::Write); @@ -510,7 +532,9 @@ 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(), + Triple("x86_64-apple-darwin"), 8, + llvm::endianness::little, getGenericEdgeKindName); auto &Sec1 = G.createSection("__data.1", orc::MemProt::Read | orc::MemProt::Write); @@ -558,7 +582,9 @@ 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(), + Triple("x86_64-apple-darwin"), 8, + llvm::endianness::little, getGenericEdgeKindName); auto &Sec1 = G.createSection("__data.1", orc::MemProt::Read | orc::MemProt::Write); @@ -644,7 +670,9 @@ 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(), + Triple("x86_64-apple-darwin"), 8, + llvm::endianness::little, getGenericEdgeKindName); auto &Sec = G.createSection("__data", orc::MemProt::Read | orc::MemProt::Write); @@ -740,7 +768,9 @@ } TEST(LinkGraphTest, GraphAllocationMethods) { - LinkGraph G("foo", Triple("x86_64-apple-darwin"), 8, llvm::endianness::little, + LinkGraph G("foo", std::make_shared(), + Triple("x86_64-apple-darwin"), 8, + llvm::endianness::little, getGenericEdgeKindName); // Test allocation of sized, uninitialized buffer. @@ -761,7 +791,9 @@ 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(), + Triple("x86_64-apple-darwin"), 8, + llvm::endianness::little, getGenericEdgeKindName); auto &Sec = G.createSection("__data", orc::MemProt::Read | orc::MemProt::Write); @@ -785,8 +817,9 @@ } 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(), + Triple("x86_64-apple-darwin"), 8, + llvm::endianness::little, getGenericEdgeKindName); // Create a regular section and block. diff --git a/llvm/unittests/ExecutionEngine/JITLink/MemoryManagerErrorTests.cpp b/llvm/unittests/ExecutionEngine/JITLink/MemoryManagerErrorTests.cpp --- a/llvm/unittests/ExecutionEngine/JITLink/MemoryManagerErrorTests.cpp +++ b/llvm/unittests/ExecutionEngine/JITLink/MemoryManagerErrorTests.cpp @@ -18,9 +18,10 @@ TEST(MemoryManagerErrorTest, ErrorOnFirstAllocate) { // Check that we can get addresses for blocks, symbols, and edges. - auto G = std::make_unique("foo", Triple("x86_64-apple-darwin"), 8, - llvm::endianness::little, - getGenericEdgeKindName); + auto G = std::make_unique( + "foo", std::make_shared(), + Triple("x86_64-apple-darwin"), 8, llvm::endianness::little, + getGenericEdgeKindName); ArrayRef Content = "hello, world!"; auto &Sec = diff --git a/llvm/unittests/ExecutionEngine/JITLink/StubsTests.cpp b/llvm/unittests/ExecutionEngine/JITLink/StubsTests.cpp --- a/llvm/unittests/ExecutionEngine/JITLink/StubsTests.cpp +++ b/llvm/unittests/ExecutionEngine/JITLink/StubsTests.cpp @@ -60,7 +60,8 @@ TEST(StubsTest, StubsGeneration_x86_64) { const char PointerJumpStubContent[6] = { static_cast(0xFFu), 0x25, 0x00, 0x00, 0x00, 0x00}; - LinkGraph G("foo", Triple("x86_64-apple-darwin"), 8, llvm::endianness::little, + LinkGraph G("foo", std::make_shared(), + Triple("x86_64-apple-darwin"), 8, llvm::endianness::little, getGenericEdgeKindName); auto [PointerSym, StubSym] = GenerateStub(G, 8U, x86_64::Pointer64); @@ -80,7 +81,8 @@ 0x10, 0x02, 0x40, (char)0xf9u, // LDR x16, [x16, @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(), + Triple("aarch64-linux-gnu"), 8, llvm::endianness::little, getGenericEdgeKindName); auto [PointerSym, StubSym] = GenerateStub(G, 8U, aarch64::Pointer64); @@ -100,8 +102,9 @@ TEST(StubsTest, StubsGeneration_i386) { const char PointerJumpStubContent[6] = { static_cast(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(), + 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(), @@ -129,7 +132,8 @@ 0x00, 0x4c // jr $t8 }; - LinkGraph G("foo", Triple("loongarch32"), 4, llvm::endianness::little, + LinkGraph G("foo", std::make_shared(), + Triple("loongarch32"), 4, llvm::endianness::little, getGenericEdgeKindName); auto [PointerSym, StubSym] = GenerateStub(G, 4U, loongarch::Pointer32); @@ -161,7 +165,8 @@ 0x00, 0x4c // jr $t8 }; - LinkGraph G("foo", Triple("loongarch64"), 8, llvm::endianness::little, + LinkGraph G("foo", std::make_shared(), + Triple("loongarch64"), 8, llvm::endianness::little, getGenericEdgeKindName); auto [PointerSym, StubSym] = GenerateStub(G, 8U, loongarch::Pointer64); diff --git a/llvm/unittests/ExecutionEngine/Orc/ObjectLinkingLayerTest.cpp b/llvm/unittests/ExecutionEngine/Orc/ObjectLinkingLayerTest.cpp --- a/llvm/unittests/ExecutionEngine/Orc/ObjectLinkingLayerTest.cpp +++ b/llvm/unittests/ExecutionEngine/Orc/ObjectLinkingLayerTest.cpp @@ -39,9 +39,10 @@ }; TEST_F(ObjectLinkingLayerTest, AddLinkGraph) { - auto G = std::make_unique("foo", Triple("x86_64-apple-darwin"), 8, - llvm::endianness::little, - x86_64::getEdgeKindName); + auto G = std::make_unique( + "foo", std::make_shared(), + Triple("x86_64-apple-darwin"), 8, llvm::endianness::little, + x86_64::getEdgeKindName); auto &Sec1 = G->createSection("__data", MemProt::Read | MemProt::Write); auto &B1 = G->createContentBlock(Sec1, BlockContent, @@ -104,9 +105,10 @@ ObjLinkingLayer.addPlugin(std::make_unique()); - auto G = std::make_unique("foo", Triple("x86_64-apple-darwin"), 8, - llvm::endianness::little, - x86_64::getEdgeKindName); + auto G = std::make_unique( + "foo", std::make_shared(), + 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, @@ -158,9 +160,10 @@ ObjLinkingLayer.addPlugin(std::make_unique()); - auto G = std::make_unique("foo", Triple("x86_64-apple-darwin"), 8, - llvm::endianness::little, - x86_64::getEdgeKindName); + auto G = std::make_unique( + "foo", std::make_shared(), + 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,