551 lines
18 KiB
C++
551 lines
18 KiB
C++
//===---- ExecutionUtils.cpp - Utilities for executing functions in Orc ---===//
|
|
//
|
|
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
|
// See https://llvm.org/LICENSE.txt for license information.
|
|
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "llvm/ExecutionEngine/Orc/ExecutionUtils.h"
|
|
#include "llvm/ExecutionEngine/JITLink/x86_64.h"
|
|
#include "llvm/ExecutionEngine/Orc/Layer.h"
|
|
#include "llvm/ExecutionEngine/Orc/ObjectFileInterface.h"
|
|
#include "llvm/IR/Constants.h"
|
|
#include "llvm/IR/Function.h"
|
|
#include "llvm/IR/GlobalVariable.h"
|
|
#include "llvm/IR/Module.h"
|
|
#include "llvm/MC/TargetRegistry.h"
|
|
#include "llvm/Object/MachOUniversal.h"
|
|
#include "llvm/Support/FormatVariadic.h"
|
|
#include "llvm/Target/TargetMachine.h"
|
|
#include <string>
|
|
|
|
namespace llvm {
|
|
namespace orc {
|
|
|
|
CtorDtorIterator::CtorDtorIterator(const GlobalVariable *GV, bool End)
|
|
: InitList(
|
|
GV ? dyn_cast_or_null<ConstantArray>(GV->getInitializer()) : nullptr),
|
|
I((InitList && End) ? InitList->getNumOperands() : 0) {
|
|
}
|
|
|
|
bool CtorDtorIterator::operator==(const CtorDtorIterator &Other) const {
|
|
assert(InitList == Other.InitList && "Incomparable iterators.");
|
|
return I == Other.I;
|
|
}
|
|
|
|
bool CtorDtorIterator::operator!=(const CtorDtorIterator &Other) const {
|
|
return !(*this == Other);
|
|
}
|
|
|
|
CtorDtorIterator& CtorDtorIterator::operator++() {
|
|
++I;
|
|
return *this;
|
|
}
|
|
|
|
CtorDtorIterator CtorDtorIterator::operator++(int) {
|
|
CtorDtorIterator Temp = *this;
|
|
++I;
|
|
return Temp;
|
|
}
|
|
|
|
CtorDtorIterator::Element CtorDtorIterator::operator*() const {
|
|
ConstantStruct *CS = dyn_cast<ConstantStruct>(InitList->getOperand(I));
|
|
assert(CS && "Unrecognized type in llvm.global_ctors/llvm.global_dtors");
|
|
|
|
Constant *FuncC = CS->getOperand(1);
|
|
Function *Func = nullptr;
|
|
|
|
// Extract function pointer, pulling off any casts.
|
|
while (FuncC) {
|
|
if (Function *F = dyn_cast_or_null<Function>(FuncC)) {
|
|
Func = F;
|
|
break;
|
|
} else if (ConstantExpr *CE = dyn_cast_or_null<ConstantExpr>(FuncC)) {
|
|
if (CE->isCast())
|
|
FuncC = CE->getOperand(0);
|
|
else
|
|
break;
|
|
} else {
|
|
// This isn't anything we recognize. Bail out with Func left set to null.
|
|
break;
|
|
}
|
|
}
|
|
|
|
auto *Priority = cast<ConstantInt>(CS->getOperand(0));
|
|
Value *Data = CS->getNumOperands() == 3 ? CS->getOperand(2) : nullptr;
|
|
if (Data && !isa<GlobalValue>(Data))
|
|
Data = nullptr;
|
|
return Element(Priority->getZExtValue(), Func, Data);
|
|
}
|
|
|
|
iterator_range<CtorDtorIterator> getConstructors(const Module &M) {
|
|
const GlobalVariable *CtorsList = M.getNamedGlobal("llvm.global_ctors");
|
|
return make_range(CtorDtorIterator(CtorsList, false),
|
|
CtorDtorIterator(CtorsList, true));
|
|
}
|
|
|
|
iterator_range<CtorDtorIterator> getDestructors(const Module &M) {
|
|
const GlobalVariable *DtorsList = M.getNamedGlobal("llvm.global_dtors");
|
|
return make_range(CtorDtorIterator(DtorsList, false),
|
|
CtorDtorIterator(DtorsList, true));
|
|
}
|
|
|
|
bool StaticInitGVIterator::isStaticInitGlobal(GlobalValue &GV) {
|
|
if (GV.isDeclaration())
|
|
return false;
|
|
|
|
if (GV.hasName() && (GV.getName() == "llvm.global_ctors" ||
|
|
GV.getName() == "llvm.global_dtors"))
|
|
return true;
|
|
|
|
if (ObjFmt == Triple::MachO) {
|
|
// FIXME: These section checks are too strict: We should match first and
|
|
// second word split by comma.
|
|
if (GV.hasSection() &&
|
|
(GV.getSection().startswith("__DATA,__objc_classlist") ||
|
|
GV.getSection().startswith("__DATA,__objc_selrefs")))
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
void CtorDtorRunner::add(iterator_range<CtorDtorIterator> CtorDtors) {
|
|
if (CtorDtors.empty())
|
|
return;
|
|
|
|
MangleAndInterner Mangle(
|
|
JD.getExecutionSession(),
|
|
(*CtorDtors.begin()).Func->getParent()->getDataLayout());
|
|
|
|
for (auto CtorDtor : CtorDtors) {
|
|
assert(CtorDtor.Func && CtorDtor.Func->hasName() &&
|
|
"Ctor/Dtor function must be named to be runnable under the JIT");
|
|
|
|
// FIXME: Maybe use a symbol promoter here instead.
|
|
if (CtorDtor.Func->hasLocalLinkage()) {
|
|
CtorDtor.Func->setLinkage(GlobalValue::ExternalLinkage);
|
|
CtorDtor.Func->setVisibility(GlobalValue::HiddenVisibility);
|
|
}
|
|
|
|
if (CtorDtor.Data && cast<GlobalValue>(CtorDtor.Data)->isDeclaration()) {
|
|
dbgs() << " Skipping because why now?\n";
|
|
continue;
|
|
}
|
|
|
|
CtorDtorsByPriority[CtorDtor.Priority].push_back(
|
|
Mangle(CtorDtor.Func->getName()));
|
|
}
|
|
}
|
|
|
|
Error CtorDtorRunner::run() {
|
|
using CtorDtorTy = void (*)();
|
|
|
|
SymbolLookupSet LookupSet;
|
|
for (auto &KV : CtorDtorsByPriority)
|
|
for (auto &Name : KV.second)
|
|
LookupSet.add(Name);
|
|
assert(!LookupSet.containsDuplicates() &&
|
|
"Ctor/Dtor list contains duplicates");
|
|
|
|
auto &ES = JD.getExecutionSession();
|
|
if (auto CtorDtorMap = ES.lookup(
|
|
makeJITDylibSearchOrder(&JD, JITDylibLookupFlags::MatchAllSymbols),
|
|
std::move(LookupSet))) {
|
|
for (auto &KV : CtorDtorsByPriority) {
|
|
for (auto &Name : KV.second) {
|
|
assert(CtorDtorMap->count(Name) && "No entry for Name");
|
|
auto CtorDtor = reinterpret_cast<CtorDtorTy>(
|
|
static_cast<uintptr_t>((*CtorDtorMap)[Name].getAddress()));
|
|
CtorDtor();
|
|
}
|
|
}
|
|
CtorDtorsByPriority.clear();
|
|
return Error::success();
|
|
} else
|
|
return CtorDtorMap.takeError();
|
|
}
|
|
|
|
void LocalCXXRuntimeOverridesBase::runDestructors() {
|
|
auto& CXXDestructorDataPairs = DSOHandleOverride;
|
|
for (auto &P : CXXDestructorDataPairs)
|
|
P.first(P.second);
|
|
CXXDestructorDataPairs.clear();
|
|
}
|
|
|
|
int LocalCXXRuntimeOverridesBase::CXAAtExitOverride(DestructorPtr Destructor,
|
|
void *Arg,
|
|
void *DSOHandle) {
|
|
auto& CXXDestructorDataPairs =
|
|
*reinterpret_cast<CXXDestructorDataPairList*>(DSOHandle);
|
|
CXXDestructorDataPairs.push_back(std::make_pair(Destructor, Arg));
|
|
return 0;
|
|
}
|
|
|
|
Error LocalCXXRuntimeOverrides::enable(JITDylib &JD,
|
|
MangleAndInterner &Mangle) {
|
|
SymbolMap RuntimeInterposes;
|
|
RuntimeInterposes[Mangle("__dso_handle")] =
|
|
JITEvaluatedSymbol(toTargetAddress(&DSOHandleOverride),
|
|
JITSymbolFlags::Exported);
|
|
RuntimeInterposes[Mangle("__cxa_atexit")] =
|
|
JITEvaluatedSymbol(toTargetAddress(&CXAAtExitOverride),
|
|
JITSymbolFlags::Exported);
|
|
|
|
return JD.define(absoluteSymbols(std::move(RuntimeInterposes)));
|
|
}
|
|
|
|
void ItaniumCXAAtExitSupport::registerAtExit(void (*F)(void *), void *Ctx,
|
|
void *DSOHandle) {
|
|
std::lock_guard<std::mutex> Lock(AtExitsMutex);
|
|
AtExitRecords[DSOHandle].push_back({F, Ctx});
|
|
}
|
|
|
|
void ItaniumCXAAtExitSupport::runAtExits(void *DSOHandle) {
|
|
std::vector<AtExitRecord> AtExitsToRun;
|
|
|
|
{
|
|
std::lock_guard<std::mutex> Lock(AtExitsMutex);
|
|
auto I = AtExitRecords.find(DSOHandle);
|
|
if (I != AtExitRecords.end()) {
|
|
AtExitsToRun = std::move(I->second);
|
|
AtExitRecords.erase(I);
|
|
}
|
|
}
|
|
|
|
while (!AtExitsToRun.empty()) {
|
|
AtExitsToRun.back().F(AtExitsToRun.back().Ctx);
|
|
AtExitsToRun.pop_back();
|
|
}
|
|
}
|
|
|
|
DynamicLibrarySearchGenerator::DynamicLibrarySearchGenerator(
|
|
sys::DynamicLibrary Dylib, char GlobalPrefix, SymbolPredicate Allow)
|
|
: Dylib(std::move(Dylib)), Allow(std::move(Allow)),
|
|
GlobalPrefix(GlobalPrefix) {}
|
|
|
|
Expected<std::unique_ptr<DynamicLibrarySearchGenerator>>
|
|
DynamicLibrarySearchGenerator::Load(const char *FileName, char GlobalPrefix,
|
|
SymbolPredicate Allow) {
|
|
std::string ErrMsg;
|
|
auto Lib = sys::DynamicLibrary::getPermanentLibrary(FileName, &ErrMsg);
|
|
if (!Lib.isValid())
|
|
return make_error<StringError>(std::move(ErrMsg), inconvertibleErrorCode());
|
|
return std::make_unique<DynamicLibrarySearchGenerator>(
|
|
std::move(Lib), GlobalPrefix, std::move(Allow));
|
|
}
|
|
|
|
Error DynamicLibrarySearchGenerator::tryToGenerate(
|
|
LookupState &LS, LookupKind K, JITDylib &JD,
|
|
JITDylibLookupFlags JDLookupFlags, const SymbolLookupSet &Symbols) {
|
|
orc::SymbolMap NewSymbols;
|
|
|
|
bool HasGlobalPrefix = (GlobalPrefix != '\0');
|
|
|
|
for (auto &KV : Symbols) {
|
|
auto &Name = KV.first;
|
|
|
|
if ((*Name).empty())
|
|
continue;
|
|
|
|
if (Allow && !Allow(Name))
|
|
continue;
|
|
|
|
if (HasGlobalPrefix && (*Name).front() != GlobalPrefix)
|
|
continue;
|
|
|
|
std::string Tmp((*Name).data() + HasGlobalPrefix,
|
|
(*Name).size() - HasGlobalPrefix);
|
|
if (void *Addr = Dylib.getAddressOfSymbol(Tmp.c_str())) {
|
|
NewSymbols[Name] = JITEvaluatedSymbol(
|
|
static_cast<JITTargetAddress>(reinterpret_cast<uintptr_t>(Addr)),
|
|
JITSymbolFlags::Exported);
|
|
}
|
|
}
|
|
|
|
if (NewSymbols.empty())
|
|
return Error::success();
|
|
|
|
return JD.define(absoluteSymbols(std::move(NewSymbols)));
|
|
}
|
|
|
|
Expected<std::unique_ptr<StaticLibraryDefinitionGenerator>>
|
|
StaticLibraryDefinitionGenerator::Load(
|
|
ObjectLayer &L, const char *FileName,
|
|
GetObjectFileInterface GetObjFileInterface) {
|
|
auto ArchiveBuffer = MemoryBuffer::getFile(FileName);
|
|
|
|
if (!ArchiveBuffer)
|
|
return createFileError(FileName, ArchiveBuffer.getError());
|
|
|
|
return Create(L, std::move(*ArchiveBuffer), std::move(GetObjFileInterface));
|
|
}
|
|
|
|
Expected<std::unique_ptr<StaticLibraryDefinitionGenerator>>
|
|
StaticLibraryDefinitionGenerator::Load(
|
|
ObjectLayer &L, const char *FileName, const Triple &TT,
|
|
GetObjectFileInterface GetObjFileInterface) {
|
|
|
|
auto B = object::createBinary(FileName);
|
|
if (!B)
|
|
return createFileError(FileName, B.takeError());
|
|
|
|
// If this is a regular archive then create an instance from it.
|
|
if (isa<object::Archive>(B->getBinary()))
|
|
return Create(L, std::move(B->takeBinary().second),
|
|
std::move(GetObjFileInterface));
|
|
|
|
// If this is a universal binary then search for a slice matching the given
|
|
// Triple.
|
|
if (auto *UB = cast<object::MachOUniversalBinary>(B->getBinary())) {
|
|
for (const auto &Obj : UB->objects()) {
|
|
auto ObjTT = Obj.getTriple();
|
|
if (ObjTT.getArch() == TT.getArch() &&
|
|
ObjTT.getSubArch() == TT.getSubArch() &&
|
|
(TT.getVendor() == Triple::UnknownVendor ||
|
|
ObjTT.getVendor() == TT.getVendor())) {
|
|
// We found a match. Create an instance from a buffer covering this
|
|
// slice.
|
|
auto SliceBuffer = MemoryBuffer::getFileSlice(FileName, Obj.getSize(),
|
|
Obj.getOffset());
|
|
if (!SliceBuffer)
|
|
return make_error<StringError>(
|
|
Twine("Could not create buffer for ") + TT.str() + " slice of " +
|
|
FileName + ": [ " + formatv("{0:x}", Obj.getOffset()) +
|
|
" .. " + formatv("{0:x}", Obj.getOffset() + Obj.getSize()) +
|
|
": " + SliceBuffer.getError().message(),
|
|
SliceBuffer.getError());
|
|
return Create(L, std::move(*SliceBuffer),
|
|
std::move(GetObjFileInterface));
|
|
}
|
|
}
|
|
|
|
return make_error<StringError>(Twine("Universal binary ") + FileName +
|
|
" does not contain a slice for " +
|
|
TT.str(),
|
|
inconvertibleErrorCode());
|
|
}
|
|
|
|
return make_error<StringError>(Twine("Unrecognized file type for ") +
|
|
FileName,
|
|
inconvertibleErrorCode());
|
|
}
|
|
|
|
Expected<std::unique_ptr<StaticLibraryDefinitionGenerator>>
|
|
StaticLibraryDefinitionGenerator::Create(
|
|
ObjectLayer &L, std::unique_ptr<MemoryBuffer> ArchiveBuffer,
|
|
GetObjectFileInterface GetObjFileInterface) {
|
|
Error Err = Error::success();
|
|
|
|
std::unique_ptr<StaticLibraryDefinitionGenerator> ADG(
|
|
new StaticLibraryDefinitionGenerator(
|
|
L, std::move(ArchiveBuffer), std::move(GetObjFileInterface), Err));
|
|
|
|
if (Err)
|
|
return std::move(Err);
|
|
|
|
return std::move(ADG);
|
|
}
|
|
|
|
Error StaticLibraryDefinitionGenerator::tryToGenerate(
|
|
LookupState &LS, LookupKind K, JITDylib &JD,
|
|
JITDylibLookupFlags JDLookupFlags, const SymbolLookupSet &Symbols) {
|
|
// Don't materialize symbols from static archives unless this is a static
|
|
// lookup.
|
|
if (K != LookupKind::Static)
|
|
return Error::success();
|
|
|
|
// Bail out early if we've already freed the archive.
|
|
if (!Archive)
|
|
return Error::success();
|
|
|
|
DenseSet<std::pair<StringRef, StringRef>> ChildBufferInfos;
|
|
|
|
for (const auto &KV : Symbols) {
|
|
const auto &Name = KV.first;
|
|
if (!ObjectFilesMap.count(Name))
|
|
continue;
|
|
auto ChildBuffer = ObjectFilesMap[Name];
|
|
ChildBufferInfos.insert(
|
|
{ChildBuffer.getBuffer(), ChildBuffer.getBufferIdentifier()});
|
|
}
|
|
|
|
for (auto ChildBufferInfo : ChildBufferInfos) {
|
|
MemoryBufferRef ChildBufferRef(ChildBufferInfo.first,
|
|
ChildBufferInfo.second);
|
|
|
|
auto I = GetObjFileInterface(L.getExecutionSession(), ChildBufferRef);
|
|
if (!I)
|
|
return I.takeError();
|
|
|
|
if (auto Err = L.add(JD, MemoryBuffer::getMemBuffer(ChildBufferRef, false),
|
|
std::move(*I)))
|
|
return Err;
|
|
}
|
|
|
|
return Error::success();
|
|
}
|
|
|
|
Error StaticLibraryDefinitionGenerator::buildObjectFilesMap() {
|
|
DenseMap<uint64_t, MemoryBufferRef> MemoryBuffers;
|
|
DenseSet<uint64_t> Visited;
|
|
DenseSet<uint64_t> Excluded;
|
|
for (auto &S : Archive->symbols()) {
|
|
StringRef SymName = S.getName();
|
|
auto Member = S.getMember();
|
|
if (!Member)
|
|
return Member.takeError();
|
|
auto DataOffset = Member->getDataOffset();
|
|
if (!Visited.count(DataOffset)) {
|
|
Visited.insert(DataOffset);
|
|
auto Child = Member->getAsBinary();
|
|
if (!Child)
|
|
return Child.takeError();
|
|
if ((*Child)->isCOFFImportFile()) {
|
|
ImportedDynamicLibraries.insert((*Child)->getFileName().str());
|
|
Excluded.insert(DataOffset);
|
|
continue;
|
|
}
|
|
MemoryBuffers[DataOffset] = (*Child)->getMemoryBufferRef();
|
|
}
|
|
if (!Excluded.count(DataOffset))
|
|
ObjectFilesMap[L.getExecutionSession().intern(SymName)] =
|
|
MemoryBuffers[DataOffset];
|
|
}
|
|
|
|
return Error::success();
|
|
}
|
|
|
|
StaticLibraryDefinitionGenerator::StaticLibraryDefinitionGenerator(
|
|
ObjectLayer &L, std::unique_ptr<MemoryBuffer> ArchiveBuffer,
|
|
GetObjectFileInterface GetObjFileInterface, Error &Err)
|
|
: L(L), GetObjFileInterface(std::move(GetObjFileInterface)),
|
|
ArchiveBuffer(std::move(ArchiveBuffer)),
|
|
Archive(std::make_unique<object::Archive>(*this->ArchiveBuffer, Err)) {
|
|
ErrorAsOutParameter _(&Err);
|
|
if (!this->GetObjFileInterface)
|
|
this->GetObjFileInterface = getObjectFileInterface;
|
|
if (!Err)
|
|
Err = buildObjectFilesMap();
|
|
}
|
|
|
|
std::unique_ptr<DLLImportDefinitionGenerator>
|
|
DLLImportDefinitionGenerator::Create(ExecutionSession &ES,
|
|
ObjectLinkingLayer &L) {
|
|
return std::unique_ptr<DLLImportDefinitionGenerator>(
|
|
new DLLImportDefinitionGenerator(ES, L));
|
|
}
|
|
|
|
Error DLLImportDefinitionGenerator::tryToGenerate(
|
|
LookupState &LS, LookupKind K, JITDylib &JD,
|
|
JITDylibLookupFlags JDLookupFlags, const SymbolLookupSet &Symbols) {
|
|
JITDylibSearchOrder LinkOrder;
|
|
JD.withLinkOrderDo([&](const JITDylibSearchOrder &LO) {
|
|
LinkOrder.reserve(LO.size());
|
|
for (auto &KV : LO) {
|
|
if (KV.first == &JD)
|
|
continue;
|
|
LinkOrder.push_back(KV);
|
|
}
|
|
});
|
|
|
|
// FIXME: if regular symbol name start with __imp_ we have to issue lookup of
|
|
// both __imp_ and stripped name and use the lookup information to resolve the
|
|
// real symbol name.
|
|
SymbolLookupSet LookupSet;
|
|
DenseMap<StringRef, SymbolLookupFlags> ToLookUpSymbols;
|
|
for (auto &KV : Symbols) {
|
|
StringRef Deinterned = *KV.first;
|
|
if (Deinterned.startswith(getImpPrefix()))
|
|
Deinterned = Deinterned.drop_front(StringRef(getImpPrefix()).size());
|
|
// Don't degrade the required state
|
|
if (ToLookUpSymbols.count(Deinterned) &&
|
|
ToLookUpSymbols[Deinterned] == SymbolLookupFlags::RequiredSymbol)
|
|
continue;
|
|
ToLookUpSymbols[Deinterned] = KV.second;
|
|
}
|
|
|
|
for (auto &KV : ToLookUpSymbols)
|
|
LookupSet.add(ES.intern(KV.first), KV.second);
|
|
|
|
auto Resolved =
|
|
ES.lookup(LinkOrder, LookupSet, LookupKind::DLSym, SymbolState::Resolved);
|
|
if (!Resolved)
|
|
return Resolved.takeError();
|
|
|
|
auto G = createStubsGraph(*Resolved);
|
|
if (!G)
|
|
return G.takeError();
|
|
return L.add(JD, std::move(*G));
|
|
}
|
|
|
|
Expected<unsigned>
|
|
DLLImportDefinitionGenerator::getTargetPointerSize(const Triple &TT) {
|
|
switch (TT.getArch()) {
|
|
case Triple::x86_64:
|
|
return 8;
|
|
default:
|
|
return make_error<StringError>(
|
|
"architecture unsupported by DLLImportDefinitionGenerator",
|
|
inconvertibleErrorCode());
|
|
}
|
|
}
|
|
|
|
Expected<support::endianness>
|
|
DLLImportDefinitionGenerator::getTargetEndianness(const Triple &TT) {
|
|
switch (TT.getArch()) {
|
|
case Triple::x86_64:
|
|
return support::endianness::little;
|
|
default:
|
|
return make_error<StringError>(
|
|
"architecture unsupported by DLLImportDefinitionGenerator",
|
|
inconvertibleErrorCode());
|
|
}
|
|
}
|
|
|
|
Expected<std::unique_ptr<jitlink::LinkGraph>>
|
|
DLLImportDefinitionGenerator::createStubsGraph(const SymbolMap &Resolved) {
|
|
Triple TT = ES.getExecutorProcessControl().getTargetTriple();
|
|
auto PointerSize = getTargetEndianness(TT);
|
|
if (!PointerSize)
|
|
return PointerSize.takeError();
|
|
auto Endianness = getTargetEndianness(TT);
|
|
if (!Endianness)
|
|
return Endianness.takeError();
|
|
|
|
auto G = std::make_unique<jitlink::LinkGraph>(
|
|
"<DLLIMPORT_STUBS>", TT, *PointerSize, *Endianness,
|
|
jitlink::getGenericEdgeKindName);
|
|
jitlink::Section &Sec = G->createSection(
|
|
getSectionName(), jitlink::MemProt::Read | jitlink::MemProt::Exec);
|
|
|
|
for (auto &KV : Resolved) {
|
|
jitlink::Symbol &Target = G->addAbsoluteSymbol(
|
|
*KV.first, ExecutorAddr(KV.second.getAddress()), *PointerSize,
|
|
jitlink::Linkage::Strong, jitlink::Scope::Local, false);
|
|
|
|
// Create __imp_ symbol
|
|
jitlink::Symbol &Ptr =
|
|
jitlink::x86_64::createAnonymousPointer(*G, Sec, &Target);
|
|
auto NameCopy = G->allocateString(Twine(getImpPrefix()) + *KV.first);
|
|
StringRef NameCopyRef = StringRef(NameCopy.data(), NameCopy.size());
|
|
Ptr.setName(NameCopyRef);
|
|
Ptr.setLinkage(jitlink::Linkage::Strong);
|
|
Ptr.setScope(jitlink::Scope::Default);
|
|
|
|
// Create PLT stub
|
|
// FIXME: check PLT stub of data symbol is not accessed
|
|
jitlink::Block &StubBlock =
|
|
jitlink::x86_64::createPointerJumpStubBlock(*G, Sec, Ptr);
|
|
G->addDefinedSymbol(StubBlock, 0, *KV.first, StubBlock.getSize(),
|
|
jitlink::Linkage::Strong, jitlink::Scope::Default, true,
|
|
false);
|
|
}
|
|
|
|
return std::move(G);
|
|
}
|
|
|
|
} // End namespace orc.
|
|
} // End namespace llvm.
|