#define LLVM_EXECUTIONENGINE_ORC_INDIRECTIONUTILS_H
#include "JITSymbol.h"
+#include "LambdaResolver.h"
+#include "llvm/ADT/DenseSet.h"
+#include "llvm/ExecutionEngine/RuntimeDyld.h"
+#include "llvm/IR/IRBuilder.h"
#include "llvm/IR/Mangler.h"
#include "llvm/IR/Module.h"
+#include "llvm/Transforms/Utils/ValueMapper.h"
#include <sstream>
namespace llvm {
+namespace orc {
-/// @brief Persistent name mangling.
-///
-/// This class provides name mangling that can outlive a Module (and its
-/// DataLayout).
-class PersistentMangler {
+/// @brief Base class for JITLayer independent aspects of
+/// JITCompileCallbackManager.
+class JITCompileCallbackManagerBase {
public:
- PersistentMangler(DataLayout DL) : DL(std::move(DL)), M(&this->DL) {}
- std::string getMangledName(StringRef Name) const {
- std::string MangledName;
- {
- raw_string_ostream MangledNameStream(MangledName);
- M.getNameWithPrefix(MangledNameStream, Name);
+ typedef std::function<TargetAddress()> CompileFtor;
+
+ /// @brief Handle to a newly created compile callback. Can be used to get an
+ /// IR constant representing the address of the trampoline, and to set
+ /// the compile action for the callback.
+ class CompileCallbackInfo {
+ public:
+ CompileCallbackInfo(TargetAddress Addr, CompileFtor &Compile)
+ : Addr(Addr), Compile(Compile) {}
+
+ TargetAddress getAddress() const { return Addr; }
+ void setCompileAction(CompileFtor Compile) {
+ this->Compile = std::move(Compile);
}
- return MangledName;
+ private:
+ TargetAddress Addr;
+ CompileFtor &Compile;
+ };
+
+ /// @brief Construct a JITCompileCallbackManagerBase.
+ /// @param ErrorHandlerAddress The address of an error handler in the target
+ /// process to be used if a compile callback fails.
+ /// @param NumTrampolinesPerBlock Number of trampolines to emit if there is no
+ /// available trampoline when getCompileCallback is
+ /// called.
+ JITCompileCallbackManagerBase(TargetAddress ErrorHandlerAddress,
+ unsigned NumTrampolinesPerBlock)
+ : ErrorHandlerAddress(ErrorHandlerAddress),
+ NumTrampolinesPerBlock(NumTrampolinesPerBlock) {}
+
+ virtual ~JITCompileCallbackManagerBase() {}
+
+ /// @brief Execute the callback for the given trampoline id. Called by the JIT
+ /// to compile functions on demand.
+ TargetAddress executeCompileCallback(TargetAddress TrampolineAddr) {
+ auto I = ActiveTrampolines.find(TrampolineAddr);
+ // FIXME: Also raise an error in the Orc error-handler when we finally have
+ // one.
+ if (I == ActiveTrampolines.end())
+ return ErrorHandlerAddress;
+
+ // Found a callback handler. Yank this trampoline out of the active list and
+ // put it back in the available trampolines list, then try to run the
+ // handler's compile and update actions.
+ // Moving the trampoline ID back to the available list first means there's at
+ // least one available trampoline if the compile action triggers a request for
+ // a new one.
+ auto Compile = std::move(I->second);
+ ActiveTrampolines.erase(I);
+ AvailableTrampolines.push_back(TrampolineAddr);
+
+ if (auto Addr = Compile())
+ return Addr;
+
+ return ErrorHandlerAddress;
+ }
+
+ /// @brief Reserve a compile callback.
+ virtual CompileCallbackInfo getCompileCallback(LLVMContext &Context) = 0;
+
+ /// @brief Get a CompileCallbackInfo for an existing callback.
+ CompileCallbackInfo getCompileCallbackInfo(TargetAddress TrampolineAddr) {
+ auto I = ActiveTrampolines.find(TrampolineAddr);
+ assert(I != ActiveTrampolines.end() && "Not an active trampoline.");
+ return CompileCallbackInfo(I->first, I->second);
+ }
+
+ /// @brief Release a compile callback.
+ ///
+ /// Note: Callbacks are auto-released after they execute. This method should
+ /// only be called to manually release a callback that is not going to
+ /// execute.
+ void releaseCompileCallback(TargetAddress TrampolineAddr) {
+ auto I = ActiveTrampolines.find(TrampolineAddr);
+ assert(I != ActiveTrampolines.end() && "Not an active trampoline.");
+ ActiveTrampolines.erase(I);
+ AvailableTrampolines.push_back(TrampolineAddr);
}
+protected:
+ TargetAddress ErrorHandlerAddress;
+ unsigned NumTrampolinesPerBlock;
+
+ typedef std::map<TargetAddress, CompileFtor> TrampolineMapT;
+ TrampolineMapT ActiveTrampolines;
+ std::vector<TargetAddress> AvailableTrampolines;
+
private:
- DataLayout DL;
- Mangler M;
+ virtual void anchor();
};
-/// @brief Handle callbacks from the JIT process requesting the definitions of
-/// symbols.
-///
-/// This utility is intended to be used to support compile-on-demand for
-/// functions.
-class JITResolveCallbackHandler {
+/// @brief Manage compile callbacks.
+template <typename JITLayerT, typename TargetT>
+class JITCompileCallbackManager : public JITCompileCallbackManagerBase {
+public:
+
+ /// @brief Construct a JITCompileCallbackManager.
+ /// @param JIT JIT layer to emit callback trampolines, etc. into.
+ /// @param Context LLVMContext to use for trampoline & resolve block modules.
+ /// @param ErrorHandlerAddress The address of an error handler in the target
+ /// process to be used if a compile callback fails.
+ /// @param NumTrampolinesPerBlock Number of trampolines to allocate whenever
+ /// there is no existing callback trampoline.
+ /// (Trampolines are allocated in blocks for
+ /// efficiency.)
+ JITCompileCallbackManager(JITLayerT &JIT, RuntimeDyld::MemoryManager &MemMgr,
+ LLVMContext &Context,
+ TargetAddress ErrorHandlerAddress,
+ unsigned NumTrampolinesPerBlock)
+ : JITCompileCallbackManagerBase(ErrorHandlerAddress,
+ NumTrampolinesPerBlock),
+ JIT(JIT), MemMgr(MemMgr) {
+ emitResolverBlock(Context);
+ }
+
+ /// @brief Get/create a compile callback with the given signature.
+ CompileCallbackInfo getCompileCallback(LLVMContext &Context) final {
+ TargetAddress TrampolineAddr = getAvailableTrampolineAddr(Context);
+ auto &Compile = this->ActiveTrampolines[TrampolineAddr];
+ return CompileCallbackInfo(TrampolineAddr, Compile);
+ }
+
private:
- typedef std::vector<std::string> FuncNameList;
-public:
- typedef FuncNameList::size_type StubIndex;
+ std::vector<std::unique_ptr<Module>>
+ SingletonSet(std::unique_ptr<Module> M) {
+ std::vector<std::unique_ptr<Module>> Ms;
+ Ms.push_back(std::move(M));
+ return Ms;
+ }
+
+ void emitResolverBlock(LLVMContext &Context) {
+ std::unique_ptr<Module> M(new Module("resolver_block_module",
+ Context));
+ TargetT::insertResolverBlock(*M, *this);
+ auto NonResolver =
+ createLambdaResolver(
+ [](const std::string &Name) -> RuntimeDyld::SymbolInfo {
+ llvm_unreachable("External symbols in resolver block?");
+ },
+ [](const std::string &Name) -> RuntimeDyld::SymbolInfo {
+ llvm_unreachable("Dylib symbols in resolver block?");
+ });
+ auto H = JIT.addModuleSet(SingletonSet(std::move(M)), &MemMgr,
+ std::move(NonResolver));
+ JIT.emitAndFinalize(H);
+ auto ResolverBlockSymbol =
+ JIT.findSymbolIn(H, TargetT::ResolverBlockName, false);
+ assert(ResolverBlockSymbol && "Failed to insert resolver block");
+ ResolverBlockAddr = ResolverBlockSymbol.getAddress();
+ }
+
+ TargetAddress getAvailableTrampolineAddr(LLVMContext &Context) {
+ if (this->AvailableTrampolines.empty())
+ grow(Context);
+ assert(!this->AvailableTrampolines.empty() &&
+ "Failed to grow available trampolines.");
+ TargetAddress TrampolineAddr = this->AvailableTrampolines.back();
+ this->AvailableTrampolines.pop_back();
+ return TrampolineAddr;
+ }
+
+ void grow(LLVMContext &Context) {
+ assert(this->AvailableTrampolines.empty() && "Growing prematurely?");
+ std::unique_ptr<Module> M(new Module("trampoline_block", Context));
+ auto GetLabelName =
+ TargetT::insertCompileCallbackTrampolines(*M, ResolverBlockAddr,
+ this->NumTrampolinesPerBlock,
+ this->ActiveTrampolines.size());
+ auto NonResolver =
+ createLambdaResolver(
+ [](const std::string &Name) -> RuntimeDyld::SymbolInfo {
+ llvm_unreachable("External symbols in trampoline block?");
+ },
+ [](const std::string &Name) -> RuntimeDyld::SymbolInfo {
+ llvm_unreachable("Dylib symbols in trampoline block?");
+ });
+ auto H = JIT.addModuleSet(SingletonSet(std::move(M)), &MemMgr,
+ std::move(NonResolver));
+ JIT.emitAndFinalize(H);
+ for (unsigned I = 0; I < this->NumTrampolinesPerBlock; ++I) {
+ std::string Name = GetLabelName(I);
+ auto TrampolineSymbol = JIT.findSymbolIn(H, Name, false);
+ assert(TrampolineSymbol && "Failed to emit trampoline.");
+ this->AvailableTrampolines.push_back(TrampolineSymbol.getAddress());
+ }
+ }
+ JITLayerT &JIT;
+ RuntimeDyld::MemoryManager &MemMgr;
+ TargetAddress ResolverBlockAddr;
+};
+
+/// @brief Base class for managing collections of named indirect stubs.
+class IndirectStubsManagerBase {
public:
- /// @brief Create a JITResolveCallbackHandler with the given functors for
- /// looking up symbols and updating their use-sites.
- ///
- /// @return A JITResolveCallbackHandler instance that will invoke the
- /// Lookup and Update functors as needed to resolve missing symbol
- /// definitions.
- template <typename LookupFtor, typename UpdateFtor>
- static std::unique_ptr<JITResolveCallbackHandler> create(LookupFtor Lookup,
- UpdateFtor Update);
-
- /// @brief Destroy instance. Does not modify existing emitted symbols.
- ///
- /// Not-yet-emitted symbols will need to be resolved some other way after
- /// this class is destroyed.
- virtual ~JITResolveCallbackHandler() {}
- /// @brief Add a function to be resolved on demand.
- void addFuncName(std::string Name) { FuncNames.push_back(std::move(Name)); }
+ /// @brief Map type for initializing the manager. See init.
+ typedef StringMap<std::pair<TargetAddress, JITSymbolFlags>> StubInitsMap;
- /// @brief Get the name associated with the given index.
- const std::string &getFuncName(StubIndex Idx) const { return FuncNames[Idx]; }
+ virtual ~IndirectStubsManagerBase() {}
- /// @brief Returns the number of symbols being managed by this instance.
- StubIndex getNumFuncs() const { return FuncNames.size(); }
+ /// @brief Create StubInits.size() stubs with the given names, target
+ /// addresses, and flags.
+ virtual std::error_code init(const StubInitsMap &StubInits) = 0;
- /// @brief Get the address for the symbol associated with the given index.
- ///
- /// This is expected to be called by code in the JIT process itself, in
- /// order to resolve a function.
- virtual TargetAddress resolve(StubIndex StubIdx) = 0;
+ /// @brief Find the stub with the given name. If ExportedStubsOnly is true,
+ /// this will only return a result if the stub's flags indicate that it
+ /// is exported.
+ virtual JITSymbol findStub(StringRef Name, bool ExportedStubsOnly) = 0;
+
+ /// @brief Find the implementation-pointer for the stub.
+ virtual JITSymbol findPointer(StringRef Name) = 0;
+ /// @brief Change the value of the implementation pointer for the stub.
+ virtual std::error_code updatePointer(StringRef Name, TargetAddress NewAddr) = 0;
private:
- FuncNameList FuncNames;
+ virtual void anchor();
};
-// Implementation class for JITResolveCallbackHandler.
-template <typename LookupFtor, typename UpdateFtor>
-class JITResolveCallbackHandlerImpl : public JITResolveCallbackHandler {
+/// @brief IndirectStubsManager implementation for a concrete target, e.g. OrcX86_64.
+/// (See OrcTargetSupport.h).
+template <typename TargetT>
+class IndirectStubsManager : public IndirectStubsManagerBase {
public:
- JITResolveCallbackHandlerImpl(LookupFtor Lookup, UpdateFtor Update)
- : Lookup(std::move(Lookup)), Update(std::move(Update)) {}
-
- TargetAddress resolve(StubIndex StubIdx) override {
- const std::string &FuncName = getFuncName(StubIdx);
- TargetAddress Addr = Lookup(FuncName);
- Update(FuncName, Addr);
- return Addr;
+
+ std::error_code
+ init(const StubInitsMap &StubInits) override {
+ if (auto EC = TargetT::emitIndirectStubsBlock(IndirectStubsInfo,
+ StubInits.size(),
+ nullptr))
+ return EC;
+
+ unsigned I = 0;
+ for (auto &Entry : StubInits) {
+ *IndirectStubsInfo.getPtr(I) =
+ reinterpret_cast<void*>(static_cast<uintptr_t>(Entry.second.first));
+ StubIndexes[Entry.first()] = std::make_pair(I++, Entry.second.second);
+ }
+
+ return std::error_code();
+ }
+
+ JITSymbol findStub(StringRef Name, bool ExportedStubsOnly) override {
+ auto I = StubIndexes.find(Name);
+ if (I == StubIndexes.end())
+ return nullptr;
+ void *StubAddr = IndirectStubsInfo.getStub(I->second.first);
+ assert(StubAddr && "Missing stub address");
+ auto StubTargetAddr =
+ static_cast<TargetAddress>(reinterpret_cast<uintptr_t>(StubAddr));
+ auto StubSymbol = JITSymbol(StubTargetAddr, I->second.second);
+ if (ExportedStubsOnly && !StubSymbol.isExported())
+ return nullptr;
+ return StubSymbol;
+ }
+
+ JITSymbol findPointer(StringRef Name) override {
+ auto I = StubIndexes.find(Name);
+ if (I == StubIndexes.end())
+ return nullptr;
+ void *PtrAddr = IndirectStubsInfo.getPtr(StubIndexes[Name].first);
+ assert(PtrAddr && "Missing pointer address");
+ auto PtrTargetAddr =
+ static_cast<TargetAddress>(reinterpret_cast<uintptr_t>(PtrAddr));
+ return JITSymbol(PtrTargetAddr, JITSymbolFlags::None);
+ }
+
+ std::error_code updatePointer(StringRef Name, TargetAddress NewAddr) override {
+ assert(StubIndexes.count(Name) && "No stub pointer for symbol");
+ *IndirectStubsInfo.getPtr(StubIndexes[Name].first) =
+ reinterpret_cast<void*>(static_cast<uintptr_t>(NewAddr));
+ return std::error_code();
}
private:
- LookupFtor Lookup;
- UpdateFtor Update;
+ typename TargetT::IndirectStubsInfo IndirectStubsInfo;
+ StringMap<std::pair<unsigned, JITSymbolFlags>> StubIndexes;
};
-template <typename LookupFtor, typename UpdateFtor>
-std::unique_ptr<JITResolveCallbackHandler>
-JITResolveCallbackHandler::create(LookupFtor Lookup, UpdateFtor Update) {
- typedef JITResolveCallbackHandlerImpl<LookupFtor, UpdateFtor> Impl;
- return make_unique<Impl>(std::move(Lookup), std::move(Update));
-}
-
-/// @brief Holds a list of the function names that were indirected, plus
-/// mappings from each of these names to (a) the name of function
-/// providing the implementation for that name (GetImplNames), and
-/// (b) the name of the global variable holding the address of the
-/// implementation.
+/// @brief Build a function pointer of FunctionType with the given constant
+/// address.
///
-/// This data structure can be used with a JITCallbackHandler to look up and
-/// update function implementations when lazily compiling.
-class JITIndirections {
-public:
- JITIndirections(std::vector<std::string> IndirectedNames,
- std::function<std::string(StringRef)> GetImplName,
- std::function<std::string(StringRef)> GetAddrName)
- : IndirectedNames(std::move(IndirectedNames)),
- GetImplName(std::move(GetImplName)),
- GetAddrName(std::move(GetAddrName)) {}
-
- std::vector<std::string> IndirectedNames;
- std::function<std::string(StringRef Name)> GetImplName;
- std::function<std::string(StringRef Name)> GetAddrName;
-};
+/// Usage example: Turn a trampoline address into a function pointer constant
+/// for use in a stub.
+Constant* createIRTypedAddress(FunctionType &FT, TargetAddress Addr);
-/// @brief Indirect all calls to functions matching the predicate
-/// ShouldIndirect through a global variable containing the address
-/// of the implementation.
-///
-/// @return An indirection structure containing the functions that had their
-/// call-sites re-written.
-///
-/// For each function 'F' that meets the ShouldIndirect predicate, and that
-/// is called in this Module, add a common-linkage global variable to the
-/// module that will hold the address of the implementation of that function.
-/// Rewrite all call-sites of 'F' to be indirect calls (via the global).
-/// This allows clients, either directly or via a JITCallbackHandler, to
-/// change the address of the implementation of 'F' at runtime.
-///
-/// Important notes:
-///
-/// Single indirection does not preserve pointer equality for 'F'. If the
-/// program was already calling 'F' indirectly through function pointers, or
-/// if it was taking the address of 'F' for the purpose of pointer comparisons
-/// or arithmetic double indirection should be used instead.
-///
-/// This method does *not* initialize the function implementation addresses.
-/// The client must do this prior to running any call-sites that have been
-/// indirected.
-JITIndirections makeCallsSingleIndirect(
- llvm::Module &M,
- const std::function<bool(const Function &)> &ShouldIndirect,
- const char *JITImplSuffix, const char *JITAddrSuffix);
-
-/// @brief Replace the body of functions matching the predicate ShouldIndirect
-/// with indirect calls to the implementation.
-///
-/// @return An indirections structure containing the functions that had their
-/// implementations re-written.
+/// @brief Create a function pointer with the given type, name, and initializer
+/// in the given Module.
+GlobalVariable* createImplPointer(PointerType &PT, Module &M,
+ const Twine &Name, Constant *Initializer);
+
+/// @brief Turn a function declaration into a stub function that makes an
+/// indirect call using the given function pointer.
+void makeStub(Function &F, Value &ImplPointer);
+
+/// @brief Raise linkage types and rename as necessary to ensure that all
+/// symbols are accessible for other modules.
///
-/// For each function 'F' that meets the ShouldIndirect predicate, add a
-/// common-linkage global variable to the module that will hold the address of
-/// the implementation of that function and rewrite the implementation of 'F'
-/// to call through to the implementation indirectly (via the global).
-/// This allows clients, either directly or via a JITCallbackHandler, to
-/// change the address of the implementation of 'F' at runtime.
+/// This should be called before partitioning a module to ensure that the
+/// partitions retain access to each other's symbols.
+void makeAllSymbolsExternallyAccessible(Module &M);
+
+/// @brief Clone a function declaration into a new module.
///
-/// Important notes:
+/// This function can be used as the first step towards creating a callback
+/// stub (see makeStub), or moving a function body (see moveFunctionBody).
///
-/// Double indirection is slower than single indirection, but preserves
-/// function pointer relation tests and correct behavior for function pointers
-/// (all calls to 'F', direct or indirect) go the address stored in the global
-/// variable at the time of the call.
+/// If the VMap argument is non-null, a mapping will be added between F and
+/// the new declaration, and between each of F's arguments and the new
+/// declaration's arguments. This map can then be passed in to moveFunction to
+/// move the function body if required. Note: When moving functions between
+/// modules with these utilities, all decls should be cloned (and added to a
+/// single VMap) before any bodies are moved. This will ensure that references
+/// between functions all refer to the versions in the new module.
+Function* cloneFunctionDecl(Module &Dst, const Function &F,
+ ValueToValueMapTy *VMap = nullptr);
+
+/// @brief Move the body of function 'F' to a cloned function declaration in a
+/// different module (See related cloneFunctionDecl).
///
-/// This method does *not* initialize the function implementation addresses.
-/// The client must do this prior to running any call-sites that have been
-/// indirected.
-JITIndirections makeCallsDoubleIndirect(
- llvm::Module &M,
- const std::function<bool(const Function &)> &ShouldIndirect,
- const char *JITImplSuffix, const char *JITAddrSuffix);
-
-/// @brief Given a set of indirections and a symbol lookup functor, create a
-/// JITResolveCallbackHandler instance that will resolve the
-/// implementations for the indirected symbols on demand.
-template <typename SymbolLookupFtor>
-std::unique_ptr<JITResolveCallbackHandler>
-createCallbackHandlerFromJITIndirections(const JITIndirections &Indirs,
- const PersistentMangler &NM,
- SymbolLookupFtor Lookup) {
- auto GetImplName = Indirs.GetImplName;
- auto GetAddrName = Indirs.GetAddrName;
-
- std::unique_ptr<JITResolveCallbackHandler> J =
- JITResolveCallbackHandler::create(
- [=](const std::string &S) {
- return Lookup(NM.getMangledName(GetImplName(S)));
- },
- [=](const std::string &S, TargetAddress Addr) {
- void *ImplPtr = reinterpret_cast<void *>(
- Lookup(NM.getMangledName(GetAddrName(S))));
- memcpy(ImplPtr, &Addr, sizeof(TargetAddress));
- });
-
- for (const auto &FuncName : Indirs.IndirectedNames)
- J->addFuncName(FuncName);
-
- return J;
-}
-
-/// @brief Insert callback asm into module M for the symbols managed by
-/// JITResolveCallbackHandler J.
-void insertX86CallbackAsm(Module &M, JITResolveCallbackHandler &J);
-
-/// @brief Initialize global indirects to point into the callback asm.
-template <typename LookupFtor>
-void initializeFuncAddrs(JITResolveCallbackHandler &J,
- const JITIndirections &Indirs,
- const PersistentMangler &NM, LookupFtor Lookup) {
- // Forward declare so that we can access this, even though it's an
- // implementation detail.
- std::string getJITResolveCallbackIndexLabel(unsigned I);
-
- if (J.getNumFuncs() == 0)
- return;
-
- // Force a look up one of the global addresses for a function that has been
- // indirected. We need to do this to trigger the emission of the module
- // holding the callback asm. We can't rely on that emission happening
- // automatically when we look up the callback asm symbols, since lazy-emitting
- // layers can't see those.
- Lookup(NM.getMangledName(Indirs.GetAddrName(J.getFuncName(0))));
-
- // Now update indirects to point to the JIT resolve callback asm.
- for (JITResolveCallbackHandler::StubIndex I = 0; I < J.getNumFuncs(); ++I) {
- TargetAddress ResolveCallbackIdxAddr =
- Lookup(getJITResolveCallbackIndexLabel(I));
- void *AddrPtr = reinterpret_cast<void *>(
- Lookup(NM.getMangledName(Indirs.GetAddrName(J.getFuncName(I)))));
- assert(AddrPtr && "Can't find stub addr global to initialize.");
- memcpy(AddrPtr, &ResolveCallbackIdxAddr, sizeof(TargetAddress));
- }
-}
-
-/// @brief Extract all functions matching the predicate ShouldExtract in to
-/// their own modules. (Does not modify the original module.)
+/// If the target function declaration is not supplied via the NewF parameter
+/// then it will be looked up via the VMap.
///
-/// @return A set of modules, the first containing all symbols (including
-/// globals and aliases) that did not pass ShouldExtract, and each
-/// subsequent module containing one of the functions that did meet
-/// ShouldExtract.
+/// This will delete the body of function 'F' from its original parent module,
+/// but leave its declaration.
+void moveFunctionBody(Function &OrigF, ValueToValueMapTy &VMap,
+ ValueMaterializer *Materializer = nullptr,
+ Function *NewF = nullptr);
+
+/// @brief Clone a global variable declaration into a new module.
+GlobalVariable* cloneGlobalVariableDecl(Module &Dst, const GlobalVariable &GV,
+ ValueToValueMapTy *VMap = nullptr);
+
+/// @brief Move global variable GV from its parent module to cloned global
+/// declaration in a different module.
///
-/// By adding the resulting modules separately (not as a set) to a
-/// LazyEmittingLayer instance, compilation can be deferred until symbols are
-/// actually needed.
-std::vector<std::unique_ptr<llvm::Module>>
-explode(const llvm::Module &OrigMod,
- const std::function<bool(const Function &)> &ShouldExtract);
-
-/// @brief Given a module that has been indirectified, break each function
-/// that has been indirected out into its own module. (Does not modify
-/// the original module).
+/// If the target global declaration is not supplied via the NewGV parameter
+/// then it will be looked up via the VMap.
///
-/// @returns A set of modules covering the symbols provided by OrigMod.
-std::vector<std::unique_ptr<llvm::Module>>
-explode(const llvm::Module &OrigMod, const JITIndirections &Indirections);
-}
+/// This will delete the initializer of GV from its original parent module,
+/// but leave its declaration.
+void moveGlobalVariableInitializer(GlobalVariable &OrigGV,
+ ValueToValueMapTy &VMap,
+ ValueMaterializer *Materializer = nullptr,
+ GlobalVariable *NewGV = nullptr);
+
+/// @brief Clone
+GlobalAlias* cloneGlobalAliasDecl(Module &Dst, const GlobalAlias &OrigA,
+ ValueToValueMapTy &VMap);
+
+} // End namespace orc.
+} // End namespace llvm.
#endif // LLVM_EXECUTIONENGINE_ORC_INDIRECTIONUTILS_H