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(SR);
37    if (!Flags)
38      return Flags.takeError();
39    Flags->getTargetFlags() = ARMJITSymbolFlags::fromObjectSymbol(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(RE.Offset);
65
66    switch (RE.RelType) {
67      default:
68        return memcpyAddend(RE);
69      case MachO::ARM_RELOC_BR24: {
70        uint32_t Temp = readBytesUnaligned(LocalAddress, 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>(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(LocalAddress, 2);
82        if ((HighInsn & 0xf800) != 0xf000)
83          return make_error<StringError>("Unrecognized thumb branch encoding "
84                                         "(BR22 high bits)",
85                                         inconvertibleErrorCode());
86
87        uint16_t LowInsn = readBytesUnaligned(LocalAddress + 2, 2);
88        if ((LowInsn & 0xf800) != 0xf800)
89          return make_error<StringError>("Unrecognized thumb branch encoding "
90                                         "(BR22 low bits)",
91                                         inconvertibleErrorCode());
92
93        return SignExtend64<23>(((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(RelI->getRawDataRefImpl());
108    uint32_t RelType = Obj.getAnyRelocationType(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(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(TargetName);
125      if (EntryItr != GlobalSymbolTable.end()) {
126        TargetIsLocalThumbFunc =
127          EntryItr->second.getFlags().getTargetFlags() &
128          ARMJITSymbolFlags::Thumb;
129      }
130    }
131
132    if (Obj.isRelocationScattered(RelInfo)) {
133      if (RelType == MachO::ARM_RELOC_HALF_SECTDIFF)
134        return processHALFSECTDIFFRelocation(SectionID, RelI, Obj,
135                                             ObjSectionToID);
136      else if (RelType == MachO::GENERIC_RELOC_VANILLA)
137        return processScatteredVANILLA(SectionID, RelI, 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>(("MachO ARM relocation type " +
154                                             Twine(RelType) +
155                                             " is out of range").str());
156      break;
157    }
158
159    RelocationEntry RE(getRelocationEntry(SectionID, Obj, 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(Obj, 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, RelI,
180                           (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(Value.SectionID, 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, Value.SymbolName);
195      else
196        addRelocationForSection(RE, 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(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(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(LocalAddress, 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(LocalAddress + 2, 2);
226      assert((LowInsn & 0xf800) == 0xf800 &&
227             "Unrecognized thumb branch encoding (BR22 low bits)");
228      LowInsn = (LowInsn & 0xf800) | ((Value >> 1) & 0x7ff);
229
230      writeBytesUnaligned(HighInsn, LocalAddress, 2);
231      writeBytesUnaligned(LowInsn, LocalAddress + 2, 2);
232      break;
233    }
234
235    case MachO::ARM_RELOC_VANILLA:
236      if (RE.IsTargetThumbFunc)
237        Value |= 0x01;
238      writeBytesUnaligned(Value + RE.Addend, LocalAddress, 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(LocalAddress, 4);
254      writeBytesUnaligned((Temp & ~0xffffff) | FinalValue, LocalAddress, 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(LocalAddress, 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(Insn, LocalAddress, 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(NameOrErr.takeError());
295
296    if (Name == "__nl_symbol_ptr")
297      return populateIndirectSymbolPointersSection(cast<MachOObjectFile>(Obj),
298                                                   Section, 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(Value);
311    uint8_t *Addr;
312    if (i != Stubs.end()) {
313      Addr = Section.getAddressWithOffset(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(Section.getStubOffset());
326      writeBytesUnaligned(StubOpcode, Addr, 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(StubRE, Value.SymbolName);
334      else
335        addRelocationForSection(StubRE, Value.SectionID);
336      Section.advanceStubOffset(getMaxStubSize());
337    }
338    RelocationEntry TargetRE(RE.SectionID, RE.Offset, RE.RelType, 0,
339                             RE.IsPCRel, RE.Size);
340    resolveRelocation(TargetRE, (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(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(Offset);
364    int64_t Immediate = readBytesUnaligned(LocalAddress, 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(RelI->getRawDataRefImpl());
377    uint32_t AddrA = MachO.getScatteredRelocationValue(RE);
378    section_iterator SAI = getSectionByAddress(MachO, 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(MachO, SectionA, IsCode, ObjSectionToID))
387      SectionAID = *SectionAIDOrErr;
388    else
389      return SectionAIDOrErr.takeError();
390
391    uint32_t AddrB = MachO.getScatteredRelocationValue(RE2);
392    section_iterator SBI = getSectionByAddress(MachO, 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(MachO, SectionB, IsCode, ObjSectionToID))
400      SectionBID = *SectionBIDOrErr;
401    else
402      return SectionBIDOrErr.takeError();
403
404    uint32_t OtherHalf = MachO.getAnyRelocationAddress(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(R, SectionAID);
422
423    return ++RelI;
424  }
425
426};
427}
428
429#undef DEBUG_TYPE
430
431#endif
432