1//===----- RuntimeDyldMachOARM.h ---- MachO/ARM 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#ifndef LLVM_LIB_EXECUTIONENGINE_RUNTIMEDYLD_TARGETS_RUNTIMEDYLDMACHOARM_H
10#define LLVM_LIB_EXECUTIONENGINE_RUNTIMEDYLD_TARGETS_RUNTIMEDYLDMACHOARM_H
11
12#include "../RuntimeDyldMachO.h"
13
14#define DEBUG_TYPE "dyld"
15
16namespace llvm {
17
18class RuntimeDyldMachOARM
19 : public RuntimeDyldMachOCRTPBase<RuntimeDyldMachOARM> {
20private:
21 typedef RuntimeDyldMachOCRTPBase<RuntimeDyldMachOARM> ParentT;
22
23public:
24
25 typedef uint32_t TargetPtrT;
26
27 RuntimeDyldMachOARM(RuntimeDyld::MemoryManager &MM,
28 JITSymbolResolver &Resolver)
29 : RuntimeDyldMachOCRTPBase(MM, Resolver) {}
30
31 unsigned getMaxStubSize() const override { return 8; }
32
33 Align getStubAlignment() override { return Align(4); }
34
35 Expected<JITSymbolFlags> getJITSymbolFlags(const SymbolRef &SR) override {
36 auto Flags = RuntimeDyldImpl::getJITSymbolFlags(Sym: SR);
37 if (!Flags)
38 return Flags.takeError();
39 Flags->getTargetFlags() = ARMJITSymbolFlags::fromObjectSymbol(Symbol: SR);
40 return Flags;
41 }
42
43 uint64_t modifyAddressBasedOnFlags(uint64_t Addr,
44 JITSymbolFlags Flags) const override {
45 if (Flags.getTargetFlags() & ARMJITSymbolFlags::Thumb)
46 Addr |= 0x1;
47 return Addr;
48 }
49
50 bool isAddrTargetThumb(unsigned SectionID, uint64_t Offset) {
51 auto TargetObjAddr = Sections[SectionID].getObjAddress() + Offset;
52 for (auto &KV : GlobalSymbolTable) {
53 auto &Entry = KV.second;
54 auto SymbolObjAddr =
55 Sections[Entry.getSectionID()].getObjAddress() + Entry.getOffset();
56 if (TargetObjAddr == SymbolObjAddr)
57 return (Entry.getFlags().getTargetFlags() & ARMJITSymbolFlags::Thumb);
58 }
59 return false;
60 }
61
62 Expected<int64_t> decodeAddend(const RelocationEntry &RE) const {
63 const SectionEntry &Section = Sections[RE.SectionID];
64 uint8_t *LocalAddress = Section.getAddressWithOffset(OffsetBytes: RE.Offset);
65
66 switch (RE.RelType) {
67 default:
68 return memcpyAddend(RE);
69 case MachO::ARM_RELOC_BR24: {
70 uint32_t Temp = readBytesUnaligned(Src: LocalAddress, Size: 4);
71 Temp &= 0x00ffffff; // Mask out the opcode.
72 // Now we've got the shifted immediate, shift by 2, sign extend and ret.
73 return SignExtend32<26>(X: Temp << 2);
74 }
75
76 case MachO::ARM_THUMB_RELOC_BR22: {
77 // This is a pair of instructions whose operands combine to provide 22
78 // bits of displacement:
79 // Encoding for high bits 1111 0XXX XXXX XXXX
80 // Encoding for low bits 1111 1XXX XXXX XXXX
81 uint16_t HighInsn = readBytesUnaligned(Src: LocalAddress, Size: 2);
82 if ((HighInsn & 0xf800) != 0xf000)
83 return make_error<StringError>(Args: "Unrecognized thumb branch encoding "
84 "(BR22 high bits)",
85 Args: inconvertibleErrorCode());
86
87 uint16_t LowInsn = readBytesUnaligned(Src: LocalAddress + 2, Size: 2);
88 if ((LowInsn & 0xf800) != 0xf800)
89 return make_error<StringError>(Args: "Unrecognized thumb branch encoding "
90 "(BR22 low bits)",
91 Args: inconvertibleErrorCode());
92
93 return SignExtend64<23>(x: ((HighInsn & 0x7ff) << 12) |
94 ((LowInsn & 0x7ff) << 1));
95 }
96 }
97 }
98
99 Expected<relocation_iterator>
100 processRelocationRef(unsigned SectionID, relocation_iterator RelI,
101 const ObjectFile &BaseObjT,
102 ObjSectionToIDMap &ObjSectionToID,
103 StubMap &Stubs) override {
104 const MachOObjectFile &Obj =
105 static_cast<const MachOObjectFile &>(BaseObjT);
106 MachO::any_relocation_info RelInfo =
107 Obj.getRelocation(Rel: RelI->getRawDataRefImpl());
108 uint32_t RelType = Obj.getAnyRelocationType(RE: RelInfo);
109
110 // Set to true for thumb functions in this (or previous) TUs.
111 // Will be used to set the TargetIsThumbFunc member on the relocation entry.
112 bool TargetIsLocalThumbFunc = false;
113 if (Obj.getPlainRelocationExternal(RE: RelInfo)) {
114 auto Symbol = RelI->getSymbol();
115 StringRef TargetName;
116 if (auto TargetNameOrErr = Symbol->getName())
117 TargetName = *TargetNameOrErr;
118 else
119 return TargetNameOrErr.takeError();
120
121 // If the target is external but the value doesn't have a name then we've
122 // converted the value to a section/offset pair, but we still need to set
123 // the IsTargetThumbFunc bit, so look the value up in the globla symbol table.
124 auto EntryItr = GlobalSymbolTable.find(Key: TargetName);
125 if (EntryItr != GlobalSymbolTable.end()) {
126 TargetIsLocalThumbFunc =
127 EntryItr->second.getFlags().getTargetFlags() &
128 ARMJITSymbolFlags::Thumb;
129 }
130 }
131
132 if (Obj.isRelocationScattered(RE: RelInfo)) {
133 if (RelType == MachO::ARM_RELOC_HALF_SECTDIFF)
134 return processHALFSECTDIFFRelocation(SectionID, RelI, BaseTObj: Obj,
135 ObjSectionToID);
136 else if (RelType == MachO::GENERIC_RELOC_VANILLA)
137 return processScatteredVANILLA(SectionID, RelI, BaseObjT: Obj, ObjSectionToID,
138 TargetIsLocalThumbFunc);
139 else
140 return ++RelI;
141 }
142
143 // Validate the relocation type.
144 switch (RelType) {
145 UNIMPLEMENTED_RELOC(MachO::ARM_RELOC_PAIR);
146 UNIMPLEMENTED_RELOC(MachO::ARM_RELOC_SECTDIFF);
147 UNIMPLEMENTED_RELOC(MachO::ARM_RELOC_LOCAL_SECTDIFF);
148 UNIMPLEMENTED_RELOC(MachO::ARM_RELOC_PB_LA_PTR);
149 UNIMPLEMENTED_RELOC(MachO::ARM_THUMB_32BIT_BRANCH);
150 UNIMPLEMENTED_RELOC(MachO::ARM_RELOC_HALF);
151 default:
152 if (RelType > MachO::ARM_RELOC_HALF_SECTDIFF)
153 return make_error<RuntimeDyldError>(Args: ("MachO ARM relocation type " +
154 Twine(RelType) +
155 " is out of range").str());
156 break;
157 }
158
159 RelocationEntry RE(getRelocationEntry(SectionID, BaseTObj: Obj, RI: RelI));
160 if (auto AddendOrErr = decodeAddend(RE))
161 RE.Addend = *AddendOrErr;
162 else
163 return AddendOrErr.takeError();
164 RE.IsTargetThumbFunc = TargetIsLocalThumbFunc;
165
166 RelocationValueRef Value;
167 if (auto ValueOrErr = getRelocationValueRef(BaseTObj: Obj, RI: RelI, RE, ObjSectionToID))
168 Value = *ValueOrErr;
169 else
170 return ValueOrErr.takeError();
171
172 // If this is a branch from a thumb function (BR22) then make sure we mark
173 // the value as being a thumb stub: we don't want to mix it up with an ARM
174 // stub targeting the same function.
175 if (RE.RelType == MachO::ARM_THUMB_RELOC_BR22)
176 Value.IsStubThumb = true;
177
178 if (RE.IsPCRel)
179 makeValueAddendPCRel(Value, RI: RelI,
180 OffsetToNextPC: (RE.RelType == MachO::ARM_THUMB_RELOC_BR22) ? 4 : 8);
181
182 // If this is a non-external branch target check whether Value points to a
183 // thumb func.
184 if (!Value.SymbolName && (RelType == MachO::ARM_RELOC_BR24 ||
185 RelType == MachO::ARM_THUMB_RELOC_BR22))
186 RE.IsTargetThumbFunc = isAddrTargetThumb(SectionID: Value.SectionID, Offset: Value.Offset);
187
188 if (RE.RelType == MachO::ARM_RELOC_BR24 ||
189 RE.RelType == MachO::ARM_THUMB_RELOC_BR22)
190 processBranchRelocation(RE, Value, Stubs);
191 else {
192 RE.Addend = Value.Offset;
193 if (Value.SymbolName)
194 addRelocationForSymbol(RE, SymbolName: Value.SymbolName);
195 else
196 addRelocationForSection(RE, SectionID: Value.SectionID);
197 }
198
199 return ++RelI;
200 }
201
202 void resolveRelocation(const RelocationEntry &RE, uint64_t Value) override {
203 LLVM_DEBUG(dumpRelocationToResolve(RE, Value));
204 const SectionEntry &Section = Sections[RE.SectionID];
205 uint8_t *LocalAddress = Section.getAddressWithOffset(OffsetBytes: RE.Offset);
206
207 // If the relocation is PC-relative, the value to be encoded is the
208 // pointer difference.
209 if (RE.IsPCRel) {
210 uint64_t FinalAddress = Section.getLoadAddressWithOffset(OffsetBytes: RE.Offset);
211 Value -= FinalAddress;
212 // ARM PCRel relocations have an effective-PC offset of two instructions
213 // (four bytes in Thumb mode, 8 bytes in ARM mode).
214 Value -= (RE.RelType == MachO::ARM_THUMB_RELOC_BR22) ? 4 : 8;
215 }
216
217 switch (RE.RelType) {
218 case MachO::ARM_THUMB_RELOC_BR22: {
219 Value += RE.Addend;
220 uint16_t HighInsn = readBytesUnaligned(Src: LocalAddress, Size: 2);
221 assert((HighInsn & 0xf800) == 0xf000 &&
222 "Unrecognized thumb branch encoding (BR22 high bits)");
223 HighInsn = (HighInsn & 0xf800) | ((Value >> 12) & 0x7ff);
224
225 uint16_t LowInsn = readBytesUnaligned(Src: LocalAddress + 2, Size: 2);
226 assert((LowInsn & 0xf800) == 0xf800 &&
227 "Unrecognized thumb branch encoding (BR22 low bits)");
228 LowInsn = (LowInsn & 0xf800) | ((Value >> 1) & 0x7ff);
229
230 writeBytesUnaligned(Value: HighInsn, Dst: LocalAddress, Size: 2);
231 writeBytesUnaligned(Value: LowInsn, Dst: LocalAddress + 2, Size: 2);
232 break;
233 }
234
235 case MachO::ARM_RELOC_VANILLA:
236 if (RE.IsTargetThumbFunc)
237 Value |= 0x01;
238 writeBytesUnaligned(Value: Value + RE.Addend, Dst: LocalAddress, Size: 1 << RE.Size);
239 break;
240 case MachO::ARM_RELOC_BR24: {
241 // Mask the value into the target address. We know instructions are
242 // 32-bit aligned, so we can do it all at once.
243 Value += RE.Addend;
244 // The low two bits of the value are not encoded.
245 Value >>= 2;
246 // Mask the value to 24 bits.
247 uint64_t FinalValue = Value & 0xffffff;
248 // FIXME: If the destination is a Thumb function (and the instruction
249 // is a non-predicated BL instruction), we need to change it to a BLX
250 // instruction instead.
251
252 // Insert the value into the instruction.
253 uint32_t Temp = readBytesUnaligned(Src: LocalAddress, Size: 4);
254 writeBytesUnaligned(Value: (Temp & ~0xffffff) | FinalValue, Dst: LocalAddress, Size: 4);
255
256 break;
257 }
258 case MachO::ARM_RELOC_HALF_SECTDIFF: {
259 uint64_t SectionABase = Sections[RE.Sections.SectionA].getLoadAddress();
260 uint64_t SectionBBase = Sections[RE.Sections.SectionB].getLoadAddress();
261 assert((Value == SectionABase || Value == SectionBBase) &&
262 "Unexpected HALFSECTDIFF relocation value.");
263 Value = SectionABase - SectionBBase + RE.Addend;
264 if (RE.Size & 0x1) // :upper16:
265 Value = (Value >> 16);
266
267 bool IsThumb = RE.Size & 0x2;
268
269 Value &= 0xffff;
270
271 uint32_t Insn = readBytesUnaligned(Src: LocalAddress, Size: 4);
272
273 if (IsThumb)
274 Insn = (Insn & 0x8f00fbf0) | ((Value & 0xf000) >> 12) |
275 ((Value & 0x0800) >> 1) | ((Value & 0x0700) << 20) |
276 ((Value & 0x00ff) << 16);
277 else
278 Insn = (Insn & 0xfff0f000) | ((Value & 0xf000) << 4) | (Value & 0x0fff);
279 writeBytesUnaligned(Value: Insn, Dst: LocalAddress, Size: 4);
280 break;
281 }
282
283 default:
284 llvm_unreachable("Invalid relocation type");
285 }
286 }
287
288 Error finalizeSection(const ObjectFile &Obj, unsigned SectionID,
289 const SectionRef &Section) {
290 StringRef Name;
291 if (Expected<StringRef> NameOrErr = Section.getName())
292 Name = *NameOrErr;
293 else
294 consumeError(Err: NameOrErr.takeError());
295
296 if (Name == "__nl_symbol_ptr")
297 return populateIndirectSymbolPointersSection(Obj: cast<MachOObjectFile>(Val: Obj),
298 PTSection: Section, PTSectionID: SectionID);
299 return Error::success();
300 }
301
302private:
303
304 void processBranchRelocation(const RelocationEntry &RE,
305 const RelocationValueRef &Value,
306 StubMap &Stubs) {
307 // This is an ARM branch relocation, need to use a stub function.
308 // Look up for existing stub.
309 SectionEntry &Section = Sections[RE.SectionID];
310 RuntimeDyldMachO::StubMap::const_iterator i = Stubs.find(x: Value);
311 uint8_t *Addr;
312 if (i != Stubs.end()) {
313 Addr = Section.getAddressWithOffset(OffsetBytes: i->second);
314 } else {
315 // Create a new stub function.
316 assert(Section.getStubOffset() % 4 == 0 && "Misaligned stub");
317 Stubs[Value] = Section.getStubOffset();
318 uint32_t StubOpcode = 0;
319 if (RE.RelType == MachO::ARM_RELOC_BR24)
320 StubOpcode = 0xe51ff004; // ldr pc, [pc, #-4]
321 else if (RE.RelType == MachO::ARM_THUMB_RELOC_BR22)
322 StubOpcode = 0xf000f8df; // ldr pc, [pc]
323 else
324 llvm_unreachable("Unrecognized relocation");
325 Addr = Section.getAddressWithOffset(OffsetBytes: Section.getStubOffset());
326 writeBytesUnaligned(Value: StubOpcode, Dst: Addr, Size: 4);
327 uint8_t *StubTargetAddr = Addr + 4;
328 RelocationEntry StubRE(
329 RE.SectionID, StubTargetAddr - Section.getAddress(),
330 MachO::GENERIC_RELOC_VANILLA, Value.Offset, false, 2);
331 StubRE.IsTargetThumbFunc = RE.IsTargetThumbFunc;
332 if (Value.SymbolName)
333 addRelocationForSymbol(RE: StubRE, SymbolName: Value.SymbolName);
334 else
335 addRelocationForSection(RE: StubRE, SectionID: Value.SectionID);
336 Section.advanceStubOffset(StubSize: getMaxStubSize());
337 }
338 RelocationEntry TargetRE(RE.SectionID, RE.Offset, RE.RelType, 0,
339 RE.IsPCRel, RE.Size);
340 resolveRelocation(RE: TargetRE, Value: (uint64_t)Addr);
341 }
342
343 Expected<relocation_iterator>
344 processHALFSECTDIFFRelocation(unsigned SectionID, relocation_iterator RelI,
345 const ObjectFile &BaseTObj,
346 ObjSectionToIDMap &ObjSectionToID) {
347 const MachOObjectFile &MachO =
348 static_cast<const MachOObjectFile&>(BaseTObj);
349 MachO::any_relocation_info RE =
350 MachO.getRelocation(Rel: RelI->getRawDataRefImpl());
351
352 // For a half-diff relocation the length bits actually record whether this
353 // is a movw/movt, and whether this is arm or thumb.
354 // Bit 0 indicates movw (b0 == 0) or movt (b0 == 1).
355 // Bit 1 indicates arm (b1 == 0) or thumb (b1 == 1).
356 unsigned HalfDiffKindBits = MachO.getAnyRelocationLength(RE);
357 bool IsThumb = HalfDiffKindBits & 0x2;
358
359 SectionEntry &Section = Sections[SectionID];
360 uint32_t RelocType = MachO.getAnyRelocationType(RE);
361 bool IsPCRel = MachO.getAnyRelocationPCRel(RE);
362 uint64_t Offset = RelI->getOffset();
363 uint8_t *LocalAddress = Section.getAddressWithOffset(OffsetBytes: Offset);
364 int64_t Immediate = readBytesUnaligned(Src: LocalAddress, Size: 4); // Copy the whole instruction out.
365
366 if (IsThumb)
367 Immediate = ((Immediate & 0x0000000f) << 12) |
368 ((Immediate & 0x00000400) << 1) |
369 ((Immediate & 0x70000000) >> 20) |
370 ((Immediate & 0x00ff0000) >> 16);
371 else
372 Immediate = ((Immediate >> 4) & 0xf000) | (Immediate & 0xfff);
373
374 ++RelI;
375 MachO::any_relocation_info RE2 =
376 MachO.getRelocation(Rel: RelI->getRawDataRefImpl());
377 uint32_t AddrA = MachO.getScatteredRelocationValue(RE);
378 section_iterator SAI = getSectionByAddress(Obj: MachO, Addr: AddrA);
379 assert(SAI != MachO.section_end() && "Can't find section for address A");
380 uint64_t SectionABase = SAI->getAddress();
381 uint64_t SectionAOffset = AddrA - SectionABase;
382 SectionRef SectionA = *SAI;
383 bool IsCode = SectionA.isText();
384 uint32_t SectionAID = ~0U;
385 if (auto SectionAIDOrErr =
386 findOrEmitSection(Obj: MachO, Section: SectionA, IsCode, LocalSections&: ObjSectionToID))
387 SectionAID = *SectionAIDOrErr;
388 else
389 return SectionAIDOrErr.takeError();
390
391 uint32_t AddrB = MachO.getScatteredRelocationValue(RE: RE2);
392 section_iterator SBI = getSectionByAddress(Obj: MachO, Addr: AddrB);
393 assert(SBI != MachO.section_end() && "Can't find section for address B");
394 uint64_t SectionBBase = SBI->getAddress();
395 uint64_t SectionBOffset = AddrB - SectionBBase;
396 SectionRef SectionB = *SBI;
397 uint32_t SectionBID = ~0U;
398 if (auto SectionBIDOrErr =
399 findOrEmitSection(Obj: MachO, Section: SectionB, IsCode, LocalSections&: ObjSectionToID))
400 SectionBID = *SectionBIDOrErr;
401 else
402 return SectionBIDOrErr.takeError();
403
404 uint32_t OtherHalf = MachO.getAnyRelocationAddress(RE: RE2) & 0xffff;
405 unsigned Shift = (HalfDiffKindBits & 0x1) ? 16 : 0;
406 uint32_t FullImmVal = (Immediate << Shift) | (OtherHalf << (16 - Shift));
407 int64_t Addend = FullImmVal - (AddrA - AddrB);
408
409 // addend = Encoded - Expected
410 // = Encoded - (AddrA - AddrB)
411
412 LLVM_DEBUG(dbgs() << "Found SECTDIFF: AddrA: " << AddrA
413 << ", AddrB: " << AddrB << ", Addend: " << Addend
414 << ", SectionA ID: " << SectionAID << ", SectionAOffset: "
415 << SectionAOffset << ", SectionB ID: " << SectionBID
416 << ", SectionBOffset: " << SectionBOffset << "\n");
417 RelocationEntry R(SectionID, Offset, RelocType, Addend, SectionAID,
418 SectionAOffset, SectionBID, SectionBOffset, IsPCRel,
419 HalfDiffKindBits);
420
421 addRelocationForSection(RE: R, SectionID: SectionAID);
422
423 return ++RelI;
424 }
425
426};
427}
428
429#undef DEBUG_TYPE
430
431#endif
432