LLVM  9.0.0svn
RuntimeDyldELF.h
Go to the documentation of this file.
1 //===-- RuntimeDyldELF.h - 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 // ELF support for MC-JIT runtime dynamic linker.
10 //
11 //===----------------------------------------------------------------------===//
12 
13 #ifndef LLVM_LIB_EXECUTIONENGINE_RUNTIMEDYLD_RUNTIMEDYLDELF_H
14 #define LLVM_LIB_EXECUTIONENGINE_RUNTIMEDYLD_RUNTIMEDYLDELF_H
15 
16 #include "RuntimeDyldImpl.h"
17 #include "llvm/ADT/DenseMap.h"
18 
19 using namespace llvm;
20 
21 namespace llvm {
22 namespace object {
23 class ELFObjectFileBase;
24 }
25 
27 
28  void resolveRelocation(const SectionEntry &Section, uint64_t Offset,
29  uint64_t Value, uint32_t Type, int64_t Addend,
30  uint64_t SymOffset = 0, SID SectionID = 0);
31 
32  void resolveX86_64Relocation(const SectionEntry &Section, uint64_t Offset,
33  uint64_t Value, uint32_t Type, int64_t Addend,
34  uint64_t SymOffset);
35 
36  void resolveX86Relocation(const SectionEntry &Section, uint64_t Offset,
37  uint32_t Value, uint32_t Type, int32_t Addend);
38 
39  void resolveAArch64Relocation(const SectionEntry &Section, uint64_t Offset,
40  uint64_t Value, uint32_t Type, int64_t Addend);
41 
42  bool resolveAArch64ShortBranch(unsigned SectionID, relocation_iterator RelI,
43  const RelocationValueRef &Value);
44 
45  void resolveAArch64Branch(unsigned SectionID, const RelocationValueRef &Value,
46  relocation_iterator RelI, StubMap &Stubs);
47 
48  void resolveARMRelocation(const SectionEntry &Section, uint64_t Offset,
49  uint32_t Value, uint32_t Type, int32_t Addend);
50 
51  void resolvePPC32Relocation(const SectionEntry &Section, uint64_t Offset,
52  uint64_t Value, uint32_t Type, int64_t Addend);
53 
54  void resolvePPC64Relocation(const SectionEntry &Section, uint64_t Offset,
55  uint64_t Value, uint32_t Type, int64_t Addend);
56 
57  void resolveSystemZRelocation(const SectionEntry &Section, uint64_t Offset,
58  uint64_t Value, uint32_t Type, int64_t Addend);
59 
60  void resolveBPFRelocation(const SectionEntry &Section, uint64_t Offset,
61  uint64_t Value, uint32_t Type, int64_t Addend);
62 
63  unsigned getMaxStubSize() const override {
64  if (Arch == Triple::aarch64 || Arch == Triple::aarch64_be)
65  return 20; // movz; movk; movk; movk; br
66  if (Arch == Triple::arm || Arch == Triple::thumb)
67  return 8; // 32-bit instruction and 32-bit address
68  else if (IsMipsO32ABI || IsMipsN32ABI)
69  return 16;
70  else if (IsMipsN64ABI)
71  return 32;
72  else if (Arch == Triple::ppc64 || Arch == Triple::ppc64le)
73  return 44;
74  else if (Arch == Triple::x86_64)
75  return 6; // 2-byte jmp instruction + 32-bit relative address
76  else if (Arch == Triple::systemz)
77  return 16;
78  else
79  return 0;
80  }
81 
82  unsigned getStubAlignment() override {
83  if (Arch == Triple::systemz)
84  return 8;
85  else
86  return 1;
87  }
88 
89  void setMipsABI(const ObjectFile &Obj) override;
90 
91  Error findPPC64TOCSection(const ELFObjectFileBase &Obj,
92  ObjSectionToIDMap &LocalSections,
93  RelocationValueRef &Rel);
94  Error findOPDEntrySection(const ELFObjectFileBase &Obj,
95  ObjSectionToIDMap &LocalSections,
96  RelocationValueRef &Rel);
97 protected:
98  size_t getGOTEntrySize() override;
99 
100 private:
101  SectionEntry &getSection(unsigned SectionID) { return Sections[SectionID]; }
102 
103  // Allocate no GOT entries for use in the given section.
104  uint64_t allocateGOTEntries(unsigned no);
105 
106  // Find GOT entry corresponding to relocation or create new one.
107  uint64_t findOrAllocGOTEntry(const RelocationValueRef &Value,
108  unsigned GOTRelType);
109 
110  // Resolve the relvative address of GOTOffset in Section ID and place
111  // it at the given Offset
112  void resolveGOTOffsetRelocation(unsigned SectionID, uint64_t Offset,
113  uint64_t GOTOffset, uint32_t Type);
114 
115  // For a GOT entry referenced from SectionID, compute a relocation entry
116  // that will place the final resolved value in the GOT slot
117  RelocationEntry computeGOTOffsetRE(uint64_t GOTOffset, uint64_t SymbolOffset,
118  unsigned Type);
119 
120  // Compute the address in memory where we can find the placeholder
121  void *computePlaceholderAddress(unsigned SectionID, uint64_t Offset) const;
122 
123  // Split out common case for createing the RelocationEntry for when the relocation requires
124  // no particular advanced processing.
125  void processSimpleRelocation(unsigned SectionID, uint64_t Offset, unsigned RelType, RelocationValueRef Value);
126 
127  // Return matching *LO16 relocation (Mips specific)
128  uint32_t getMatchingLoRelocation(uint32_t RelType,
129  bool IsLocal = false) const;
130 
131  // The tentative ID for the GOT section
132  unsigned GOTSectionID;
133 
134  // Records the current number of allocated slots in the GOT
135  // (This would be equivalent to GOTEntries.size() were it not for relocations
136  // that consume more than one slot)
137  unsigned CurrentGOTIndex;
138 
139 protected:
140  // A map from section to a GOT section that has entries for section's GOT
141  // relocations. (Mips64 specific)
143 
144 private:
145  // A map to avoid duplicate got entries (Mips64 specific)
146  StringMap<uint64_t> GOTSymbolOffsets;
147 
148  // *HI16 relocations will be added for resolving when we find matching
149  // *LO16 part. (Mips specific)
151 
152  // When a module is loaded we save the SectionID of the EH frame section
153  // in a table until we receive a request to register all unregistered
154  // EH frame sections with the memory manager.
155  SmallVector<SID, 2> UnregisteredEHFrameSections;
156 
157  // Map between GOT relocation value and corresponding GOT offset
158  std::map<RelocationValueRef, uint64_t> GOTOffsetMap;
159 
160  bool relocationNeedsGot(const RelocationRef &R) const override;
161  bool relocationNeedsStub(const RelocationRef &R) const override;
162 
163 public:
166  ~RuntimeDyldELF() override;
167 
168  static std::unique_ptr<RuntimeDyldELF>
169  create(Triple::ArchType Arch, RuntimeDyld::MemoryManager &MemMgr,
171 
172  std::unique_ptr<RuntimeDyld::LoadedObjectInfo>
173  loadObject(const object::ObjectFile &O) override;
174 
175  void resolveRelocation(const RelocationEntry &RE, uint64_t Value) override;
177  processRelocationRef(unsigned SectionID, relocation_iterator RelI,
178  const ObjectFile &Obj,
179  ObjSectionToIDMap &ObjSectionToID,
180  StubMap &Stubs) override;
181  bool isCompatibleFile(const object::ObjectFile &Obj) const override;
182  void registerEHFrames() override;
183  Error finalizeLoad(const ObjectFile &Obj,
184  ObjSectionToIDMap &SectionMap) override;
185 };
186 
187 } // end namespace llvm
188 
189 #endif
RelocationEntry - used to represent relocations internally in the dynamic linker. ...
This class represents lattice values for constants.
Definition: AllocatorList.h:23
This class is the base class for all object file types.
Definition: ObjectFile.h:225
This is a value type class that represents a single relocation in the list of relocations in the obje...
Definition: ObjectFile.h:51
std::map< RelocationValueRef, uintptr_t > StubMap
Tagged union holding either a T or a Error.
Definition: CachePruning.h:22
Expected< const typename ELFT::Shdr * > getSection(typename ELFT::ShdrRange Sections, uint32_t Index)
Definition: ELF.h:272
The instances of the Type class are immutable: once they are created, they are never changed...
Definition: Type.h:45
Interface for looking up the initializer for a variable name, used by Init::resolveReferences.
Definition: Record.h:1856
Symbol resolution interface.
Definition: JITSymbol.h:343
DenseMap< SID, SID > SectionToGOTMap
This is a &#39;vector&#39; (really, a variable-sized array), optimized for the case when the array is small...
Definition: SmallVector.h:841
std::map< SectionRef, unsigned > ObjSectionToIDMap
SectionEntry - represents a section emitted into memory by the dynamic linker.
LLVM Value Representation.
Definition: Value.h:72
Lightweight error class with error context and mandatory checking.
Definition: Error.h:157