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 
26 class RuntimeDyldELF : public RuntimeDyldImpl {
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)
142   DenseMap<SID, SID> SectionToGOTMap;
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)
150   SmallVector<std::pair<RelocationValueRef, RelocationEntry>, 8> PendingRelocs;
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:
164   RuntimeDyldELF(RuntimeDyld::MemoryManager &MemMgr,
165                  JITSymbolResolver &Resolver);
166   ~RuntimeDyldELF() override;
167 
168   static std::unique_ptr<RuntimeDyldELF>
169   create(Triple::ArchType Arch, RuntimeDyld::MemoryManager &MemMgr,
170          JITSymbolResolver &Resolver);
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;
176   Expected<relocation_iterator>
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
190