diff --git a/llvm/examples/Kaleidoscope/BuildingAJIT/Chapter4/KaleidoscopeJIT.h b/llvm/examples/Kaleidoscope/BuildingAJIT/Chapter4/KaleidoscopeJIT.h index 863304b02113ec..972b8be3236671 100644 --- a/llvm/examples/Kaleidoscope/BuildingAJIT/Chapter4/KaleidoscopeJIT.h +++ b/llvm/examples/Kaleidoscope/BuildingAJIT/Chapter4/KaleidoscopeJIT.h @@ -102,12 +102,12 @@ class KaleidoscopeASTLayer { BaseLayer.emit(std::move(MR), irgenAndTakeOwnership(*F, "")); } - SymbolFlagsMap getInterface(FunctionAST &F) { + MaterializationUnit::Interface getInterface(FunctionAST &F) { MangleAndInterner Mangle(BaseLayer.getExecutionSession(), DL); SymbolFlagsMap Symbols; Symbols[Mangle(F.getName())] = JITSymbolFlags(JITSymbolFlags::Exported | JITSymbolFlags::Callable); - return Symbols; + return MaterializationUnit::Interface(std::move(Symbols), nullptr); } private: @@ -117,7 +117,7 @@ class KaleidoscopeASTLayer { KaleidoscopeASTMaterializationUnit::KaleidoscopeASTMaterializationUnit( KaleidoscopeASTLayer &L, std::unique_ptr F) - : MaterializationUnit(L.getInterface(*F), nullptr), L(L), F(std::move(F)) {} + : MaterializationUnit(L.getInterface(*F)), L(L), F(std::move(F)) {} void KaleidoscopeASTMaterializationUnit::materialize( std::unique_ptr R) { diff --git a/llvm/include/llvm/ExecutionEngine/Orc/Core.h b/llvm/include/llvm/ExecutionEngine/Orc/Core.h index 2180be3341e1cf..b5f5636800df23 100644 --- a/llvm/include/llvm/ExecutionEngine/Orc/Core.h +++ b/llvm/include/llvm/ExecutionEngine/Orc/Core.h @@ -670,14 +670,22 @@ class MaterializationUnit { public: static char ID; - MaterializationUnit(SymbolFlagsMap InitalSymbolFlags, - SymbolStringPtr InitSymbol) - : SymbolFlags(std::move(InitalSymbolFlags)), - InitSymbol(std::move(InitSymbol)) { - assert((!this->InitSymbol || this->SymbolFlags.count(this->InitSymbol)) && - "If set, InitSymbol should appear in InitialSymbolFlags map"); - } + struct Interface { + Interface() = default; + Interface(SymbolFlagsMap InitalSymbolFlags, SymbolStringPtr InitSymbol) + : SymbolFlags(std::move(InitalSymbolFlags)), + InitSymbol(std::move(InitSymbol)) { + assert((!this->InitSymbol || this->SymbolFlags.count(this->InitSymbol)) && + "If set, InitSymbol should appear in InitialSymbolFlags map"); + } + + SymbolFlagsMap SymbolFlags; + SymbolStringPtr InitSymbol; + }; + MaterializationUnit(Interface I) + : SymbolFlags(std::move(I.SymbolFlags)), + InitSymbol(std::move(I.InitSymbol)) {} virtual ~MaterializationUnit() {} /// Return the name of this materialization unit. Useful for debugging @@ -730,7 +738,7 @@ class AbsoluteSymbolsMaterializationUnit : public MaterializationUnit { private: void materialize(std::unique_ptr R) override; void discard(const JITDylib &JD, const SymbolStringPtr &Name) override; - static SymbolFlagsMap extractFlags(const SymbolMap &Symbols); + static MaterializationUnit::Interface extractFlags(const SymbolMap &Symbols); SymbolMap Symbols; }; @@ -772,7 +780,8 @@ class ReExportsMaterializationUnit : public MaterializationUnit { private: void materialize(std::unique_ptr R) override; void discard(const JITDylib &JD, const SymbolStringPtr &Name) override; - static SymbolFlagsMap extractFlags(const SymbolAliasMap &Aliases); + static MaterializationUnit::Interface + extractFlags(const SymbolAliasMap &Aliases); JITDylib *SourceJD = nullptr; JITDylibLookupFlags SourceJDLookupFlags; diff --git a/llvm/include/llvm/ExecutionEngine/Orc/Layer.h b/llvm/include/llvm/ExecutionEngine/Orc/Layer.h index dccbb4be9b520f..f3be51149a435a 100644 --- a/llvm/include/llvm/ExecutionEngine/Orc/Layer.h +++ b/llvm/include/llvm/ExecutionEngine/Orc/Layer.h @@ -43,8 +43,7 @@ class IRMaterializationUnit : public MaterializationUnit { /// entries for each definition in M. /// This constructor is useful for delegating work from one /// IRMaterializationUnit to another. - IRMaterializationUnit(ThreadSafeModule TSM, SymbolFlagsMap SymbolFlags, - SymbolStringPtr InitSymbol, + IRMaterializationUnit(ThreadSafeModule TSM, Interface I, SymbolNameToDefinitionMap SymbolToDefinition); /// Return the ModuleIdentifier as the name for this MaterializationUnit. @@ -166,8 +165,7 @@ class BasicObjectLayerMaterializationUnit : public MaterializationUnit { BasicObjectLayerMaterializationUnit(ObjectLayer &L, std::unique_ptr O, - SymbolFlagsMap SymbolFlags, - SymbolStringPtr InitSymbol); + Interface I); /// Return the buffer's identifier as the name for this MaterializationUnit. StringRef getName() const override; diff --git a/llvm/include/llvm/ExecutionEngine/Orc/LazyReexports.h b/llvm/include/llvm/ExecutionEngine/Orc/LazyReexports.h index e6a9d894528510..f81cdcef6655a4 100644 --- a/llvm/include/llvm/ExecutionEngine/Orc/LazyReexports.h +++ b/llvm/include/llvm/ExecutionEngine/Orc/LazyReexports.h @@ -151,7 +151,8 @@ class LazyReexportsMaterializationUnit : public MaterializationUnit { private: void materialize(std::unique_ptr R) override; void discard(const JITDylib &JD, const SymbolStringPtr &Name) override; - static SymbolFlagsMap extractFlags(const SymbolAliasMap &Aliases); + static MaterializationUnit::Interface + extractFlags(const SymbolAliasMap &Aliases); LazyCallThroughManager &LCTManager; IndirectStubsManager &ISManager; diff --git a/llvm/include/llvm/ExecutionEngine/Orc/Mangling.h b/llvm/include/llvm/ExecutionEngine/Orc/Mangling.h index e0f770a601fbe8..313842b6d3d0d5 100644 --- a/llvm/include/llvm/ExecutionEngine/Orc/Mangling.h +++ b/llvm/include/llvm/ExecutionEngine/Orc/Mangling.h @@ -57,8 +57,8 @@ class IRSymbolMapper { /// Returns a SymbolFlagsMap for the object file represented by the given /// buffer, or an error if the buffer does not contain a valid object file. -Expected> -getObjectSymbolInfo(ExecutionSession &ES, MemoryBufferRef ObjBuffer); +Expected +getObjectInterface(ExecutionSession &ES, MemoryBufferRef ObjBuffer); } // End namespace orc } // End namespace llvm diff --git a/llvm/lib/ExecutionEngine/Orc/CompileOnDemandLayer.cpp b/llvm/lib/ExecutionEngine/Orc/CompileOnDemandLayer.cpp index 9ff6cec8c6c52a..e2a0cadb6348ae 100644 --- a/llvm/lib/ExecutionEngine/Orc/CompileOnDemandLayer.cpp +++ b/llvm/lib/ExecutionEngine/Orc/CompileOnDemandLayer.cpp @@ -78,11 +78,10 @@ class PartitioningIRMaterializationUnit : public IRMaterializationUnit { : IRMaterializationUnit(ES, MO, std::move(TSM)), Parent(Parent) {} PartitioningIRMaterializationUnit( - ThreadSafeModule TSM, SymbolFlagsMap SymbolFlags, - SymbolStringPtr InitSymbol, SymbolNameToDefinitionMap SymbolToDefinition, + ThreadSafeModule TSM, Interface I, + SymbolNameToDefinitionMap SymbolToDefinition, CompileOnDemandLayer &Parent) - : IRMaterializationUnit(std::move(TSM), std::move(SymbolFlags), - std::move(InitSymbol), + : IRMaterializationUnit(std::move(TSM), std::move(I), std::move(SymbolToDefinition)), Parent(Parent) {} @@ -298,7 +297,9 @@ void CompileOnDemandLayer::emitPartition( if (GVsToExtract->empty()) { if (auto Err = R->replace(std::make_unique( - std::move(TSM), R->getSymbols(), R->getInitializerSymbol(), + std::move(TSM), + MaterializationUnit::Interface(R->getSymbols(), + R->getInitializerSymbol()), std::move(Defs), *this))) { getExecutionSession().reportError(std::move(Err)); R->failMaterialization(); diff --git a/llvm/lib/ExecutionEngine/Orc/Core.cpp b/llvm/lib/ExecutionEngine/Orc/Core.cpp index 56a97f83d91520..b06dff1260638e 100644 --- a/llvm/lib/ExecutionEngine/Orc/Core.cpp +++ b/llvm/lib/ExecutionEngine/Orc/Core.cpp @@ -243,8 +243,7 @@ void AsynchronousSymbolQuery::detach() { AbsoluteSymbolsMaterializationUnit::AbsoluteSymbolsMaterializationUnit( SymbolMap Symbols) - : MaterializationUnit(extractFlags(Symbols), nullptr), - Symbols(std::move(Symbols)) {} + : MaterializationUnit(extractFlags(Symbols)), Symbols(std::move(Symbols)) {} StringRef AbsoluteSymbolsMaterializationUnit::getName() const { return ""; @@ -263,18 +262,18 @@ void AbsoluteSymbolsMaterializationUnit::discard(const JITDylib &JD, Symbols.erase(Name); } -SymbolFlagsMap +MaterializationUnit::Interface AbsoluteSymbolsMaterializationUnit::extractFlags(const SymbolMap &Symbols) { SymbolFlagsMap Flags; for (const auto &KV : Symbols) Flags[KV.first] = KV.second.getFlags(); - return Flags; + return MaterializationUnit::Interface(std::move(Flags), nullptr); } ReExportsMaterializationUnit::ReExportsMaterializationUnit( JITDylib *SourceJD, JITDylibLookupFlags SourceJDLookupFlags, SymbolAliasMap Aliases) - : MaterializationUnit(extractFlags(Aliases), nullptr), SourceJD(SourceJD), + : MaterializationUnit(extractFlags(Aliases)), SourceJD(SourceJD), SourceJDLookupFlags(SourceJDLookupFlags), Aliases(std::move(Aliases)) {} StringRef ReExportsMaterializationUnit::getName() const { @@ -456,13 +455,13 @@ void ReExportsMaterializationUnit::discard(const JITDylib &JD, Aliases.erase(Name); } -SymbolFlagsMap +MaterializationUnit::Interface ReExportsMaterializationUnit::extractFlags(const SymbolAliasMap &Aliases) { SymbolFlagsMap SymbolFlags; for (auto &KV : Aliases) SymbolFlags[KV.first] = KV.second.AliasFlags; - return SymbolFlags; + return MaterializationUnit::Interface(std::move(SymbolFlags), nullptr); } Expected buildSimpleReexportsAliasMap(JITDylib &SourceJD, diff --git a/llvm/lib/ExecutionEngine/Orc/ELFNixPlatform.cpp b/llvm/lib/ExecutionEngine/Orc/ELFNixPlatform.cpp index b17d196f01b63a..eded54f4bfb396 100644 --- a/llvm/lib/ExecutionEngine/Orc/ELFNixPlatform.cpp +++ b/llvm/lib/ExecutionEngine/Orc/ELFNixPlatform.cpp @@ -28,8 +28,8 @@ class DSOHandleMaterializationUnit : public MaterializationUnit { public: DSOHandleMaterializationUnit(ELFNixPlatform &ENP, const SymbolStringPtr &DSOHandleSymbol) - : MaterializationUnit(createDSOHandleSectionSymbols(ENP, DSOHandleSymbol), - DSOHandleSymbol), + : MaterializationUnit( + createDSOHandleSectionInterface(ENP, DSOHandleSymbol)), ENP(ENP) {} StringRef getName() const override { return "DSOHandleMU"; } @@ -70,12 +70,13 @@ class DSOHandleMaterializationUnit : public MaterializationUnit { void discard(const JITDylib &JD, const SymbolStringPtr &Sym) override {} private: - static SymbolFlagsMap - createDSOHandleSectionSymbols(ELFNixPlatform &ENP, - const SymbolStringPtr &DSOHandleSymbol) { + static MaterializationUnit::Interface + createDSOHandleSectionInterface(ELFNixPlatform &ENP, + const SymbolStringPtr &DSOHandleSymbol) { SymbolFlagsMap SymbolFlags; SymbolFlags[DSOHandleSymbol] = JITSymbolFlags::Exported; - return SymbolFlags; + return MaterializationUnit::Interface(std::move(SymbolFlags), + DSOHandleSymbol); } ArrayRef getDSOHandleContent(size_t PointerSize) { diff --git a/llvm/lib/ExecutionEngine/Orc/IndirectionUtils.cpp b/llvm/lib/ExecutionEngine/Orc/IndirectionUtils.cpp index ee1630a2ffa886..f427271bb45de1 100644 --- a/llvm/lib/ExecutionEngine/Orc/IndirectionUtils.cpp +++ b/llvm/lib/ExecutionEngine/Orc/IndirectionUtils.cpp @@ -31,8 +31,8 @@ class CompileCallbackMaterializationUnit : public orc::MaterializationUnit { CompileCallbackMaterializationUnit(SymbolStringPtr Name, CompileFunction Compile) - : MaterializationUnit(SymbolFlagsMap({{Name, JITSymbolFlags::Exported}}), - nullptr), + : MaterializationUnit(Interface( + SymbolFlagsMap({{Name, JITSymbolFlags::Exported}}), nullptr)), Name(std::move(Name)), Compile(std::move(Compile)) {} StringRef getName() const override { return ""; } diff --git a/llvm/lib/ExecutionEngine/Orc/Layer.cpp b/llvm/lib/ExecutionEngine/Orc/Layer.cpp index 20dfba23bf10e6..9ec2db640eb41b 100644 --- a/llvm/lib/ExecutionEngine/Orc/Layer.cpp +++ b/llvm/lib/ExecutionEngine/Orc/Layer.cpp @@ -33,7 +33,7 @@ Error IRLayer::add(ResourceTrackerSP RT, ThreadSafeModule TSM) { IRMaterializationUnit::IRMaterializationUnit( ExecutionSession &ES, const IRSymbolMapper::ManglingOptions &MO, ThreadSafeModule TSM) - : MaterializationUnit(SymbolFlagsMap(), nullptr), TSM(std::move(TSM)) { + : MaterializationUnit(Interface()), TSM(std::move(TSM)) { assert(this->TSM && "Module must not be null"); @@ -98,10 +98,10 @@ IRMaterializationUnit::IRMaterializationUnit( } IRMaterializationUnit::IRMaterializationUnit( - ThreadSafeModule TSM, SymbolFlagsMap SymbolFlags, - SymbolStringPtr InitSymbol, SymbolNameToDefinitionMap SymbolToDefinition) - : MaterializationUnit(std::move(SymbolFlags), std::move(InitSymbol)), - TSM(std::move(TSM)), SymbolToDefinition(std::move(SymbolToDefinition)) {} + ThreadSafeModule TSM, Interface I, + SymbolNameToDefinitionMap SymbolToDefinition) + : MaterializationUnit(std::move(I)), TSM(std::move(TSM)), + SymbolToDefinition(std::move(SymbolToDefinition)) {} StringRef IRMaterializationUnit::getName() const { if (TSM) @@ -173,25 +173,20 @@ Error ObjectLayer::add(ResourceTrackerSP RT, std::unique_ptr O) { Expected> BasicObjectLayerMaterializationUnit::Create(ObjectLayer &L, std::unique_ptr O) { - auto ObjSymInfo = - getObjectSymbolInfo(L.getExecutionSession(), O->getMemBufferRef()); + auto ObjInterface = + getObjectInterface(L.getExecutionSession(), O->getMemBufferRef()); - if (!ObjSymInfo) - return ObjSymInfo.takeError(); - - auto &SymbolFlags = ObjSymInfo->first; - auto &InitSymbol = ObjSymInfo->second; + if (!ObjInterface) + return ObjInterface.takeError(); return std::unique_ptr( - new BasicObjectLayerMaterializationUnit( - L, std::move(O), std::move(SymbolFlags), std::move(InitSymbol))); + new BasicObjectLayerMaterializationUnit(L, std::move(O), + std::move(*ObjInterface))); } BasicObjectLayerMaterializationUnit::BasicObjectLayerMaterializationUnit( - ObjectLayer &L, std::unique_ptr O, SymbolFlagsMap SymbolFlags, - SymbolStringPtr InitSymbol) - : MaterializationUnit(std::move(SymbolFlags), std::move(InitSymbol)), L(L), - O(std::move(O)) {} + ObjectLayer &L, std::unique_ptr O, Interface I) + : MaterializationUnit(std::move(I)), L(L), O(std::move(O)) {} StringRef BasicObjectLayerMaterializationUnit::getName() const { if (O) diff --git a/llvm/lib/ExecutionEngine/Orc/LazyReexports.cpp b/llvm/lib/ExecutionEngine/Orc/LazyReexports.cpp index e1f494415e86b0..66453e6a632fc9 100644 --- a/llvm/lib/ExecutionEngine/Orc/LazyReexports.cpp +++ b/llvm/lib/ExecutionEngine/Orc/LazyReexports.cpp @@ -144,7 +144,7 @@ createLocalLazyCallThroughManager(const Triple &T, ExecutionSession &ES, LazyReexportsMaterializationUnit::LazyReexportsMaterializationUnit( LazyCallThroughManager &LCTManager, IndirectStubsManager &ISManager, JITDylib &SourceJD, SymbolAliasMap CallableAliases, ImplSymbolMap *SrcJDLoc) - : MaterializationUnit(extractFlags(CallableAliases), nullptr), + : MaterializationUnit(extractFlags(CallableAliases)), LCTManager(LCTManager), ISManager(ISManager), SourceJD(SourceJD), CallableAliases(std::move(CallableAliases)), AliaseeTable(SrcJDLoc) {} @@ -219,7 +219,7 @@ void LazyReexportsMaterializationUnit::discard(const JITDylib &JD, CallableAliases.erase(Name); } -SymbolFlagsMap +MaterializationUnit::Interface LazyReexportsMaterializationUnit::extractFlags(const SymbolAliasMap &Aliases) { SymbolFlagsMap SymbolFlags; for (auto &KV : Aliases) { @@ -227,7 +227,7 @@ LazyReexportsMaterializationUnit::extractFlags(const SymbolAliasMap &Aliases) { "Lazy re-exports must be callable symbols"); SymbolFlags[KV.first] = KV.second.AliasFlags; } - return SymbolFlags; + return MaterializationUnit::Interface(std::move(SymbolFlags), nullptr); } } // End namespace orc. diff --git a/llvm/lib/ExecutionEngine/Orc/MachOPlatform.cpp b/llvm/lib/ExecutionEngine/Orc/MachOPlatform.cpp index 46c915dfea9eb6..fb2e90e1c9c53e 100644 --- a/llvm/lib/ExecutionEngine/Orc/MachOPlatform.cpp +++ b/llvm/lib/ExecutionEngine/Orc/MachOPlatform.cpp @@ -28,8 +28,7 @@ class MachOHeaderMaterializationUnit : public MaterializationUnit { public: MachOHeaderMaterializationUnit(MachOPlatform &MOP, const SymbolStringPtr &HeaderStartSymbol) - : MaterializationUnit(createHeaderSymbols(MOP, HeaderStartSymbol), - HeaderStartSymbol), + : MaterializationUnit(createHeaderInterface(MOP, HeaderStartSymbol)), MOP(MOP) {} StringRef getName() const override { return "MachOHeaderMU"; } @@ -110,9 +109,9 @@ class MachOHeaderMaterializationUnit : public MaterializationUnit { return G.createContentBlock(HeaderSection, HeaderContent, 0, 8, 0); } - static SymbolFlagsMap - createHeaderSymbols(MachOPlatform &MOP, - const SymbolStringPtr &HeaderStartSymbol) { + static MaterializationUnit::Interface + createHeaderInterface(MachOPlatform &MOP, + const SymbolStringPtr &HeaderStartSymbol) { SymbolFlagsMap HeaderSymbolFlags; HeaderSymbolFlags[HeaderStartSymbol] = JITSymbolFlags::Exported; @@ -120,7 +119,8 @@ class MachOHeaderMaterializationUnit : public MaterializationUnit { HeaderSymbolFlags[MOP.getExecutionSession().intern(HS.Name)] = JITSymbolFlags::Exported; - return HeaderSymbolFlags; + return MaterializationUnit::Interface(std::move(HeaderSymbolFlags), + HeaderStartSymbol); } MachOPlatform &MOP; diff --git a/llvm/lib/ExecutionEngine/Orc/Mangling.cpp b/llvm/lib/ExecutionEngine/Orc/Mangling.cpp index 7b21e6a684cac9..3639370c171706 100644 --- a/llvm/lib/ExecutionEngine/Orc/Mangling.cpp +++ b/llvm/lib/ExecutionEngine/Orc/Mangling.cpp @@ -102,7 +102,7 @@ static SymbolStringPtr addInitSymbol(SymbolFlagsMap &SymbolFlags, return InitSymbol; } -static Expected> +static Expected getMachOObjectFileSymbolInfo(ExecutionSession &ES, const object::MachOObjectFile &Obj) { SymbolFlagsMap SymbolFlags; @@ -158,10 +158,11 @@ getMachOObjectFileSymbolInfo(ExecutionSession &ES, } } - return std::make_pair(std::move(SymbolFlags), std::move(InitSymbol)); + return MaterializationUnit::Interface(std::move(SymbolFlags), + std::move(InitSymbol)); } -static Expected> +static Expected getELFObjectFileSymbolInfo(ExecutionSession &ES, const object::ELFObjectFileBase &Obj) { SymbolFlagsMap SymbolFlags; @@ -211,10 +212,11 @@ getELFObjectFileSymbolInfo(ExecutionSession &ES, } } - return std::make_pair(std::move(SymbolFlags), InitSymbol); + return MaterializationUnit::Interface(std::move(SymbolFlags), + std::move(InitSymbol)); } -Expected> +Expected getGenericObjectFileSymbolInfo(ExecutionSession &ES, const object::ObjectFile &Obj) { SymbolFlagsMap SymbolFlags; @@ -250,11 +252,11 @@ getGenericObjectFileSymbolInfo(ExecutionSession &ES, SymbolFlags[InternedName] = std::move(*SymFlags); } - return std::make_pair(std::move(SymbolFlags), nullptr); + return MaterializationUnit::Interface(std::move(SymbolFlags), nullptr); } -Expected> -getObjectSymbolInfo(ExecutionSession &ES, MemoryBufferRef ObjBuffer) { +Expected +getObjectInterface(ExecutionSession &ES, MemoryBufferRef ObjBuffer) { auto Obj = object::ObjectFile::createObjectFile(ObjBuffer); if (!Obj) diff --git a/llvm/lib/ExecutionEngine/Orc/ObjectLinkingLayer.cpp b/llvm/lib/ExecutionEngine/Orc/ObjectLinkingLayer.cpp index 6f840a079dd1b8..a6d3ca7d94e2ad 100644 --- a/llvm/lib/ExecutionEngine/Orc/ObjectLinkingLayer.cpp +++ b/llvm/lib/ExecutionEngine/Orc/ObjectLinkingLayer.cpp @@ -23,12 +23,6 @@ using namespace llvm::orc; namespace { class LinkGraphMaterializationUnit : public MaterializationUnit { -private: - struct LinkGraphInterface { - SymbolFlagsMap SymbolFlags; - SymbolStringPtr InitSymbol; - }; - public: static std::unique_ptr Create(ObjectLinkingLayer &ObjLinkingLayer, std::unique_ptr G) { @@ -44,9 +38,9 @@ class LinkGraphMaterializationUnit : public MaterializationUnit { } private: - static LinkGraphInterface scanLinkGraph(ExecutionSession &ES, LinkGraph &G) { + static Interface scanLinkGraph(ExecutionSession &ES, LinkGraph &G) { - LinkGraphInterface LGI; + Interface LGI; for (auto *Sym : G.defined_symbols()) { // Skip local symbols. @@ -98,11 +92,9 @@ class LinkGraphMaterializationUnit : public MaterializationUnit { } LinkGraphMaterializationUnit(ObjectLinkingLayer &ObjLinkingLayer, - std::unique_ptr G, - LinkGraphInterface LGI) - : MaterializationUnit(std::move(LGI.SymbolFlags), - std::move(LGI.InitSymbol)), - ObjLinkingLayer(ObjLinkingLayer), G(std::move(G)) {} + std::unique_ptr G, Interface LGI) + : MaterializationUnit(std::move(LGI)), ObjLinkingLayer(ObjLinkingLayer), + G(std::move(G)) {} void discard(const JITDylib &JD, const SymbolStringPtr &Name) override { for (auto *Sym : G->defined_symbols()) diff --git a/llvm/lib/ExecutionEngine/Orc/OrcV2CBindings.cpp b/llvm/lib/ExecutionEngine/Orc/OrcV2CBindings.cpp index 673f7394450f2c..77a8f5af8ba0e2 100644 --- a/llvm/lib/ExecutionEngine/Orc/OrcV2CBindings.cpp +++ b/llvm/lib/ExecutionEngine/Orc/OrcV2CBindings.cpp @@ -192,8 +192,8 @@ class OrcCAPIMaterializationUnit : public llvm::orc::MaterializationUnit { LLVMOrcMaterializationUnitMaterializeFunction Materialize, LLVMOrcMaterializationUnitDiscardFunction Discard, LLVMOrcMaterializationUnitDestroyFunction Destroy) - : llvm::orc::MaterializationUnit(std::move(InitialSymbolFlags), - std::move(InitSymbol)), + : llvm::orc::MaterializationUnit( + Interface(std::move(InitialSymbolFlags), std::move(InitSymbol))), Name(std::move(Name)), Ctx(Ctx), Materialize(Materialize), Discard(Discard), Destroy(Destroy) {} diff --git a/llvm/tools/llvm-jitlink/llvm-jitlink.cpp b/llvm/tools/llvm-jitlink/llvm-jitlink.cpp index b643a8f0f76d68..96833ea02c90b7 100644 --- a/llvm/tools/llvm-jitlink/llvm-jitlink.cpp +++ b/llvm/tools/llvm-jitlink/llvm-jitlink.cpp @@ -649,24 +649,23 @@ Error LLVMJITLinkObjectLinkingLayer::add(ResourceTrackerSP RT, // Use getObjectSymbolInfo to compute the init symbol, but ignore // the symbols field. We'll handle that manually to include promotion. - auto ObjSymInfo = - getObjectSymbolInfo(getExecutionSession(), O->getMemBufferRef()); + auto ObjInterface = + getObjectInterface(getExecutionSession(), O->getMemBufferRef()); - if (!ObjSymInfo) - return ObjSymInfo.takeError(); - - auto &InitSymbol = ObjSymInfo->second; + if (!ObjInterface) + return ObjInterface.takeError(); // If creating an object file was going to fail it would have happened above, // so we can 'cantFail' this. auto Obj = cantFail(object::ObjectFile::createObjectFile(O->getMemBufferRef())); - SymbolFlagsMap SymbolFlags; + ObjInterface->SymbolFlags.clear(); // The init symbol must be included in the SymbolFlags map if present. - if (InitSymbol) - SymbolFlags[InitSymbol] = JITSymbolFlags::MaterializationSideEffectsOnly; + if (ObjInterface->InitSymbol) + ObjInterface->SymbolFlags[ObjInterface->InitSymbol] = + JITSymbolFlags::MaterializationSideEffectsOnly; for (auto &Sym : Obj->symbols()) { Expected SymFlagsOrErr = Sym.getFlags(); @@ -710,11 +709,11 @@ Error LLVMJITLinkObjectLinkingLayer::add(ResourceTrackerSP RT, continue; auto InternedName = S.ES.intern(*Name); - SymbolFlags[InternedName] = std::move(*SymFlags); + ObjInterface->SymbolFlags[InternedName] = std::move(*SymFlags); } auto MU = std::make_unique( - *this, std::move(O), std::move(SymbolFlags), std::move(InitSymbol)); + *this, std::move(O), std::move(*ObjInterface)); auto &JD = RT->getJITDylib(); return JD.define(std::move(MU), std::move(RT)); @@ -1034,10 +1033,10 @@ Session::Session(std::unique_ptr EPC, Error &Err) auto ObjBuffer = ExitOnErr(errorOrToExpected(MemoryBuffer::getFile(HarnessFile))); - auto ObjSymbolInfo = - ExitOnErr(getObjectSymbolInfo(ES, ObjBuffer->getMemBufferRef())); + auto ObjInterface = + ExitOnErr(getObjectInterface(ES, ObjBuffer->getMemBufferRef())); - for (auto &KV : ObjSymbolInfo.first) + for (auto &KV : ObjInterface.SymbolFlags) HarnessDefinitions.insert(*KV.first); auto Obj = ExitOnErr( diff --git a/llvm/unittests/ExecutionEngine/Orc/OrcTestCommon.h b/llvm/unittests/ExecutionEngine/Orc/OrcTestCommon.h index 8472584d9ee549..c2db65d1a57dbf 100644 --- a/llvm/unittests/ExecutionEngine/Orc/OrcTestCommon.h +++ b/llvm/unittests/ExecutionEngine/Orc/OrcTestCommon.h @@ -103,7 +103,8 @@ class SimpleMaterializationUnit : public orc::MaterializationUnit { orc::SymbolStringPtr InitSym = nullptr, DiscardFunction Discard = DiscardFunction(), DestructorFunction Destructor = DestructorFunction()) - : MaterializationUnit(std::move(SymbolFlags), std::move(InitSym)), + : MaterializationUnit( + Interface(std::move(SymbolFlags), std::move(InitSym))), Materialize(std::move(Materialize)), Discard(std::move(Discard)), Destructor(std::move(Destructor)) {}