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