2015-02-22 09:45:31 +08:00
|
|
|
//===---- IndirectionUtils.cpp - Utilities for call indirection in Orc ----===//
|
|
|
|
//
|
|
|
|
// The LLVM Compiler Infrastructure
|
|
|
|
//
|
|
|
|
// This file is distributed under the University of Illinois Open Source
|
|
|
|
// License. See LICENSE.TXT for details.
|
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
2015-03-02 05:28:53 +08:00
|
|
|
#include "llvm/ADT/STLExtras.h"
|
[Orc] New JIT APIs.
This patch adds a new set of JIT APIs to LLVM. The aim of these new APIs is to
cleanly support a wider range of JIT use cases in LLVM, and encourage the
development and contribution of re-usable infrastructure for LLVM JIT use-cases.
These APIs are intended to live alongside the MCJIT APIs, and should not affect
existing clients.
Included in this patch:
1) New headers in include/llvm/ExecutionEngine/Orc that provide a set of
components for building JIT infrastructure.
Implementation code for these headers lives in lib/ExecutionEngine/Orc.
2) A prototype re-implementation of MCJIT (OrcMCJITReplacement) built out of the
new components.
3) Minor changes to RTDyldMemoryManager needed to support the new components.
These changes should not impact existing clients.
4) A new flag for lli, -use-orcmcjit, which will cause lli to use the
OrcMCJITReplacement class as its underlying execution engine, rather than
MCJIT itself.
Tests to follow shortly.
Special thanks to Michael Ilseman, Pete Cooper, David Blaikie, Eric Christopher,
Justin Bogner, and Jim Grosbach for extensive feedback and discussion.
llvm-svn: 226940
2015-01-24 05:25:00 +08:00
|
|
|
#include "llvm/ADT/Triple.h"
|
2015-02-13 17:09:03 +08:00
|
|
|
#include "llvm/ExecutionEngine/Orc/IndirectionUtils.h"
|
2016-05-27 01:20:35 +08:00
|
|
|
#include "llvm/ExecutionEngine/Orc/OrcABISupport.h"
|
[Orc] New JIT APIs.
This patch adds a new set of JIT APIs to LLVM. The aim of these new APIs is to
cleanly support a wider range of JIT use cases in LLVM, and encourage the
development and contribution of re-usable infrastructure for LLVM JIT use-cases.
These APIs are intended to live alongside the MCJIT APIs, and should not affect
existing clients.
Included in this patch:
1) New headers in include/llvm/ExecutionEngine/Orc that provide a set of
components for building JIT infrastructure.
Implementation code for these headers lives in lib/ExecutionEngine/Orc.
2) A prototype re-implementation of MCJIT (OrcMCJITReplacement) built out of the
new components.
3) Minor changes to RTDyldMemoryManager needed to support the new components.
These changes should not impact existing clients.
4) A new flag for lli, -use-orcmcjit, which will cause lli to use the
OrcMCJITReplacement class as its underlying execution engine, rather than
MCJIT itself.
Tests to follow shortly.
Special thanks to Michael Ilseman, Pete Cooper, David Blaikie, Eric Christopher,
Justin Bogner, and Jim Grosbach for extensive feedback and discussion.
llvm-svn: 226940
2015-01-24 05:25:00 +08:00
|
|
|
#include "llvm/IR/CallSite.h"
|
|
|
|
#include "llvm/IR/IRBuilder.h"
|
2015-05-06 01:37:18 +08:00
|
|
|
#include "llvm/Transforms/Utils/Cloning.h"
|
2015-04-13 04:05:51 +08:00
|
|
|
#include <sstream>
|
[Orc] New JIT APIs.
This patch adds a new set of JIT APIs to LLVM. The aim of these new APIs is to
cleanly support a wider range of JIT use cases in LLVM, and encourage the
development and contribution of re-usable infrastructure for LLVM JIT use-cases.
These APIs are intended to live alongside the MCJIT APIs, and should not affect
existing clients.
Included in this patch:
1) New headers in include/llvm/ExecutionEngine/Orc that provide a set of
components for building JIT infrastructure.
Implementation code for these headers lives in lib/ExecutionEngine/Orc.
2) A prototype re-implementation of MCJIT (OrcMCJITReplacement) built out of the
new components.
3) Minor changes to RTDyldMemoryManager needed to support the new components.
These changes should not impact existing clients.
4) A new flag for lli, -use-orcmcjit, which will cause lli to use the
OrcMCJITReplacement class as its underlying execution engine, rather than
MCJIT itself.
Tests to follow shortly.
Special thanks to Michael Ilseman, Pete Cooper, David Blaikie, Eric Christopher,
Justin Bogner, and Jim Grosbach for extensive feedback and discussion.
llvm-svn: 226940
2015-01-24 05:25:00 +08:00
|
|
|
|
|
|
|
namespace llvm {
|
2015-02-22 04:44:36 +08:00
|
|
|
namespace orc {
|
[Orc] New JIT APIs.
This patch adds a new set of JIT APIs to LLVM. The aim of these new APIs is to
cleanly support a wider range of JIT use cases in LLVM, and encourage the
development and contribution of re-usable infrastructure for LLVM JIT use-cases.
These APIs are intended to live alongside the MCJIT APIs, and should not affect
existing clients.
Included in this patch:
1) New headers in include/llvm/ExecutionEngine/Orc that provide a set of
components for building JIT infrastructure.
Implementation code for these headers lives in lib/ExecutionEngine/Orc.
2) A prototype re-implementation of MCJIT (OrcMCJITReplacement) built out of the
new components.
3) Minor changes to RTDyldMemoryManager needed to support the new components.
These changes should not impact existing clients.
4) A new flag for lli, -use-orcmcjit, which will cause lli to use the
OrcMCJITReplacement class as its underlying execution engine, rather than
MCJIT itself.
Tests to follow shortly.
Special thanks to Michael Ilseman, Pete Cooper, David Blaikie, Eric Christopher,
Justin Bogner, and Jim Grosbach for extensive feedback and discussion.
llvm-svn: 226940
2015-01-24 05:25:00 +08:00
|
|
|
|
2015-12-04 10:15:39 +08:00
|
|
|
void JITCompileCallbackManager::anchor() {}
|
2015-12-07 03:44:45 +08:00
|
|
|
void IndirectStubsManager::anchor() {}
|
2015-10-20 01:43:51 +08:00
|
|
|
|
2016-05-27 01:20:35 +08:00
|
|
|
std::unique_ptr<JITCompileCallbackManager>
|
2016-06-09 03:09:22 +08:00
|
|
|
createLocalCompileCallbackManager(const Triple &T,
|
2016-08-02 04:49:11 +08:00
|
|
|
JITTargetAddress ErrorHandlerAddress) {
|
2016-05-27 01:20:35 +08:00
|
|
|
switch (T.getArch()) {
|
|
|
|
default: return nullptr;
|
|
|
|
|
|
|
|
case Triple::x86: {
|
|
|
|
typedef orc::LocalJITCompileCallbackManager<orc::OrcI386> CCMgrT;
|
|
|
|
return llvm::make_unique<CCMgrT>(ErrorHandlerAddress);
|
|
|
|
}
|
|
|
|
|
|
|
|
case Triple::x86_64: {
|
|
|
|
if ( T.getOS() == Triple::OSType::Win32 ) {
|
|
|
|
typedef orc::LocalJITCompileCallbackManager<orc::OrcX86_64_Win32> CCMgrT;
|
|
|
|
return llvm::make_unique<CCMgrT>(ErrorHandlerAddress);
|
|
|
|
} else {
|
|
|
|
typedef orc::LocalJITCompileCallbackManager<orc::OrcX86_64_SysV> CCMgrT;
|
|
|
|
return llvm::make_unique<CCMgrT>(ErrorHandlerAddress);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
std::function<std::unique_ptr<IndirectStubsManager>()>
|
2016-06-09 03:09:22 +08:00
|
|
|
createLocalIndirectStubsManagerBuilder(const Triple &T) {
|
2016-05-27 01:20:35 +08:00
|
|
|
switch (T.getArch()) {
|
|
|
|
default: return nullptr;
|
|
|
|
|
|
|
|
case Triple::x86:
|
|
|
|
return [](){
|
|
|
|
return llvm::make_unique<
|
|
|
|
orc::LocalIndirectStubsManager<orc::OrcI386>>();
|
|
|
|
};
|
|
|
|
|
|
|
|
case Triple::x86_64:
|
|
|
|
if (T.getOS() == Triple::OSType::Win32) {
|
|
|
|
return [](){
|
|
|
|
return llvm::make_unique<
|
|
|
|
orc::LocalIndirectStubsManager<orc::OrcX86_64_Win32>>();
|
|
|
|
};
|
|
|
|
} else {
|
|
|
|
return [](){
|
|
|
|
return llvm::make_unique<
|
|
|
|
orc::LocalIndirectStubsManager<orc::OrcX86_64_SysV>>();
|
|
|
|
};
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-08-02 04:49:11 +08:00
|
|
|
Constant* createIRTypedAddress(FunctionType &FT, JITTargetAddress Addr) {
|
2015-04-11 08:23:49 +08:00
|
|
|
Constant *AddrIntVal =
|
|
|
|
ConstantInt::get(Type::getInt64Ty(FT.getContext()), Addr);
|
|
|
|
Constant *AddrPtrVal =
|
|
|
|
ConstantExpr::getCast(Instruction::IntToPtr, AddrIntVal,
|
|
|
|
PointerType::get(&FT, 0));
|
|
|
|
return AddrPtrVal;
|
|
|
|
}
|
|
|
|
|
|
|
|
GlobalVariable* createImplPointer(PointerType &PT, Module &M,
|
|
|
|
const Twine &Name, Constant *Initializer) {
|
2015-05-06 01:37:18 +08:00
|
|
|
auto IP = new GlobalVariable(M, &PT, false, GlobalValue::ExternalLinkage,
|
|
|
|
Initializer, Name, nullptr,
|
|
|
|
GlobalValue::NotThreadLocal, 0, true);
|
|
|
|
IP->setVisibility(GlobalValue::HiddenVisibility);
|
|
|
|
return IP;
|
[Orc] New JIT APIs.
This patch adds a new set of JIT APIs to LLVM. The aim of these new APIs is to
cleanly support a wider range of JIT use cases in LLVM, and encourage the
development and contribution of re-usable infrastructure for LLVM JIT use-cases.
These APIs are intended to live alongside the MCJIT APIs, and should not affect
existing clients.
Included in this patch:
1) New headers in include/llvm/ExecutionEngine/Orc that provide a set of
components for building JIT infrastructure.
Implementation code for these headers lives in lib/ExecutionEngine/Orc.
2) A prototype re-implementation of MCJIT (OrcMCJITReplacement) built out of the
new components.
3) Minor changes to RTDyldMemoryManager needed to support the new components.
These changes should not impact existing clients.
4) A new flag for lli, -use-orcmcjit, which will cause lli to use the
OrcMCJITReplacement class as its underlying execution engine, rather than
MCJIT itself.
Tests to follow shortly.
Special thanks to Michael Ilseman, Pete Cooper, David Blaikie, Eric Christopher,
Justin Bogner, and Jim Grosbach for extensive feedback and discussion.
llvm-svn: 226940
2015-01-24 05:25:00 +08:00
|
|
|
}
|
|
|
|
|
2015-10-20 01:43:51 +08:00
|
|
|
void makeStub(Function &F, Value &ImplPointer) {
|
2015-02-17 09:18:38 +08:00
|
|
|
assert(F.isDeclaration() && "Can't turn a definition into a stub.");
|
|
|
|
assert(F.getParent() && "Function isn't in a module.");
|
|
|
|
Module &M = *F.getParent();
|
|
|
|
BasicBlock *EntryBlock = BasicBlock::Create(M.getContext(), "entry", &F);
|
|
|
|
IRBuilder<> Builder(EntryBlock);
|
|
|
|
LoadInst *ImplAddr = Builder.CreateLoad(&ImplPointer);
|
|
|
|
std::vector<Value*> CallArgs;
|
|
|
|
for (auto &A : F.args())
|
|
|
|
CallArgs.push_back(&A);
|
|
|
|
CallInst *Call = Builder.CreateCall(ImplAddr, CallArgs);
|
|
|
|
Call->setTailCall();
|
2015-04-21 04:41:45 +08:00
|
|
|
Call->setAttributes(F.getAttributes());
|
2015-05-06 01:37:18 +08:00
|
|
|
if (F.getReturnType()->isVoidTy())
|
|
|
|
Builder.CreateRetVoid();
|
|
|
|
else
|
|
|
|
Builder.CreateRet(Call);
|
2015-02-17 09:18:38 +08:00
|
|
|
}
|
[Orc] New JIT APIs.
This patch adds a new set of JIT APIs to LLVM. The aim of these new APIs is to
cleanly support a wider range of JIT use cases in LLVM, and encourage the
development and contribution of re-usable infrastructure for LLVM JIT use-cases.
These APIs are intended to live alongside the MCJIT APIs, and should not affect
existing clients.
Included in this patch:
1) New headers in include/llvm/ExecutionEngine/Orc that provide a set of
components for building JIT infrastructure.
Implementation code for these headers lives in lib/ExecutionEngine/Orc.
2) A prototype re-implementation of MCJIT (OrcMCJITReplacement) built out of the
new components.
3) Minor changes to RTDyldMemoryManager needed to support the new components.
These changes should not impact existing clients.
4) A new flag for lli, -use-orcmcjit, which will cause lli to use the
OrcMCJITReplacement class as its underlying execution engine, rather than
MCJIT itself.
Tests to follow shortly.
Special thanks to Michael Ilseman, Pete Cooper, David Blaikie, Eric Christopher,
Justin Bogner, and Jim Grosbach for extensive feedback and discussion.
llvm-svn: 226940
2015-01-24 05:25:00 +08:00
|
|
|
|
2015-04-13 04:05:51 +08:00
|
|
|
// Utility class for renaming global values and functions during partitioning.
|
|
|
|
class GlobalRenamer {
|
|
|
|
public:
|
|
|
|
|
|
|
|
static bool needsRenaming(const Value &New) {
|
2015-11-06 05:18:09 +08:00
|
|
|
return !New.hasName() || New.getName().startswith("\01L");
|
2015-04-13 04:05:51 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
const std::string& getRename(const Value &Orig) {
|
|
|
|
// See if we have a name for this global.
|
|
|
|
{
|
|
|
|
auto I = Names.find(&Orig);
|
|
|
|
if (I != Names.end())
|
|
|
|
return I->second;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Nope. Create a new one.
|
|
|
|
// FIXME: Use a more robust uniquing scheme. (This may blow up if the user
|
|
|
|
// writes a "__orc_anon[[:digit:]]* method).
|
|
|
|
unsigned ID = Names.size();
|
|
|
|
std::ostringstream NameStream;
|
|
|
|
NameStream << "__orc_anon" << ID++;
|
|
|
|
auto I = Names.insert(std::make_pair(&Orig, NameStream.str()));
|
|
|
|
return I.first->second;
|
|
|
|
}
|
|
|
|
private:
|
|
|
|
DenseMap<const Value*, std::string> Names;
|
|
|
|
};
|
|
|
|
|
2015-05-06 01:37:18 +08:00
|
|
|
static void raiseVisibilityOnValue(GlobalValue &V, GlobalRenamer &R) {
|
|
|
|
if (V.hasLocalLinkage()) {
|
|
|
|
if (R.needsRenaming(V))
|
|
|
|
V.setName(R.getRename(V));
|
|
|
|
V.setLinkage(GlobalValue::ExternalLinkage);
|
|
|
|
V.setVisibility(GlobalValue::HiddenVisibility);
|
[Orc] New JIT APIs.
This patch adds a new set of JIT APIs to LLVM. The aim of these new APIs is to
cleanly support a wider range of JIT use cases in LLVM, and encourage the
development and contribution of re-usable infrastructure for LLVM JIT use-cases.
These APIs are intended to live alongside the MCJIT APIs, and should not affect
existing clients.
Included in this patch:
1) New headers in include/llvm/ExecutionEngine/Orc that provide a set of
components for building JIT infrastructure.
Implementation code for these headers lives in lib/ExecutionEngine/Orc.
2) A prototype re-implementation of MCJIT (OrcMCJITReplacement) built out of the
new components.
3) Minor changes to RTDyldMemoryManager needed to support the new components.
These changes should not impact existing clients.
4) A new flag for lli, -use-orcmcjit, which will cause lli to use the
OrcMCJITReplacement class as its underlying execution engine, rather than
MCJIT itself.
Tests to follow shortly.
Special thanks to Michael Ilseman, Pete Cooper, David Blaikie, Eric Christopher,
Justin Bogner, and Jim Grosbach for extensive feedback and discussion.
llvm-svn: 226940
2015-01-24 05:25:00 +08:00
|
|
|
}
|
2016-06-15 05:01:22 +08:00
|
|
|
V.setUnnamedAddr(GlobalValue::UnnamedAddr::None);
|
2015-05-06 01:37:18 +08:00
|
|
|
assert(!R.needsRenaming(V) && "Invalid global name.");
|
[Orc] New JIT APIs.
This patch adds a new set of JIT APIs to LLVM. The aim of these new APIs is to
cleanly support a wider range of JIT use cases in LLVM, and encourage the
development and contribution of re-usable infrastructure for LLVM JIT use-cases.
These APIs are intended to live alongside the MCJIT APIs, and should not affect
existing clients.
Included in this patch:
1) New headers in include/llvm/ExecutionEngine/Orc that provide a set of
components for building JIT infrastructure.
Implementation code for these headers lives in lib/ExecutionEngine/Orc.
2) A prototype re-implementation of MCJIT (OrcMCJITReplacement) built out of the
new components.
3) Minor changes to RTDyldMemoryManager needed to support the new components.
These changes should not impact existing clients.
4) A new flag for lli, -use-orcmcjit, which will cause lli to use the
OrcMCJITReplacement class as its underlying execution engine, rather than
MCJIT itself.
Tests to follow shortly.
Special thanks to Michael Ilseman, Pete Cooper, David Blaikie, Eric Christopher,
Justin Bogner, and Jim Grosbach for extensive feedback and discussion.
llvm-svn: 226940
2015-01-24 05:25:00 +08:00
|
|
|
}
|
|
|
|
|
2015-05-06 01:37:18 +08:00
|
|
|
void makeAllSymbolsExternallyAccessible(Module &M) {
|
|
|
|
GlobalRenamer Renamer;
|
[Orc] New JIT APIs.
This patch adds a new set of JIT APIs to LLVM. The aim of these new APIs is to
cleanly support a wider range of JIT use cases in LLVM, and encourage the
development and contribution of re-usable infrastructure for LLVM JIT use-cases.
These APIs are intended to live alongside the MCJIT APIs, and should not affect
existing clients.
Included in this patch:
1) New headers in include/llvm/ExecutionEngine/Orc that provide a set of
components for building JIT infrastructure.
Implementation code for these headers lives in lib/ExecutionEngine/Orc.
2) A prototype re-implementation of MCJIT (OrcMCJITReplacement) built out of the
new components.
3) Minor changes to RTDyldMemoryManager needed to support the new components.
These changes should not impact existing clients.
4) A new flag for lli, -use-orcmcjit, which will cause lli to use the
OrcMCJITReplacement class as its underlying execution engine, rather than
MCJIT itself.
Tests to follow shortly.
Special thanks to Michael Ilseman, Pete Cooper, David Blaikie, Eric Christopher,
Justin Bogner, and Jim Grosbach for extensive feedback and discussion.
llvm-svn: 226940
2015-01-24 05:25:00 +08:00
|
|
|
|
2015-05-06 01:37:18 +08:00
|
|
|
for (auto &F : M)
|
|
|
|
raiseVisibilityOnValue(F, Renamer);
|
[Orc] New JIT APIs.
This patch adds a new set of JIT APIs to LLVM. The aim of these new APIs is to
cleanly support a wider range of JIT use cases in LLVM, and encourage the
development and contribution of re-usable infrastructure for LLVM JIT use-cases.
These APIs are intended to live alongside the MCJIT APIs, and should not affect
existing clients.
Included in this patch:
1) New headers in include/llvm/ExecutionEngine/Orc that provide a set of
components for building JIT infrastructure.
Implementation code for these headers lives in lib/ExecutionEngine/Orc.
2) A prototype re-implementation of MCJIT (OrcMCJITReplacement) built out of the
new components.
3) Minor changes to RTDyldMemoryManager needed to support the new components.
These changes should not impact existing clients.
4) A new flag for lli, -use-orcmcjit, which will cause lli to use the
OrcMCJITReplacement class as its underlying execution engine, rather than
MCJIT itself.
Tests to follow shortly.
Special thanks to Michael Ilseman, Pete Cooper, David Blaikie, Eric Christopher,
Justin Bogner, and Jim Grosbach for extensive feedback and discussion.
llvm-svn: 226940
2015-01-24 05:25:00 +08:00
|
|
|
|
2015-05-06 01:37:18 +08:00
|
|
|
for (auto &GV : M.globals())
|
|
|
|
raiseVisibilityOnValue(GV, Renamer);
|
2015-10-20 01:43:51 +08:00
|
|
|
|
|
|
|
for (auto &A : M.aliases())
|
|
|
|
raiseVisibilityOnValue(A, Renamer);
|
2015-05-06 01:37:18 +08:00
|
|
|
}
|
2015-05-05 07:30:01 +08:00
|
|
|
|
2015-05-06 01:37:18 +08:00
|
|
|
Function* cloneFunctionDecl(Module &Dst, const Function &F,
|
|
|
|
ValueToValueMapTy *VMap) {
|
|
|
|
assert(F.getParent() != &Dst && "Can't copy decl over existing function.");
|
|
|
|
Function *NewF =
|
2016-01-17 04:30:46 +08:00
|
|
|
Function::Create(cast<FunctionType>(F.getValueType()),
|
2015-05-06 01:37:18 +08:00
|
|
|
F.getLinkage(), F.getName(), &Dst);
|
|
|
|
NewF->copyAttributesFrom(&F);
|
|
|
|
|
|
|
|
if (VMap) {
|
|
|
|
(*VMap)[&F] = NewF;
|
|
|
|
auto NewArgI = NewF->arg_begin();
|
|
|
|
for (auto ArgI = F.arg_begin(), ArgE = F.arg_end(); ArgI != ArgE;
|
|
|
|
++ArgI, ++NewArgI)
|
2015-10-14 02:10:59 +08:00
|
|
|
(*VMap)[&*ArgI] = &*NewArgI;
|
[Orc] New JIT APIs.
This patch adds a new set of JIT APIs to LLVM. The aim of these new APIs is to
cleanly support a wider range of JIT use cases in LLVM, and encourage the
development and contribution of re-usable infrastructure for LLVM JIT use-cases.
These APIs are intended to live alongside the MCJIT APIs, and should not affect
existing clients.
Included in this patch:
1) New headers in include/llvm/ExecutionEngine/Orc that provide a set of
components for building JIT infrastructure.
Implementation code for these headers lives in lib/ExecutionEngine/Orc.
2) A prototype re-implementation of MCJIT (OrcMCJITReplacement) built out of the
new components.
3) Minor changes to RTDyldMemoryManager needed to support the new components.
These changes should not impact existing clients.
4) A new flag for lli, -use-orcmcjit, which will cause lli to use the
OrcMCJITReplacement class as its underlying execution engine, rather than
MCJIT itself.
Tests to follow shortly.
Special thanks to Michael Ilseman, Pete Cooper, David Blaikie, Eric Christopher,
Justin Bogner, and Jim Grosbach for extensive feedback and discussion.
llvm-svn: 226940
2015-01-24 05:25:00 +08:00
|
|
|
}
|
|
|
|
|
2015-05-06 01:37:18 +08:00
|
|
|
return NewF;
|
|
|
|
}
|
[Orc] New JIT APIs.
This patch adds a new set of JIT APIs to LLVM. The aim of these new APIs is to
cleanly support a wider range of JIT use cases in LLVM, and encourage the
development and contribution of re-usable infrastructure for LLVM JIT use-cases.
These APIs are intended to live alongside the MCJIT APIs, and should not affect
existing clients.
Included in this patch:
1) New headers in include/llvm/ExecutionEngine/Orc that provide a set of
components for building JIT infrastructure.
Implementation code for these headers lives in lib/ExecutionEngine/Orc.
2) A prototype re-implementation of MCJIT (OrcMCJITReplacement) built out of the
new components.
3) Minor changes to RTDyldMemoryManager needed to support the new components.
These changes should not impact existing clients.
4) A new flag for lli, -use-orcmcjit, which will cause lli to use the
OrcMCJITReplacement class as its underlying execution engine, rather than
MCJIT itself.
Tests to follow shortly.
Special thanks to Michael Ilseman, Pete Cooper, David Blaikie, Eric Christopher,
Justin Bogner, and Jim Grosbach for extensive feedback and discussion.
llvm-svn: 226940
2015-01-24 05:25:00 +08:00
|
|
|
|
2015-05-06 01:37:18 +08:00
|
|
|
void moveFunctionBody(Function &OrigF, ValueToValueMapTy &VMap,
|
|
|
|
ValueMaterializer *Materializer,
|
|
|
|
Function *NewF) {
|
|
|
|
assert(!OrigF.isDeclaration() && "Nothing to move");
|
|
|
|
if (!NewF)
|
|
|
|
NewF = cast<Function>(VMap[&OrigF]);
|
|
|
|
else
|
|
|
|
assert(VMap[&OrigF] == NewF && "Incorrect function mapping in VMap.");
|
|
|
|
assert(NewF && "Function mapping missing from VMap.");
|
|
|
|
assert(NewF->getParent() != OrigF.getParent() &&
|
|
|
|
"moveFunctionBody should only be used to move bodies between "
|
|
|
|
"modules.");
|
|
|
|
|
|
|
|
SmallVector<ReturnInst *, 8> Returns; // Ignore returns cloned.
|
|
|
|
CloneFunctionInto(NewF, &OrigF, VMap, /*ModuleLevelChanges=*/true, Returns,
|
|
|
|
"", nullptr, nullptr, Materializer);
|
|
|
|
OrigF.deleteBody();
|
|
|
|
}
|
2015-05-05 07:30:01 +08:00
|
|
|
|
2015-05-06 01:37:18 +08:00
|
|
|
GlobalVariable* cloneGlobalVariableDecl(Module &Dst, const GlobalVariable &GV,
|
|
|
|
ValueToValueMapTy *VMap) {
|
|
|
|
assert(GV.getParent() != &Dst && "Can't copy decl over existing global var.");
|
|
|
|
GlobalVariable *NewGV = new GlobalVariable(
|
2016-01-17 04:30:46 +08:00
|
|
|
Dst, GV.getValueType(), GV.isConstant(),
|
2015-05-06 01:37:18 +08:00
|
|
|
GV.getLinkage(), nullptr, GV.getName(), nullptr,
|
|
|
|
GV.getThreadLocalMode(), GV.getType()->getAddressSpace());
|
|
|
|
NewGV->copyAttributesFrom(&GV);
|
|
|
|
if (VMap)
|
|
|
|
(*VMap)[&GV] = NewGV;
|
|
|
|
return NewGV;
|
|
|
|
}
|
2015-02-17 09:18:38 +08:00
|
|
|
|
2015-05-06 01:37:18 +08:00
|
|
|
void moveGlobalVariableInitializer(GlobalVariable &OrigGV,
|
|
|
|
ValueToValueMapTy &VMap,
|
|
|
|
ValueMaterializer *Materializer,
|
|
|
|
GlobalVariable *NewGV) {
|
|
|
|
assert(OrigGV.hasInitializer() && "Nothing to move");
|
|
|
|
if (!NewGV)
|
|
|
|
NewGV = cast<GlobalVariable>(VMap[&OrigGV]);
|
|
|
|
else
|
|
|
|
assert(VMap[&OrigGV] == NewGV &&
|
|
|
|
"Incorrect global variable mapping in VMap.");
|
|
|
|
assert(NewGV->getParent() != OrigGV.getParent() &&
|
|
|
|
"moveGlobalVariable should only be used to move initializers between "
|
|
|
|
"modules");
|
|
|
|
|
|
|
|
NewGV->setInitializer(MapValue(OrigGV.getInitializer(), VMap, RF_None,
|
|
|
|
nullptr, Materializer));
|
[Orc] New JIT APIs.
This patch adds a new set of JIT APIs to LLVM. The aim of these new APIs is to
cleanly support a wider range of JIT use cases in LLVM, and encourage the
development and contribution of re-usable infrastructure for LLVM JIT use-cases.
These APIs are intended to live alongside the MCJIT APIs, and should not affect
existing clients.
Included in this patch:
1) New headers in include/llvm/ExecutionEngine/Orc that provide a set of
components for building JIT infrastructure.
Implementation code for these headers lives in lib/ExecutionEngine/Orc.
2) A prototype re-implementation of MCJIT (OrcMCJITReplacement) built out of the
new components.
3) Minor changes to RTDyldMemoryManager needed to support the new components.
These changes should not impact existing clients.
4) A new flag for lli, -use-orcmcjit, which will cause lli to use the
OrcMCJITReplacement class as its underlying execution engine, rather than
MCJIT itself.
Tests to follow shortly.
Special thanks to Michael Ilseman, Pete Cooper, David Blaikie, Eric Christopher,
Justin Bogner, and Jim Grosbach for extensive feedback and discussion.
llvm-svn: 226940
2015-01-24 05:25:00 +08:00
|
|
|
}
|
2015-02-17 09:18:38 +08:00
|
|
|
|
2015-10-20 01:43:51 +08:00
|
|
|
GlobalAlias* cloneGlobalAliasDecl(Module &Dst, const GlobalAlias &OrigA,
|
|
|
|
ValueToValueMapTy &VMap) {
|
2015-10-07 06:55:05 +08:00
|
|
|
assert(OrigA.getAliasee() && "Original alias doesn't have an aliasee?");
|
|
|
|
auto *NewA = GlobalAlias::create(OrigA.getValueType(),
|
|
|
|
OrigA.getType()->getPointerAddressSpace(),
|
|
|
|
OrigA.getLinkage(), OrigA.getName(), &Dst);
|
|
|
|
NewA->copyAttributesFrom(&OrigA);
|
|
|
|
VMap[&OrigA] = NewA;
|
|
|
|
return NewA;
|
|
|
|
}
|
|
|
|
|
2016-09-05 01:53:30 +08:00
|
|
|
void cloneModuleFlagsMetadata(Module &Dst, const Module &Src,
|
|
|
|
ValueToValueMapTy &VMap) {
|
|
|
|
auto *MFs = Src.getModuleFlagsMetadata();
|
|
|
|
if (!MFs)
|
|
|
|
return;
|
|
|
|
for (auto *MF : MFs->operands())
|
|
|
|
Dst.addModuleFlag(MapMetadata(MF, VMap));
|
|
|
|
}
|
|
|
|
|
2015-02-22 04:44:36 +08:00
|
|
|
} // End namespace orc.
|
|
|
|
} // End namespace llvm.
|