1 //===--- RuntimeDyldCOFFThumb.h --- COFF/Thumb specific code ---*- 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 // COFF thumb support for MC-JIT runtime dynamic linker.
10 //
11 //===----------------------------------------------------------------------===//
12 
13 #ifndef LLVM_LIB_EXECUTIONENGINE_RUNTIMEDYLD_TARGETS_RUNTIMEDYLDCOFFTHUMB_H
14 #define LLVM_LIB_EXECUTIONENGINE_RUNTIMEDYLD_TARGETS_RUNTIMEDYLDCOFFTHUMB_H
15 
16 #include "../RuntimeDyldCOFF.h"
17 #include "llvm/BinaryFormat/COFF.h"
18 #include "llvm/Object/COFF.h"
19 
20 #define DEBUG_TYPE "dyld"
21 
22 namespace llvm {
23 
isThumbFunc(object::symbol_iterator Symbol,const object::ObjectFile & Obj,object::section_iterator Section)24 static bool isThumbFunc(object::symbol_iterator Symbol,
25                         const object::ObjectFile &Obj,
26                         object::section_iterator Section) {
27   Expected<object::SymbolRef::Type> SymTypeOrErr = Symbol->getType();
28   if (!SymTypeOrErr) {
29     std::string Buf;
30     raw_string_ostream OS(Buf);
31     logAllUnhandledErrors(SymTypeOrErr.takeError(), OS);
32     report_fatal_error(Twine(OS.str()));
33   }
34 
35   if (*SymTypeOrErr != object::SymbolRef::ST_Function)
36     return false;
37 
38   // We check the IMAGE_SCN_MEM_16BIT flag in the section of the symbol to tell
39   // if it's thumb or not
40   return cast<object::COFFObjectFile>(Obj)
41              .getCOFFSection(*Section)
42              ->Characteristics &
43          COFF::IMAGE_SCN_MEM_16BIT;
44 }
45 
46 class RuntimeDyldCOFFThumb : public RuntimeDyldCOFF {
47 public:
RuntimeDyldCOFFThumb(RuntimeDyld::MemoryManager & MM,JITSymbolResolver & Resolver)48   RuntimeDyldCOFFThumb(RuntimeDyld::MemoryManager &MM,
49                        JITSymbolResolver &Resolver)
50       : RuntimeDyldCOFF(MM, Resolver, 4, COFF::IMAGE_REL_ARM_ADDR32) {}
51 
getMaxStubSize()52   unsigned getMaxStubSize() const override {
53     return 16; // 8-byte load instructions, 4-byte jump, 4-byte padding
54   }
55 
getStubAlignment()56   Align getStubAlignment() override { return Align(1); }
57 
58   Expected<object::relocation_iterator>
processRelocationRef(unsigned SectionID,object::relocation_iterator RelI,const object::ObjectFile & Obj,ObjSectionToIDMap & ObjSectionToID,StubMap & Stubs)59   processRelocationRef(unsigned SectionID,
60                        object::relocation_iterator RelI,
61                        const object::ObjectFile &Obj,
62                        ObjSectionToIDMap &ObjSectionToID,
63                        StubMap &Stubs) override {
64     auto Symbol = RelI->getSymbol();
65     if (Symbol == Obj.symbol_end())
66       report_fatal_error("Unknown symbol in relocation");
67 
68     Expected<StringRef> TargetNameOrErr = Symbol->getName();
69     if (!TargetNameOrErr)
70       return TargetNameOrErr.takeError();
71     StringRef TargetName = *TargetNameOrErr;
72 
73     auto SectionOrErr = Symbol->getSection();
74     if (!SectionOrErr)
75       return SectionOrErr.takeError();
76     auto Section = *SectionOrErr;
77 
78     uint64_t RelType = RelI->getType();
79     uint64_t Offset = RelI->getOffset();
80 
81     // Determine the Addend used to adjust the relocation value.
82     uint64_t Addend = 0;
83     SectionEntry &AddendSection = Sections[SectionID];
84     uintptr_t ObjTarget = AddendSection.getObjAddress() + Offset;
85     uint8_t *Displacement = (uint8_t *)ObjTarget;
86 
87     switch (RelType) {
88     case COFF::IMAGE_REL_ARM_ADDR32:
89     case COFF::IMAGE_REL_ARM_ADDR32NB:
90     case COFF::IMAGE_REL_ARM_SECREL:
91       Addend = readBytesUnaligned(Displacement, 4);
92       break;
93     default:
94       break;
95     }
96 
97 #if !defined(NDEBUG)
98     SmallString<32> RelTypeName;
99     RelI->getTypeName(RelTypeName);
100 #endif
101     LLVM_DEBUG(dbgs() << "\t\tIn Section " << SectionID << " Offset " << Offset
102                       << " RelType: " << RelTypeName << " TargetName: "
103                       << TargetName << " Addend " << Addend << "\n");
104 
105     bool IsExtern = Section == Obj.section_end();
106     unsigned TargetSectionID = -1;
107     uint64_t TargetOffset = -1;
108 
109     if (TargetName.startswith(getImportSymbolPrefix())) {
110       TargetSectionID = SectionID;
111       TargetOffset = getDLLImportOffset(SectionID, Stubs, TargetName, true);
112       TargetName = StringRef();
113       IsExtern = false;
114     } else if (!IsExtern) {
115       if (auto TargetSectionIDOrErr =
116           findOrEmitSection(Obj, *Section, Section->isText(), ObjSectionToID))
117         TargetSectionID = *TargetSectionIDOrErr;
118       else
119         return TargetSectionIDOrErr.takeError();
120       if (RelType != COFF::IMAGE_REL_ARM_SECTION)
121         TargetOffset = getSymbolOffset(*Symbol);
122     }
123 
124     if (IsExtern) {
125       RelocationEntry RE(SectionID, Offset, RelType, 0, -1, 0, 0, 0, false, 0);
126       addRelocationForSymbol(RE, TargetName);
127     } else {
128 
129       // We need to find out if the relocation is relative to a thumb function
130       // so that we include the ISA selection bit when resolve the relocation
131       bool IsTargetThumbFunc = isThumbFunc(Symbol, Obj, Section);
132 
133       switch (RelType) {
134       default: llvm_unreachable("unsupported relocation type");
135       case COFF::IMAGE_REL_ARM_ABSOLUTE:
136         // This relocation is ignored.
137         break;
138       case COFF::IMAGE_REL_ARM_ADDR32: {
139         RelocationEntry RE =
140             RelocationEntry(SectionID, Offset, RelType, Addend, TargetSectionID,
141                             TargetOffset, 0, 0, false, 0, IsTargetThumbFunc);
142         addRelocationForSection(RE, TargetSectionID);
143         break;
144       }
145       case COFF::IMAGE_REL_ARM_ADDR32NB: {
146         RelocationEntry RE =
147             RelocationEntry(SectionID, Offset, RelType, Addend, TargetSectionID,
148                             TargetOffset, 0, 0, false, 0);
149         addRelocationForSection(RE, TargetSectionID);
150         break;
151       }
152       case COFF::IMAGE_REL_ARM_SECTION: {
153         RelocationEntry RE =
154             RelocationEntry(TargetSectionID, Offset, RelType, 0);
155         addRelocationForSection(RE, TargetSectionID);
156         break;
157       }
158       case COFF::IMAGE_REL_ARM_SECREL: {
159         RelocationEntry RE =
160             RelocationEntry(SectionID, Offset, RelType, TargetOffset + Addend);
161         addRelocationForSection(RE, TargetSectionID);
162         break;
163       }
164       case COFF::IMAGE_REL_ARM_MOV32T: {
165         RelocationEntry RE =
166             RelocationEntry(SectionID, Offset, RelType, Addend, TargetSectionID,
167                             TargetOffset, 0, 0, false, 0, IsTargetThumbFunc);
168         addRelocationForSection(RE, TargetSectionID);
169         break;
170       }
171       case COFF::IMAGE_REL_ARM_BRANCH20T:
172       case COFF::IMAGE_REL_ARM_BRANCH24T:
173       case COFF::IMAGE_REL_ARM_BLX23T: {
174         RelocationEntry RE = RelocationEntry(SectionID, Offset, RelType,
175                                              TargetOffset + Addend, true, 0);
176         addRelocationForSection(RE, TargetSectionID);
177         break;
178       }
179       }
180     }
181 
182     return ++RelI;
183   }
184 
resolveRelocation(const RelocationEntry & RE,uint64_t Value)185   void resolveRelocation(const RelocationEntry &RE, uint64_t Value) override {
186     const auto Section = Sections[RE.SectionID];
187     uint8_t *Target = Section.getAddressWithOffset(RE.Offset);
188     int ISASelectionBit = RE.IsTargetThumbFunc ? 1 : 0;
189 
190     switch (RE.RelType) {
191     default: llvm_unreachable("unsupported relocation type");
192     case COFF::IMAGE_REL_ARM_ABSOLUTE:
193       // This relocation is ignored.
194       break;
195     case COFF::IMAGE_REL_ARM_ADDR32: {
196       // The target's 32-bit VA.
197       uint64_t Result =
198           RE.Sections.SectionA == static_cast<uint32_t>(-1)
199               ? Value
200               : Sections[RE.Sections.SectionA].getLoadAddressWithOffset(RE.Addend);
201       Result |= ISASelectionBit;
202       assert(Result <= UINT32_MAX && "relocation overflow");
203       LLVM_DEBUG(dbgs() << "\t\tOffset: " << RE.Offset
204                         << " RelType: IMAGE_REL_ARM_ADDR32"
205                         << " TargetSection: " << RE.Sections.SectionA
206                         << " Value: " << format("0x%08" PRIx32, Result)
207                         << '\n');
208       writeBytesUnaligned(Result, Target, 4);
209       break;
210     }
211     case COFF::IMAGE_REL_ARM_ADDR32NB: {
212       // The target's 32-bit RVA.
213       // NOTE: use Section[0].getLoadAddress() as an approximation of ImageBase
214       uint64_t Result = Sections[RE.Sections.SectionA].getLoadAddress() -
215                         Sections[0].getLoadAddress() + RE.Addend;
216       assert(Result <= UINT32_MAX && "relocation overflow");
217       LLVM_DEBUG(dbgs() << "\t\tOffset: " << RE.Offset
218                         << " RelType: IMAGE_REL_ARM_ADDR32NB"
219                         << " TargetSection: " << RE.Sections.SectionA
220                         << " Value: " << format("0x%08" PRIx32, Result)
221                         << '\n');
222       Result |= ISASelectionBit;
223       writeBytesUnaligned(Result, Target, 4);
224       break;
225     }
226     case COFF::IMAGE_REL_ARM_SECTION:
227       // 16-bit section index of the section that contains the target.
228       assert(static_cast<uint32_t>(RE.SectionID) <= UINT16_MAX &&
229              "relocation overflow");
230       LLVM_DEBUG(dbgs() << "\t\tOffset: " << RE.Offset
231                         << " RelType: IMAGE_REL_ARM_SECTION Value: "
232                         << RE.SectionID << '\n');
233       writeBytesUnaligned(RE.SectionID, Target, 2);
234       break;
235     case COFF::IMAGE_REL_ARM_SECREL:
236       // 32-bit offset of the target from the beginning of its section.
237       assert(static_cast<uint64_t>(RE.Addend) <= UINT32_MAX &&
238              "relocation overflow");
239       LLVM_DEBUG(dbgs() << "\t\tOffset: " << RE.Offset
240                         << " RelType: IMAGE_REL_ARM_SECREL Value: " << RE.Addend
241                         << '\n');
242       writeBytesUnaligned(RE.Addend, Target, 2);
243       break;
244     case COFF::IMAGE_REL_ARM_MOV32T: {
245       // 32-bit VA of the target applied to a contiguous MOVW+MOVT pair.
246       uint64_t Result =
247           Sections[RE.Sections.SectionA].getLoadAddressWithOffset(RE.Addend);
248       assert(Result <= UINT32_MAX && "relocation overflow");
249       LLVM_DEBUG(dbgs() << "\t\tOffset: " << RE.Offset
250                         << " RelType: IMAGE_REL_ARM_MOV32T"
251                         << " TargetSection: " << RE.Sections.SectionA
252                         << " Value: " << format("0x%08" PRIx32, Result)
253                         << '\n');
254 
255       // MOVW(T3): |11110|i|10|0|1|0|0|imm4|0|imm3|Rd|imm8|
256       //            imm32 = zext imm4:i:imm3:imm8
257       // MOVT(T1): |11110|i|10|1|1|0|0|imm4|0|imm3|Rd|imm8|
258       //            imm16 =      imm4:i:imm3:imm8
259 
260       auto EncodeImmediate = [](uint8_t *Bytes, uint16_t Immediate)  {
261         Bytes[0] |= ((Immediate & 0xf000) >> 12);
262         Bytes[1] |= ((Immediate & 0x0800) >> 11);
263         Bytes[2] |= ((Immediate & 0x00ff) >>  0);
264         Bytes[3] |= (((Immediate & 0x0700) >>  8) << 4);
265       };
266 
267       EncodeImmediate(&Target[0],
268                       (static_cast<uint32_t>(Result) >> 00) | ISASelectionBit);
269       EncodeImmediate(&Target[4], static_cast<uint32_t>(Result) >> 16);
270       break;
271     }
272     case COFF::IMAGE_REL_ARM_BRANCH20T: {
273       // The most significant 20-bits of the signed 21-bit relative displacement
274       uint64_t Value =
275           RE.Addend - (Sections[RE.SectionID].getLoadAddress() + RE.Offset) - 4;
276       assert(static_cast<int64_t>(RE.Addend) <= INT32_MAX &&
277              "relocation overflow");
278       assert(static_cast<int64_t>(RE.Addend) >= INT32_MIN &&
279              "relocation underflow");
280       LLVM_DEBUG(dbgs() << "\t\tOffset: " << RE.Offset
281                         << " RelType: IMAGE_REL_ARM_BRANCH20T"
282                         << " Value: " << static_cast<int32_t>(Value) << '\n');
283       static_cast<void>(Value);
284       llvm_unreachable("unimplemented relocation");
285       break;
286     }
287     case COFF::IMAGE_REL_ARM_BRANCH24T: {
288       // The most significant 24-bits of the signed 25-bit relative displacement
289       uint64_t Value =
290           RE.Addend - (Sections[RE.SectionID].getLoadAddress() + RE.Offset) - 4;
291       assert(static_cast<int64_t>(RE.Addend) <= INT32_MAX &&
292              "relocation overflow");
293       assert(static_cast<int64_t>(RE.Addend) >= INT32_MIN &&
294              "relocation underflow");
295       LLVM_DEBUG(dbgs() << "\t\tOffset: " << RE.Offset
296                         << " RelType: IMAGE_REL_ARM_BRANCH24T"
297                         << " Value: " << static_cast<int32_t>(Value) << '\n');
298       static_cast<void>(Value);
299       llvm_unreachable("unimplemented relocation");
300       break;
301     }
302     case COFF::IMAGE_REL_ARM_BLX23T: {
303       // The most significant 24-bits of the signed 25-bit relative displacement
304       uint64_t Value =
305           RE.Addend - (Sections[RE.SectionID].getLoadAddress() + RE.Offset) - 4;
306       assert(static_cast<int64_t>(RE.Addend) <= INT32_MAX &&
307              "relocation overflow");
308       assert(static_cast<int64_t>(RE.Addend) >= INT32_MIN &&
309              "relocation underflow");
310       LLVM_DEBUG(dbgs() << "\t\tOffset: " << RE.Offset
311                         << " RelType: IMAGE_REL_ARM_BLX23T"
312                         << " Value: " << static_cast<int32_t>(Value) << '\n');
313       static_cast<void>(Value);
314       llvm_unreachable("unimplemented relocation");
315       break;
316     }
317     }
318   }
319 
registerEHFrames()320   void registerEHFrames() override {}
321 };
322 
323 }
324 
325 #endif
326