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

[ORC] Switch from shared_ptr to unique_ptr for addModule methods. 

Layer implementations typically mutate module state, and this is better
reflected by having layers own the Module they are operating on.

llvm-svn: 327566
This commit is contained in:
Lang Hames 2018-03-14 20:29:45 +00:00
parent db46a62e2b
commit 7bea03c2bb
17 changed files with 83 additions and 112 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -51,7 +51,7 @@ private:
IRCompileLayer<decltype(ObjectLayer), SimpleCompiler> CompileLayer;
using OptimizeFunction =
std::function<std::shared_ptr<Module>(std::shared_ptr<Module>)>;
std::function<std::unique_ptr<Module>(std::unique_ptr<Module>)>;
IRTransformLayer<decltype(CompileLayer), OptimizeFunction> OptimizeLayer;
@ -77,7 +77,7 @@ public:
std::make_shared<SectionMemoryManager>(), Resolver};
}),
CompileLayer(ObjectLayer, SimpleCompiler(*TM)),
OptimizeLayer(CompileLayer, [this](std::shared_ptr<Module> M) {
OptimizeLayer(CompileLayer, [this](std::unique_ptr<Module> M) {
return optimizeModule(std::move(M));
}) {
llvm::sys::DynamicLibrary::LoadLibraryPermanently(nullptr);
@ -104,7 +104,7 @@ public:
}
private:
std::shared_ptr<Module> optimizeModule(std::shared_ptr<Module> M) {
std::unique_ptr<Module> optimizeModule(std::unique_ptr<Module> M) {
// Create a function pass manager.
auto FPM = llvm::make_unique<legacy::FunctionPassManager>(M.get());

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

@ -55,7 +55,7 @@ private:
IRCompileLayer<decltype(ObjectLayer), SimpleCompiler> CompileLayer;
using OptimizeFunction =
std::function<std::shared_ptr<Module>(std::shared_ptr<Module>)>;
std::function<std::unique_ptr<Module>(std::unique_ptr<Module>)>;
IRTransformLayer<decltype(CompileLayer), OptimizeFunction> OptimizeLayer;
@ -73,7 +73,7 @@ public:
}),
CompileLayer(ObjectLayer, SimpleCompiler(*TM)),
OptimizeLayer(CompileLayer,
[this](std::shared_ptr<Module> M) {
[this](std::unique_ptr<Module> M) {
return optimizeModule(std::move(M));
}),
CompileCallbackManager(
@ -127,7 +127,7 @@ public:
}
private:
std::shared_ptr<Module> optimizeModule(std::shared_ptr<Module> M) {
std::unique_ptr<Module> optimizeModule(std::unique_ptr<Module> M) {
// Create a function pass manager.
auto FPM = llvm::make_unique<legacy::FunctionPassManager>(M.get());

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

@ -81,7 +81,7 @@ private:
IRCompileLayer<decltype(ObjectLayer), SimpleCompiler> CompileLayer;
using OptimizeFunction =
std::function<std::shared_ptr<Module>(std::shared_ptr<Module>)>;
std::function<std::unique_ptr<Module>(std::unique_ptr<Module>)>;
IRTransformLayer<decltype(CompileLayer), OptimizeFunction> OptimizeLayer;
@ -113,7 +113,7 @@ public:
}),
CompileLayer(ObjectLayer, SimpleCompiler(*TM)),
OptimizeLayer(CompileLayer,
[this](std::shared_ptr<Module> M) {
[this](std::unique_ptr<Module> M) {
return optimizeModule(std::move(M));
}),
CompileCallbackMgr(
@ -207,7 +207,7 @@ private:
return MangledNameStream.str();
}
std::shared_ptr<Module> optimizeModule(std::shared_ptr<Module> M) {
std::unique_ptr<Module> optimizeModule(std::unique_ptr<Module> M) {
// Create a function pass manager.
auto FPM = llvm::make_unique<legacy::FunctionPassManager>(M.get());

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

@ -86,7 +86,7 @@ private:
IRCompileLayer<decltype(ObjectLayer), SimpleCompiler> CompileLayer;
using OptimizeFunction =
std::function<std::shared_ptr<Module>(std::shared_ptr<Module>)>;
std::function<std::unique_ptr<Module>(std::unique_ptr<Module>)>;
IRTransformLayer<decltype(CompileLayer), OptimizeFunction> OptimizeLayer;
@ -121,7 +121,7 @@ public:
}),
CompileLayer(ObjectLayer, SimpleCompiler(*TM)),
OptimizeLayer(CompileLayer,
[this](std::shared_ptr<Module> M) {
[this](std::unique_ptr<Module> M) {
return optimizeModule(std::move(M));
}),
Remote(Remote) {
@ -223,7 +223,7 @@ private:
return MangledNameStream.str();
}
std::shared_ptr<Module> optimizeModule(std::shared_ptr<Module> M) {
std::unique_ptr<Module> optimizeModule(std::unique_ptr<Module> M) {
// Create a function pass manager.
auto FPM = llvm::make_unique<legacy::FunctionPassManager>(M.get());

32
llvm/include/llvm-c/OrcBindings.h
View File

@ -29,7 +29,6 @@
extern "C" {
#endif
typedef struct LLVMOpaqueSharedModule *LLVMSharedModuleRef;
typedef struct LLVMOrcOpaqueJITStack *LLVMOrcJITStackRef;
typedef uint64_t LLVMOrcModuleHandle;
typedef uint64_t LLVMOrcTargetAddress;
@ -39,33 +38,6 @@ typedef uint64_t (*LLVMOrcLazyCompileCallbackFn)(LLVMOrcJITStackRef JITStack,
typedef enum { LLVMOrcErrSuccess = 0, LLVMOrcErrGeneric } LLVMOrcErrorCode;
/**
* Turn an LLVMModuleRef into an LLVMSharedModuleRef.
*
* The JIT uses shared ownership for LLVM modules, since it is generally
* difficult to know when the JIT will be finished with a module (and the JIT
* has no way of knowing when a user may be finished with one).
*
* Calling this method with an LLVMModuleRef creates a shared-pointer to the
* module, and returns a reference to this shared pointer.
*
* The shared module should be disposed when finished with by calling
* LLVMOrcDisposeSharedModule (not LLVMDisposeModule). The Module will be
* deleted when the last shared pointer owner relinquishes it.
*/
LLVMSharedModuleRef LLVMOrcMakeSharedModule(LLVMModuleRef Mod);
/**
* Dispose of a shared module.
*
* The module should not be accessed after this call. The module will be
* deleted once all clients (including the JIT itself) have released their
* shared pointers.
*/
void LLVMOrcDisposeSharedModuleRef(LLVMSharedModuleRef SharedMod);
/**
* Create an ORC JIT stack.
*
@ -126,7 +98,7 @@ LLVMOrcErrorCode LLVMOrcSetIndirectStubPointer(LLVMOrcJITStackRef JITStack,
LLVMOrcErrorCode
LLVMOrcAddEagerlyCompiledIR(LLVMOrcJITStackRef JITStack,
LLVMOrcModuleHandle *RetHandle,
LLVMSharedModuleRef Mod,
LLVMModuleRef Mod,
LLVMOrcSymbolResolverFn SymbolResolver,
void *SymbolResolverCtx);
@ -136,7 +108,7 @@ LLVMOrcAddEagerlyCompiledIR(LLVMOrcJITStackRef JITStack,
LLVMOrcErrorCode
LLVMOrcAddLazilyCompiledIR(LLVMOrcJITStackRef JITStack,
LLVMOrcModuleHandle *RetHandle,
LLVMSharedModuleRef Mod,
LLVMModuleRef Mod,
LLVMOrcSymbolResolverFn SymbolResolver,
void *SymbolResolverCtx);

10
llvm/include/llvm/ExecutionEngine/Orc/CompileOnDemandLayer.h
View File

@ -138,7 +138,7 @@ private:
struct LogicalDylib {
struct SourceModuleEntry {
std::shared_ptr<Module> SourceMod;
std::unique_ptr<Module> SourceMod;
std::set<Function*> StubsToClone;
};
@ -153,7 +153,7 @@ private:
StubsMgr(std::move(StubsMgr)) {}
SourceModuleHandle
addSourceModule(std::shared_ptr<Module> M) {
addSourceModule(std::unique_ptr<Module> M) {
SourceModuleHandle H = SourceModules.size();
SourceModules.push_back(SourceModuleEntry());
SourceModules.back().SourceMod = std::move(M);
@ -232,7 +232,7 @@ public:
}
/// @brief Add a module to the compile-on-demand layer.
Error addModule(VModuleKey K, std::shared_ptr<Module> M) {
Error addModule(VModuleKey K, std::unique_ptr<Module> M) {
assert(!LogicalDylibs.count(K) && "VModuleKey K already in use");
auto I = LogicalDylibs.insert(
@ -244,7 +244,7 @@ public:
}
/// @brief Add extra modules to an existing logical module.
Error addExtraModule(VModuleKey K, std::shared_ptr<Module> M) {
Error addExtraModule(VModuleKey K, std::unique_ptr<Module> M) {
return addLogicalModule(LogicalDylibs[K], std::move(M));
}
@ -311,7 +311,7 @@ public:
private:
Error addLogicalModule(LogicalDylib &LD, std::shared_ptr<Module> SrcMPtr) {
Error addLogicalModule(LogicalDylib &LD, std::unique_ptr<Module> SrcMPtr) {
// Rename all static functions / globals to $static.X :
// This will unique the names across all modules in the logical dylib,

24
llvm/include/llvm/ExecutionEngine/Orc/IRCompileLayer.h
View File

@ -36,18 +36,33 @@ template <typename BaseLayerT, typename CompileFtor>
class IRCompileLayer {
public:
/// @brief Callback type for notifications when modules are compiled.
using NotifyCompiledCallback = std::function<void(VModuleKey K,
std::unique_ptr<Module>)>;
/// @brief Construct an IRCompileLayer with the given BaseLayer, which must
/// implement the ObjectLayer concept.
IRCompileLayer(BaseLayerT &BaseLayer, CompileFtor Compile)
: BaseLayer(BaseLayer), Compile(std::move(Compile)) {}
IRCompileLayer(BaseLayerT &BaseLayer, CompileFtor Compile,
NotifyCompiledCallback NotifyCompiled = NotifyCompiledCallback())
: BaseLayer(BaseLayer), Compile(std::move(Compile)),
NotifyCompiled(std::move(NotifyCompiled)) {}
/// @brief Get a reference to the compiler functor.
CompileFtor& getCompiler() { return Compile; }
/// @brief (Re)set the NotifyCompiled callback.
void setNotifyCompiled(NotifyCompiledCallback NotifyCompiled) {
this->NotifyCompiled = std::move(NotifyCompiled);
}
/// @brief Compile the module, and add the resulting object to the base layer
/// along with the given memory manager and symbol resolver.
Error addModule(VModuleKey K, std::shared_ptr<Module> M) {
return BaseLayer.addObject(std::move(K), Compile(*M));
Error addModule(VModuleKey K, std::unique_ptr<Module> M) {
if (auto Err = BaseLayer.addObject(std::move(K), Compile(*M)))
return Err;
if (NotifyCompiled)
NotifyCompiled(std::move(K), std::move(M));
return Error::success();
}
/// @brief Remove the module associated with the VModuleKey K.
@ -82,6 +97,7 @@ public:
private:
BaseLayerT &BaseLayer;
CompileFtor Compile;
NotifyCompiledCallback NotifyCompiled;
};
} // end namespace orc

2
llvm/include/llvm/ExecutionEngine/Orc/IRTransformLayer.h
View File

@ -40,7 +40,7 @@ public:
/// the layer below, along with the memory manager and symbol resolver.
///
/// @return A handle for the added modules.
Error addModule(VModuleKey K, std::shared_ptr<Module> M) {
Error addModule(VModuleKey K, std::unique_ptr<Module> M) {
return BaseLayer.addModule(std::move(K), Transform(std::move(M)));
}

7
llvm/include/llvm/ExecutionEngine/Orc/LazyEmittingLayer.h
View File

@ -41,9 +41,10 @@ namespace orc {
/// JITSymbol::getAddress) for a symbol contained in this layer.
template <typename BaseLayerT> class LazyEmittingLayer {
private:
class EmissionDeferredModule {
public:
EmissionDeferredModule(VModuleKey K, std::shared_ptr<Module> M)
EmissionDeferredModule(VModuleKey K, std::unique_ptr<Module> M)
: K(std::move(K)), M(std::move(M)) {}
JITSymbol find(StringRef Name, bool ExportedSymbolsOnly, BaseLayerT &B) {
@ -187,7 +188,7 @@ private:
enum { NotEmitted, Emitting, Emitted } EmitState = NotEmitted;
VModuleKey K;
std::shared_ptr<Module> M;
std::unique_ptr<Module> M;
mutable std::unique_ptr<StringMap<const GlobalValue*>> MangledSymbols;
};
@ -200,7 +201,7 @@ public:
LazyEmittingLayer(BaseLayerT &BaseLayer) : BaseLayer(BaseLayer) {}
/// @brief Add the given module to the lazy emitting layer.
Error addModule(VModuleKey K, std::shared_ptr<Module> M) {
Error addModule(VModuleKey K, std::unique_ptr<Module> M) {
assert(!ModuleMap.count(K) && "VModuleKey K already in use");
ModuleMap[K] =
llvm::make_unique<EmissionDeferredModule>(std::move(K), std::move(M));

22
llvm/lib/ExecutionEngine/Orc/OrcCBindings.cpp
View File

@ -12,14 +12,6 @@
using namespace llvm;
LLVMSharedModuleRef LLVMOrcMakeSharedModule(LLVMModuleRef Mod) {
return wrap(new std::shared_ptr<Module>(unwrap(Mod)));
}
void LLVMOrcDisposeSharedModuleRef(LLVMSharedModuleRef SharedMod) {
delete unwrap(SharedMod);
}
LLVMOrcJITStackRef LLVMOrcCreateInstance(LLVMTargetMachineRef TM) {
TargetMachine *TM2(unwrap(TM));
@ -76,23 +68,25 @@ LLVMOrcErrorCode LLVMOrcSetIndirectStubPointer(LLVMOrcJITStackRef JITStack,
LLVMOrcErrorCode
LLVMOrcAddEagerlyCompiledIR(LLVMOrcJITStackRef JITStack,
LLVMOrcModuleHandle *RetHandle,
LLVMSharedModuleRef Mod,
LLVMModuleRef Mod,
LLVMOrcSymbolResolverFn SymbolResolver,
void *SymbolResolverCtx) {
OrcCBindingsStack &J = *unwrap(JITStack);
std::shared_ptr<Module> *M(unwrap(Mod));
return J.addIRModuleEager(*RetHandle, *M, SymbolResolver, SymbolResolverCtx);
std::unique_ptr<Module> M(unwrap(Mod));
return J.addIRModuleEager(*RetHandle, std::move(M), SymbolResolver,
SymbolResolverCtx);
}
LLVMOrcErrorCode
LLVMOrcAddLazilyCompiledIR(LLVMOrcJITStackRef JITStack,
LLVMOrcModuleHandle *RetHandle,
LLVMSharedModuleRef Mod,
LLVMModuleRef Mod,
LLVMOrcSymbolResolverFn SymbolResolver,
void *SymbolResolverCtx) {
OrcCBindingsStack &J = *unwrap(JITStack);
std::shared_ptr<Module> *M(unwrap(Mod));
return J.addIRModuleLazy(*RetHandle, *M, SymbolResolver, SymbolResolverCtx);
std::unique_ptr<Module> M(unwrap(Mod));
return J.addIRModuleLazy(*RetHandle, std::move(M), SymbolResolver,
SymbolResolverCtx);
}
LLVMOrcErrorCode

8
llvm/lib/ExecutionEngine/Orc/OrcCBindingsStack.h
View File

@ -43,8 +43,6 @@ namespace llvm {
class OrcCBindingsStack;
DEFINE_SIMPLE_CONVERSION_FUNCTIONS(std::shared_ptr<Module>,
LLVMSharedModuleRef)
DEFINE_SIMPLE_CONVERSION_FUNCTIONS(OrcCBindingsStack, LLVMOrcJITStackRef)
DEFINE_SIMPLE_CONVERSION_FUNCTIONS(TargetMachine, LLVMTargetMachineRef)
@ -284,7 +282,7 @@ public:
}
template <typename LayerT>
LLVMOrcErrorCode
addIRModule(orc::VModuleKey &RetKey, LayerT &Layer, std::shared_ptr<Module> M,
addIRModule(orc::VModuleKey &RetKey, LayerT &Layer, std::unique_ptr<Module> M,
std::unique_ptr<RuntimeDyld::MemoryManager> MemMgr,
LLVMOrcSymbolResolverFn ExternalResolver,
void *ExternalResolverCtx) {
@ -323,7 +321,7 @@ public:
}
LLVMOrcErrorCode addIRModuleEager(orc::VModuleKey &RetKey,
std::shared_ptr<Module> M,
std::unique_ptr<Module> M,
LLVMOrcSymbolResolverFn ExternalResolver,
void *ExternalResolverCtx) {
return addIRModule(RetKey, CompileLayer, std::move(M),
@ -332,7 +330,7 @@ public:
}
LLVMOrcErrorCode addIRModuleLazy(orc::VModuleKey &RetKey,
std::shared_ptr<Module> M,
std::unique_ptr<Module> M,
LLVMOrcSymbolResolverFn ExternalResolver,
void *ExternalResolverCtx) {
return addIRModule(RetKey, CODLayer, std::move(M),

2
llvm/lib/ExecutionEngine/Orc/OrcMCJITReplacement.cpp
View File

@ -125,7 +125,7 @@ OrcMCJITReplacement::runFunction(Function *F,
}
void OrcMCJITReplacement::runStaticConstructorsDestructors(bool isDtors) {
for (auto &M : LocalModules)
for (auto &M : Modules)
ExecutionEngine::runStaticConstructorsDestructors(*M, isDtors);
}

34
llvm/lib/ExecutionEngine/Orc/OrcMCJITReplacement.h
View File

@ -54,6 +54,7 @@ class ObjectCache;
namespace orc {
class OrcMCJITReplacement : public ExecutionEngine {
// OrcMCJITReplacement needs to do a little extra book-keeping to ensure that
// Orc's automatic finalization doesn't kick in earlier than MCJIT clients are
// expecting - see finalizeMemory.
@ -235,7 +236,10 @@ public:
return ObjectLayerT::Resources{this->MemMgr, this->Resolver};
},
NotifyObjectLoaded, NotifyFinalized),
CompileLayer(ObjectLayer, SimpleCompiler(*this->TM)),
CompileLayer(ObjectLayer, SimpleCompiler(*this->TM),
[this](VModuleKey K, std::unique_ptr<Module> M) {
Modules.push_back(std::move(M));
}),
LazyEmitLayer(CompileLayer) {}
static void Register() {
@ -250,16 +254,7 @@ public:
} else {
assert(M->getDataLayout() == getDataLayout() && "DataLayout Mismatch");
}
auto *MPtr = M.release();
ShouldDelete[MPtr] = true;
auto Deleter = [this](Module *Mod) {
auto I = ShouldDelete.find(Mod);
if (I != ShouldDelete.end() && I->second)
delete Mod;
};
LocalModules.push_back(std::shared_ptr<Module>(MPtr, std::move(Deleter)));
cantFail(
LazyEmitLayer.addModule(ES.allocateVModule(), LocalModules.back()));
cantFail(LazyEmitLayer.addModule(ES.allocateVModule(), std::move(M)));
}
void addObjectFile(std::unique_ptr<object::ObjectFile> O) override {
@ -279,14 +274,14 @@ public:
}
bool removeModule(Module *M) override {
for (auto I = LocalModules.begin(), E = LocalModules.end(); I != E; ++I) {
if (I->get() == M) {
ShouldDelete[M] = false;
LocalModules.erase(I);
return true;
}
}
return false;
auto I = Modules.begin();
for (auto E = Modules.end(); I != E; ++I)
if (I->get() == M)
break;
if (I == Modules.end())
return false;
Modules.erase(I);
return true;
}
uint64_t getSymbolAddress(StringRef Name) {
@ -438,7 +433,6 @@ private:
// delete blocks in LocalModules refer to the ShouldDelete map, so
// LocalModules needs to be destructed before ShouldDelete.
std::map<Module*, bool> ShouldDelete;
std::vector<std::shared_ptr<Module>> LocalModules;
NotifyObjectLoadedT NotifyObjectLoaded;
NotifyFinalizedT NotifyFinalized;

10
llvm/tools/lli/OrcLazyJIT.cpp
View File

@ -54,10 +54,10 @@ static cl::opt<bool> OrcInlineStubs("orc-lazy-inline-stubs",
OrcLazyJIT::TransformFtor OrcLazyJIT::createDebugDumper() {
switch (OrcDumpKind) {
case DumpKind::NoDump:
return [](std::shared_ptr<Module> M) { return M; };
return [](std::unique_ptr<Module> M) { return M; };
case DumpKind::DumpFuncsToStdOut:
return [](std::shared_ptr<Module> M) {
return [](std::unique_ptr<Module> M) {
printf("[ ");
for (const auto &F : *M) {
@ -76,7 +76,7 @@ OrcLazyJIT::TransformFtor OrcLazyJIT::createDebugDumper() {
};
case DumpKind::DumpModsToStdOut:
return [](std::shared_ptr<Module> M) {
return [](std::unique_ptr<Module> M) {
outs() << "----- Module Start -----\n" << *M
<< "----- Module End -----\n";
@ -84,7 +84,7 @@ OrcLazyJIT::TransformFtor OrcLazyJIT::createDebugDumper() {
};
case DumpKind::DumpModsToDisk:
return [](std::shared_ptr<Module> M) {
return [](std::unique_ptr<Module> M) {
std::error_code EC;
raw_fd_ostream Out(M->getModuleIdentifier() + ".ll", EC,
sys::fs::F_Text);
@ -148,7 +148,7 @@ int llvm::runOrcLazyJIT(std::vector<std::unique_ptr<Module>> Ms,
// Add the module, look up main and run it.
for (auto &M : Ms)
cantFail(J.addModule(std::shared_ptr<Module>(std::move(M))));
cantFail(J.addModule(std::move(M)));
if (auto MainSym = J.findSymbol("main")) {
typedef int (*MainFnPtr)(int, const char*[]);

4
llvm/tools/lli/OrcLazyJIT.h
View File

@ -51,7 +51,7 @@ public:
using ObjLayerT = orc::RTDyldObjectLinkingLayer;
using CompileLayerT = orc::IRCompileLayer<ObjLayerT, orc::SimpleCompiler>;
using TransformFtor =
std::function<std::shared_ptr<Module>(std::shared_ptr<Module>)>;
std::function<std::unique_ptr<Module>(std::unique_ptr<Module>)>;
using IRDumpLayerT = orc::IRTransformLayer<CompileLayerT, TransformFtor>;
using CODLayerT = orc::CompileOnDemandLayer<IRDumpLayerT, CompileCallbackMgr>;
using IndirectStubsManagerBuilder = CODLayerT::IndirectStubsManagerBuilderT;
@ -106,7 +106,7 @@ public:
}
}
Error addModule(std::shared_ptr<Module> M) {
Error addModule(std::unique_ptr<Module> M) {
if (M->getDataLayout().isDefault())
M->setDataLayout(DL);

3
llvm/unittests/ExecutionEngine/Orc/ObjectTransformLayerTest.cpp
View File

@ -14,6 +14,7 @@
#include "llvm/ExecutionEngine/Orc/NullResolver.h"
#include "llvm/ExecutionEngine/Orc/RTDyldObjectLinkingLayer.h"
#include "llvm/ExecutionEngine/SectionMemoryManager.h"
#include "llvm/IR/Module.h"
#include "llvm/Object/ObjectFile.h"
#include "gtest/gtest.h"
@ -302,7 +303,7 @@ TEST(ObjectTransformLayerTest, Main) {
// Make sure that the calls from IRCompileLayer to ObjectTransformLayer
// compile.
cantFail(CompileLayer.addModule(ES.allocateVModule(),
std::shared_ptr<llvm::Module>()));
std::unique_ptr<llvm::Module>()));
// Make sure that the calls from ObjectTransformLayer to ObjectLinkingLayer
// compile.

13
llvm/unittests/ExecutionEngine/Orc/OrcCAPITest.cpp
View File

@ -73,9 +73,8 @@ protected:
CompileContext *CCtx = static_cast<CompileContext*>(Ctx);
auto *ET = CCtx->APIExecTest;
CCtx->M = ET->createTestModule(ET->TM->getTargetTriple());
LLVMSharedModuleRef SM = LLVMOrcMakeSharedModule(wrap(CCtx->M.release()));
LLVMOrcAddEagerlyCompiledIR(JITStack, &CCtx->H, SM, myResolver, nullptr);
LLVMOrcDisposeSharedModuleRef(SM);
LLVMOrcAddEagerlyCompiledIR(JITStack, &CCtx->H, wrap(CCtx->M.release()),
myResolver, nullptr);
CCtx->Compiled = true;
LLVMOrcTargetAddress MainAddr;
LLVMOrcGetSymbolAddress(JITStack, &MainAddr, "main");
@ -97,10 +96,8 @@ TEST_F(OrcCAPIExecutionTest, TestEagerIRCompilation) {
LLVMOrcGetMangledSymbol(JIT, &testFuncName, "testFunc");
LLVMSharedModuleRef SM = LLVMOrcMakeSharedModule(wrap(M.release()));
LLVMOrcModuleHandle H;
LLVMOrcAddEagerlyCompiledIR(JIT, &H, SM, myResolver, nullptr);
LLVMOrcDisposeSharedModuleRef(SM);
LLVMOrcAddEagerlyCompiledIR(JIT, &H, wrap(M.release()), myResolver, nullptr);
LLVMOrcTargetAddress MainAddr;
LLVMOrcGetSymbolAddress(JIT, &MainAddr, "main");
MainFnTy MainFn = (MainFnTy)MainAddr;
@ -125,10 +122,8 @@ TEST_F(OrcCAPIExecutionTest, TestLazyIRCompilation) {
LLVMOrcGetMangledSymbol(JIT, &testFuncName, "testFunc");
LLVMSharedModuleRef SM = LLVMOrcMakeSharedModule(wrap(M.release()));
LLVMOrcModuleHandle H;
LLVMOrcAddLazilyCompiledIR(JIT, &H, SM, myResolver, nullptr);
LLVMOrcDisposeSharedModuleRef(SM);
LLVMOrcAddLazilyCompiledIR(JIT, &H, wrap(M.release()), myResolver, nullptr);
LLVMOrcTargetAddress MainAddr;
LLVMOrcGetSymbolAddress(JIT, &MainAddr, "main");
MainFnTy MainFn = (MainFnTy)MainAddr;