maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity

[ORC] Add a MaterializationUnit::Interface struct. 

MaterializationUnit::Interface holds the values that make up the interface
(for ORC's purposes) of a materialization unit: the symbol flags map and
initializer symbol.

Having a type for this will make functions that build materializer interfaces
more readable and maintainable.
This commit is contained in:
Lang Hames 2021-12-08 08:10:41 +11:00
parent c16c99ab03
commit ae73f3fdd6
17 changed files with 102 additions and 104 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
llvm/examples/Kaleidoscope/BuildingAJIT/Chapter4/KaleidoscopeJIT.h
View File

@ -102,12 +102,12 @@ public:
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 @@ private:
KaleidoscopeASTMaterializationUnit::KaleidoscopeASTMaterializationUnit(
KaleidoscopeASTLayer &L, std::unique_ptr<FunctionAST> 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<MaterializationResponsibility> R) {

27
llvm/include/llvm/ExecutionEngine/Orc/Core.h
View File

@ -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 @@ public:
private:
void materialize(std::unique_ptr<MaterializationResponsibility> 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 @@ public:
private:
void materialize(std::unique_ptr<MaterializationResponsibility> 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;

6
llvm/include/llvm/ExecutionEngine/Orc/Layer.h
View File

@ -43,8 +43,7 @@ public:
/// 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 @@ public:
BasicObjectLayerMaterializationUnit(ObjectLayer &L,
std::unique_ptr<MemoryBuffer> O,
SymbolFlagsMap SymbolFlags,
SymbolStringPtr InitSymbol);
Interface I);
/// Return the buffer's identifier as the name for this MaterializationUnit.
StringRef getName() const override;

3
llvm/include/llvm/ExecutionEngine/Orc/LazyReexports.h
View File

@ -151,7 +151,8 @@ public:
private:
void materialize(std::unique_ptr<MaterializationResponsibility> 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;

4
llvm/include/llvm/ExecutionEngine/Orc/Mangling.h
View File

@ -57,8 +57,8 @@ public:
/// 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<std::pair<SymbolFlagsMap, SymbolStringPtr>>
getObjectSymbolInfo(ExecutionSession &ES, MemoryBufferRef ObjBuffer);
Expected<MaterializationUnit::Interface>
getObjectInterface(ExecutionSession &ES, MemoryBufferRef ObjBuffer);
} // End namespace orc
} // End namespace llvm

11
llvm/lib/ExecutionEngine/Orc/CompileOnDemandLayer.cpp
View File

@ -78,11 +78,10 @@ public:
: 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<PartitioningIRMaterializationUnit>(
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();

13
llvm/lib/ExecutionEngine/Orc/Core.cpp
View File

@ -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 "<Absolute Symbols>";
@ -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<SymbolAliasMap> buildSimpleReexportsAliasMap(JITDylib &SourceJD,

13
llvm/lib/ExecutionEngine/Orc/ELFNixPlatform.cpp
View File

@ -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 @@ public:
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<char> getDSOHandleContent(size_t PointerSize) {

4
llvm/lib/ExecutionEngine/Orc/IndirectionUtils.cpp
View File

@ -31,8 +31,8 @@ public:
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 "<Compile Callbacks>"; }

31
llvm/lib/ExecutionEngine/Orc/Layer.cpp
View File

@ -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<MemoryBuffer> O) {
Expected<std::unique_ptr<BasicObjectLayerMaterializationUnit>>
BasicObjectLayerMaterializationUnit::Create(ObjectLayer &L,
std::unique_ptr<MemoryBuffer> 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<BasicObjectLayerMaterializationUnit>(
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<MemoryBuffer> O, SymbolFlagsMap SymbolFlags,
SymbolStringPtr InitSymbol)
: MaterializationUnit(std::move(SymbolFlags), std::move(InitSymbol)), L(L),
O(std::move(O)) {}
ObjectLayer &L, std::unique_ptr<MemoryBuffer> O, Interface I)
: MaterializationUnit(std::move(I)), L(L), O(std::move(O)) {}
StringRef BasicObjectLayerMaterializationUnit::getName() const {
if (O)

6
llvm/lib/ExecutionEngine/Orc/LazyReexports.cpp
View File

@ -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.

12
llvm/lib/ExecutionEngine/Orc/MachOPlatform.cpp
View File

@ -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 @@ private:
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 @@ private:
HeaderSymbolFlags[MOP.getExecutionSession().intern(HS.Name)] =
JITSymbolFlags::Exported;
return HeaderSymbolFlags;
return MaterializationUnit::Interface(std::move(HeaderSymbolFlags),
HeaderStartSymbol);
}
MachOPlatform &MOP;

18
llvm/lib/ExecutionEngine/Orc/Mangling.cpp
View File

@ -102,7 +102,7 @@ static SymbolStringPtr addInitSymbol(SymbolFlagsMap &SymbolFlags,
return InitSymbol;
}
static Expected<std::pair<SymbolFlagsMap, SymbolStringPtr>>
static Expected<MaterializationUnit::Interface>
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<std::pair<SymbolFlagsMap, SymbolStringPtr>>
static Expected<MaterializationUnit::Interface>
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<std::pair<SymbolFlagsMap, SymbolStringPtr>>
Expected<MaterializationUnit::Interface>
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<std::pair<SymbolFlagsMap, SymbolStringPtr>>
getObjectSymbolInfo(ExecutionSession &ES, MemoryBufferRef ObjBuffer) {
Expected<MaterializationUnit::Interface>
getObjectInterface(ExecutionSession &ES, MemoryBufferRef ObjBuffer) {
auto Obj = object::ObjectFile::createObjectFile(ObjBuffer);
if (!Obj)

18
llvm/lib/ExecutionEngine/Orc/ObjectLinkingLayer.cpp
View File

@ -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<LinkGraphMaterializationUnit>
Create(ObjectLinkingLayer &ObjLinkingLayer, std::unique_ptr<LinkGraph> G) {
@ -44,9 +38,9 @@ public:
}
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 @@ private:
}
LinkGraphMaterializationUnit(ObjectLinkingLayer &ObjLinkingLayer,
std::unique_ptr<LinkGraph> G,
LinkGraphInterface LGI)
: MaterializationUnit(std::move(LGI.SymbolFlags),
std::move(LGI.InitSymbol)),
ObjLinkingLayer(ObjLinkingLayer), G(std::move(G)) {}
std::unique_ptr<LinkGraph> G, Interface LGI)
: MaterializationUnit(std::move(LGI)), ObjLinkingLayer(ObjLinkingLayer),
G(std::move(G)) {}
void discard(const JITDylib &JD, const SymbolStringPtr &Name) override {
for (auto *Sym : G->defined_symbols())

4
llvm/lib/ExecutionEngine/Orc/OrcV2CBindings.cpp
View File

@ -192,8 +192,8 @@ public:
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) {}

27
llvm/tools/llvm-jitlink/llvm-jitlink.cpp
View File

@ -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<uint32_t> 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<BasicObjectLayerMaterializationUnit>(
*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<ExecutorProcessControl> 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(

3
llvm/unittests/ExecutionEngine/Orc/OrcTestCommon.h
View File

@ -103,7 +103,8 @@ public:
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)) {}