xref: /freebsd/contrib/llvm-project/llvm/lib/ExecutionEngine/Orc/ExecutionUtils.cpp (revision 2e3507c25e42292b45a5482e116d278f5515d04d) 
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<support::endianness>
542 DLLImportDefinitionGenerator::getTargetEndianness(const Triple &TT) {
543   switch (TT.getArch()) {
544   case Triple::x86_64:
545     return support::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 = getTargetEndianness(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.
597