llvm/lib/ExecutionEngine/Orc/ExecutionUtils.cpp

   1 //===---- ExecutionUtils.cpp - Utilities for executing functions in Orc ---===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8
   9 #include "llvm/ExecutionEngine/Orc/ExecutionUtils.h"
  10 #include "llvm/ExecutionEngine/JITLink/x86_64.h"
  11 #include "llvm/ExecutionEngine/Orc/Layer.h"
  12 #include "llvm/ExecutionEngine/Orc/ObjectFileInterface.h"
  13 #include "llvm/IR/Constants.h"
  14 #include "llvm/IR/Function.h"
  15 #include "llvm/IR/GlobalVariable.h"
  16 #include "llvm/IR/Module.h"
  17 #include "llvm/MC/TargetRegistry.h"
  18 #include "llvm/Object/MachOUniversal.h"
  19 #include "llvm/Support/FormatVariadic.h"
  20 #include "llvm/Target/TargetMachine.h"
  21 #include <string>
  22
  23 namespace llvm {
  24 namespace orc {
  25
  26 CtorDtorIterator::CtorDtorIterator(const GlobalVariable *GV, bool End)
  27   : InitList(
  28       GV ? dyn_cast_or_null<ConstantArray>(GV->getInitializer()) : nullptr),
  29     I((InitList && End) ? InitList->getNumOperands() : 0) {
  30 }
  31
  32 bool CtorDtorIterator::operator==(const CtorDtorIterator &Other) const {
  33   assert(InitList == Other.InitList && "Incomparable iterators.");
  34   return I == Other.I;
  35 }
  36
  37 bool CtorDtorIterator::operator!=(const CtorDtorIterator &Other) const {
  38   return !(*this == Other);
  39 }
  40
  41 CtorDtorIterator& CtorDtorIterator::operator++() {
  42   ++I;
  43   return *this;
  44 }
  45
  46 CtorDtorIterator CtorDtorIterator::operator++(int) {
  47   CtorDtorIterator Temp = *this;
  48   ++I;
  49   return Temp;
  50 }
  51
  52 CtorDtorIterator::Element CtorDtorIterator::operator*() const {
  53   ConstantStruct *CS = dyn_cast<ConstantStruct>(InitList->getOperand(I));
  54   assert(CS && "Unrecognized type in llvm.global_ctors/llvm.global_dtors");
  55
  56   Constant *FuncC = CS->getOperand(1);
  57   Function *Func = nullptr;
  58
  59   // Extract function pointer, pulling off any casts.
  60   while (FuncC) {
  61     if (Function *F = dyn_cast_or_null<Function>(FuncC)) {
  62       Func = F;
  63       break;
  64     } else if (ConstantExpr *CE = dyn_cast_or_null<ConstantExpr>(FuncC)) {
  65       if (CE->isCast())
  66         FuncC = CE->getOperand(0);
  67       else
  68         break;
  69     } else {
  70       // This isn't anything we recognize. Bail out with Func left set to null.
  71       break;
  72     }
  73   }
  74
  75   auto *Priority = cast<ConstantInt>(CS->getOperand(0));
  76   Value *Data = CS->getNumOperands() == 3 ? CS->getOperand(2) : nullptr;
  77   if (Data && !isa<GlobalValue>(Data))
  78     Data = nullptr;
  79   return Element(Priority->getZExtValue(), Func, Data);
  80 }
  81
  82 iterator_range<CtorDtorIterator> getConstructors(const Module &M) {
  83   const GlobalVariable *CtorsList = M.getNamedGlobal("llvm.global_ctors");
  84   return make_range(CtorDtorIterator(CtorsList, false),
  85                     CtorDtorIterator(CtorsList, true));
  86 }
  87
  88 iterator_range<CtorDtorIterator> getDestructors(const Module &M) {
  89   const GlobalVariable *DtorsList = M.getNamedGlobal("llvm.global_dtors");
  90   return make_range(CtorDtorIterator(DtorsList, false),
  91                     CtorDtorIterator(DtorsList, true));
  92 }
  93
  94 bool StaticInitGVIterator::isStaticInitGlobal(GlobalValue &GV) {
  95   if (GV.isDeclaration())
  96     return false;
  97
  98   if (GV.hasName() && (GV.getName() == "llvm.global_ctors" ||
  99                        GV.getName() == "llvm.global_dtors"))
 100     return true;
 101
 102   if (ObjFmt == Triple::MachO) {
 103     // FIXME: These section checks are too strict: We should match first and
 104     // second word split by comma.
 105     if (GV.hasSection() &&
 106         (GV.getSection().startswith("__DATA,__objc_classlist") ||
 107          GV.getSection().startswith("__DATA,__objc_selrefs")))
 108       return true;
 109   }
 110
 111   return false;
 112 }
 113
 114 void CtorDtorRunner::add(iterator_range<CtorDtorIterator> CtorDtors) {
 115   if (CtorDtors.empty())
 116     return;
 117
 118   MangleAndInterner Mangle(
 119       JD.getExecutionSession(),
 120       (*CtorDtors.begin()).Func->getParent()->getDataLayout());
 121
 122   for (auto CtorDtor : CtorDtors) {
 123     assert(CtorDtor.Func && CtorDtor.Func->hasName() &&
 124            "Ctor/Dtor function must be named to be runnable under the JIT");
 125
 126     // FIXME: Maybe use a symbol promoter here instead.
 127     if (CtorDtor.Func->hasLocalLinkage()) {
 128       CtorDtor.Func->setLinkage(GlobalValue::ExternalLinkage);
 129       CtorDtor.Func->setVisibility(GlobalValue::HiddenVisibility);
 130     }
 131
 132     if (CtorDtor.Data && cast<GlobalValue>(CtorDtor.Data)->isDeclaration()) {
 133       dbgs() << "  Skipping because why now?\n";
 134       continue;
 135     }
 136
 137     CtorDtorsByPriority[CtorDtor.Priority].push_back(
 138         Mangle(CtorDtor.Func->getName()));
 139   }
 140 }
 141
 142 Error CtorDtorRunner::run() {
 143   using CtorDtorTy = void (*)();
 144
 145   SymbolLookupSet LookupSet;
 146   for (auto &KV : CtorDtorsByPriority)
 147     for (auto &Name : KV.second)
 148       LookupSet.add(Name);
 149   assert(!LookupSet.containsDuplicates() &&
 150          "Ctor/Dtor list contains duplicates");
 151
 152   auto &ES = JD.getExecutionSession();
 153   if (auto CtorDtorMap = ES.lookup(
 154           makeJITDylibSearchOrder(&JD, JITDylibLookupFlags::MatchAllSymbols),
 155           std::move(LookupSet))) {
 156     for (auto &KV : CtorDtorsByPriority) {
 157       for (auto &Name : KV.second) {
 158         assert(CtorDtorMap->count(Name) && "No entry for Name");
 159         auto CtorDtor = (*CtorDtorMap)[Name].getAddress().toPtr<CtorDtorTy>();
 160         CtorDtor();
 161       }
 162     }
 163     CtorDtorsByPriority.clear();
 164     return Error::success();
 165   } else
 166     return CtorDtorMap.takeError();
 167 }
 168
 169 void LocalCXXRuntimeOverridesBase::runDestructors() {
 170   auto& CXXDestructorDataPairs = DSOHandleOverride;
 171   for (auto &P : CXXDestructorDataPairs)
 172     P.first(P.second);
 173   CXXDestructorDataPairs.clear();
 174 }
 175
 176 int LocalCXXRuntimeOverridesBase::CXAAtExitOverride(DestructorPtr Destructor,
 177                                                     void *Arg,
 178                                                     void *DSOHandle) {
 179   auto& CXXDestructorDataPairs =
 180     *reinterpret_cast<CXXDestructorDataPairList*>(DSOHandle);
 181   CXXDestructorDataPairs.push_back(std::make_pair(Destructor, Arg));
 182   return 0;
 183 }
 184
 185 Error LocalCXXRuntimeOverrides::enable(JITDylib &JD,
 186                                         MangleAndInterner &Mangle) {
 187   SymbolMap RuntimeInterposes;
 188   RuntimeInterposes[Mangle("__dso_handle")] = {
 189       ExecutorAddr::fromPtr(&DSOHandleOverride), JITSymbolFlags::Exported};
 190   RuntimeInterposes[Mangle("__cxa_atexit")] = {
 191       ExecutorAddr::fromPtr(&CXAAtExitOverride), JITSymbolFlags::Exported};
 192
 193   return JD.define(absoluteSymbols(std::move(RuntimeInterposes)));
 194 }
 195
 196 void ItaniumCXAAtExitSupport::registerAtExit(void (*F)(void *), void *Ctx,
 197                                              void *DSOHandle) {
 198   std::lock_guard<std::mutex> Lock(AtExitsMutex);
 199   AtExitRecords[DSOHandle].push_back({F, Ctx});
 200 }
 201
 202 void ItaniumCXAAtExitSupport::runAtExits(void *DSOHandle) {
 203   std::vector<AtExitRecord> AtExitsToRun;
 204
 205   {
 206     std::lock_guard<std::mutex> Lock(AtExitsMutex);
 207     auto I = AtExitRecords.find(DSOHandle);
 208     if (I != AtExitRecords.end()) {
 209       AtExitsToRun = std::move(I->second);
 210       AtExitRecords.erase(I);
 211     }
 212   }
 213
 214   while (!AtExitsToRun.empty()) {
 215     AtExitsToRun.back().F(AtExitsToRun.back().Ctx);
 216     AtExitsToRun.pop_back();
 217   }
 218 }
 219
 220 DynamicLibrarySearchGenerator::DynamicLibrarySearchGenerator(
 221     sys::DynamicLibrary Dylib, char GlobalPrefix, SymbolPredicate Allow)
 222     : Dylib(std::move(Dylib)), Allow(std::move(Allow)),
 223       GlobalPrefix(GlobalPrefix) {}
 224
 225 Expected<std::unique_ptr<DynamicLibrarySearchGenerator>>
 226 DynamicLibrarySearchGenerator::Load(const char *FileName, char GlobalPrefix,
 227                                     SymbolPredicate Allow) {
 228   std::string ErrMsg;
 229   auto Lib = sys::DynamicLibrary::getPermanentLibrary(FileName, &ErrMsg);
 230   if (!Lib.isValid())
 231     return make_error<StringError>(std::move(ErrMsg), inconvertibleErrorCode());
 232   return std::make_unique<DynamicLibrarySearchGenerator>(
 233       std::move(Lib), GlobalPrefix, std::move(Allow));
 234 }
 235
 236 Error DynamicLibrarySearchGenerator::tryToGenerate(
 237     LookupState &LS, LookupKind K, JITDylib &JD,
 238     JITDylibLookupFlags JDLookupFlags, const SymbolLookupSet &Symbols) {
 239   orc::SymbolMap NewSymbols;
 240
 241   bool HasGlobalPrefix = (GlobalPrefix != '\0');
 242
 243   for (auto &KV : Symbols) {
 244     auto &Name = KV.first;
 245
 246     if ((*Name).empty())
 247       continue;
 248
 249     if (Allow && !Allow(Name))
 250       continue;
 251
 252     if (HasGlobalPrefix && (*Name).front() != GlobalPrefix)
 253       continue;
 254
 255     std::string Tmp((*Name).data() + HasGlobalPrefix,
 256                     (*Name).size() - HasGlobalPrefix);
 257     if (void *P = Dylib.getAddressOfSymbol(Tmp.c_str()))
 258       NewSymbols[Name] = {ExecutorAddr::fromPtr(P), JITSymbolFlags::Exported};
 259   }
 260
 261   if (NewSymbols.empty())
 262     return Error::success();
 263
 264   return JD.define(absoluteSymbols(std::move(NewSymbols)));
 265 }
 266
 267 Expected<std::unique_ptr<StaticLibraryDefinitionGenerator>>
 268 StaticLibraryDefinitionGenerator::Load(
 269     ObjectLayer &L, const char *FileName,
 270     GetObjectFileInterface GetObjFileInterface) {
 271
 272   auto B = object::createBinary(FileName);
 273   if (!B)
 274     return createFileError(FileName, B.takeError());
 275
 276   // If this is a regular archive then create an instance from it.
 277   if (isa<object::Archive>(B->getBinary())) {
 278     auto [Archive, ArchiveBuffer] = B->takeBinary();
 279     return Create(L, std::move(ArchiveBuffer),
 280                   std::unique_ptr<object::Archive>(
 281                       static_cast<object::Archive *>(Archive.release())),
 282                   std::move(GetObjFileInterface));
 283   }
 284
 285   // If this is a universal binary then search for a slice matching the given
 286   // Triple.
 287   if (auto *UB = cast<object::MachOUniversalBinary>(B->getBinary())) {
 288
 289     const auto &TT = L.getExecutionSession().getTargetTriple();
 290
 291     auto SliceRange = getSliceRangeForArch(*UB, TT);
 292     if (!SliceRange)
 293       return SliceRange.takeError();
 294
 295     auto SliceBuffer = MemoryBuffer::getFileSlice(FileName, SliceRange->second,
 296                                                   SliceRange->first);
 297     if (!SliceBuffer)
 298       return make_error<StringError>(
 299           Twine("Could not create buffer for ") + TT.str() + " slice of " +
 300               FileName + ": [ " + formatv("{0:x}", SliceRange->first) + " .. " +
 301               formatv("{0:x}", SliceRange->first + SliceRange->second) + ": " +
 302               SliceBuffer.getError().message(),
 303           SliceBuffer.getError());
 304
 305     return Create(L, std::move(*SliceBuffer), std::move(GetObjFileInterface));
 306   }
 307
 308   return make_error<StringError>(Twine("Unrecognized file type for ") +
 309                                      FileName,
 310                                  inconvertibleErrorCode());
 311 }
 312
 313 Expected<std::unique_ptr<StaticLibraryDefinitionGenerator>>
 314 StaticLibraryDefinitionGenerator::Create(
 315     ObjectLayer &L, std::unique_ptr<MemoryBuffer> ArchiveBuffer,
 316     std::unique_ptr<object::Archive> Archive,
 317     GetObjectFileInterface GetObjFileInterface) {
 318
 319   Error Err = Error::success();
 320
 321   std::unique_ptr<StaticLibraryDefinitionGenerator> ADG(
 322       new StaticLibraryDefinitionGenerator(
 323           L, std::move(ArchiveBuffer), std::move(Archive),
 324           std::move(GetObjFileInterface), Err));
 325
 326   if (Err)
 327     return std::move(Err);
 328
 329   return std::move(ADG);
 330 }
 331
 332 Expected<std::unique_ptr<StaticLibraryDefinitionGenerator>>
 333 StaticLibraryDefinitionGenerator::Create(
 334     ObjectLayer &L, std::unique_ptr<MemoryBuffer> ArchiveBuffer,
 335     GetObjectFileInterface GetObjFileInterface) {
 336
 337   auto B = object::createBinary(ArchiveBuffer->getMemBufferRef());
 338   if (!B)
 339     return B.takeError();
 340
 341   // If this is a regular archive then create an instance from it.
 342   if (isa<object::Archive>(*B))
 343     return Create(L, std::move(ArchiveBuffer),
 344                   std::unique_ptr<object::Archive>(
 345                       static_cast<object::Archive *>(B->release())),
 346                   std::move(GetObjFileInterface));
 347
 348   // If this is a universal binary then search for a slice matching the given
 349   // Triple.
 350   if (auto *UB = cast<object::MachOUniversalBinary>(B->get())) {
 351
 352     const auto &TT = L.getExecutionSession().getTargetTriple();
 353
 354     auto SliceRange = getSliceRangeForArch(*UB, TT);
 355     if (!SliceRange)
 356       return SliceRange.takeError();
 357
 358     MemoryBufferRef SliceRef(
 359         StringRef(ArchiveBuffer->getBufferStart() + SliceRange->first,
 360                   SliceRange->second),
 361         ArchiveBuffer->getBufferIdentifier());
 362
 363     auto Archive = object::Archive::create(SliceRef);
 364     if (!Archive)
 365       return Archive.takeError();
 366
 367     return Create(L, std::move(ArchiveBuffer), std::move(*Archive),
 368                   std::move(GetObjFileInterface));
 369   }
 370
 371   return make_error<StringError>(Twine("Unrecognized file type for ") +
 372                                      ArchiveBuffer->getBufferIdentifier(),
 373                                  inconvertibleErrorCode());
 374 }
 375
 376 Error StaticLibraryDefinitionGenerator::tryToGenerate(
 377     LookupState &LS, LookupKind K, JITDylib &JD,
 378     JITDylibLookupFlags JDLookupFlags, const SymbolLookupSet &Symbols) {
 379   // Don't materialize symbols from static archives unless this is a static
 380   // lookup.
 381   if (K != LookupKind::Static)
 382     return Error::success();
 383
 384   // Bail out early if we've already freed the archive.
 385   if (!Archive)
 386     return Error::success();
 387
 388   DenseSet<std::pair<StringRef, StringRef>> ChildBufferInfos;
 389
 390   for (const auto &KV : Symbols) {
 391     const auto &Name = KV.first;
 392     if (!ObjectFilesMap.count(Name))
 393       continue;
 394     auto ChildBuffer = ObjectFilesMap[Name];
 395     ChildBufferInfos.insert(
 396         {ChildBuffer.getBuffer(), ChildBuffer.getBufferIdentifier()});
 397   }
 398
 399   for (auto ChildBufferInfo : ChildBufferInfos) {
 400     MemoryBufferRef ChildBufferRef(ChildBufferInfo.first,
 401                                    ChildBufferInfo.second);
 402
 403     auto I = GetObjFileInterface(L.getExecutionSession(), ChildBufferRef);
 404     if (!I)
 405       return I.takeError();
 406
 407     if (auto Err = L.add(JD, MemoryBuffer::getMemBuffer(ChildBufferRef, false),
 408                          std::move(*I)))
 409       return Err;
 410   }
 411
 412   return Error::success();
 413 }
 414
 415 Error StaticLibraryDefinitionGenerator::buildObjectFilesMap() {
 416   DenseMap<uint64_t, MemoryBufferRef> MemoryBuffers;
 417   DenseSet<uint64_t> Visited;
 418   DenseSet<uint64_t> Excluded;
 419   for (auto &S : Archive->symbols()) {
 420     StringRef SymName = S.getName();
 421     auto Member = S.getMember();
 422     if (!Member)
 423       return Member.takeError();
 424     auto DataOffset = Member->getDataOffset();
 425     if (!Visited.count(DataOffset)) {
 426       Visited.insert(DataOffset);
 427       auto Child = Member->getAsBinary();
 428       if (!Child)
 429         return Child.takeError();
 430       if ((*Child)->isCOFFImportFile()) {
 431         ImportedDynamicLibraries.insert((*Child)->getFileName().str());
 432         Excluded.insert(DataOffset);
 433         continue;
 434       }
 435       MemoryBuffers[DataOffset] = (*Child)->getMemoryBufferRef();
 436     }
 437     if (!Excluded.count(DataOffset))
 438       ObjectFilesMap[L.getExecutionSession().intern(SymName)] =
 439           MemoryBuffers[DataOffset];
 440   }
 441
 442   return Error::success();
 443 }
 444
 445 Expected<std::pair<size_t, size_t>>
 446 StaticLibraryDefinitionGenerator::getSliceRangeForArch(
 447     object::MachOUniversalBinary &UB, const Triple &TT) {
 448
 449   for (const auto &Obj : UB.objects()) {
 450     auto ObjTT = Obj.getTriple();
 451     if (ObjTT.getArch() == TT.getArch() &&
 452         ObjTT.getSubArch() == TT.getSubArch() &&
 453         (TT.getVendor() == Triple::UnknownVendor ||
 454          ObjTT.getVendor() == TT.getVendor())) {
 455       // We found a match. Return the range for the slice.
 456       return std::make_pair(Obj.getOffset(), Obj.getSize());
 457     }
 458   }
 459
 460   return make_error<StringError>(Twine("Universal binary ") + UB.getFileName() +
 461                                      " does not contain a slice for " +
 462                                      TT.str(),
 463                                  inconvertibleErrorCode());
 464 }
 465
 466 StaticLibraryDefinitionGenerator::StaticLibraryDefinitionGenerator(
 467     ObjectLayer &L, std::unique_ptr<MemoryBuffer> ArchiveBuffer,
 468     std::unique_ptr<object::Archive> Archive,
 469     GetObjectFileInterface GetObjFileInterface, Error &Err)
 470     : L(L), GetObjFileInterface(std::move(GetObjFileInterface)),
 471       ArchiveBuffer(std::move(ArchiveBuffer)), Archive(std::move(Archive)) {
 472   ErrorAsOutParameter _(&Err);
 473   if (!this->GetObjFileInterface)
 474     this->GetObjFileInterface = getObjectFileInterface;
 475   if (!Err)
 476     Err = buildObjectFilesMap();
 477 }
 478
 479 std::unique_ptr<DLLImportDefinitionGenerator>
 480 DLLImportDefinitionGenerator::Create(ExecutionSession &ES,
 481                                      ObjectLinkingLayer &L) {
 482   return std::unique_ptr<DLLImportDefinitionGenerator>(
 483       new DLLImportDefinitionGenerator(ES, L));
 484 }
 485
 486 Error DLLImportDefinitionGenerator::tryToGenerate(
 487     LookupState &LS, LookupKind K, JITDylib &JD,
 488     JITDylibLookupFlags JDLookupFlags, const SymbolLookupSet &Symbols) {
 489   JITDylibSearchOrder LinkOrder;
 490   JD.withLinkOrderDo([&](const JITDylibSearchOrder &LO) {
 491     LinkOrder.reserve(LO.size());
 492     for (auto &KV : LO) {
 493       if (KV.first == &JD)
 494         continue;
 495       LinkOrder.push_back(KV);
 496     }
 497   });
 498
 499   // FIXME: if regular symbol name start with __imp_ we have to issue lookup of
 500   // both __imp_ and stripped name and use the lookup information to resolve the
 501   // real symbol name.
 502   SymbolLookupSet LookupSet;
 503   DenseMap<StringRef, SymbolLookupFlags> ToLookUpSymbols;
 504   for (auto &KV : Symbols) {
 505     StringRef Deinterned = *KV.first;
 506     if (Deinterned.startswith(getImpPrefix()))
 507       Deinterned = Deinterned.drop_front(StringRef(getImpPrefix()).size());
 508     // Don't degrade the required state
 509     if (ToLookUpSymbols.count(Deinterned) &&
 510         ToLookUpSymbols[Deinterned] == SymbolLookupFlags::RequiredSymbol)
 511       continue;
 512     ToLookUpSymbols[Deinterned] = KV.second;
 513   }
 514
 515   for (auto &KV : ToLookUpSymbols)
 516     LookupSet.add(ES.intern(KV.first), KV.second);
 517
 518   auto Resolved =
 519       ES.lookup(LinkOrder, LookupSet, LookupKind::DLSym, SymbolState::Resolved);
 520   if (!Resolved)
 521     return Resolved.takeError();
 522
 523   auto G = createStubsGraph(*Resolved);
 524   if (!G)
 525     return G.takeError();
 526   return L.add(JD, std::move(*G));
 527 }
 528
 529 Expected<unsigned>
 530 DLLImportDefinitionGenerator::getTargetPointerSize(const Triple &TT) {
 531   switch (TT.getArch()) {
 532   case Triple::x86_64:
 533     return 8;
 534   default:
 535     return make_error<StringError>(
 536         "architecture unsupported by DLLImportDefinitionGenerator",
 537         inconvertibleErrorCode());
 538   }
 539 }
 540
 541 Expected<llvm::endianness>
 542 DLLImportDefinitionGenerator::getTargetEndianness(const Triple &TT) {
 543   switch (TT.getArch()) {
 544   case Triple::x86_64:
 545     return llvm::endianness::little;
 546   default:
 547     return make_error<StringError>(
 548         "architecture unsupported by DLLImportDefinitionGenerator",
 549         inconvertibleErrorCode());
 550   }
 551 }
 552
 553 Expected<std::unique_ptr<jitlink::LinkGraph>>
 554 DLLImportDefinitionGenerator::createStubsGraph(const SymbolMap &Resolved) {
 555   Triple TT = ES.getTargetTriple();
 556   auto PointerSize = getTargetPointerSize(TT);
 557   if (!PointerSize)
 558     return PointerSize.takeError();
 559   auto Endianness = getTargetEndianness(TT);
 560   if (!Endianness)
 561     return Endianness.takeError();
 562
 563   auto G = std::make_unique<jitlink::LinkGraph>(
 564       "<DLLIMPORT_STUBS>", TT, *PointerSize, *Endianness,
 565       jitlink::getGenericEdgeKindName);
 566   jitlink::Section &Sec =
 567       G->createSection(getSectionName(), MemProt::Read | MemProt::Exec);
 568
 569   for (auto &KV : Resolved) {
 570     jitlink::Symbol &Target = G->addAbsoluteSymbol(
 571         *KV.first, KV.second.getAddress(), *PointerSize,
 572         jitlink::Linkage::Strong, jitlink::Scope::Local, false);
 573
 574     // Create __imp_ symbol
 575     jitlink::Symbol &Ptr =
 576         jitlink::x86_64::createAnonymousPointer(*G, Sec, &Target);
 577     auto NameCopy = G->allocateContent(Twine(getImpPrefix()) + *KV.first);
 578     StringRef NameCopyRef = StringRef(NameCopy.data(), NameCopy.size());
 579     Ptr.setName(NameCopyRef);
 580     Ptr.setLinkage(jitlink::Linkage::Strong);
 581     Ptr.setScope(jitlink::Scope::Default);
 582
 583     // Create PLT stub
 584     // FIXME: check PLT stub of data symbol is not accessed
 585     jitlink::Block &StubBlock =
 586         jitlink::x86_64::createPointerJumpStubBlock(*G, Sec, Ptr);
 587     G->addDefinedSymbol(StubBlock, 0, *KV.first, StubBlock.getSize(),
 588                         jitlink::Linkage::Strong, jitlink::Scope::Default, true,
 589                         false);
 590   }
 591
 592   return std::move(G);
 593 }
 594
 595 } // End namespace orc.
 596 } // End namespace llvm.