std::shared_ptr<SymbolResolver> Resolver;
std::unique_ptr<TargetMachine> TM;
const DataLayout DL;
- RTDyldObjectLinkingLayer ObjectLayer;
- IRCompileLayer<decltype(ObjectLayer), SimpleCompiler> CompileLayer;
+ LegacyRTDyldObjectLinkingLayer ObjectLayer;
+ LegacyIRCompileLayer<decltype(ObjectLayer), SimpleCompiler> CompileLayer;
public:
KaleidoscopeJIT()
TM(EngineBuilder().selectTarget()), DL(TM->createDataLayout()),
ObjectLayer(ES,
[this](VModuleKey) {
- return RTDyldObjectLinkingLayer::Resources{
+ return LegacyRTDyldObjectLinkingLayer::Resources{
std::make_shared<SectionMemoryManager>(), Resolver};
}),
CompileLayer(ObjectLayer, SimpleCompiler(*TM)) {
std::shared_ptr<SymbolResolver> Resolver;
std::unique_ptr<TargetMachine> TM;
const DataLayout DL;
- RTDyldObjectLinkingLayer ObjectLayer;
- IRCompileLayer<decltype(ObjectLayer), SimpleCompiler> CompileLayer;
+ LegacyRTDyldObjectLinkingLayer ObjectLayer;
+ LegacyIRCompileLayer<decltype(ObjectLayer), SimpleCompiler> CompileLayer;
using OptimizeFunction =
std::function<std::unique_ptr<Module>(std::unique_ptr<Module>)>;
- IRTransformLayer<decltype(CompileLayer), OptimizeFunction> OptimizeLayer;
+ LegacyIRTransformLayer<decltype(CompileLayer), OptimizeFunction> OptimizeLayer;
public:
KaleidoscopeJIT()
TM(EngineBuilder().selectTarget()), DL(TM->createDataLayout()),
ObjectLayer(ES,
[this](VModuleKey) {
- return RTDyldObjectLinkingLayer::Resources{
+ return LegacyRTDyldObjectLinkingLayer::Resources{
std::make_shared<SectionMemoryManager>(), Resolver};
}),
CompileLayer(ObjectLayer, SimpleCompiler(*TM)),
std::map<VModuleKey, std::shared_ptr<SymbolResolver>> Resolvers;
std::unique_ptr<TargetMachine> TM;
const DataLayout DL;
- RTDyldObjectLinkingLayer ObjectLayer;
- IRCompileLayer<decltype(ObjectLayer), SimpleCompiler> CompileLayer;
+ LegacyRTDyldObjectLinkingLayer ObjectLayer;
+ LegacyIRCompileLayer<decltype(ObjectLayer), SimpleCompiler> CompileLayer;
using OptimizeFunction =
std::function<std::unique_ptr<Module>(std::unique_ptr<Module>)>;
- IRTransformLayer<decltype(CompileLayer), OptimizeFunction> OptimizeLayer;
+ LegacyIRTransformLayer<decltype(CompileLayer), OptimizeFunction> OptimizeLayer;
std::unique_ptr<JITCompileCallbackManager> CompileCallbackManager;
- CompileOnDemandLayer<decltype(OptimizeLayer)> CODLayer;
+ LegacyCompileOnDemandLayer<decltype(OptimizeLayer)> CODLayer;
public:
KaleidoscopeJIT()
: TM(EngineBuilder().selectTarget()), DL(TM->createDataLayout()),
ObjectLayer(ES,
[this](VModuleKey K) {
- return RTDyldObjectLinkingLayer::Resources{
+ return LegacyRTDyldObjectLinkingLayer::Resources{
std::make_shared<SectionMemoryManager>(),
Resolvers[K]};
}),
std::shared_ptr<SymbolResolver> Resolver;
std::unique_ptr<TargetMachine> TM;
const DataLayout DL;
- RTDyldObjectLinkingLayer ObjectLayer;
- IRCompileLayer<decltype(ObjectLayer), SimpleCompiler> CompileLayer;
+ LegacyRTDyldObjectLinkingLayer ObjectLayer;
+ LegacyIRCompileLayer<decltype(ObjectLayer), SimpleCompiler> CompileLayer;
using OptimizeFunction =
std::function<std::unique_ptr<Module>(std::unique_ptr<Module>)>;
- IRTransformLayer<decltype(CompileLayer), OptimizeFunction> OptimizeLayer;
+ LegacyIRTransformLayer<decltype(CompileLayer), OptimizeFunction> OptimizeLayer;
std::unique_ptr<JITCompileCallbackManager> CompileCallbackMgr;
std::unique_ptr<IndirectStubsManager> IndirectStubsMgr;
TM(EngineBuilder().selectTarget()), DL(TM->createDataLayout()),
ObjectLayer(ES,
[this](VModuleKey K) {
- return RTDyldObjectLinkingLayer::Resources{
+ return LegacyRTDyldObjectLinkingLayer::Resources{
std::make_shared<SectionMemoryManager>(), Resolver};
}),
CompileLayer(ObjectLayer, SimpleCompiler(*TM)),
std::shared_ptr<SymbolResolver> Resolver;
std::unique_ptr<TargetMachine> TM;
const DataLayout DL;
- RTDyldObjectLinkingLayer ObjectLayer;
- IRCompileLayer<decltype(ObjectLayer), SimpleCompiler> CompileLayer;
+ LegacyRTDyldObjectLinkingLayer ObjectLayer;
+ LegacyIRCompileLayer<decltype(ObjectLayer), SimpleCompiler> CompileLayer;
using OptimizeFunction =
std::function<std::unique_ptr<Module>(std::unique_ptr<Module>)>;
- IRTransformLayer<decltype(CompileLayer), OptimizeFunction> OptimizeLayer;
+ LegacyIRTransformLayer<decltype(CompileLayer), OptimizeFunction> OptimizeLayer;
JITCompileCallbackManager *CompileCallbackMgr;
std::unique_ptr<IndirectStubsManager> IndirectStubsMgr;
DL(TM->createDataLayout()),
ObjectLayer(ES,
[this](VModuleKey K) {
- return RTDyldObjectLinkingLayer::Resources{
+ return LegacyRTDyldObjectLinkingLayer::Resources{
cantFail(this->Remote.createRemoteMemoryManager()),
Resolver};
}),
class KaleidoscopeJIT {
public:
- using ObjLayerT = RTDyldObjectLinkingLayer;
- using CompileLayerT = IRCompileLayer<ObjLayerT, SimpleCompiler>;
+ using ObjLayerT = LegacyRTDyldObjectLinkingLayer;
+ using CompileLayerT = LegacyIRCompileLayer<ObjLayerT, SimpleCompiler>;
KaleidoscopeJIT()
: Resolver(createLegacyLookupResolver(
class ExtractingIRMaterializationUnit;
-class CompileOnDemandLayer2 : public IRLayer {
+class CompileOnDemandLayer : public IRLayer {
friend class PartitioningIRMaterializationUnit;
public:
/// symbol in them is requested.
static Optional<GlobalValueSet> compileWholeModule(GlobalValueSet Requested);
- /// Construct a CompileOnDemandLayer2.
- CompileOnDemandLayer2(ExecutionSession &ES, IRLayer &BaseLayer,
+ /// Construct a CompileOnDemandLayer.
+ CompileOnDemandLayer(ExecutionSession &ES, IRLayer &BaseLayer,
LazyCallThroughManager &LCTMgr,
IndirectStubsManagerBuilder BuildIndirectStubsManager);
template <typename BaseLayerT,
typename CompileCallbackMgrT = JITCompileCallbackManager,
typename IndirectStubsMgrT = IndirectStubsManager>
-class CompileOnDemandLayer {
+class LegacyCompileOnDemandLayer {
private:
template <typename MaterializerFtor>
class LambdaMaterializer final : public ValueMaterializer {
std::function<void(VModuleKey K, std::shared_ptr<SymbolResolver> R)>;
/// Construct a compile-on-demand layer instance.
- CompileOnDemandLayer(ExecutionSession &ES, BaseLayerT &BaseLayer,
- SymbolResolverGetter GetSymbolResolver,
- SymbolResolverSetter SetSymbolResolver,
- PartitioningFtor Partition,
- CompileCallbackMgrT &CallbackMgr,
- IndirectStubsManagerBuilderT CreateIndirectStubsManager,
- bool CloneStubsIntoPartitions = true)
+ LegacyCompileOnDemandLayer(ExecutionSession &ES, BaseLayerT &BaseLayer,
+ SymbolResolverGetter GetSymbolResolver,
+ SymbolResolverSetter SetSymbolResolver,
+ PartitioningFtor Partition,
+ CompileCallbackMgrT &CallbackMgr,
+ IndirectStubsManagerBuilderT CreateIndirectStubsManager,
+ bool CloneStubsIntoPartitions = true)
: ES(ES), BaseLayer(BaseLayer),
GetSymbolResolver(std::move(GetSymbolResolver)),
SetSymbolResolver(std::move(SetSymbolResolver)),
CreateIndirectStubsManager(std::move(CreateIndirectStubsManager)),
CloneStubsIntoPartitions(CloneStubsIntoPartitions) {}
- ~CompileOnDemandLayer() {
+ ~LegacyCompileOnDemandLayer() {
// FIXME: Report error on log.
while (!LogicalDylibs.empty())
consumeError(removeModule(LogicalDylibs.begin()->first));
/// Convenience class for recording constructor/destructor names for
/// later execution.
template <typename JITLayerT>
-class CtorDtorRunner {
+class LegacyCtorDtorRunner {
public:
/// Construct a CtorDtorRunner for the given range using the given
/// name mangling function.
- CtorDtorRunner(std::vector<std::string> CtorDtorNames, VModuleKey K)
+ LegacyCtorDtorRunner(std::vector<std::string> CtorDtorNames, VModuleKey K)
: CtorDtorNames(std::move(CtorDtorNames)), K(K) {}
/// Run the recorded constructors/destructors through the given JIT
orc::VModuleKey K;
};
-class CtorDtorRunner2 {
+class CtorDtorRunner {
public:
- CtorDtorRunner2(JITDylib &JD) : JD(JD) {}
+ CtorDtorRunner(JITDylib &JD) : JD(JD) {}
void add(iterator_range<CtorDtorIterator> CtorDtors);
Error run();
void *DSOHandle);
};
-class LocalCXXRuntimeOverrides : public LocalCXXRuntimeOverridesBase {
+class LegacyLocalCXXRuntimeOverrides : public LocalCXXRuntimeOverridesBase {
public:
/// Create a runtime-overrides class.
template <typename MangleFtorT>
- LocalCXXRuntimeOverrides(const MangleFtorT &Mangle) {
+ LegacyLocalCXXRuntimeOverrides(const MangleFtorT &Mangle) {
addOverride(Mangle("__dso_handle"), toTargetAddress(&DSOHandleOverride));
addOverride(Mangle("__cxa_atexit"), toTargetAddress(&CXAAtExitOverride));
}
StringMap<JITTargetAddress> CXXRuntimeOverrides;
};
-class LocalCXXRuntimeOverrides2 : public LocalCXXRuntimeOverridesBase {
+class LocalCXXRuntimeOverrides : public LocalCXXRuntimeOverridesBase {
public:
Error enable(JITDylib &JD, MangleAndInterner &Mangler);
};
namespace orc {
-class IRCompileLayer2 : public IRLayer {
+class IRCompileLayer : public IRLayer {
public:
using CompileFunction =
std::function<Expected<std::unique_ptr<MemoryBuffer>>(Module &)>;
using NotifyCompiledFunction =
std::function<void(VModuleKey K, ThreadSafeModule TSM)>;
- IRCompileLayer2(ExecutionSession &ES, ObjectLayer &BaseLayer,
- CompileFunction Compile);
+ IRCompileLayer(ExecutionSession &ES, ObjectLayer &BaseLayer,
+ CompileFunction Compile);
void setNotifyCompiled(NotifyCompiledFunction NotifyCompiled);
/// object file and adds this module file to the layer below, which must
/// implement the object layer concept.
template <typename BaseLayerT, typename CompileFtor>
-class IRCompileLayer {
+class LegacyIRCompileLayer {
public:
/// Callback type for notifications when modules are compiled.
using NotifyCompiledCallback =
std::function<void(VModuleKey K, std::unique_ptr<Module>)>;
- /// Construct an IRCompileLayer with the given BaseLayer, which must
+ /// Construct an LegacyIRCompileLayer with the given BaseLayer, which must
/// implement the ObjectLayer concept.
- IRCompileLayer(
+ LegacyIRCompileLayer(
BaseLayerT &BaseLayer, CompileFtor Compile,
NotifyCompiledCallback NotifyCompiled = NotifyCompiledCallback())
: BaseLayer(BaseLayer), Compile(std::move(Compile)),
class Module;
namespace orc {
-class IRTransformLayer2 : public IRLayer {
+class IRTransformLayer : public IRLayer {
public:
using TransformFunction = std::function<Expected<ThreadSafeModule>(
ThreadSafeModule, const MaterializationResponsibility &R)>;
- IRTransformLayer2(ExecutionSession &ES, IRLayer &BaseLayer,
- TransformFunction Transform = identityTransform);
+ IRTransformLayer(ExecutionSession &ES, IRLayer &BaseLayer,
+ TransformFunction Transform = identityTransform);
void setTransform(TransformFunction Transform) {
this->Transform = std::move(Transform);
/// This layer applies a user supplied transform to each module that is added,
/// then adds the transformed module to the layer below.
template <typename BaseLayerT, typename TransformFtor>
-class IRTransformLayer {
+class LegacyIRTransformLayer {
public:
- /// Construct an IRTransformLayer with the given BaseLayer
- IRTransformLayer(BaseLayerT &BaseLayer,
+ /// Construct an LegacyIRTransformLayer with the given BaseLayer
+ LegacyIRTransformLayer(BaseLayerT &BaseLayer,
TransformFtor Transform = TransformFtor())
: BaseLayer(BaseLayer), Transform(std::move(Transform)) {}
Error runDestructors() { return DtorRunner.run(); }
/// Returns a reference to the ObjLinkingLayer
- RTDyldObjectLinkingLayer2 &getObjLinkingLayer() { return ObjLinkingLayer; }
+ RTDyldObjectLinkingLayer &getObjLinkingLayer() { return ObjLinkingLayer; }
protected:
DataLayout DL;
std::unique_ptr<ThreadPool> CompileThreads;
- RTDyldObjectLinkingLayer2 ObjLinkingLayer;
- IRCompileLayer2 CompileLayer;
+ RTDyldObjectLinkingLayer ObjLinkingLayer;
+ IRCompileLayer CompileLayer;
- CtorDtorRunner2 CtorRunner, DtorRunner;
+ CtorDtorRunner CtorRunner, DtorRunner;
};
/// An extended version of LLJIT that supports lazy function-at-a-time
/// Set an IR transform (e.g. pass manager pipeline) to run on each function
/// when it is compiled.
- void setLazyCompileTransform(IRTransformLayer2::TransformFunction Transform) {
+ void setLazyCompileTransform(IRTransformLayer::TransformFunction Transform) {
TransformLayer.setTransform(std::move(Transform));
}
/// Sets the partition function.
void
- setPartitionFunction(CompileOnDemandLayer2::PartitionFunction Partition) {
+ setPartitionFunction(CompileOnDemandLayer::PartitionFunction Partition) {
CODLayer.setPartitionFunction(std::move(Partition));
}
std::unique_ptr<LazyCallThroughManager> LCTMgr;
std::function<std::unique_ptr<IndirectStubsManager>()> ISMBuilder;
- IRTransformLayer2 TransformLayer;
- CompileOnDemandLayer2 CODLayer;
+ IRTransformLayer TransformLayer;
+ CompileOnDemandLayer CODLayer;
};
} // End namespace orc
namespace llvm {
namespace orc {
-class ObjectTransformLayer2 : public ObjectLayer {
+class ObjectTransformLayer : public ObjectLayer {
public:
using TransformFunction =
std::function<Expected<std::unique_ptr<MemoryBuffer>>(
std::unique_ptr<MemoryBuffer>)>;
- ObjectTransformLayer2(ExecutionSession &ES, ObjectLayer &BaseLayer,
- TransformFunction Transform);
+ ObjectTransformLayer(ExecutionSession &ES, ObjectLayer &BaseLayer,
+ TransformFunction Transform);
void emit(MaterializationResponsibility R, VModuleKey K,
std::unique_ptr<MemoryBuffer> O) override;
/// immediately applies the user supplied functor to each object, then adds
/// the set of transformed objects to the layer below.
template <typename BaseLayerT, typename TransformFtor>
-class ObjectTransformLayer {
+class LegacyObjectTransformLayer {
public:
/// Construct an ObjectTransformLayer with the given BaseLayer
- ObjectTransformLayer(BaseLayerT &BaseLayer,
- TransformFtor Transform = TransformFtor())
+ LegacyObjectTransformLayer(BaseLayerT &BaseLayer,
+ TransformFtor Transform = TransformFtor())
: BaseLayer(BaseLayer), Transform(std::move(Transform)) {}
/// Apply the transform functor to each object in the object set, then
namespace llvm {
namespace orc {
-class RTDyldObjectLinkingLayer2 : public ObjectLayer {
+class RTDyldObjectLinkingLayer : public ObjectLayer {
public:
/// Functor for receiving object-loaded notifications.
using NotifyLoadedFunction =
/// Construct an ObjectLinkingLayer with the given NotifyLoaded,
/// and NotifyEmitted functors.
- RTDyldObjectLinkingLayer2(
+ RTDyldObjectLinkingLayer(
ExecutionSession &ES, GetMemoryManagerFunction GetMemoryManager,
NotifyLoadedFunction NotifyLoaded = NotifyLoadedFunction(),
NotifyEmittedFunction NotifyEmitted = NotifyEmittedFunction());
/// the memory manager, rather than just the sections required for execution.
///
/// This is kludgy, and may be removed in the future.
- RTDyldObjectLinkingLayer2 &setProcessAllSections(bool ProcessAllSections) {
+ RTDyldObjectLinkingLayer &setProcessAllSections(bool ProcessAllSections) {
this->ProcessAllSections = ProcessAllSections;
return *this;
}
///
/// FIXME: We should be able to remove this if/when COFF properly tracks
/// exported symbols.
- RTDyldObjectLinkingLayer2 &
+ RTDyldObjectLinkingLayer &
setOverrideObjectFlagsWithResponsibilityFlags(bool OverrideObjectFlags) {
this->OverrideObjectFlags = OverrideObjectFlags;
return *this;
}
- /// If set, this RTDyldObjectLinkingLayer2 instance will claim responsibility
+ /// If set, this RTDyldObjectLinkingLayer instance will claim responsibility
/// for any symbols provided by a given object file that were not already in
/// the MaterializationResponsibility instance. Setting this flag allows
/// higher-level program representations (e.g. LLVM IR) to be added based on
/// deterministically). If this option is set, clashes for the additional
/// symbols may not be detected until late, and detection may depend on
/// the flow of control through JIT'd code. Use with care.
- RTDyldObjectLinkingLayer2 &
+ RTDyldObjectLinkingLayer &
setAutoClaimResponsibilityForObjectSymbols(bool AutoClaimObjectSymbols) {
this->AutoClaimObjectSymbols = AutoClaimObjectSymbols;
return *this;
std::map<VModuleKey, std::shared_ptr<RuntimeDyld::MemoryManager>> MemMgrs;
};
-class RTDyldObjectLinkingLayerBase {
+class LegacyRTDyldObjectLinkingLayerBase {
public:
using ObjectPtr = std::unique_ptr<MemoryBuffer>;
/// object files to be loaded into memory, linked, and the addresses of their
/// symbols queried. All objects added to this layer can see each other's
/// symbols.
-class RTDyldObjectLinkingLayer : public RTDyldObjectLinkingLayerBase {
+class LegacyRTDyldObjectLinkingLayer : public LegacyRTDyldObjectLinkingLayerBase {
public:
- using RTDyldObjectLinkingLayerBase::ObjectPtr;
+ using LegacyRTDyldObjectLinkingLayerBase::ObjectPtr;
/// Functor for receiving object-loaded notifications.
using NotifyLoadedFtor =
template <typename MemoryManagerPtrT>
class ConcreteLinkedObject : public LinkedObject {
public:
- ConcreteLinkedObject(RTDyldObjectLinkingLayer &Parent, VModuleKey K,
+ ConcreteLinkedObject(LegacyRTDyldObjectLinkingLayer &Parent, VModuleKey K,
OwnedObject Obj, MemoryManagerPtrT MemMgr,
std::shared_ptr<SymbolResolver> Resolver,
bool ProcessAllSections)
};
VModuleKey K;
- RTDyldObjectLinkingLayer &Parent;
+ LegacyRTDyldObjectLinkingLayer &Parent;
MemoryManagerPtrT MemMgr;
OwnedObject ObjForNotify;
std::unique_ptr<PreFinalizeContents> PFC;
template <typename MemoryManagerPtrT>
std::unique_ptr<ConcreteLinkedObject<MemoryManagerPtrT>>
- createLinkedObject(RTDyldObjectLinkingLayer &Parent, VModuleKey K,
+ createLinkedObject(LegacyRTDyldObjectLinkingLayer &Parent, VModuleKey K,
OwnedObject Obj, MemoryManagerPtrT MemMgr,
std::shared_ptr<SymbolResolver> Resolver,
bool ProcessAllSections) {
/// Construct an ObjectLinkingLayer with the given NotifyLoaded,
/// and NotifyFinalized functors.
- RTDyldObjectLinkingLayer(
+ LegacyRTDyldObjectLinkingLayer(
ExecutionSession &ES, ResourcesGetter GetResources,
NotifyLoadedFtor NotifyLoaded = NotifyLoadedFtor(),
NotifyFinalizedFtor NotifyFinalized = NotifyFinalizedFtor(),
class PartitioningIRMaterializationUnit : public IRMaterializationUnit {
public:
PartitioningIRMaterializationUnit(ExecutionSession &ES, ThreadSafeModule TSM,
- CompileOnDemandLayer2 &Parent)
+ CompileOnDemandLayer &Parent)
: IRMaterializationUnit(ES, std::move(TSM)), Parent(Parent) {}
PartitioningIRMaterializationUnit(
ThreadSafeModule TSM, SymbolFlagsMap SymbolFlags,
SymbolNameToDefinitionMap SymbolToDefinition,
- CompileOnDemandLayer2 &Parent)
+ CompileOnDemandLayer &Parent)
: IRMaterializationUnit(std::move(TSM), std::move(SymbolFlags),
std::move(SymbolToDefinition)),
Parent(Parent) {}
}
mutable std::mutex SourceModuleMutex;
- CompileOnDemandLayer2 &Parent;
+ CompileOnDemandLayer &Parent;
};
-Optional<CompileOnDemandLayer2::GlobalValueSet>
-CompileOnDemandLayer2::compileRequested(GlobalValueSet Requested) {
+Optional<CompileOnDemandLayer::GlobalValueSet>
+CompileOnDemandLayer::compileRequested(GlobalValueSet Requested) {
return std::move(Requested);
}
-Optional<CompileOnDemandLayer2::GlobalValueSet>
-CompileOnDemandLayer2::compileWholeModule(GlobalValueSet Requested) {
+Optional<CompileOnDemandLayer::GlobalValueSet>
+CompileOnDemandLayer::compileWholeModule(GlobalValueSet Requested) {
return None;
}
-CompileOnDemandLayer2::CompileOnDemandLayer2(
+CompileOnDemandLayer::CompileOnDemandLayer(
ExecutionSession &ES, IRLayer &BaseLayer, LazyCallThroughManager &LCTMgr,
IndirectStubsManagerBuilder BuildIndirectStubsManager)
: IRLayer(ES), BaseLayer(BaseLayer), LCTMgr(LCTMgr),
BuildIndirectStubsManager(std::move(BuildIndirectStubsManager)) {}
-void CompileOnDemandLayer2::setPartitionFunction(PartitionFunction Partition) {
+void CompileOnDemandLayer::setPartitionFunction(PartitionFunction Partition) {
this->Partition = std::move(Partition);
}
-void CompileOnDemandLayer2::emit(MaterializationResponsibility R, VModuleKey K,
+void CompileOnDemandLayer::emit(MaterializationResponsibility R, VModuleKey K,
ThreadSafeModule TSM) {
assert(TSM.getModule() && "Null module");
std::move(Callables)));
}
-CompileOnDemandLayer2::PerDylibResources &
-CompileOnDemandLayer2::getPerDylibResources(JITDylib &TargetD) {
+CompileOnDemandLayer::PerDylibResources &
+CompileOnDemandLayer::getPerDylibResources(JITDylib &TargetD) {
auto I = DylibResources.find(&TargetD);
if (I == DylibResources.end()) {
auto &ImplD =
return I->second;
}
-void CompileOnDemandLayer2::cleanUpModule(Module &M) {
+void CompileOnDemandLayer::cleanUpModule(Module &M) {
for (auto &F : M.functions()) {
if (F.isDeclaration())
continue;
}
}
-void CompileOnDemandLayer2::expandPartition(GlobalValueSet &Partition) {
+void CompileOnDemandLayer::expandPartition(GlobalValueSet &Partition) {
// Expands the partition to ensure the following rules hold:
// (1) If any alias is in the partition, its aliasee is also in the partition.
// (2) If any aliasee is in the partition, its aliases are also in the
Partition.insert(GV);
}
-void CompileOnDemandLayer2::emitPartition(
+void CompileOnDemandLayer::emitPartition(
MaterializationResponsibility R, ThreadSafeModule TSM,
IRMaterializationUnit::SymbolNameToDefinitionMap Defs) {
CtorDtorIterator(DtorsList, true));
}
-void CtorDtorRunner2::add(iterator_range<CtorDtorIterator> CtorDtors) {
+void CtorDtorRunner::add(iterator_range<CtorDtorIterator> CtorDtors) {
if (CtorDtors.begin() == CtorDtors.end())
return;
}
}
-Error CtorDtorRunner2::run() {
+Error CtorDtorRunner::run() {
using CtorDtorTy = void (*)();
SymbolNameSet Names;
return 0;
}
-Error LocalCXXRuntimeOverrides2::enable(JITDylib &JD,
+Error LocalCXXRuntimeOverrides::enable(JITDylib &JD,
MangleAndInterner &Mangle) {
SymbolMap RuntimeInterposes;
RuntimeInterposes[Mangle("__dso_handle")] =
namespace llvm {
namespace orc {
-IRCompileLayer2::IRCompileLayer2(ExecutionSession &ES, ObjectLayer &BaseLayer,
+IRCompileLayer::IRCompileLayer(ExecutionSession &ES, ObjectLayer &BaseLayer,
CompileFunction Compile)
: IRLayer(ES), BaseLayer(BaseLayer), Compile(std::move(Compile)) {}
-void IRCompileLayer2::setNotifyCompiled(NotifyCompiledFunction NotifyCompiled) {
+void IRCompileLayer::setNotifyCompiled(NotifyCompiledFunction NotifyCompiled) {
std::lock_guard<std::mutex> Lock(IRLayerMutex);
this->NotifyCompiled = std::move(NotifyCompiled);
}
-void IRCompileLayer2::emit(MaterializationResponsibility R, VModuleKey K,
+void IRCompileLayer::emit(MaterializationResponsibility R, VModuleKey K,
ThreadSafeModule TSM) {
assert(TSM.getModule() && "Module must not be null");
namespace llvm {
namespace orc {
-IRTransformLayer2::IRTransformLayer2(ExecutionSession &ES,
+IRTransformLayer::IRTransformLayer(ExecutionSession &ES,
IRLayer &BaseLayer,
TransformFunction Transform)
: IRLayer(ES), BaseLayer(BaseLayer), Transform(std::move(Transform)) {}
-void IRTransformLayer2::emit(MaterializationResponsibility R, VModuleKey K,
+void IRTransformLayer::emit(MaterializationResponsibility R, VModuleKey K,
ThreadSafeModule TSM) {
assert(TSM.getModule() && "Module must not be null");
: llvm::orc::SimpleCompiler(*TM), TM(std::move(TM)) {}
private:
// FIXME: shared because std::functions (and thus
- // IRCompileLayer2::CompileFunction) are not moveable.
+ // IRCompileLayer::CompileFunction) are not moveable.
std::shared_ptr<llvm::TargetMachine> TM;
};
namespace llvm {
namespace orc {
-ObjectTransformLayer2::ObjectTransformLayer2(ExecutionSession &ES,
- ObjectLayer &BaseLayer,
- TransformFunction Transform)
+ObjectTransformLayer::ObjectTransformLayer(ExecutionSession &ES,
+ ObjectLayer &BaseLayer,
+ TransformFunction Transform)
: ObjectLayer(ES), BaseLayer(BaseLayer), Transform(std::move(Transform)) {}
-void ObjectTransformLayer2::emit(MaterializationResponsibility R, VModuleKey K,
- std::unique_ptr<MemoryBuffer> O) {
+void ObjectTransformLayer::emit(MaterializationResponsibility R, VModuleKey K,
+ std::unique_ptr<MemoryBuffer> O) {
assert(O && "Module must not be null");
if (auto TransformedObj = Transform(std::move(O)))
};
template <>
- class GenericLayerImpl<orc::RTDyldObjectLinkingLayer> : public GenericLayer {
+ class GenericLayerImpl<orc::LegacyRTDyldObjectLinkingLayer> : public GenericLayer {
private:
- using LayerT = orc::RTDyldObjectLinkingLayer;
+ using LayerT = orc::LegacyRTDyldObjectLinkingLayer;
public:
GenericLayerImpl(LayerT &Layer) : Layer(Layer) {}
public:
using CompileCallbackMgr = orc::JITCompileCallbackManager;
- using ObjLayerT = orc::RTDyldObjectLinkingLayer;
- using CompileLayerT = orc::IRCompileLayer<ObjLayerT, orc::SimpleCompiler>;
+ using ObjLayerT = orc::LegacyRTDyldObjectLinkingLayer;
+ using CompileLayerT = orc::LegacyIRCompileLayer<ObjLayerT, orc::SimpleCompiler>;
using CODLayerT =
- orc::CompileOnDemandLayer<CompileLayerT, CompileCallbackMgr>;
+ orc::LegacyCompileOnDemandLayer<CompileLayerT, CompileCallbackMgr>;
using CallbackManagerBuilder =
std::function<std::unique_ptr<CompileCallbackMgr>()>;
// Run the static constructors, and save the static destructor runner for
// execution when the JIT is torn down.
- orc::CtorDtorRunner<OrcCBindingsStack> CtorRunner(std::move(CtorNames), K);
+ orc::LegacyCtorDtorRunner<OrcCBindingsStack> CtorRunner(std::move(CtorNames), K);
if (auto Err = CtorRunner.runViaLayer(*this))
return std::move(Err);
std::map<orc::VModuleKey, std::unique_ptr<detail::GenericLayer>> KeyLayers;
- orc::LocalCXXRuntimeOverrides CXXRuntimeOverrides;
- std::vector<orc::CtorDtorRunner<OrcCBindingsStack>> IRStaticDestructorRunners;
+ orc::LegacyLocalCXXRuntimeOverrides CXXRuntimeOverrides;
+ std::vector<orc::LegacyCtorDtorRunner<OrcCBindingsStack>> IRStaticDestructorRunners;
std::string ErrMsg;
ResolverMap Resolvers;
auto &CtorDtorsMap = isDtors ? UnexecutedDestructors : UnexecutedConstructors;
for (auto &KV : CtorDtorsMap)
- cantFail(CtorDtorRunner<LazyEmitLayerT>(std::move(KV.second), KV.first)
+ cantFail(LegacyCtorDtorRunner<LazyEmitLayerT>(std::move(KV.second), KV.first)
.runViaLayer(LazyEmitLayer));
CtorDtorsMap.clear();
return MangledName;
}
- using ObjectLayerT = RTDyldObjectLinkingLayer;
- using CompileLayerT = IRCompileLayer<ObjectLayerT, orc::SimpleCompiler>;
+ using ObjectLayerT = LegacyRTDyldObjectLinkingLayer;
+ using CompileLayerT = LegacyIRCompileLayer<ObjectLayerT, orc::SimpleCompiler>;
using LazyEmitLayerT = LazyEmittingLayer<CompileLayerT>;
ExecutionSession ES;
namespace llvm {
namespace orc {
-RTDyldObjectLinkingLayer2::RTDyldObjectLinkingLayer2(
+RTDyldObjectLinkingLayer::RTDyldObjectLinkingLayer(
ExecutionSession &ES, GetMemoryManagerFunction GetMemoryManager,
NotifyLoadedFunction NotifyLoaded, NotifyEmittedFunction NotifyEmitted)
: ObjectLayer(ES), GetMemoryManager(GetMemoryManager),
NotifyLoaded(std::move(NotifyLoaded)),
NotifyEmitted(std::move(NotifyEmitted)) {}
-void RTDyldObjectLinkingLayer2::emit(MaterializationResponsibility R,
+void RTDyldObjectLinkingLayer::emit(MaterializationResponsibility R,
VModuleKey K,
std::unique_ptr<MemoryBuffer> O) {
assert(O && "Object must not be null");
});
}
-Error RTDyldObjectLinkingLayer2::onObjLoad(
+Error RTDyldObjectLinkingLayer::onObjLoad(
VModuleKey K, MaterializationResponsibility &R, object::ObjectFile &Obj,
std::unique_ptr<RuntimeDyld::LoadedObjectInfo> LoadedObjInfo,
std::map<StringRef, JITEvaluatedSymbol> Resolved,
return Error::success();
}
-void RTDyldObjectLinkingLayer2::onObjEmit(VModuleKey K,
+void RTDyldObjectLinkingLayer::onObjEmit(VModuleKey K,
MaterializationResponsibility &R,
Error Err) {
if (Err) {
return Result;
}
-static orc::IRTransformLayer2::TransformFunction createDebugDumper() {
+static orc::IRTransformLayer::TransformFunction createDebugDumper() {
switch (OrcDumpKind) {
case DumpKind::NoDump:
return [](orc::ThreadSafeModule TSM,
auto J = ExitOnErr(orc::LLLazyJIT::Create(std::move(JTMB), DL, LazyJITCompileThreads));
if (PerModuleLazy)
- J->setPartitionFunction(orc::CompileOnDemandLayer2::compileWholeModule);
+ J->setPartitionFunction(orc::CompileOnDemandLayer::compileWholeModule);
auto Dump = createDebugDumper();
ExitOnErr(orc::DynamicLibrarySearchGenerator::GetForCurrentProcess(DL)));
orc::MangleAndInterner Mangle(J->getExecutionSession(), DL);
- orc::LocalCXXRuntimeOverrides2 CXXRuntimeOverrides;
+ orc::LocalCXXRuntimeOverrides CXXRuntimeOverrides;
ExitOnErr(CXXRuntimeOverrides.enable(J->getMainJITDylib(), Mangle));
// Add the main module.
)
add_llvm_unittest(OrcJITTests
- CompileOnDemandLayerTest.cpp
CoreAPIsTest.cpp
IndirectionUtilsTest.cpp
GlobalMappingLayerTest.cpp
LazyCallThroughAndReexportsTest.cpp
LazyEmittingLayerTest.cpp
LegacyAPIInteropTest.cpp
+ LegacyCompileOnDemandLayerTest.cpp
+ LegacyRTDyldObjectLinkingLayerTest.cpp
ObjectTransformLayerTest.cpp
OrcCAPITest.cpp
OrcTestCommon.cpp
RemoteObjectLayerTest.cpp
RPCUtilsTest.cpp
RTDyldObjectLinkingLayerTest.cpp
- RTDyldObjectLinkingLayer2Test.cpp
SymbolStringPoolTest.cpp
ThreadSafeModuleTest.cpp
)
}
};
-TEST(CompileOnDemandLayerTest, FindSymbol) {
+TEST(LegacyCompileOnDemandLayerTest, FindSymbol) {
MockBaseLayer<int, std::shared_ptr<Module>> TestBaseLayer;
TestBaseLayer.findSymbolImpl =
[](const std::string &Name, bool) {
llvm_unreachable("Should never be called");
};
- llvm::orc::CompileOnDemandLayer<decltype(TestBaseLayer)> COD(
+ llvm::orc::LegacyCompileOnDemandLayer<decltype(TestBaseLayer)> COD(
ES, TestBaseLayer, GetResolver, SetResolver,
[](Function &F) { return std::set<Function *>{&F}; }, CallbackMgr,
[] { return llvm::make_unique<DummyStubsManager>(); }, true);
--- /dev/null
+//===- RTDyldObjectLinkingLayerTest.cpp - RTDyld linking layer unit tests -===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "llvm/ExecutionEngine/Orc/RTDyldObjectLinkingLayer.h"
+#include "OrcTestCommon.h"
+#include "llvm/ExecutionEngine/ExecutionEngine.h"
+#include "llvm/ExecutionEngine/Orc/CompileUtils.h"
+#include "llvm/ExecutionEngine/Orc/LambdaResolver.h"
+#include "llvm/ExecutionEngine/Orc/Legacy.h"
+#include "llvm/ExecutionEngine/Orc/NullResolver.h"
+#include "llvm/ExecutionEngine/SectionMemoryManager.h"
+#include "llvm/IR/Constants.h"
+#include "llvm/IR/LLVMContext.h"
+#include "gtest/gtest.h"
+
+using namespace llvm;
+using namespace llvm::orc;
+
+namespace {
+
+class LegacyRTDyldObjectLinkingLayerExecutionTest : public testing::Test,
+ public OrcExecutionTest {
+
+};
+
+class SectionMemoryManagerWrapper : public SectionMemoryManager {
+public:
+ int FinalizationCount = 0;
+ int NeedsToReserveAllocationSpaceCount = 0;
+
+ bool needsToReserveAllocationSpace() override {
+ ++NeedsToReserveAllocationSpaceCount;
+ return SectionMemoryManager::needsToReserveAllocationSpace();
+ }
+
+ bool finalizeMemory(std::string *ErrMsg = nullptr) override {
+ ++FinalizationCount;
+ return SectionMemoryManager::finalizeMemory(ErrMsg);
+ }
+};
+
+TEST(LegacyRTDyldObjectLinkingLayerTest, TestSetProcessAllSections) {
+ class MemoryManagerWrapper : public SectionMemoryManager {
+ public:
+ MemoryManagerWrapper(bool &DebugSeen) : DebugSeen(DebugSeen) {}
+ uint8_t *allocateDataSection(uintptr_t Size, unsigned Alignment,
+ unsigned SectionID,
+ StringRef SectionName,
+ bool IsReadOnly) override {
+ if (SectionName == ".debug_str")
+ DebugSeen = true;
+ return SectionMemoryManager::allocateDataSection(Size, Alignment,
+ SectionID,
+ SectionName,
+ IsReadOnly);
+ }
+ private:
+ bool &DebugSeen;
+ };
+
+ bool DebugSectionSeen = false;
+ auto MM = std::make_shared<MemoryManagerWrapper>(DebugSectionSeen);
+
+ ExecutionSession ES;
+
+ LegacyRTDyldObjectLinkingLayer ObjLayer(ES, [&MM](VModuleKey) {
+ return LegacyRTDyldObjectLinkingLayer::Resources{
+ MM, std::make_shared<NullResolver>()};
+ });
+
+ LLVMContext Context;
+ auto M = llvm::make_unique<Module>("", Context);
+ M->setTargetTriple("x86_64-unknown-linux-gnu");
+ Type *Int32Ty = IntegerType::get(Context, 32);
+ GlobalVariable *GV =
+ new GlobalVariable(*M, Int32Ty, false, GlobalValue::ExternalLinkage,
+ ConstantInt::get(Int32Ty, 42), "foo");
+
+ GV->setSection(".debug_str");
+
+
+ // Initialize the native target in case this is the first unit test
+ // to try to build a TM.
+ OrcNativeTarget::initialize();
+ std::unique_ptr<TargetMachine> TM(
+ EngineBuilder().selectTarget(Triple(M->getTargetTriple()), "", "",
+ SmallVector<std::string, 1>()));
+ if (!TM)
+ return;
+
+ auto Obj = SimpleCompiler(*TM)(*M);
+
+ {
+ // Test with ProcessAllSections = false (the default).
+ auto K = ES.allocateVModule();
+ cantFail(ObjLayer.addObject(
+ K, MemoryBuffer::getMemBufferCopy(Obj->getBuffer())));
+ cantFail(ObjLayer.emitAndFinalize(K));
+ EXPECT_EQ(DebugSectionSeen, false)
+ << "Unexpected debug info section";
+ cantFail(ObjLayer.removeObject(K));
+ }
+
+ {
+ // Test with ProcessAllSections = true.
+ ObjLayer.setProcessAllSections(true);
+ auto K = ES.allocateVModule();
+ cantFail(ObjLayer.addObject(K, std::move(Obj)));
+ cantFail(ObjLayer.emitAndFinalize(K));
+ EXPECT_EQ(DebugSectionSeen, true)
+ << "Expected debug info section not seen";
+ cantFail(ObjLayer.removeObject(K));
+ }
+}
+
+TEST_F(LegacyRTDyldObjectLinkingLayerExecutionTest, NoDuplicateFinalization) {
+ if (!SupportsJIT)
+ return;
+
+ ExecutionSession ES;
+
+ auto MM = std::make_shared<SectionMemoryManagerWrapper>();
+
+ std::map<orc::VModuleKey, std::shared_ptr<orc::SymbolResolver>> Resolvers;
+
+ LegacyRTDyldObjectLinkingLayer ObjLayer(ES, [&](VModuleKey K) {
+ auto I = Resolvers.find(K);
+ assert(I != Resolvers.end() && "Missing resolver");
+ auto R = std::move(I->second);
+ Resolvers.erase(I);
+ return LegacyRTDyldObjectLinkingLayer::Resources{MM, std::move(R)};
+ });
+ SimpleCompiler Compile(*TM);
+
+ // Create a pair of modules that will trigger recursive finalization:
+ // Module 1:
+ // int bar() { return 42; }
+ // Module 2:
+ // int bar();
+ // int foo() { return bar(); }
+ //
+ // Verify that the memory manager is only finalized once (for Module 2).
+ // Failure suggests that finalize is being called on the inner RTDyld
+ // instance (for Module 1) which is unsafe, as it will prevent relocation of
+ // Module 2.
+
+ ModuleBuilder MB1(Context, "", "dummy");
+ {
+ MB1.getModule()->setDataLayout(TM->createDataLayout());
+ Function *BarImpl = MB1.createFunctionDecl<int32_t(void)>("bar");
+ BasicBlock *BarEntry = BasicBlock::Create(Context, "entry", BarImpl);
+ IRBuilder<> Builder(BarEntry);
+ IntegerType *Int32Ty = IntegerType::get(Context, 32);
+ Value *FourtyTwo = ConstantInt::getSigned(Int32Ty, 42);
+ Builder.CreateRet(FourtyTwo);
+ }
+
+ auto Obj1 = Compile(*MB1.getModule());
+
+ ModuleBuilder MB2(Context, "", "dummy");
+ {
+ MB2.getModule()->setDataLayout(TM->createDataLayout());
+ Function *BarDecl = MB2.createFunctionDecl<int32_t(void)>("bar");
+ Function *FooImpl = MB2.createFunctionDecl<int32_t(void)>("foo");
+ BasicBlock *FooEntry = BasicBlock::Create(Context, "entry", FooImpl);
+ IRBuilder<> Builder(FooEntry);
+ Builder.CreateRet(Builder.CreateCall(BarDecl));
+ }
+ auto Obj2 = Compile(*MB2.getModule());
+
+ auto K1 = ES.allocateVModule();
+ Resolvers[K1] = std::make_shared<NullResolver>();
+ cantFail(ObjLayer.addObject(K1, std::move(Obj1)));
+
+ auto K2 = ES.allocateVModule();
+ auto LegacyLookup = [&](const std::string &Name) {
+ return ObjLayer.findSymbol(Name, true);
+ };
+
+ Resolvers[K2] = createSymbolResolver(
+ [&](const SymbolNameSet &Symbols) {
+ return cantFail(
+ getResponsibilitySetWithLegacyFn(Symbols, LegacyLookup));
+ },
+ [&](std::shared_ptr<AsynchronousSymbolQuery> Query,
+ const SymbolNameSet &Symbols) {
+ return lookupWithLegacyFn(ES, *Query, Symbols, LegacyLookup);
+ });
+
+ cantFail(ObjLayer.addObject(K2, std::move(Obj2)));
+ cantFail(ObjLayer.emitAndFinalize(K2));
+ cantFail(ObjLayer.removeObject(K2));
+
+ // Finalization of module 2 should trigger finalization of module 1.
+ // Verify that finalize on SMMW is only called once.
+ EXPECT_EQ(MM->FinalizationCount, 1)
+ << "Extra call to finalize";
+}
+
+TEST_F(LegacyRTDyldObjectLinkingLayerExecutionTest, NoPrematureAllocation) {
+ if (!SupportsJIT)
+ return;
+
+ ExecutionSession ES;
+
+ auto MM = std::make_shared<SectionMemoryManagerWrapper>();
+
+ LegacyRTDyldObjectLinkingLayer ObjLayer(ES, [&MM](VModuleKey K) {
+ return LegacyRTDyldObjectLinkingLayer::Resources{
+ MM, std::make_shared<NullResolver>()};
+ });
+ SimpleCompiler Compile(*TM);
+
+ // Create a pair of unrelated modules:
+ //
+ // Module 1:
+ // int foo() { return 42; }
+ // Module 2:
+ // int bar() { return 7; }
+ //
+ // Both modules will share a memory manager. We want to verify that the
+ // second object is not loaded before the first one is finalized. To do this
+ // in a portable way, we abuse the
+ // RuntimeDyld::MemoryManager::needsToReserveAllocationSpace hook, which is
+ // called once per object before any sections are allocated.
+
+ ModuleBuilder MB1(Context, "", "dummy");
+ {
+ MB1.getModule()->setDataLayout(TM->createDataLayout());
+ Function *BarImpl = MB1.createFunctionDecl<int32_t(void)>("foo");
+ BasicBlock *BarEntry = BasicBlock::Create(Context, "entry", BarImpl);
+ IRBuilder<> Builder(BarEntry);
+ IntegerType *Int32Ty = IntegerType::get(Context, 32);
+ Value *FourtyTwo = ConstantInt::getSigned(Int32Ty, 42);
+ Builder.CreateRet(FourtyTwo);
+ }
+
+ auto Obj1 = Compile(*MB1.getModule());
+
+ ModuleBuilder MB2(Context, "", "dummy");
+ {
+ MB2.getModule()->setDataLayout(TM->createDataLayout());
+ Function *BarImpl = MB2.createFunctionDecl<int32_t(void)>("bar");
+ BasicBlock *BarEntry = BasicBlock::Create(Context, "entry", BarImpl);
+ IRBuilder<> Builder(BarEntry);
+ IntegerType *Int32Ty = IntegerType::get(Context, 32);
+ Value *Seven = ConstantInt::getSigned(Int32Ty, 7);
+ Builder.CreateRet(Seven);
+ }
+ auto Obj2 = Compile(*MB2.getModule());
+
+ auto K = ES.allocateVModule();
+ cantFail(ObjLayer.addObject(K, std::move(Obj1)));
+ cantFail(ObjLayer.addObject(ES.allocateVModule(), std::move(Obj2)));
+ cantFail(ObjLayer.emitAndFinalize(K));
+ cantFail(ObjLayer.removeObject(K));
+
+ // Only one call to needsToReserveAllocationSpace should have been made.
+ EXPECT_EQ(MM->NeedsToReserveAllocationSpaceCount, 1)
+ << "More than one call to needsToReserveAllocationSpace "
+ "(multiple unrelated objects loaded prior to finalization)";
+}
+
+TEST_F(LegacyRTDyldObjectLinkingLayerExecutionTest, TestNotifyLoadedSignature) {
+ ExecutionSession ES;
+ LegacyRTDyldObjectLinkingLayer ObjLayer(
+ ES,
+ [](VModuleKey) {
+ return LegacyRTDyldObjectLinkingLayer::Resources{
+ nullptr, std::make_shared<NullResolver>()};
+ },
+ [](VModuleKey, const object::ObjectFile &obj,
+ const RuntimeDyld::LoadedObjectInfo &info) {});
+}
+
+} // end anonymous namespace
}
};
-// Test each operation on ObjectTransformLayer.
-TEST(ObjectTransformLayerTest, Main) {
+// Test each operation on LegacyObjectTransformLayer.
+TEST(LegacyObjectTransformLayerTest, Main) {
MockBaseLayer M;
ExecutionSession ES(std::make_shared<SymbolStringPool>());
// Create one object transform layer using a transform (as a functor)
// that allocates new objects, and deals in unique pointers.
- ObjectTransformLayer<MockBaseLayer, AllocatingTransform> T1(M);
+ LegacyObjectTransformLayer<MockBaseLayer, AllocatingTransform> T1(M);
// Create a second object transform layer using a transform (as a lambda)
// that mutates objects in place, and deals in naked pointers
- ObjectTransformLayer<MockBaseLayer,
+ LegacyObjectTransformLayer<MockBaseLayer,
std::function<std::shared_ptr<MockObjectFile>(
std::shared_ptr<MockObjectFile>)>>
T2(M, [](std::shared_ptr<MockObjectFile> Obj) {
if (!RunStaticChecks)
return;
- // Make sure that ObjectTransformLayer implements the object layer concept
+ // Make sure that LegacyObjectTransformLayer implements the object layer concept
// correctly by sandwitching one between an ObjectLinkingLayer and an
- // IRCompileLayer, verifying that it compiles if we have a call to the
+ // LegacyIRCompileLayer, verifying that it compiles if we have a call to the
// IRComileLayer's addModule that should call the transform layer's
// addObject, and also calling the other public transform layer methods
// directly to make sure the methods they intend to forward to exist on
};
// Construct the jit layers.
- RTDyldObjectLinkingLayer BaseLayer(ES, [](VModuleKey) {
- return RTDyldObjectLinkingLayer::Resources{
+ LegacyRTDyldObjectLinkingLayer BaseLayer(ES, [](VModuleKey) {
+ return LegacyRTDyldObjectLinkingLayer::Resources{
std::make_shared<llvm::SectionMemoryManager>(),
std::make_shared<NullResolver>()};
});
auto IdentityTransform = [](std::unique_ptr<llvm::MemoryBuffer> Obj) {
return Obj;
};
- ObjectTransformLayer<decltype(BaseLayer), decltype(IdentityTransform)>
+ LegacyObjectTransformLayer<decltype(BaseLayer), decltype(IdentityTransform)>
TransformLayer(BaseLayer, IdentityTransform);
auto NullCompiler = [](llvm::Module &) {
return std::unique_ptr<llvm::MemoryBuffer>(nullptr);
};
- IRCompileLayer<decltype(TransformLayer), decltype(NullCompiler)>
+ LegacyIRCompileLayer<decltype(TransformLayer), decltype(NullCompiler)>
CompileLayer(TransformLayer, NullCompiler);
- // Make sure that the calls from IRCompileLayer to ObjectTransformLayer
+ // Make sure that the calls from LegacyIRCompileLayer to LegacyObjectTransformLayer
// compile.
cantFail(CompileLayer.addModule(ES.allocateVModule(),
std::unique_ptr<llvm::Module>()));
- // Make sure that the calls from ObjectTransformLayer to ObjectLinkingLayer
+ // Make sure that the calls from LegacyObjectTransformLayer to ObjectLinkingLayer
// compile.
VModuleKey DummyKey = ES.allocateVModule();
cantFail(TransformLayer.emitAndFinalize(DummyKey));
+++ /dev/null
-//===--- RTDyldObjectLinkingLayer2Test.cpp - RTDyld linking layer tests ---===//
-//
-// The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-
-#include "OrcTestCommon.h"
-#include "llvm/ExecutionEngine/ExecutionEngine.h"
-#include "llvm/ExecutionEngine/Orc/CompileUtils.h"
-#include "llvm/ExecutionEngine/Orc/IRCompileLayer.h"
-#include "llvm/ExecutionEngine/Orc/LambdaResolver.h"
-#include "llvm/ExecutionEngine/Orc/Legacy.h"
-#include "llvm/ExecutionEngine/Orc/NullResolver.h"
-#include "llvm/ExecutionEngine/Orc/RTDyldObjectLinkingLayer.h"
-#include "llvm/ExecutionEngine/SectionMemoryManager.h"
-#include "llvm/IR/Constants.h"
-#include "llvm/IR/LLVMContext.h"
-#include "gtest/gtest.h"
-
-using namespace llvm;
-using namespace llvm::orc;
-
-namespace {
-
-class RTDyldObjectLinkingLayer2ExecutionTest : public testing::Test,
- public OrcExecutionTest {};
-
-// Adds an object with a debug section to RuntimeDyld and then returns whether
-// the debug section was passed to the memory manager.
-static bool testSetProcessAllSections(std::unique_ptr<MemoryBuffer> Obj,
- bool ProcessAllSections) {
- class MemoryManagerWrapper : public SectionMemoryManager {
- public:
- MemoryManagerWrapper(bool &DebugSeen) : DebugSeen(DebugSeen) {}
- uint8_t *allocateDataSection(uintptr_t Size, unsigned Alignment,
- unsigned SectionID, StringRef SectionName,
- bool IsReadOnly) override {
- if (SectionName == ".debug_str")
- DebugSeen = true;
- return SectionMemoryManager::allocateDataSection(
- Size, Alignment, SectionID, SectionName, IsReadOnly);
- }
-
- private:
- bool &DebugSeen;
- };
-
- bool DebugSectionSeen = false;
-
- ExecutionSession ES;
- auto &JD = ES.createJITDylib("main");
- auto Foo = ES.intern("foo");
-
- RTDyldObjectLinkingLayer2 ObjLayer(ES, [&DebugSectionSeen](VModuleKey) {
- return llvm::make_unique<MemoryManagerWrapper>(DebugSectionSeen);
- });
-
- auto OnResolveDoNothing = [](Expected<SymbolMap> R) {
- cantFail(std::move(R));
- };
-
- auto OnReadyDoNothing = [](Error Err) { cantFail(std::move(Err)); };
-
- ObjLayer.setProcessAllSections(ProcessAllSections);
- auto K = ES.allocateVModule();
- cantFail(ObjLayer.add(JD, K, std::move(Obj)));
- ES.lookup({&JD}, {Foo}, OnResolveDoNothing, OnReadyDoNothing,
- NoDependenciesToRegister);
- return DebugSectionSeen;
-}
-
-TEST(RTDyldObjectLinkingLayer2Test, TestSetProcessAllSections) {
- LLVMContext Context;
- auto M = llvm::make_unique<Module>("", Context);
- M->setTargetTriple("x86_64-unknown-linux-gnu");
- Type *Int32Ty = IntegerType::get(Context, 32);
- GlobalVariable *GV =
- new GlobalVariable(*M, Int32Ty, false, GlobalValue::ExternalLinkage,
- ConstantInt::get(Int32Ty, 42), "foo");
-
- GV->setSection(".debug_str");
-
- // Initialize the native target in case this is the first unit test
- // to try to build a TM.
- OrcNativeTarget::initialize();
- std::unique_ptr<TargetMachine> TM(EngineBuilder().selectTarget(
- Triple(M->getTargetTriple()), "", "", SmallVector<std::string, 1>()));
- if (!TM)
- return;
-
- auto Obj = SimpleCompiler(*TM)(*M);
-
- EXPECT_FALSE(testSetProcessAllSections(
- MemoryBuffer::getMemBufferCopy(Obj->getBuffer()), false))
- << "Debug section seen despite ProcessAllSections being false";
- EXPECT_TRUE(testSetProcessAllSections(std::move(Obj), true))
- << "Expected to see debug section when ProcessAllSections is true";
-}
-
-TEST(RTDyldObjectLinkingLayer2Test, TestOverrideObjectFlags) {
-
- OrcNativeTarget::initialize();
-
- std::unique_ptr<TargetMachine> TM(
- EngineBuilder().selectTarget(Triple("x86_64-unknown-linux-gnu"), "", "",
- SmallVector<std::string, 1>()));
-
- if (!TM)
- return;
-
- // Our compiler is going to modify symbol visibility settings without telling
- // ORC. This will test our ability to override the flags later.
- class FunkySimpleCompiler : public SimpleCompiler {
- public:
- FunkySimpleCompiler(TargetMachine &TM) : SimpleCompiler(TM) {}
-
- CompileResult operator()(Module &M) {
- auto *Foo = M.getFunction("foo");
- assert(Foo && "Expected function Foo not found");
- Foo->setVisibility(GlobalValue::HiddenVisibility);
- return SimpleCompiler::operator()(M);
- }
- };
-
- // Create a module with two void() functions: foo and bar.
- ThreadSafeContext TSCtx(llvm::make_unique<LLVMContext>());
- ThreadSafeModule M;
- {
- ModuleBuilder MB(*TSCtx.getContext(), TM->getTargetTriple().str(), "dummy");
- MB.getModule()->setDataLayout(TM->createDataLayout());
-
- Function *FooImpl = MB.createFunctionDecl<void()>("foo");
- BasicBlock *FooEntry =
- BasicBlock::Create(*TSCtx.getContext(), "entry", FooImpl);
- IRBuilder<> B1(FooEntry);
- B1.CreateRetVoid();
-
- Function *BarImpl = MB.createFunctionDecl<void()>("bar");
- BasicBlock *BarEntry =
- BasicBlock::Create(*TSCtx.getContext(), "entry", BarImpl);
- IRBuilder<> B2(BarEntry);
- B2.CreateRetVoid();
-
- M = ThreadSafeModule(MB.takeModule(), std::move(TSCtx));
- }
-
- // Create a simple stack and set the override flags option.
- ExecutionSession ES;
- auto &JD = ES.createJITDylib("main");
- auto Foo = ES.intern("foo");
- RTDyldObjectLinkingLayer2 ObjLayer(
- ES, [](VModuleKey) { return llvm::make_unique<SectionMemoryManager>(); });
- IRCompileLayer2 CompileLayer(ES, ObjLayer, FunkySimpleCompiler(*TM));
-
- ObjLayer.setOverrideObjectFlagsWithResponsibilityFlags(true);
-
- cantFail(CompileLayer.add(JD, ES.allocateVModule(), std::move(M)));
- ES.lookup({&JD}, {Foo}, [](Expected<SymbolMap> R) { cantFail(std::move(R)); },
- [](Error Err) { cantFail(std::move(Err)); },
- NoDependenciesToRegister);
-}
-
-TEST(RTDyldObjectLinkingLayer2Test, TestAutoClaimResponsibilityForSymbols) {
-
- OrcNativeTarget::initialize();
-
- std::unique_ptr<TargetMachine> TM(
- EngineBuilder().selectTarget(Triple("x86_64-unknown-linux-gnu"), "", "",
- SmallVector<std::string, 1>()));
-
- if (!TM)
- return;
-
- // Our compiler is going to add a new symbol without telling ORC.
- // This will test our ability to auto-claim responsibility later.
- class FunkySimpleCompiler : public SimpleCompiler {
- public:
- FunkySimpleCompiler(TargetMachine &TM) : SimpleCompiler(TM) {}
-
- CompileResult operator()(Module &M) {
- Function *BarImpl =
- Function::Create(TypeBuilder<void(), false>::get(M.getContext()),
- GlobalValue::ExternalLinkage, "bar", &M);
- BasicBlock *BarEntry =
- BasicBlock::Create(M.getContext(), "entry", BarImpl);
- IRBuilder<> B(BarEntry);
- B.CreateRetVoid();
-
- return SimpleCompiler::operator()(M);
- }
- };
-
- // Create a module with two void() functions: foo and bar.
- ThreadSafeContext TSCtx(llvm::make_unique<LLVMContext>());
- ThreadSafeModule M;
- {
- ModuleBuilder MB(*TSCtx.getContext(), TM->getTargetTriple().str(), "dummy");
- MB.getModule()->setDataLayout(TM->createDataLayout());
-
- Function *FooImpl = MB.createFunctionDecl<void()>("foo");
- BasicBlock *FooEntry =
- BasicBlock::Create(*TSCtx.getContext(), "entry", FooImpl);
- IRBuilder<> B(FooEntry);
- B.CreateRetVoid();
-
- M = ThreadSafeModule(MB.takeModule(), std::move(TSCtx));
- }
-
- // Create a simple stack and set the override flags option.
- ExecutionSession ES;
- auto &JD = ES.createJITDylib("main");
- auto Foo = ES.intern("foo");
- RTDyldObjectLinkingLayer2 ObjLayer(
- ES, [](VModuleKey) { return llvm::make_unique<SectionMemoryManager>(); });
- IRCompileLayer2 CompileLayer(ES, ObjLayer, FunkySimpleCompiler(*TM));
-
- ObjLayer.setAutoClaimResponsibilityForObjectSymbols(true);
-
- cantFail(CompileLayer.add(JD, ES.allocateVModule(), std::move(M)));
- ES.lookup({&JD}, {Foo}, [](Expected<SymbolMap> R) { cantFail(std::move(R)); },
- [](Error Err) { cantFail(std::move(Err)); },
- NoDependenciesToRegister);
-}
-
-} // end anonymous namespace
-//===- RTDyldObjectLinkingLayerTest.cpp - RTDyld linking layer unit tests -===//
+//===--- RTDyldObjectLinkingLayerTest.cpp - RTDyld linking layer tests ---===//
//
// The LLVM Compiler Infrastructure
//
//
//===----------------------------------------------------------------------===//
-#include "llvm/ExecutionEngine/Orc/RTDyldObjectLinkingLayer.h"
#include "OrcTestCommon.h"
#include "llvm/ExecutionEngine/ExecutionEngine.h"
#include "llvm/ExecutionEngine/Orc/CompileUtils.h"
+#include "llvm/ExecutionEngine/Orc/IRCompileLayer.h"
#include "llvm/ExecutionEngine/Orc/LambdaResolver.h"
#include "llvm/ExecutionEngine/Orc/Legacy.h"
#include "llvm/ExecutionEngine/Orc/NullResolver.h"
+#include "llvm/ExecutionEngine/Orc/RTDyldObjectLinkingLayer.h"
#include "llvm/ExecutionEngine/SectionMemoryManager.h"
#include "llvm/IR/Constants.h"
#include "llvm/IR/LLVMContext.h"
namespace {
class RTDyldObjectLinkingLayerExecutionTest : public testing::Test,
- public OrcExecutionTest {
-
-};
-
-class SectionMemoryManagerWrapper : public SectionMemoryManager {
-public:
- int FinalizationCount = 0;
- int NeedsToReserveAllocationSpaceCount = 0;
-
- bool needsToReserveAllocationSpace() override {
- ++NeedsToReserveAllocationSpaceCount;
- return SectionMemoryManager::needsToReserveAllocationSpace();
- }
-
- bool finalizeMemory(std::string *ErrMsg = nullptr) override {
- ++FinalizationCount;
- return SectionMemoryManager::finalizeMemory(ErrMsg);
- }
-};
+ public OrcExecutionTest {};
-TEST(RTDyldObjectLinkingLayerTest, TestSetProcessAllSections) {
+// Adds an object with a debug section to RuntimeDyld and then returns whether
+// the debug section was passed to the memory manager.
+static bool testSetProcessAllSections(std::unique_ptr<MemoryBuffer> Obj,
+ bool ProcessAllSections) {
class MemoryManagerWrapper : public SectionMemoryManager {
public:
MemoryManagerWrapper(bool &DebugSeen) : DebugSeen(DebugSeen) {}
uint8_t *allocateDataSection(uintptr_t Size, unsigned Alignment,
- unsigned SectionID,
- StringRef SectionName,
+ unsigned SectionID, StringRef SectionName,
bool IsReadOnly) override {
if (SectionName == ".debug_str")
DebugSeen = true;
- return SectionMemoryManager::allocateDataSection(Size, Alignment,
- SectionID,
- SectionName,
- IsReadOnly);
+ return SectionMemoryManager::allocateDataSection(
+ Size, Alignment, SectionID, SectionName, IsReadOnly);
}
+
private:
bool &DebugSeen;
};
bool DebugSectionSeen = false;
- auto MM = std::make_shared<MemoryManagerWrapper>(DebugSectionSeen);
ExecutionSession ES;
+ auto &JD = ES.createJITDylib("main");
+ auto Foo = ES.intern("foo");
- RTDyldObjectLinkingLayer ObjLayer(ES, [&MM](VModuleKey) {
- return RTDyldObjectLinkingLayer::Resources{
- MM, std::make_shared<NullResolver>()};
+ RTDyldObjectLinkingLayer ObjLayer(ES, [&DebugSectionSeen](VModuleKey) {
+ return llvm::make_unique<MemoryManagerWrapper>(DebugSectionSeen);
});
+ auto OnResolveDoNothing = [](Expected<SymbolMap> R) {
+ cantFail(std::move(R));
+ };
+
+ auto OnReadyDoNothing = [](Error Err) { cantFail(std::move(Err)); };
+
+ ObjLayer.setProcessAllSections(ProcessAllSections);
+ auto K = ES.allocateVModule();
+ cantFail(ObjLayer.add(JD, K, std::move(Obj)));
+ ES.lookup({&JD}, {Foo}, OnResolveDoNothing, OnReadyDoNothing,
+ NoDependenciesToRegister);
+ return DebugSectionSeen;
+}
+
+TEST(RTDyldObjectLinkingLayerTest, TestSetProcessAllSections) {
LLVMContext Context;
auto M = llvm::make_unique<Module>("", Context);
M->setTargetTriple("x86_64-unknown-linux-gnu");
Type *Int32Ty = IntegerType::get(Context, 32);
GlobalVariable *GV =
- new GlobalVariable(*M, Int32Ty, false, GlobalValue::ExternalLinkage,
+ new GlobalVariable(*M, Int32Ty, false, GlobalValue::ExternalLinkage,
ConstantInt::get(Int32Ty, 42), "foo");
GV->setSection(".debug_str");
-
// Initialize the native target in case this is the first unit test
// to try to build a TM.
OrcNativeTarget::initialize();
- std::unique_ptr<TargetMachine> TM(
- EngineBuilder().selectTarget(Triple(M->getTargetTriple()), "", "",
- SmallVector<std::string, 1>()));
+ std::unique_ptr<TargetMachine> TM(EngineBuilder().selectTarget(
+ Triple(M->getTargetTriple()), "", "", SmallVector<std::string, 1>()));
if (!TM)
return;
auto Obj = SimpleCompiler(*TM)(*M);
- {
- // Test with ProcessAllSections = false (the default).
- auto K = ES.allocateVModule();
- cantFail(ObjLayer.addObject(
- K, MemoryBuffer::getMemBufferCopy(Obj->getBuffer())));
- cantFail(ObjLayer.emitAndFinalize(K));
- EXPECT_EQ(DebugSectionSeen, false)
- << "Unexpected debug info section";
- cantFail(ObjLayer.removeObject(K));
- }
-
- {
- // Test with ProcessAllSections = true.
- ObjLayer.setProcessAllSections(true);
- auto K = ES.allocateVModule();
- cantFail(ObjLayer.addObject(K, std::move(Obj)));
- cantFail(ObjLayer.emitAndFinalize(K));
- EXPECT_EQ(DebugSectionSeen, true)
- << "Expected debug info section not seen";
- cantFail(ObjLayer.removeObject(K));
- }
+ EXPECT_FALSE(testSetProcessAllSections(
+ MemoryBuffer::getMemBufferCopy(Obj->getBuffer()), false))
+ << "Debug section seen despite ProcessAllSections being false";
+ EXPECT_TRUE(testSetProcessAllSections(std::move(Obj), true))
+ << "Expected to see debug section when ProcessAllSections is true";
}
-TEST_F(RTDyldObjectLinkingLayerExecutionTest, NoDuplicateFinalization) {
- if (!SupportsJIT)
- return;
+TEST(RTDyldObjectLinkingLayerTest, TestOverrideObjectFlags) {
- ExecutionSession ES;
+ OrcNativeTarget::initialize();
- auto MM = std::make_shared<SectionMemoryManagerWrapper>();
+ std::unique_ptr<TargetMachine> TM(
+ EngineBuilder().selectTarget(Triple("x86_64-unknown-linux-gnu"), "", "",
+ SmallVector<std::string, 1>()));
- std::map<orc::VModuleKey, std::shared_ptr<orc::SymbolResolver>> Resolvers;
+ if (!TM)
+ return;
- RTDyldObjectLinkingLayer ObjLayer(ES, [&](VModuleKey K) {
- auto I = Resolvers.find(K);
- assert(I != Resolvers.end() && "Missing resolver");
- auto R = std::move(I->second);
- Resolvers.erase(I);
- return RTDyldObjectLinkingLayer::Resources{MM, std::move(R)};
- });
- SimpleCompiler Compile(*TM);
-
- // Create a pair of modules that will trigger recursive finalization:
- // Module 1:
- // int bar() { return 42; }
- // Module 2:
- // int bar();
- // int foo() { return bar(); }
- //
- // Verify that the memory manager is only finalized once (for Module 2).
- // Failure suggests that finalize is being called on the inner RTDyld
- // instance (for Module 1) which is unsafe, as it will prevent relocation of
- // Module 2.
-
- ModuleBuilder MB1(Context, "", "dummy");
- {
- MB1.getModule()->setDataLayout(TM->createDataLayout());
- Function *BarImpl = MB1.createFunctionDecl<int32_t(void)>("bar");
- BasicBlock *BarEntry = BasicBlock::Create(Context, "entry", BarImpl);
- IRBuilder<> Builder(BarEntry);
- IntegerType *Int32Ty = IntegerType::get(Context, 32);
- Value *FourtyTwo = ConstantInt::getSigned(Int32Ty, 42);
- Builder.CreateRet(FourtyTwo);
- }
+ // Our compiler is going to modify symbol visibility settings without telling
+ // ORC. This will test our ability to override the flags later.
+ class FunkySimpleCompiler : public SimpleCompiler {
+ public:
+ FunkySimpleCompiler(TargetMachine &TM) : SimpleCompiler(TM) {}
- auto Obj1 = Compile(*MB1.getModule());
+ CompileResult operator()(Module &M) {
+ auto *Foo = M.getFunction("foo");
+ assert(Foo && "Expected function Foo not found");
+ Foo->setVisibility(GlobalValue::HiddenVisibility);
+ return SimpleCompiler::operator()(M);
+ }
+ };
- ModuleBuilder MB2(Context, "", "dummy");
+ // Create a module with two void() functions: foo and bar.
+ ThreadSafeContext TSCtx(llvm::make_unique<LLVMContext>());
+ ThreadSafeModule M;
{
- MB2.getModule()->setDataLayout(TM->createDataLayout());
- Function *BarDecl = MB2.createFunctionDecl<int32_t(void)>("bar");
- Function *FooImpl = MB2.createFunctionDecl<int32_t(void)>("foo");
- BasicBlock *FooEntry = BasicBlock::Create(Context, "entry", FooImpl);
- IRBuilder<> Builder(FooEntry);
- Builder.CreateRet(Builder.CreateCall(BarDecl));
+ ModuleBuilder MB(*TSCtx.getContext(), TM->getTargetTriple().str(), "dummy");
+ MB.getModule()->setDataLayout(TM->createDataLayout());
+
+ Function *FooImpl = MB.createFunctionDecl<void()>("foo");
+ BasicBlock *FooEntry =
+ BasicBlock::Create(*TSCtx.getContext(), "entry", FooImpl);
+ IRBuilder<> B1(FooEntry);
+ B1.CreateRetVoid();
+
+ Function *BarImpl = MB.createFunctionDecl<void()>("bar");
+ BasicBlock *BarEntry =
+ BasicBlock::Create(*TSCtx.getContext(), "entry", BarImpl);
+ IRBuilder<> B2(BarEntry);
+ B2.CreateRetVoid();
+
+ M = ThreadSafeModule(MB.takeModule(), std::move(TSCtx));
}
- auto Obj2 = Compile(*MB2.getModule());
- auto K1 = ES.allocateVModule();
- Resolvers[K1] = std::make_shared<NullResolver>();
- cantFail(ObjLayer.addObject(K1, std::move(Obj1)));
+ // Create a simple stack and set the override flags option.
+ ExecutionSession ES;
+ auto &JD = ES.createJITDylib("main");
+ auto Foo = ES.intern("foo");
+ RTDyldObjectLinkingLayer ObjLayer(
+ ES, [](VModuleKey) { return llvm::make_unique<SectionMemoryManager>(); });
+ IRCompileLayer CompileLayer(ES, ObjLayer, FunkySimpleCompiler(*TM));
- auto K2 = ES.allocateVModule();
- auto LegacyLookup = [&](const std::string &Name) {
- return ObjLayer.findSymbol(Name, true);
- };
+ ObjLayer.setOverrideObjectFlagsWithResponsibilityFlags(true);
- Resolvers[K2] = createSymbolResolver(
- [&](const SymbolNameSet &Symbols) {
- return cantFail(
- getResponsibilitySetWithLegacyFn(Symbols, LegacyLookup));
- },
- [&](std::shared_ptr<AsynchronousSymbolQuery> Query,
- const SymbolNameSet &Symbols) {
- return lookupWithLegacyFn(ES, *Query, Symbols, LegacyLookup);
- });
-
- cantFail(ObjLayer.addObject(K2, std::move(Obj2)));
- cantFail(ObjLayer.emitAndFinalize(K2));
- cantFail(ObjLayer.removeObject(K2));
-
- // Finalization of module 2 should trigger finalization of module 1.
- // Verify that finalize on SMMW is only called once.
- EXPECT_EQ(MM->FinalizationCount, 1)
- << "Extra call to finalize";
+ cantFail(CompileLayer.add(JD, ES.allocateVModule(), std::move(M)));
+ ES.lookup({&JD}, {Foo}, [](Expected<SymbolMap> R) { cantFail(std::move(R)); },
+ [](Error Err) { cantFail(std::move(Err)); },
+ NoDependenciesToRegister);
}
-TEST_F(RTDyldObjectLinkingLayerExecutionTest, NoPrematureAllocation) {
- if (!SupportsJIT)
- return;
+TEST(RTDyldObjectLinkingLayerTest, TestAutoClaimResponsibilityForSymbols) {
- ExecutionSession ES;
+ OrcNativeTarget::initialize();
- auto MM = std::make_shared<SectionMemoryManagerWrapper>();
+ std::unique_ptr<TargetMachine> TM(
+ EngineBuilder().selectTarget(Triple("x86_64-unknown-linux-gnu"), "", "",
+ SmallVector<std::string, 1>()));
- RTDyldObjectLinkingLayer ObjLayer(ES, [&MM](VModuleKey K) {
- return RTDyldObjectLinkingLayer::Resources{
- MM, std::make_shared<NullResolver>()};
- });
- SimpleCompiler Compile(*TM);
-
- // Create a pair of unrelated modules:
- //
- // Module 1:
- // int foo() { return 42; }
- // Module 2:
- // int bar() { return 7; }
- //
- // Both modules will share a memory manager. We want to verify that the
- // second object is not loaded before the first one is finalized. To do this
- // in a portable way, we abuse the
- // RuntimeDyld::MemoryManager::needsToReserveAllocationSpace hook, which is
- // called once per object before any sections are allocated.
-
- ModuleBuilder MB1(Context, "", "dummy");
- {
- MB1.getModule()->setDataLayout(TM->createDataLayout());
- Function *BarImpl = MB1.createFunctionDecl<int32_t(void)>("foo");
- BasicBlock *BarEntry = BasicBlock::Create(Context, "entry", BarImpl);
- IRBuilder<> Builder(BarEntry);
- IntegerType *Int32Ty = IntegerType::get(Context, 32);
- Value *FourtyTwo = ConstantInt::getSigned(Int32Ty, 42);
- Builder.CreateRet(FourtyTwo);
- }
+ if (!TM)
+ return;
- auto Obj1 = Compile(*MB1.getModule());
+ // Our compiler is going to add a new symbol without telling ORC.
+ // This will test our ability to auto-claim responsibility later.
+ class FunkySimpleCompiler : public SimpleCompiler {
+ public:
+ FunkySimpleCompiler(TargetMachine &TM) : SimpleCompiler(TM) {}
+
+ CompileResult operator()(Module &M) {
+ Function *BarImpl =
+ Function::Create(TypeBuilder<void(), false>::get(M.getContext()),
+ GlobalValue::ExternalLinkage, "bar", &M);
+ BasicBlock *BarEntry =
+ BasicBlock::Create(M.getContext(), "entry", BarImpl);
+ IRBuilder<> B(BarEntry);
+ B.CreateRetVoid();
+
+ return SimpleCompiler::operator()(M);
+ }
+ };
- ModuleBuilder MB2(Context, "", "dummy");
+ // Create a module with two void() functions: foo and bar.
+ ThreadSafeContext TSCtx(llvm::make_unique<LLVMContext>());
+ ThreadSafeModule M;
{
- MB2.getModule()->setDataLayout(TM->createDataLayout());
- Function *BarImpl = MB2.createFunctionDecl<int32_t(void)>("bar");
- BasicBlock *BarEntry = BasicBlock::Create(Context, "entry", BarImpl);
- IRBuilder<> Builder(BarEntry);
- IntegerType *Int32Ty = IntegerType::get(Context, 32);
- Value *Seven = ConstantInt::getSigned(Int32Ty, 7);
- Builder.CreateRet(Seven);
- }
- auto Obj2 = Compile(*MB2.getModule());
+ ModuleBuilder MB(*TSCtx.getContext(), TM->getTargetTriple().str(), "dummy");
+ MB.getModule()->setDataLayout(TM->createDataLayout());
- auto K = ES.allocateVModule();
- cantFail(ObjLayer.addObject(K, std::move(Obj1)));
- cantFail(ObjLayer.addObject(ES.allocateVModule(), std::move(Obj2)));
- cantFail(ObjLayer.emitAndFinalize(K));
- cantFail(ObjLayer.removeObject(K));
-
- // Only one call to needsToReserveAllocationSpace should have been made.
- EXPECT_EQ(MM->NeedsToReserveAllocationSpaceCount, 1)
- << "More than one call to needsToReserveAllocationSpace "
- "(multiple unrelated objects loaded prior to finalization)";
-}
+ Function *FooImpl = MB.createFunctionDecl<void()>("foo");
+ BasicBlock *FooEntry =
+ BasicBlock::Create(*TSCtx.getContext(), "entry", FooImpl);
+ IRBuilder<> B(FooEntry);
+ B.CreateRetVoid();
-TEST_F(RTDyldObjectLinkingLayerExecutionTest, TestNotifyLoadedSignature) {
+ M = ThreadSafeModule(MB.takeModule(), std::move(TSCtx));
+ }
+
+ // Create a simple stack and set the override flags option.
ExecutionSession ES;
+ auto &JD = ES.createJITDylib("main");
+ auto Foo = ES.intern("foo");
RTDyldObjectLinkingLayer ObjLayer(
- ES,
- [](VModuleKey) {
- return RTDyldObjectLinkingLayer::Resources{
- nullptr, std::make_shared<NullResolver>()};
- },
- [](VModuleKey, const object::ObjectFile &obj,
- const RuntimeDyld::LoadedObjectInfo &info) {});
+ ES, [](VModuleKey) { return llvm::make_unique<SectionMemoryManager>(); });
+ IRCompileLayer CompileLayer(ES, ObjLayer, FunkySimpleCompiler(*TM));
+
+ ObjLayer.setAutoClaimResponsibilityForObjectSymbols(true);
+
+ cantFail(CompileLayer.add(JD, ES.allocateVModule(), std::move(M)));
+ ES.lookup({&JD}, {Foo}, [](Expected<SymbolMap> R) { cantFail(std::move(R)); },
+ [](Error Err) { cantFail(std::move(Err)); },
+ NoDependenciesToRegister);
}
} // end anonymous namespace
projects / platform / upstream / llvm.git / commitdiff