LLVM 19.0.0git
RuntimeDyld.cpp
Go to the documentation of this file.
1//===-- RuntimeDyld.cpp - Run-time dynamic linker for MC-JIT ----*- C++ -*-===//
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// Implementation of the MC-JIT runtime dynamic linker.
10//
11//===----------------------------------------------------------------------===//
12
14#include "RuntimeDyldCOFF.h"
15#include "RuntimeDyldELF.h"
16#include "RuntimeDyldImpl.h"
17#include "RuntimeDyldMachO.h"
18#include "llvm/Object/COFF.h"
23#include <mutex>
24
25#include <future>
26
27using namespace llvm;
28using namespace llvm::object;
29
30#define DEBUG_TYPE "dyld"
31
32namespace {
33
34enum RuntimeDyldErrorCode {
35 GenericRTDyldError = 1
36};
37
38// FIXME: This class is only here to support the transition to llvm::Error. It
39// will be removed once this transition is complete. Clients should prefer to
40// deal with the Error value directly, rather than converting to error_code.
41class RuntimeDyldErrorCategory : public std::error_category {
42public:
43 const char *name() const noexcept override { return "runtimedyld"; }
44
45 std::string message(int Condition) const override {
46 switch (static_cast<RuntimeDyldErrorCode>(Condition)) {
47 case GenericRTDyldError: return "Generic RuntimeDyld error";
48 }
49 llvm_unreachable("Unrecognized RuntimeDyldErrorCode");
50 }
51};
52
53}
54
56
58 OS << ErrMsg << "\n";
59}
60
61std::error_code RuntimeDyldError::convertToErrorCode() const {
62 static RuntimeDyldErrorCategory RTDyldErrorCategory;
63 return std::error_code(GenericRTDyldError, RTDyldErrorCategory);
64}
65
66// Empty out-of-line virtual destructor as the key function.
68
69// Pin LoadedObjectInfo's vtables to this file.
71
72namespace llvm {
73
75
77 MemMgr.deregisterEHFrames();
78}
79
80#ifndef NDEBUG
81static void dumpSectionMemory(const SectionEntry &S, StringRef State) {
82 dbgs() << "----- Contents of section " << S.getName() << " " << State
83 << " -----";
84
85 if (S.getAddress() == nullptr) {
86 dbgs() << "\n <section not emitted>\n";
87 return;
88 }
89
90 const unsigned ColsPerRow = 16;
91
92 uint8_t *DataAddr = S.getAddress();
93 uint64_t LoadAddr = S.getLoadAddress();
94
95 unsigned StartPadding = LoadAddr & (ColsPerRow - 1);
96 unsigned BytesRemaining = S.getSize();
97
98 if (StartPadding) {
99 dbgs() << "\n" << format("0x%016" PRIx64,
100 LoadAddr & ~(uint64_t)(ColsPerRow - 1)) << ":";
101 while (StartPadding--)
102 dbgs() << " ";
103 }
104
105 while (BytesRemaining > 0) {
106 if ((LoadAddr & (ColsPerRow - 1)) == 0)
107 dbgs() << "\n" << format("0x%016" PRIx64, LoadAddr) << ":";
108
109 dbgs() << " " << format("%02x", *DataAddr);
110
111 ++DataAddr;
112 ++LoadAddr;
113 --BytesRemaining;
114 }
115
116 dbgs() << "\n";
117}
118#endif
119
120// Resolve the relocations for all symbols we currently know about.
122 std::lock_guard<sys::Mutex> locked(lock);
123
124 // Print out the sections prior to relocation.
125 LLVM_DEBUG({
126 for (SectionEntry &S : Sections)
127 dumpSectionMemory(S, "before relocations");
128 });
129
130 // First, resolve relocations associated with external symbols.
131 if (auto Err = resolveExternalSymbols()) {
132 HasError = true;
133 ErrorStr = toString(std::move(Err));
134 }
135
136 resolveLocalRelocations();
137
138 // Print out sections after relocation.
139 LLVM_DEBUG({
140 for (SectionEntry &S : Sections)
141 dumpSectionMemory(S, "after relocations");
142 });
143}
144
146 // Iterate over all outstanding relocations
147 for (const auto &Rel : Relocations) {
148 // The Section here (Sections[i]) refers to the section in which the
149 // symbol for the relocation is located. The SectionID in the relocation
150 // entry provides the section to which the relocation will be applied.
151 unsigned Idx = Rel.first;
152 uint64_t Addr = getSectionLoadAddress(Idx);
153 LLVM_DEBUG(dbgs() << "Resolving relocations Section #" << Idx << "\t"
154 << format("%p", (uintptr_t)Addr) << "\n");
155 resolveRelocationList(Rel.second, Addr);
156 }
157 Relocations.clear();
158}
159
160void RuntimeDyldImpl::mapSectionAddress(const void *LocalAddress,
161 uint64_t TargetAddress) {
162 std::lock_guard<sys::Mutex> locked(lock);
163 for (unsigned i = 0, e = Sections.size(); i != e; ++i) {
164 if (Sections[i].getAddress() == LocalAddress) {
165 reassignSectionAddress(i, TargetAddress);
166 return;
167 }
168 }
169 llvm_unreachable("Attempting to remap address of unknown section!");
170}
171
173 uint64_t &Result) {
174 Expected<uint64_t> AddressOrErr = Sym.getAddress();
175 if (!AddressOrErr)
176 return AddressOrErr.takeError();
177 Result = *AddressOrErr - Sec.getAddress();
178 return Error::success();
179}
180
183 std::lock_guard<sys::Mutex> locked(lock);
184
185 // Save information about our target
186 Arch = (Triple::ArchType)Obj.getArch();
187 IsTargetLittleEndian = Obj.isLittleEndian();
188 setMipsABI(Obj);
189
190 // Compute the memory size required to load all sections to be loaded
191 // and pass this information to the memory manager
192 if (MemMgr.needsToReserveAllocationSpace()) {
193 uint64_t CodeSize = 0, RODataSize = 0, RWDataSize = 0;
194 Align CodeAlign, RODataAlign, RWDataAlign;
195 if (auto Err = computeTotalAllocSize(Obj, CodeSize, CodeAlign, RODataSize,
196 RODataAlign, RWDataSize, RWDataAlign))
197 return std::move(Err);
198 MemMgr.reserveAllocationSpace(CodeSize, CodeAlign, RODataSize, RODataAlign,
199 RWDataSize, RWDataAlign);
200 }
201
202 // Used sections from the object file
203 ObjSectionToIDMap LocalSections;
204
205 // Common symbols requiring allocation, with their sizes and alignments
206 CommonSymbolList CommonSymbolsToAllocate;
207
208 uint64_t CommonSize = 0;
209 uint32_t CommonAlign = 0;
210
211 // First, collect all weak and common symbols. We need to know if stronger
212 // definitions occur elsewhere.
213 JITSymbolResolver::LookupSet ResponsibilitySet;
214 {
216 for (auto &Sym : Obj.symbols()) {
217 Expected<uint32_t> FlagsOrErr = Sym.getFlags();
218 if (!FlagsOrErr)
219 // TODO: Test this error.
220 return FlagsOrErr.takeError();
221 if ((*FlagsOrErr & SymbolRef::SF_Common) ||
222 (*FlagsOrErr & SymbolRef::SF_Weak)) {
223 // Get symbol name.
224 if (auto NameOrErr = Sym.getName())
225 Symbols.insert(*NameOrErr);
226 else
227 return NameOrErr.takeError();
228 }
229 }
230
231 if (auto ResultOrErr = Resolver.getResponsibilitySet(Symbols))
232 ResponsibilitySet = std::move(*ResultOrErr);
233 else
234 return ResultOrErr.takeError();
235 }
236
237 // Parse symbols
238 LLVM_DEBUG(dbgs() << "Parse symbols:\n");
239 for (symbol_iterator I = Obj.symbol_begin(), E = Obj.symbol_end(); I != E;
240 ++I) {
241 Expected<uint32_t> FlagsOrErr = I->getFlags();
242 if (!FlagsOrErr)
243 // TODO: Test this error.
244 return FlagsOrErr.takeError();
245
246 // Skip undefined symbols.
247 if (*FlagsOrErr & SymbolRef::SF_Undefined)
248 continue;
249
250 // Get the symbol type.
252 if (auto SymTypeOrErr = I->getType())
253 SymType = *SymTypeOrErr;
254 else
255 return SymTypeOrErr.takeError();
256
257 // Get symbol name.
259 if (auto NameOrErr = I->getName())
260 Name = *NameOrErr;
261 else
262 return NameOrErr.takeError();
263
264 // Compute JIT symbol flags.
265 auto JITSymFlags = getJITSymbolFlags(*I);
266 if (!JITSymFlags)
267 return JITSymFlags.takeError();
268
269 // If this is a weak definition, check to see if there's a strong one.
270 // If there is, skip this symbol (we won't be providing it: the strong
271 // definition will). If there's no strong definition, make this definition
272 // strong.
273 if (JITSymFlags->isWeak() || JITSymFlags->isCommon()) {
274 // First check whether there's already a definition in this instance.
275 if (GlobalSymbolTable.count(Name))
276 continue;
277
278 // If we're not responsible for this symbol, skip it.
279 if (!ResponsibilitySet.count(Name))
280 continue;
281
282 // Otherwise update the flags on the symbol to make this definition
283 // strong.
284 if (JITSymFlags->isWeak())
285 *JITSymFlags &= ~JITSymbolFlags::Weak;
286 if (JITSymFlags->isCommon()) {
287 *JITSymFlags &= ~JITSymbolFlags::Common;
288 uint32_t Align = I->getAlignment();
289 uint64_t Size = I->getCommonSize();
290 if (!CommonAlign)
291 CommonAlign = Align;
292 CommonSize = alignTo(CommonSize, Align) + Size;
293 CommonSymbolsToAllocate.push_back(*I);
294 }
295 }
296
297 if (*FlagsOrErr & SymbolRef::SF_Absolute &&
298 SymType != object::SymbolRef::ST_File) {
299 uint64_t Addr = 0;
300 if (auto AddrOrErr = I->getAddress())
301 Addr = *AddrOrErr;
302 else
303 return AddrOrErr.takeError();
304
305 unsigned SectionID = AbsoluteSymbolSection;
306
307 LLVM_DEBUG(dbgs() << "\tType: " << SymType << " (absolute) Name: " << Name
308 << " SID: " << SectionID
309 << " Offset: " << format("%p", (uintptr_t)Addr)
310 << " flags: " << *FlagsOrErr << "\n");
311 // Skip absolute symbol relocations.
312 if (!Name.empty()) {
313 auto Result = GlobalSymbolTable.insert_or_assign(
314 Name, SymbolTableEntry(SectionID, Addr, *JITSymFlags));
315 processNewSymbol(*I, Result.first->getValue());
316 }
317 } else if (SymType == object::SymbolRef::ST_Function ||
318 SymType == object::SymbolRef::ST_Data ||
320 SymType == object::SymbolRef::ST_Other) {
321
322 section_iterator SI = Obj.section_end();
323 if (auto SIOrErr = I->getSection())
324 SI = *SIOrErr;
325 else
326 return SIOrErr.takeError();
327
328 if (SI == Obj.section_end())
329 continue;
330
331 // Get symbol offset.
332 uint64_t SectOffset;
333 if (auto Err = getOffset(*I, *SI, SectOffset))
334 return std::move(Err);
335
336 bool IsCode = SI->isText();
337 unsigned SectionID;
338 if (auto SectionIDOrErr =
339 findOrEmitSection(Obj, *SI, IsCode, LocalSections))
340 SectionID = *SectionIDOrErr;
341 else
342 return SectionIDOrErr.takeError();
343
344 LLVM_DEBUG(dbgs() << "\tType: " << SymType << " Name: " << Name
345 << " SID: " << SectionID
346 << " Offset: " << format("%p", (uintptr_t)SectOffset)
347 << " flags: " << *FlagsOrErr << "\n");
348 // Skip absolute symbol relocations.
349 if (!Name.empty()) {
350 auto Result = GlobalSymbolTable.insert_or_assign(
351 Name, SymbolTableEntry(SectionID, SectOffset, *JITSymFlags));
352 processNewSymbol(*I, Result.first->getValue());
353 }
354 }
355 }
356
357 // Allocate common symbols
358 if (auto Err = emitCommonSymbols(Obj, CommonSymbolsToAllocate, CommonSize,
359 CommonAlign))
360 return std::move(Err);
361
362 // Parse and process relocations
363 LLVM_DEBUG(dbgs() << "Parse relocations:\n");
364 for (section_iterator SI = Obj.section_begin(), SE = Obj.section_end();
365 SI != SE; ++SI) {
366 StubMap Stubs;
367
368 Expected<section_iterator> RelSecOrErr = SI->getRelocatedSection();
369 if (!RelSecOrErr)
370 return RelSecOrErr.takeError();
371
372 section_iterator RelocatedSection = *RelSecOrErr;
373 if (RelocatedSection == SE)
374 continue;
375
376 relocation_iterator I = SI->relocation_begin();
377 relocation_iterator E = SI->relocation_end();
378
379 if (I == E && !ProcessAllSections)
380 continue;
381
382 bool IsCode = RelocatedSection->isText();
383 unsigned SectionID = 0;
384 if (auto SectionIDOrErr = findOrEmitSection(Obj, *RelocatedSection, IsCode,
385 LocalSections))
386 SectionID = *SectionIDOrErr;
387 else
388 return SectionIDOrErr.takeError();
389
390 LLVM_DEBUG(dbgs() << "\tSectionID: " << SectionID << "\n");
391
392 for (; I != E;)
393 if (auto IOrErr = processRelocationRef(SectionID, I, Obj, LocalSections, Stubs))
394 I = *IOrErr;
395 else
396 return IOrErr.takeError();
397
398 // If there is a NotifyStubEmitted callback set, call it to register any
399 // stubs created for this section.
400 if (NotifyStubEmitted) {
401 StringRef FileName = Obj.getFileName();
402 StringRef SectionName = Sections[SectionID].getName();
403 for (auto &KV : Stubs) {
404
405 auto &VR = KV.first;
406 uint64_t StubAddr = KV.second;
407
408 // If this is a named stub, just call NotifyStubEmitted.
409 if (VR.SymbolName) {
410 NotifyStubEmitted(FileName, SectionName, VR.SymbolName, SectionID,
411 StubAddr);
412 continue;
413 }
414
415 // Otherwise we will have to try a reverse lookup on the globla symbol table.
416 for (auto &GSTMapEntry : GlobalSymbolTable) {
417 StringRef SymbolName = GSTMapEntry.first();
418 auto &GSTEntry = GSTMapEntry.second;
419 if (GSTEntry.getSectionID() == VR.SectionID &&
420 GSTEntry.getOffset() == VR.Offset) {
421 NotifyStubEmitted(FileName, SectionName, SymbolName, SectionID,
422 StubAddr);
423 break;
424 }
425 }
426 }
427 }
428 }
429
430 // Process remaining sections
431 if (ProcessAllSections) {
432 LLVM_DEBUG(dbgs() << "Process remaining sections:\n");
433 for (section_iterator SI = Obj.section_begin(), SE = Obj.section_end();
434 SI != SE; ++SI) {
435
436 /* Ignore already loaded sections */
437 if (LocalSections.find(*SI) != LocalSections.end())
438 continue;
439
440 bool IsCode = SI->isText();
441 if (auto SectionIDOrErr =
442 findOrEmitSection(Obj, *SI, IsCode, LocalSections))
443 LLVM_DEBUG(dbgs() << "\tSectionID: " << (*SectionIDOrErr) << "\n");
444 else
445 return SectionIDOrErr.takeError();
446 }
447 }
448
449 // Give the subclasses a chance to tie-up any loose ends.
450 if (auto Err = finalizeLoad(Obj, LocalSections))
451 return std::move(Err);
452
453// for (auto E : LocalSections)
454// llvm::dbgs() << "Added: " << E.first.getRawDataRefImpl() << " -> " << E.second << "\n";
455
456 return LocalSections;
457}
458
459// A helper method for computeTotalAllocSize.
460// Computes the memory size required to allocate sections with the given sizes,
461// assuming that all sections are allocated with the given alignment
462static uint64_t
463computeAllocationSizeForSections(std::vector<uint64_t> &SectionSizes,
464 Align Alignment) {
465 uint64_t TotalSize = 0;
466 for (uint64_t SectionSize : SectionSizes)
467 TotalSize += alignTo(SectionSize, Alignment);
468 return TotalSize;
469}
470
471static bool isRequiredForExecution(const SectionRef Section) {
472 const ObjectFile *Obj = Section.getObject();
473 if (isa<object::ELFObjectFileBase>(Obj))
474 return ELFSectionRef(Section).getFlags() & ELF::SHF_ALLOC;
475 if (auto *COFFObj = dyn_cast<object::COFFObjectFile>(Obj)) {
476 const coff_section *CoffSection = COFFObj->getCOFFSection(Section);
477 // Avoid loading zero-sized COFF sections.
478 // In PE files, VirtualSize gives the section size, and SizeOfRawData
479 // may be zero for sections with content. In Obj files, SizeOfRawData
480 // gives the section size, and VirtualSize is always zero. Hence
481 // the need to check for both cases below.
482 bool HasContent =
483 (CoffSection->VirtualSize > 0) || (CoffSection->SizeOfRawData > 0);
484 bool IsDiscardable =
485 CoffSection->Characteristics &
487 return HasContent && !IsDiscardable;
488 }
489
490 assert(isa<MachOObjectFile>(Obj));
491 return true;
492}
493
494static bool isReadOnlyData(const SectionRef Section) {
495 const ObjectFile *Obj = Section.getObject();
496 if (isa<object::ELFObjectFileBase>(Obj))
497 return !(ELFSectionRef(Section).getFlags() &
499 if (auto *COFFObj = dyn_cast<object::COFFObjectFile>(Obj))
500 return ((COFFObj->getCOFFSection(Section)->Characteristics &
504 ==
507
508 assert(isa<MachOObjectFile>(Obj));
509 return false;
510}
511
512static bool isZeroInit(const SectionRef Section) {
513 const ObjectFile *Obj = Section.getObject();
514 if (isa<object::ELFObjectFileBase>(Obj))
515 return ELFSectionRef(Section).getType() == ELF::SHT_NOBITS;
516 if (auto *COFFObj = dyn_cast<object::COFFObjectFile>(Obj))
517 return COFFObj->getCOFFSection(Section)->Characteristics &
519
520 auto *MachO = cast<MachOObjectFile>(Obj);
521 unsigned SectionType = MachO->getSectionType(Section);
522 return SectionType == MachO::S_ZEROFILL ||
523 SectionType == MachO::S_GB_ZEROFILL;
524}
525
526static bool isTLS(const SectionRef Section) {
527 const ObjectFile *Obj = Section.getObject();
528 if (isa<object::ELFObjectFileBase>(Obj))
529 return ELFSectionRef(Section).getFlags() & ELF::SHF_TLS;
530 return false;
531}
532
533// Compute an upper bound of the memory size that is required to load all
534// sections
536 const ObjectFile &Obj, uint64_t &CodeSize, Align &CodeAlign,
537 uint64_t &RODataSize, Align &RODataAlign, uint64_t &RWDataSize,
538 Align &RWDataAlign) {
539 // Compute the size of all sections required for execution
540 std::vector<uint64_t> CodeSectionSizes;
541 std::vector<uint64_t> ROSectionSizes;
542 std::vector<uint64_t> RWSectionSizes;
543
544 // Collect sizes of all sections to be loaded;
545 // also determine the max alignment of all sections
546 for (section_iterator SI = Obj.section_begin(), SE = Obj.section_end();
547 SI != SE; ++SI) {
548 const SectionRef &Section = *SI;
549
550 bool IsRequired = isRequiredForExecution(Section) || ProcessAllSections;
551
552 // Consider only the sections that are required to be loaded for execution
553 if (IsRequired) {
554 uint64_t DataSize = Section.getSize();
555 Align Alignment = Section.getAlignment();
556 bool IsCode = Section.isText();
557 bool IsReadOnly = isReadOnlyData(Section);
558 bool IsTLS = isTLS(Section);
559
560 Expected<StringRef> NameOrErr = Section.getName();
561 if (!NameOrErr)
562 return NameOrErr.takeError();
563 StringRef Name = *NameOrErr;
564
565 uint64_t StubBufSize = computeSectionStubBufSize(Obj, Section);
566
567 uint64_t PaddingSize = 0;
568 if (Name == ".eh_frame")
569 PaddingSize += 4;
570 if (StubBufSize != 0)
571 PaddingSize += getStubAlignment().value() - 1;
572
573 uint64_t SectionSize = DataSize + PaddingSize + StubBufSize;
574
575 // The .eh_frame section (at least on Linux) needs an extra four bytes
576 // padded
577 // with zeroes added at the end. For MachO objects, this section has a
578 // slightly different name, so this won't have any effect for MachO
579 // objects.
580 if (Name == ".eh_frame")
581 SectionSize += 4;
582
583 if (!SectionSize)
584 SectionSize = 1;
585
586 if (IsCode) {
587 CodeAlign = std::max(CodeAlign, Alignment);
588 CodeSectionSizes.push_back(SectionSize);
589 } else if (IsReadOnly) {
590 RODataAlign = std::max(RODataAlign, Alignment);
591 ROSectionSizes.push_back(SectionSize);
592 } else if (!IsTLS) {
593 RWDataAlign = std::max(RWDataAlign, Alignment);
594 RWSectionSizes.push_back(SectionSize);
595 }
596 }
597 }
598
599 // Compute Global Offset Table size. If it is not zero we
600 // also update alignment, which is equal to a size of a
601 // single GOT entry.
602 if (unsigned GotSize = computeGOTSize(Obj)) {
603 RWSectionSizes.push_back(GotSize);
604 RWDataAlign = std::max(RWDataAlign, Align(getGOTEntrySize()));
605 }
606
607 // Compute the size of all common symbols
608 uint64_t CommonSize = 0;
609 Align CommonAlign;
610 for (symbol_iterator I = Obj.symbol_begin(), E = Obj.symbol_end(); I != E;
611 ++I) {
612 Expected<uint32_t> FlagsOrErr = I->getFlags();
613 if (!FlagsOrErr)
614 // TODO: Test this error.
615 return FlagsOrErr.takeError();
616 if (*FlagsOrErr & SymbolRef::SF_Common) {
617 // Add the common symbols to a list. We'll allocate them all below.
618 uint64_t Size = I->getCommonSize();
619 Align Alignment = Align(I->getAlignment());
620 // If this is the first common symbol, use its alignment as the alignment
621 // for the common symbols section.
622 if (CommonSize == 0)
623 CommonAlign = Alignment;
624 CommonSize = alignTo(CommonSize, Alignment) + Size;
625 }
626 }
627 if (CommonSize != 0) {
628 RWSectionSizes.push_back(CommonSize);
629 RWDataAlign = std::max(RWDataAlign, CommonAlign);
630 }
631
632 if (!CodeSectionSizes.empty()) {
633 // Add 64 bytes for a potential IFunc resolver stub
634 CodeSectionSizes.push_back(64);
635 }
636
637 // Compute the required allocation space for each different type of sections
638 // (code, read-only data, read-write data) assuming that all sections are
639 // allocated with the max alignment. Note that we cannot compute with the
640 // individual alignments of the sections, because then the required size
641 // depends on the order, in which the sections are allocated.
642 CodeSize = computeAllocationSizeForSections(CodeSectionSizes, CodeAlign);
643 RODataSize = computeAllocationSizeForSections(ROSectionSizes, RODataAlign);
644 RWDataSize = computeAllocationSizeForSections(RWSectionSizes, RWDataAlign);
645
646 return Error::success();
647}
648
649// compute GOT size
651 size_t GotEntrySize = getGOTEntrySize();
652 if (!GotEntrySize)
653 return 0;
654
655 size_t GotSize = 0;
656 for (section_iterator SI = Obj.section_begin(), SE = Obj.section_end();
657 SI != SE; ++SI) {
658
659 for (const RelocationRef &Reloc : SI->relocations())
660 if (relocationNeedsGot(Reloc))
661 GotSize += GotEntrySize;
662 }
663
664 return GotSize;
665}
666
667// compute stub buffer size for the given section
669 const SectionRef &Section) {
670 if (!MemMgr.allowStubAllocation()) {
671 return 0;
672 }
673
674 unsigned StubSize = getMaxStubSize();
675 if (StubSize == 0) {
676 return 0;
677 }
678 // FIXME: this is an inefficient way to handle this. We should computed the
679 // necessary section allocation size in loadObject by walking all the sections
680 // once.
681 unsigned StubBufSize = 0;
682 for (section_iterator SI = Obj.section_begin(), SE = Obj.section_end();
683 SI != SE; ++SI) {
684
685 Expected<section_iterator> RelSecOrErr = SI->getRelocatedSection();
686 if (!RelSecOrErr)
688
689 section_iterator RelSecI = *RelSecOrErr;
690 if (!(RelSecI == Section))
691 continue;
692
693 for (const RelocationRef &Reloc : SI->relocations())
694 if (relocationNeedsStub(Reloc))
695 StubBufSize += StubSize;
696 }
697
698 // Get section data size and alignment
699 uint64_t DataSize = Section.getSize();
700 Align Alignment = Section.getAlignment();
701
702 // Add stubbuf size alignment
703 Align StubAlignment = getStubAlignment();
704 Align EndAlignment = commonAlignment(Alignment, DataSize);
705 if (StubAlignment > EndAlignment)
706 StubBufSize += StubAlignment.value() - EndAlignment.value();
707 return StubBufSize;
708}
709
711 unsigned Size) const {
712 uint64_t Result = 0;
713 if (IsTargetLittleEndian) {
714 Src += Size - 1;
715 while (Size--)
716 Result = (Result << 8) | *Src--;
717 } else
718 while (Size--)
719 Result = (Result << 8) | *Src++;
720
721 return Result;
722}
723
725 unsigned Size) const {
726 if (IsTargetLittleEndian) {
727 while (Size--) {
728 *Dst++ = Value & 0xFF;
729 Value >>= 8;
730 }
731 } else {
732 Dst += Size - 1;
733 while (Size--) {
734 *Dst-- = Value & 0xFF;
735 Value >>= 8;
736 }
737 }
738}
739
743}
744
746 CommonSymbolList &SymbolsToAllocate,
747 uint64_t CommonSize,
748 uint32_t CommonAlign) {
749 if (SymbolsToAllocate.empty())
750 return Error::success();
751
752 // Allocate memory for the section
753 unsigned SectionID = Sections.size();
754 uint8_t *Addr = MemMgr.allocateDataSection(CommonSize, CommonAlign, SectionID,
755 "<common symbols>", false);
756 if (!Addr)
757 report_fatal_error("Unable to allocate memory for common symbols!");
758 uint64_t Offset = 0;
759 Sections.push_back(
760 SectionEntry("<common symbols>", Addr, CommonSize, CommonSize, 0));
761 memset(Addr, 0, CommonSize);
762
763 LLVM_DEBUG(dbgs() << "emitCommonSection SectionID: " << SectionID
764 << " new addr: " << format("%p", Addr)
765 << " DataSize: " << CommonSize << "\n");
766
767 // Assign the address of each symbol
768 for (auto &Sym : SymbolsToAllocate) {
769 uint32_t Alignment = Sym.getAlignment();
770 uint64_t Size = Sym.getCommonSize();
772 if (auto NameOrErr = Sym.getName())
773 Name = *NameOrErr;
774 else
775 return NameOrErr.takeError();
776 if (Alignment) {
777 // This symbol has an alignment requirement.
778 uint64_t AlignOffset =
779 offsetToAlignment((uint64_t)Addr, Align(Alignment));
780 Addr += AlignOffset;
781 Offset += AlignOffset;
782 }
783 auto JITSymFlags = getJITSymbolFlags(Sym);
784
785 if (!JITSymFlags)
786 return JITSymFlags.takeError();
787
788 LLVM_DEBUG(dbgs() << "Allocating common symbol " << Name << " address "
789 << format("%p", Addr) << "\n");
790 if (!Name.empty()) // Skip absolute symbol relocations.
791 GlobalSymbolTable[Name] =
792 SymbolTableEntry(SectionID, Offset, std::move(*JITSymFlags));
793 Offset += Size;
794 Addr += Size;
795 }
796
797 return Error::success();
798}
799
802 const SectionRef &Section,
803 bool IsCode) {
804 StringRef data;
805 Align Alignment = Section.getAlignment();
806
807 unsigned PaddingSize = 0;
808 unsigned StubBufSize = 0;
809 bool IsRequired = isRequiredForExecution(Section);
810 bool IsVirtual = Section.isVirtual();
811 bool IsZeroInit = isZeroInit(Section);
812 bool IsReadOnly = isReadOnlyData(Section);
813 bool IsTLS = isTLS(Section);
814 uint64_t DataSize = Section.getSize();
815
816 Expected<StringRef> NameOrErr = Section.getName();
817 if (!NameOrErr)
818 return NameOrErr.takeError();
819 StringRef Name = *NameOrErr;
820
821 StubBufSize = computeSectionStubBufSize(Obj, Section);
822
823 // The .eh_frame section (at least on Linux) needs an extra four bytes padded
824 // with zeroes added at the end. For MachO objects, this section has a
825 // slightly different name, so this won't have any effect for MachO objects.
826 if (Name == ".eh_frame")
827 PaddingSize = 4;
828
829 uintptr_t Allocate;
830 unsigned SectionID = Sections.size();
831 uint8_t *Addr;
832 uint64_t LoadAddress = 0;
833 const char *pData = nullptr;
834
835 // If this section contains any bits (i.e. isn't a virtual or bss section),
836 // grab a reference to them.
837 if (!IsVirtual && !IsZeroInit) {
838 // In either case, set the location of the unrelocated section in memory,
839 // since we still process relocations for it even if we're not applying them.
840 if (Expected<StringRef> E = Section.getContents())
841 data = *E;
842 else
843 return E.takeError();
844 pData = data.data();
845 }
846
847 // If there are any stubs then the section alignment needs to be at least as
848 // high as stub alignment or padding calculations may by incorrect when the
849 // section is remapped.
850 if (StubBufSize != 0) {
851 Alignment = std::max(Alignment, getStubAlignment());
852 PaddingSize += getStubAlignment().value() - 1;
853 }
854
855 // Some sections, such as debug info, don't need to be loaded for execution.
856 // Process those only if explicitly requested.
857 if (IsRequired || ProcessAllSections) {
858 Allocate = DataSize + PaddingSize + StubBufSize;
859 if (!Allocate)
860 Allocate = 1;
861 if (IsTLS) {
862 auto TLSSection = MemMgr.allocateTLSSection(Allocate, Alignment.value(),
863 SectionID, Name);
864 Addr = TLSSection.InitializationImage;
865 LoadAddress = TLSSection.Offset;
866 } else if (IsCode) {
867 Addr = MemMgr.allocateCodeSection(Allocate, Alignment.value(), SectionID,
868 Name);
869 } else {
870 Addr = MemMgr.allocateDataSection(Allocate, Alignment.value(), SectionID,
871 Name, IsReadOnly);
872 }
873 if (!Addr)
874 report_fatal_error("Unable to allocate section memory!");
875
876 // Zero-initialize or copy the data from the image
877 if (IsZeroInit || IsVirtual)
878 memset(Addr, 0, DataSize);
879 else
880 memcpy(Addr, pData, DataSize);
881
882 // Fill in any extra bytes we allocated for padding
883 if (PaddingSize != 0) {
884 memset(Addr + DataSize, 0, PaddingSize);
885 // Update the DataSize variable to include padding.
886 DataSize += PaddingSize;
887
888 // Align DataSize to stub alignment if we have any stubs (PaddingSize will
889 // have been increased above to account for this).
890 if (StubBufSize > 0)
891 DataSize &= -(uint64_t)getStubAlignment().value();
892 }
893
894 LLVM_DEBUG(dbgs() << "emitSection SectionID: " << SectionID << " Name: "
895 << Name << " obj addr: " << format("%p", pData)
896 << " new addr: " << format("%p", Addr) << " DataSize: "
897 << DataSize << " StubBufSize: " << StubBufSize
898 << " Allocate: " << Allocate << "\n");
899 } else {
900 // Even if we didn't load the section, we need to record an entry for it
901 // to handle later processing (and by 'handle' I mean don't do anything
902 // with these sections).
903 Allocate = 0;
904 Addr = nullptr;
906 dbgs() << "emitSection SectionID: " << SectionID << " Name: " << Name
907 << " obj addr: " << format("%p", data.data()) << " new addr: 0"
908 << " DataSize: " << DataSize << " StubBufSize: " << StubBufSize
909 << " Allocate: " << Allocate << "\n");
910 }
911
912 Sections.push_back(
913 SectionEntry(Name, Addr, DataSize, Allocate, (uintptr_t)pData));
914
915 // The load address of a TLS section is not equal to the address of its
916 // initialization image
917 if (IsTLS)
918 Sections.back().setLoadAddress(LoadAddress);
919 // Debug info sections are linked as if their load address was zero
920 if (!IsRequired)
921 Sections.back().setLoadAddress(0);
922
923 return SectionID;
924}
925
928 const SectionRef &Section,
929 bool IsCode,
930 ObjSectionToIDMap &LocalSections) {
931
932 unsigned SectionID = 0;
933 ObjSectionToIDMap::iterator i = LocalSections.find(Section);
934 if (i != LocalSections.end())
935 SectionID = i->second;
936 else {
937 if (auto SectionIDOrErr = emitSection(Obj, Section, IsCode))
938 SectionID = *SectionIDOrErr;
939 else
940 return SectionIDOrErr.takeError();
941 LocalSections[Section] = SectionID;
942 }
943 return SectionID;
944}
945
947 unsigned SectionID) {
948 Relocations[SectionID].push_back(RE);
949}
950
952 StringRef SymbolName) {
953 // Relocation by symbol. If the symbol is found in the global symbol table,
954 // create an appropriate section relocation. Otherwise, add it to
955 // ExternalSymbolRelocations.
956 RTDyldSymbolTable::const_iterator Loc = GlobalSymbolTable.find(SymbolName);
957 if (Loc == GlobalSymbolTable.end()) {
958 ExternalSymbolRelocations[SymbolName].push_back(RE);
959 } else {
960 assert(!SymbolName.empty() &&
961 "Empty symbol should not be in GlobalSymbolTable");
962 // Copy the RE since we want to modify its addend.
963 RelocationEntry RECopy = RE;
964 const auto &SymInfo = Loc->second;
965 RECopy.Addend += SymInfo.getOffset();
966 Relocations[SymInfo.getSectionID()].push_back(RECopy);
967 }
968}
969
971 unsigned AbiVariant) {
972 if (Arch == Triple::aarch64 || Arch == Triple::aarch64_be ||
973 Arch == Triple::aarch64_32) {
974 // This stub has to be able to access the full address space,
975 // since symbol lookup won't necessarily find a handy, in-range,
976 // PLT stub for functions which could be anywhere.
977 // Stub can use ip0 (== x16) to calculate address
978 writeBytesUnaligned(0xd2e00010, Addr, 4); // movz ip0, #:abs_g3:<addr>
979 writeBytesUnaligned(0xf2c00010, Addr+4, 4); // movk ip0, #:abs_g2_nc:<addr>
980 writeBytesUnaligned(0xf2a00010, Addr+8, 4); // movk ip0, #:abs_g1_nc:<addr>
981 writeBytesUnaligned(0xf2800010, Addr+12, 4); // movk ip0, #:abs_g0_nc:<addr>
982 writeBytesUnaligned(0xd61f0200, Addr+16, 4); // br ip0
983
984 return Addr;
985 } else if (Arch == Triple::arm || Arch == Triple::armeb) {
986 // TODO: There is only ARM far stub now. We should add the Thumb stub,
987 // and stubs for branches Thumb - ARM and ARM - Thumb.
988 writeBytesUnaligned(0xe51ff004, Addr, 4); // ldr pc, [pc, #-4]
989 return Addr + 4;
990 } else if (IsMipsO32ABI || IsMipsN32ABI) {
991 // 0: 3c190000 lui t9,%hi(addr).
992 // 4: 27390000 addiu t9,t9,%lo(addr).
993 // 8: 03200008 jr t9.
994 // c: 00000000 nop.
995 const unsigned LuiT9Instr = 0x3c190000, AdduiT9Instr = 0x27390000;
996 const unsigned NopInstr = 0x0;
997 unsigned JrT9Instr = 0x03200008;
998 if ((AbiVariant & ELF::EF_MIPS_ARCH) == ELF::EF_MIPS_ARCH_32R6 ||
1000 JrT9Instr = 0x03200009;
1001
1002 writeBytesUnaligned(LuiT9Instr, Addr, 4);
1003 writeBytesUnaligned(AdduiT9Instr, Addr + 4, 4);
1004 writeBytesUnaligned(JrT9Instr, Addr + 8, 4);
1005 writeBytesUnaligned(NopInstr, Addr + 12, 4);
1006 return Addr;
1007 } else if (IsMipsN64ABI) {
1008 // 0: 3c190000 lui t9,%highest(addr).
1009 // 4: 67390000 daddiu t9,t9,%higher(addr).
1010 // 8: 0019CC38 dsll t9,t9,16.
1011 // c: 67390000 daddiu t9,t9,%hi(addr).
1012 // 10: 0019CC38 dsll t9,t9,16.
1013 // 14: 67390000 daddiu t9,t9,%lo(addr).
1014 // 18: 03200008 jr t9.
1015 // 1c: 00000000 nop.
1016 const unsigned LuiT9Instr = 0x3c190000, DaddiuT9Instr = 0x67390000,
1017 DsllT9Instr = 0x19CC38;
1018 const unsigned NopInstr = 0x0;
1019 unsigned JrT9Instr = 0x03200008;
1020 if ((AbiVariant & ELF::EF_MIPS_ARCH) == ELF::EF_MIPS_ARCH_64R6)
1021 JrT9Instr = 0x03200009;
1022
1023 writeBytesUnaligned(LuiT9Instr, Addr, 4);
1024 writeBytesUnaligned(DaddiuT9Instr, Addr + 4, 4);
1025 writeBytesUnaligned(DsllT9Instr, Addr + 8, 4);
1026 writeBytesUnaligned(DaddiuT9Instr, Addr + 12, 4);
1027 writeBytesUnaligned(DsllT9Instr, Addr + 16, 4);
1028 writeBytesUnaligned(DaddiuT9Instr, Addr + 20, 4);
1029 writeBytesUnaligned(JrT9Instr, Addr + 24, 4);
1030 writeBytesUnaligned(NopInstr, Addr + 28, 4);
1031 return Addr;
1032 } else if (Arch == Triple::ppc64 || Arch == Triple::ppc64le) {
1033 // Depending on which version of the ELF ABI is in use, we need to
1034 // generate one of two variants of the stub. They both start with
1035 // the same sequence to load the target address into r12.
1036 writeInt32BE(Addr, 0x3D800000); // lis r12, highest(addr)
1037 writeInt32BE(Addr+4, 0x618C0000); // ori r12, higher(addr)
1038 writeInt32BE(Addr+8, 0x798C07C6); // sldi r12, r12, 32
1039 writeInt32BE(Addr+12, 0x658C0000); // oris r12, r12, h(addr)
1040 writeInt32BE(Addr+16, 0x618C0000); // ori r12, r12, l(addr)
1041 if (AbiVariant == 2) {
1042 // PowerPC64 stub ELFv2 ABI: The address points to the function itself.
1043 // The address is already in r12 as required by the ABI. Branch to it.
1044 writeInt32BE(Addr+20, 0xF8410018); // std r2, 24(r1)
1045 writeInt32BE(Addr+24, 0x7D8903A6); // mtctr r12
1046 writeInt32BE(Addr+28, 0x4E800420); // bctr
1047 } else {
1048 // PowerPC64 stub ELFv1 ABI: The address points to a function descriptor.
1049 // Load the function address on r11 and sets it to control register. Also
1050 // loads the function TOC in r2 and environment pointer to r11.
1051 writeInt32BE(Addr+20, 0xF8410028); // std r2, 40(r1)
1052 writeInt32BE(Addr+24, 0xE96C0000); // ld r11, 0(r12)
1053 writeInt32BE(Addr+28, 0xE84C0008); // ld r2, 0(r12)
1054 writeInt32BE(Addr+32, 0x7D6903A6); // mtctr r11
1055 writeInt32BE(Addr+36, 0xE96C0010); // ld r11, 16(r2)
1056 writeInt32BE(Addr+40, 0x4E800420); // bctr
1057 }
1058 return Addr;
1059 } else if (Arch == Triple::systemz) {
1060 writeInt16BE(Addr, 0xC418); // lgrl %r1,.+8
1061 writeInt16BE(Addr+2, 0x0000);
1062 writeInt16BE(Addr+4, 0x0004);
1063 writeInt16BE(Addr+6, 0x07F1); // brc 15,%r1
1064 // 8-byte address stored at Addr + 8
1065 return Addr;
1066 } else if (Arch == Triple::x86_64) {
1067 *Addr = 0xFF; // jmp
1068 *(Addr+1) = 0x25; // rip
1069 // 32-bit PC-relative address of the GOT entry will be stored at Addr+2
1070 } else if (Arch == Triple::x86) {
1071 *Addr = 0xE9; // 32-bit pc-relative jump.
1072 }
1073 return Addr;
1074}
1075
1076// Assign an address to a symbol name and resolve all the relocations
1077// associated with it.
1079 uint64_t Addr) {
1080 // The address to use for relocation resolution is not
1081 // the address of the local section buffer. We must be doing
1082 // a remote execution environment of some sort. Relocations can't
1083 // be applied until all the sections have been moved. The client must
1084 // trigger this with a call to MCJIT::finalize() or
1085 // RuntimeDyld::resolveRelocations().
1086 //
1087 // Addr is a uint64_t because we can't assume the pointer width
1088 // of the target is the same as that of the host. Just use a generic
1089 // "big enough" type.
1090 LLVM_DEBUG(
1091 dbgs() << "Reassigning address for section " << SectionID << " ("
1092 << Sections[SectionID].getName() << "): "
1093 << format("0x%016" PRIx64, Sections[SectionID].getLoadAddress())
1094 << " -> " << format("0x%016" PRIx64, Addr) << "\n");
1095 Sections[SectionID].setLoadAddress(Addr);
1096}
1097
1099 uint64_t Value) {
1100 for (unsigned i = 0, e = Relocs.size(); i != e; ++i) {
1101 const RelocationEntry &RE = Relocs[i];
1102 // Ignore relocations for sections that were not loaded
1103 if (RE.SectionID != AbsoluteSymbolSection &&
1104 Sections[RE.SectionID].getAddress() == nullptr)
1105 continue;
1107 }
1108}
1109
1111 const StringMap<JITEvaluatedSymbol> ExternalSymbolMap) {
1112 for (auto &RelocKV : ExternalSymbolRelocations) {
1113 StringRef Name = RelocKV.first();
1114 RelocationList &Relocs = RelocKV.second;
1115 if (Name.size() == 0) {
1116 // This is an absolute symbol, use an address of zero.
1117 LLVM_DEBUG(dbgs() << "Resolving absolute relocations."
1118 << "\n");
1119 resolveRelocationList(Relocs, 0);
1120 } else {
1121 uint64_t Addr = 0;
1122 JITSymbolFlags Flags;
1123 RTDyldSymbolTable::const_iterator Loc = GlobalSymbolTable.find(Name);
1124 if (Loc == GlobalSymbolTable.end()) {
1125 auto RRI = ExternalSymbolMap.find(Name);
1126 assert(RRI != ExternalSymbolMap.end() && "No result for symbol");
1127 Addr = RRI->second.getAddress();
1128 Flags = RRI->second.getFlags();
1129 } else {
1130 // We found the symbol in our global table. It was probably in a
1131 // Module that we loaded previously.
1132 const auto &SymInfo = Loc->second;
1133 Addr = getSectionLoadAddress(SymInfo.getSectionID()) +
1134 SymInfo.getOffset();
1135 Flags = SymInfo.getFlags();
1136 }
1137
1138 // FIXME: Implement error handling that doesn't kill the host program!
1139 if (!Addr && !Resolver.allowsZeroSymbols())
1140 report_fatal_error(Twine("Program used external function '") + Name +
1141 "' which could not be resolved!");
1142
1143 // If Resolver returned UINT64_MAX, the client wants to handle this symbol
1144 // manually and we shouldn't resolve its relocations.
1145 if (Addr != UINT64_MAX) {
1146
1147 // Tweak the address based on the symbol flags if necessary.
1148 // For example, this is used by RuntimeDyldMachOARM to toggle the low bit
1149 // if the target symbol is Thumb.
1150 Addr = modifyAddressBasedOnFlags(Addr, Flags);
1151
1152 LLVM_DEBUG(dbgs() << "Resolving relocations Name: " << Name << "\t"
1153 << format("0x%lx", Addr) << "\n");
1154 resolveRelocationList(Relocs, Addr);
1155 }
1156 }
1157 }
1158 ExternalSymbolRelocations.clear();
1159}
1160
1162 StringMap<JITEvaluatedSymbol> ExternalSymbolMap;
1163
1164 // Resolution can trigger emission of more symbols, so iterate until
1165 // we've resolved *everything*.
1166 {
1167 JITSymbolResolver::LookupSet ResolvedSymbols;
1168
1169 while (true) {
1171
1172 for (auto &RelocKV : ExternalSymbolRelocations) {
1173 StringRef Name = RelocKV.first();
1174 if (!Name.empty() && !GlobalSymbolTable.count(Name) &&
1175 !ResolvedSymbols.count(Name))
1176 NewSymbols.insert(Name);
1177 }
1178
1179 if (NewSymbols.empty())
1180 break;
1181
1182#ifdef _MSC_VER
1183 using ExpectedLookupResult =
1185#else
1186 using ExpectedLookupResult = Expected<JITSymbolResolver::LookupResult>;
1187#endif
1188
1189 auto NewSymbolsP = std::make_shared<std::promise<ExpectedLookupResult>>();
1190 auto NewSymbolsF = NewSymbolsP->get_future();
1191 Resolver.lookup(NewSymbols,
1193 NewSymbolsP->set_value(std::move(Result));
1194 });
1195
1196 auto NewResolverResults = NewSymbolsF.get();
1197
1198 if (!NewResolverResults)
1199 return NewResolverResults.takeError();
1200
1201 assert(NewResolverResults->size() == NewSymbols.size() &&
1202 "Should have errored on unresolved symbols");
1203
1204 for (auto &RRKV : *NewResolverResults) {
1205 assert(!ResolvedSymbols.count(RRKV.first) && "Redundant resolution?");
1206 ExternalSymbolMap.insert(RRKV);
1207 ResolvedSymbols.insert(RRKV.first);
1208 }
1209 }
1210 }
1211
1212 applyExternalSymbolRelocations(ExternalSymbolMap);
1213
1214 return Error::success();
1215}
1216
1218 std::unique_ptr<RuntimeDyldImpl> This,
1220 std::unique_ptr<RuntimeDyld::LoadedObjectInfo>, Error)>
1221 OnEmitted,
1223 std::unique_ptr<RuntimeDyld::LoadedObjectInfo> Info) {
1224
1225 auto SharedThis = std::shared_ptr<RuntimeDyldImpl>(std::move(This));
1226 auto PostResolveContinuation =
1227 [SharedThis, OnEmitted = std::move(OnEmitted), O = std::move(O),
1228 Info = std::move(Info)](
1230 if (!Result) {
1231 OnEmitted(std::move(O), std::move(Info), Result.takeError());
1232 return;
1233 }
1234
1235 /// Copy the result into a StringMap, where the keys are held by value.
1237 for (auto &KV : *Result)
1238 Resolved[KV.first] = KV.second;
1239
1240 SharedThis->applyExternalSymbolRelocations(Resolved);
1241 SharedThis->resolveLocalRelocations();
1242 SharedThis->registerEHFrames();
1243 std::string ErrMsg;
1244 if (SharedThis->MemMgr.finalizeMemory(&ErrMsg))
1245 OnEmitted(std::move(O), std::move(Info),
1246 make_error<StringError>(std::move(ErrMsg),
1248 else
1249 OnEmitted(std::move(O), std::move(Info), Error::success());
1250 };
1251
1253
1254 for (auto &RelocKV : SharedThis->ExternalSymbolRelocations) {
1255 StringRef Name = RelocKV.first();
1256 if (Name.empty()) // Skip absolute symbol relocations.
1257 continue;
1258 assert(!SharedThis->GlobalSymbolTable.count(Name) &&
1259 "Name already processed. RuntimeDyld instances can not be re-used "
1260 "when finalizing with finalizeAsync.");
1261 Symbols.insert(Name);
1262 }
1263
1264 if (!Symbols.empty()) {
1265 SharedThis->Resolver.lookup(Symbols, std::move(PostResolveContinuation));
1266 } else
1267 PostResolveContinuation(std::map<StringRef, JITEvaluatedSymbol>());
1268}
1269
1270//===----------------------------------------------------------------------===//
1271// RuntimeDyld class implementation
1272
1274 const object::SectionRef &Sec) const {
1275
1276 auto I = ObjSecToIDMap.find(Sec);
1277 if (I != ObjSecToIDMap.end())
1278 return RTDyld.Sections[I->second].getLoadAddress();
1279
1280 return 0;
1281}
1282
1285 unsigned Alignment,
1286 unsigned SectionID,
1288 report_fatal_error("allocation of TLS not implemented");
1289}
1290
1291void RuntimeDyld::MemoryManager::anchor() {}
1292void JITSymbolResolver::anchor() {}
1293void LegacyJITSymbolResolver::anchor() {}
1294
1297 : MemMgr(MemMgr), Resolver(Resolver) {
1298 // FIXME: There's a potential issue lurking here if a single instance of
1299 // RuntimeDyld is used to load multiple objects. The current implementation
1300 // associates a single memory manager with a RuntimeDyld instance. Even
1301 // though the public class spawns a new 'impl' instance for each load,
1302 // they share a single memory manager. This can become a problem when page
1303 // permissions are applied.
1304 Dyld = nullptr;
1305 ProcessAllSections = false;
1306}
1307
1308RuntimeDyld::~RuntimeDyld() = default;
1309
1310static std::unique_ptr<RuntimeDyldCOFF>
1313 JITSymbolResolver &Resolver, bool ProcessAllSections,
1314 RuntimeDyld::NotifyStubEmittedFunction NotifyStubEmitted) {
1315 std::unique_ptr<RuntimeDyldCOFF> Dyld =
1317 Dyld->setProcessAllSections(ProcessAllSections);
1318 Dyld->setNotifyStubEmitted(std::move(NotifyStubEmitted));
1319 return Dyld;
1320}
1321
1322static std::unique_ptr<RuntimeDyldELF>
1324 JITSymbolResolver &Resolver, bool ProcessAllSections,
1325 RuntimeDyld::NotifyStubEmittedFunction NotifyStubEmitted) {
1326 std::unique_ptr<RuntimeDyldELF> Dyld =
1328 Dyld->setProcessAllSections(ProcessAllSections);
1329 Dyld->setNotifyStubEmitted(std::move(NotifyStubEmitted));
1330 return Dyld;
1331}
1332
1333static std::unique_ptr<RuntimeDyldMachO>
1337 bool ProcessAllSections,
1338 RuntimeDyld::NotifyStubEmittedFunction NotifyStubEmitted) {
1339 std::unique_ptr<RuntimeDyldMachO> Dyld =
1341 Dyld->setProcessAllSections(ProcessAllSections);
1342 Dyld->setNotifyStubEmitted(std::move(NotifyStubEmitted));
1343 return Dyld;
1344}
1345
1346std::unique_ptr<RuntimeDyld::LoadedObjectInfo>
1348 if (!Dyld) {
1349 if (Obj.isELF())
1350 Dyld =
1351 createRuntimeDyldELF(static_cast<Triple::ArchType>(Obj.getArch()),
1352 MemMgr, Resolver, ProcessAllSections,
1353 std::move(NotifyStubEmitted));
1354 else if (Obj.isMachO())
1356 static_cast<Triple::ArchType>(Obj.getArch()), MemMgr, Resolver,
1357 ProcessAllSections, std::move(NotifyStubEmitted));
1358 else if (Obj.isCOFF())
1359 Dyld = createRuntimeDyldCOFF(
1360 static_cast<Triple::ArchType>(Obj.getArch()), MemMgr, Resolver,
1361 ProcessAllSections, std::move(NotifyStubEmitted));
1362 else
1363 report_fatal_error("Incompatible object format!");
1364 }
1365
1366 if (!Dyld->isCompatibleFile(Obj))
1367 report_fatal_error("Incompatible object format!");
1368
1369 auto LoadedObjInfo = Dyld->loadObject(Obj);
1370 MemMgr.notifyObjectLoaded(*this, Obj);
1371 return LoadedObjInfo;
1372}
1373
1375 if (!Dyld)
1376 return nullptr;
1377 return Dyld->getSymbolLocalAddress(Name);
1378}
1379
1381 assert(Dyld && "No RuntimeDyld instance attached");
1382 return Dyld->getSymbolSectionID(Name);
1383}
1384
1386 if (!Dyld)
1387 return nullptr;
1388 return Dyld->getSymbol(Name);
1389}
1390
1391std::map<StringRef, JITEvaluatedSymbol> RuntimeDyld::getSymbolTable() const {
1392 if (!Dyld)
1393 return std::map<StringRef, JITEvaluatedSymbol>();
1394 return Dyld->getSymbolTable();
1395}
1396
1397void RuntimeDyld::resolveRelocations() { Dyld->resolveRelocations(); }
1398
1400 Dyld->reassignSectionAddress(SectionID, Addr);
1401}
1402
1403void RuntimeDyld::mapSectionAddress(const void *LocalAddress,
1404 uint64_t TargetAddress) {
1405 Dyld->mapSectionAddress(LocalAddress, TargetAddress);
1406}
1407
1408bool RuntimeDyld::hasError() { return Dyld->hasError(); }
1409
1410StringRef RuntimeDyld::getErrorString() { return Dyld->getErrorString(); }
1411
1413 bool MemoryFinalizationLocked = MemMgr.FinalizationLocked;
1414 MemMgr.FinalizationLocked = true;
1417 if (!MemoryFinalizationLocked) {
1418 MemMgr.finalizeMemory();
1419 MemMgr.FinalizationLocked = false;
1420 }
1421}
1422
1424 assert(Dyld && "No Dyld instance attached");
1425 return Dyld->getSectionContent(SectionID);
1426}
1427
1429 assert(Dyld && "No Dyld instance attached");
1430 return Dyld->getSectionLoadAddress(SectionID);
1431}
1432
1434 if (Dyld)
1435 Dyld->registerEHFrames();
1436}
1437
1439 if (Dyld)
1440 Dyld->deregisterEHFrames();
1441}
1442// FIXME: Kill this with fire once we have a new JIT linker: this is only here
1443// so that we can re-use RuntimeDyld's implementation without twisting the
1444// interface any further for ORC's purposes.
1448 bool ProcessAllSections,
1451 std::map<StringRef, JITEvaluatedSymbol>)>
1452 OnLoaded,
1454 std::unique_ptr<RuntimeDyld::LoadedObjectInfo>, Error)>
1455 OnEmitted) {
1456
1457 RuntimeDyld RTDyld(MemMgr, Resolver);
1458 RTDyld.setProcessAllSections(ProcessAllSections);
1459
1460 auto Info = RTDyld.loadObject(*O.getBinary());
1461
1462 if (RTDyld.hasError()) {
1463 OnEmitted(std::move(O), std::move(Info),
1464 make_error<StringError>(RTDyld.getErrorString(),
1466 return;
1467 }
1468
1469 if (auto Err = OnLoaded(*O.getBinary(), *Info, RTDyld.getSymbolTable()))
1470 OnEmitted(std::move(O), std::move(Info), std::move(Err));
1471
1472 RuntimeDyldImpl::finalizeAsync(std::move(RTDyld.Dyld), std::move(OnEmitted),
1473 std::move(O), std::move(Info));
1474}
1475
1476} // end namespace llvm
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
Analysis containing CSE Info
Definition: CSEInfo.cpp:27
Returns the sub type a function will return at a given Idx Should correspond to the result type of an ExtractValue instruction executed with just that one unsigned Idx
#define LLVM_DEBUG(X)
Definition: Debug.h:101
uint64_t Addr
std::string Name
uint64_t Size
Symbol * Sym
Definition: ELF_riscv.cpp:479
#define I(x, y, z)
Definition: MD5.cpp:58
static StringRef getName(Value *V)
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
static const char * name
Definition: SMEABIPass.cpp:49
raw_pwrite_stream & OS
Lightweight error class with error context and mandatory checking.
Definition: Error.h:160
static ErrorSuccess success()
Create a success value.
Definition: Error.h:337
Tagged union holding either a T or a Error.
Definition: Error.h:481
Error takeError()
Take ownership of the stored error.
Definition: Error.h:608
Represents a symbol that has been evaluated to an address already.
Definition: JITSymbol.h:229
Flags for symbols in the JIT.
Definition: JITSymbol.h:74
static Expected< JITSymbolFlags > fromObjectSymbol(const object::SymbolRef &Symbol)
Construct a JITSymbolFlags value based on the flags of the given libobject symbol.
Definition: JITSymbol.cpp:69
Symbol resolution interface.
Definition: JITSymbol.h:371
std::set< StringRef > LookupSet
Definition: JITSymbol.h:373
RelocationEntry - used to represent relocations internally in the dynamic linker.
int64_t Addend
Addend - the relocation addend encoded in the instruction itself.
unsigned SectionID
SectionID - the section this relocation points to.
Interface for looking up the initializer for a variable name, used by Init::resolveReferences.
Definition: Record.h:2213
static std::unique_ptr< RuntimeDyldCOFF > create(Triple::ArchType Arch, RuntimeDyld::MemoryManager &MemMgr, JITSymbolResolver &Resolver)
static std::unique_ptr< RuntimeDyldELF > create(Triple::ArchType Arch, RuntimeDyld::MemoryManager &MemMgr, JITSymbolResolver &Resolver)
void log(raw_ostream &OS) const override
Print an error message to an output stream.
Definition: RuntimeDyld.cpp:57
std::error_code convertToErrorCode() const override
Convert this error to a std::error_code.
Definition: RuntimeDyld.cpp:61
void mapSectionAddress(const void *LocalAddress, uint64_t TargetAddress)
void reassignSectionAddress(unsigned SectionID, uint64_t Addr)
std::map< SectionRef, unsigned > ObjSectionToIDMap
void applyExternalSymbolRelocations(const StringMap< JITEvaluatedSymbol > ExternalSymbolMap)
void resolveRelocationList(const RelocationList &Relocs, uint64_t Value)
Resolves relocations from Relocs list with address from Value.
std::map< RelocationValueRef, uintptr_t > StubMap
void addRelocationForSymbol(const RelocationEntry &RE, StringRef SymbolName)
virtual void registerEHFrames()
Definition: RuntimeDyld.cpp:74
virtual ~RuntimeDyldImpl()
static void finalizeAsync(std::unique_ptr< RuntimeDyldImpl > This, unique_function< void(object::OwningBinary< object::ObjectFile >, std::unique_ptr< RuntimeDyld::LoadedObjectInfo >, Error)> OnEmitted, object::OwningBinary< object::ObjectFile > O, std::unique_ptr< RuntimeDyld::LoadedObjectInfo > Info)
Error emitCommonSymbols(const ObjectFile &Obj, CommonSymbolList &CommonSymbols, uint64_t CommonSize, uint32_t CommonAlign)
Given the common symbols discovered in the object file, emit a new section for them and update the sy...
Expected< unsigned > emitSection(const ObjectFile &Obj, const SectionRef &Section, bool IsCode)
Emits section data from the object file to the MemoryManager.
std::vector< SymbolRef > CommonSymbolList
void addRelocationForSection(const RelocationEntry &RE, unsigned SectionID)
Expected< unsigned > findOrEmitSection(const ObjectFile &Obj, const SectionRef &Section, bool IsCode, ObjSectionToIDMap &LocalSections)
Find Section in LocalSections.
unsigned computeGOTSize(const ObjectFile &Obj)
void writeBytesUnaligned(uint64_t Value, uint8_t *Dst, unsigned Size) const
Endian-aware write.
uint8_t * createStubFunction(uint8_t *Addr, unsigned AbiVariant=0)
Emits long jump instruction to Addr.
uint64_t readBytesUnaligned(uint8_t *Src, unsigned Size) const
Endian-aware read Read the least significant Size bytes from Src.
Error computeTotalAllocSize(const ObjectFile &Obj, uint64_t &CodeSize, Align &CodeAlign, uint64_t &RODataSize, Align &RODataAlign, uint64_t &RWDataSize, Align &RWDataAlign)
unsigned computeSectionStubBufSize(const ObjectFile &Obj, const SectionRef &Section)
virtual Expected< JITSymbolFlags > getJITSymbolFlags(const SymbolRef &Sym)
Generate JITSymbolFlags from a libObject symbol.
Expected< ObjSectionToIDMap > loadObjectImpl(const object::ObjectFile &Obj)
Error resolveExternalSymbols()
Resolve relocations to external symbols.
static std::unique_ptr< RuntimeDyldMachO > create(Triple::ArchType Arch, RuntimeDyld::MemoryManager &MemMgr, JITSymbolResolver &Resolver)
Create a RuntimeDyldMachO instance for the given target architecture.
Information about the loaded object.
Definition: RuntimeDyld.h:69
uint64_t getSectionLoadAddress(const object::SectionRef &Sec) const override
Obtain the Load Address of a section by SectionRef.
virtual void notifyObjectLoaded(RuntimeDyld &RTDyld, const object::ObjectFile &Obj)
This method is called after an object has been loaded into memory but before relocations are applied ...
Definition: RuntimeDyld.h:182
virtual TLSSection allocateTLSSection(uintptr_t Size, unsigned Alignment, unsigned SectionID, StringRef SectionName)
Allocate a memory block of (at least) the given size to be used for thread-local storage (TLS).
virtual bool finalizeMemory(std::string *ErrMsg=nullptr)=0
This method is called when object loading is complete and section page permissions can be applied.
void mapSectionAddress(const void *LocalAddress, uint64_t TargetAddress)
Map a section to its target address space value.
void setProcessAllSections(bool ProcessAllSections)
By default, only sections that are "required for execution" are passed to the RTDyldMemoryManager,...
Definition: RuntimeDyld.h:262
void reassignSectionAddress(unsigned SectionID, uint64_t Addr)
uint64_t getSectionLoadAddress(unsigned SectionID) const
If the section was loaded, return the section's load address, otherwise return std::nullopt.
void * getSymbolLocalAddress(StringRef Name) const
Get the address of our local copy of the symbol.
std::map< StringRef, JITEvaluatedSymbol > getSymbolTable() const
Returns a copy of the symbol table.
void resolveRelocations()
Resolve the relocations for all symbols we currently know about.
void finalizeWithMemoryManagerLocking()
Perform all actions needed to make the code owned by this RuntimeDyld instance executable:
void registerEHFrames()
Register any EH frame sections that have been loaded but not previously registered with the memory ma...
StringRef getSectionContent(unsigned SectionID) const
Returns the section's working memory.
JITEvaluatedSymbol getSymbol(StringRef Name) const
Get the target address and flags for the named symbol.
RuntimeDyld(MemoryManager &MemMgr, JITSymbolResolver &Resolver)
Construct a RuntimeDyld instance.
std::unique_ptr< LoadedObjectInfo > loadObject(const object::ObjectFile &O)
Add the referenced object file to the list of objects to be loaded and relocated.
StringRef getErrorString()
unsigned getSymbolSectionID(StringRef Name) const
Get the section ID for the section containing the given symbol.
std::function< void(StringRef FileName, StringRef SectionName, StringRef SymbolName, unsigned SectionID, uint32_t StubOffset)> NotifyStubEmittedFunction
Definition: RuntimeDyld.h:66
SectionEntry - represents a section emitted into memory by the dynamic linker.
StringRef getName() const
uint8_t * getAddress() const
size_t getSize() const
uint64_t getLoadAddress() const
size_t size() const
Definition: SmallVector.h:91
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
Definition: SmallVector.h:1209
StringMap - This is an unconventional map that is specialized for handling keys that are "strings",...
Definition: StringMap.h:128
iterator end()
Definition: StringMap.h:220
iterator find(StringRef Key)
Definition: StringMap.h:233
bool insert(MapEntryTy *KeyValue)
insert - Insert the specified key/value pair into the map.
Definition: StringMap.h:308
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:50
constexpr const char * data() const
data - Get a pointer to the start of the string (which may not be null terminated).
Definition: StringRef.h:131
Symbol info for RuntimeDyld.
@ aarch64_be
Definition: Triple.h:52
@ aarch64_32
Definition: Triple.h:53
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
Definition: Twine.h:81
LLVM Value Representation.
Definition: Value.h:74
bool isLittleEndian() const
Definition: Binary.h:155
bool isMachO() const
Definition: Binary.h:127
bool isCOFF() const
Definition: Binary.h:131
StringRef getFileName() const
Definition: Binary.cpp:41
bool isELF() const
Definition: Binary.h:123
This class is the base class for all object file types.
Definition: ObjectFile.h:229
virtual section_iterator section_end() const =0
symbol_iterator_range symbols() const
Definition: ObjectFile.h:321
virtual Triple::ArchType getArch() const =0
virtual section_iterator section_begin() const =0
This is a value type class that represents a single relocation in the list of relocations in the obje...
Definition: ObjectFile.h:52
This is a value type class that represents a single section in the list of sections in the object fil...
Definition: ObjectFile.h:81
uint64_t getAddress() const
Definition: ObjectFile.h:521
bool isText() const
Whether this section contains instructions.
Definition: ObjectFile.h:550
This is a value type class that represents a single symbol in the list of symbols in the object file.
Definition: ObjectFile.h:168
virtual basic_symbol_iterator symbol_begin() const =0
virtual basic_symbol_iterator symbol_end() const =0
This class implements an extremely fast bulk output stream that can only output to a stream.
Definition: raw_ostream.h:52
unique_function is a type-erasing functor similar to std::function.
#define UINT64_MAX
Definition: DataTypes.h:77
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
@ IMAGE_SCN_MEM_READ
Definition: COFF.h:335
@ IMAGE_SCN_CNT_UNINITIALIZED_DATA
Definition: COFF.h:304
@ IMAGE_SCN_MEM_DISCARDABLE
Definition: COFF.h:330
@ IMAGE_SCN_LNK_INFO
Definition: COFF.h:306
@ IMAGE_SCN_CNT_INITIALIZED_DATA
Definition: COFF.h:303
@ IMAGE_SCN_MEM_WRITE
Definition: COFF.h:336
@ SHT_NOBITS
Definition: ELF.h:1074
@ SHF_ALLOC
Definition: ELF.h:1161
@ SHF_WRITE
Definition: ELF.h:1158
@ SHF_TLS
Definition: ELF.h:1186
@ SHF_EXECINSTR
Definition: ELF.h:1164
@ EF_MIPS_ARCH
Definition: ELF.h:568
@ EF_MIPS_ARCH_32R6
Definition: ELF.h:566
@ EF_MIPS_ARCH_64R6
Definition: ELF.h:567
@ S_GB_ZEROFILL
S_GB_ZEROFILL - Zero fill on demand section (that can be larger than 4 gigabytes).
Definition: MachO.h:155
@ S_ZEROFILL
S_ZEROFILL - Zero fill on demand section.
Definition: MachO.h:129
std::optional< const char * > toString(const std::optional< DWARFFormValue > &V)
Take an optional DWARFFormValue and try to extract a string value from it.
uint64_t resolveRelocation(RelocationResolver Resolver, const RelocationRef &R, uint64_t S, uint64_t LocData)
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
@ Offset
Definition: DWP.cpp:456
std::error_code inconvertibleErrorCode()
The value returned by this function can be returned from convertToErrorCode for Error values where no...
Definition: Error.cpp:98
static std::unique_ptr< RuntimeDyldMachO > createRuntimeDyldMachO(Triple::ArchType Arch, RuntimeDyld::MemoryManager &MM, JITSymbolResolver &Resolver, bool ProcessAllSections, RuntimeDyld::NotifyStubEmittedFunction NotifyStubEmitted)
static bool isTLS(const SectionRef Section)
static void dumpSectionMemory(const SectionEntry &S, StringRef State)
Definition: RuntimeDyld.cpp:81
static Error getOffset(const SymbolRef &Sym, SectionRef Sec, uint64_t &Result)
static std::unique_ptr< RuntimeDyldCOFF > createRuntimeDyldCOFF(Triple::ArchType Arch, RuntimeDyld::MemoryManager &MM, JITSymbolResolver &Resolver, bool ProcessAllSections, RuntimeDyld::NotifyStubEmittedFunction NotifyStubEmitted)
raw_ostream & dbgs()
dbgs() - This returns a reference to a raw_ostream for debugging messages.
Definition: Debug.cpp:163
void report_fatal_error(Error Err, bool gen_crash_diag=true)
Report a serious error, calling any installed error handler.
Definition: Error.cpp:167
static bool isReadOnlyData(const SectionRef Section)
void jitLinkForORC(object::OwningBinary< object::ObjectFile > O, RuntimeDyld::MemoryManager &MemMgr, JITSymbolResolver &Resolver, bool ProcessAllSections, unique_function< Error(const object::ObjectFile &Obj, RuntimeDyld::LoadedObjectInfo &, std::map< StringRef, JITEvaluatedSymbol >)> OnLoaded, unique_function< void(object::OwningBinary< object::ObjectFile >, std::unique_ptr< RuntimeDyld::LoadedObjectInfo >, Error)> OnEmitted)
format_object< Ts... > format(const char *Fmt, const Ts &... Vals)
These are helper functions used to produce formatted output.
Definition: Format.h:125
uint64_t offsetToAlignment(uint64_t Value, Align Alignment)
Returns the offset to the next integer (mod 2**64) that is greater than or equal to Value and is a mu...
Definition: Alignment.h:197
static std::unique_ptr< RuntimeDyldELF > createRuntimeDyldELF(Triple::ArchType Arch, RuntimeDyld::MemoryManager &MM, JITSymbolResolver &Resolver, bool ProcessAllSections, RuntimeDyld::NotifyStubEmittedFunction NotifyStubEmitted)
uint64_t alignTo(uint64_t Size, Align A)
Returns a multiple of A needed to store Size bytes.
Definition: Alignment.h:155
static bool isZeroInit(const SectionRef Section)
Align commonAlignment(Align A, uint64_t Offset)
Returns the alignment that satisfies both alignments.
Definition: Alignment.h:212
static uint64_t computeAllocationSizeForSections(std::vector< uint64_t > &SectionSizes, Align Alignment)
static bool isRequiredForExecution(const SectionRef Section)
SymInfo contains information about symbol: it's address and section index which is -1LL for absolute ...
This struct is a compact representation of a valid (non-zero power of two) alignment.
Definition: Alignment.h:39
uint64_t value() const
This is a hole in the type system and should not be abused.
Definition: Alignment.h:85
support::ulittle32_t VirtualSize
Definition: COFF.h:442
support::ulittle32_t Characteristics
Definition: COFF.h:450
support::ulittle32_t SizeOfRawData
Definition: COFF.h:444