1//===-- RuntimeDyldMachOX86_64.h ---- MachO/X86_64 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_RUNTIMEDYLDMACHOX86_64_H
10#define LLVM_LIB_EXECUTIONENGINE_RUNTIMEDYLD_TARGETS_RUNTIMEDYLDMACHOX86_64_H
11
12#include "../RuntimeDyldMachO.h"
13#include <string>
14
15#define DEBUG_TYPE "dyld"
16
17namespace llvm {
18
19class RuntimeDyldMachOX86_64
20    : public RuntimeDyldMachOCRTPBase<RuntimeDyldMachOX86_64> {
21public:
22
23  typedef uint64_t TargetPtrT;
24
25  RuntimeDyldMachOX86_64(RuntimeDyld::MemoryManager &MM,
26                         JITSymbolResolver &Resolver)
27      : RuntimeDyldMachOCRTPBase(MM, Resolver) {}
28
29  unsigned getMaxStubSize() const override { return 8; }
30
31  unsigned getStubAlignment() override { return 8; }
32
33  Expected<relocation_iterator>
34  processRelocationRef(unsigned SectionID, relocation_iterator RelI,
35                       const ObjectFile &BaseObjT,
36                       ObjSectionToIDMap &ObjSectionToID,
37                       StubMap &Stubs) override {
38    const MachOObjectFile &Obj =
39      static_cast<const MachOObjectFile &>(BaseObjT);
40    MachO::any_relocation_info RelInfo =
41        Obj.getRelocation(RelI->getRawDataRefImpl());
42    uint32_t RelType = Obj.getAnyRelocationType(RelInfo);
43
44    if (RelType == MachO::X86_64_RELOC_SUBTRACTOR)
45      return processSubtractRelocation(SectionID, RelI, Obj, ObjSectionToID);
46
47    assert(!Obj.isRelocationScattered(RelInfo) &&
48           "Scattered relocations not supported on X86_64");
49
50    RelocationEntry RE(getRelocationEntry(SectionID, Obj, RelI));
51    RE.Addend = memcpyAddend(RE);
52    RelocationValueRef Value;
53    if (auto ValueOrErr = getRelocationValueRef(Obj, RelI, RE, ObjSectionToID))
54      Value = *ValueOrErr;
55    else
56      return ValueOrErr.takeError();
57
58    bool IsExtern = Obj.getPlainRelocationExternal(RelInfo);
59    if (!IsExtern && RE.IsPCRel)
60      makeValueAddendPCRel(Value, RelI, 1 << RE.Size);
61
62    switch (RelType) {
63    UNIMPLEMENTED_RELOC(MachO::X86_64_RELOC_TLV);
64    default:
65      if (RelType > MachO::X86_64_RELOC_TLV)
66        return make_error<RuntimeDyldError>(("MachO X86_64 relocation type " +
67                                             Twine(RelType) +
68                                             " is out of range").str());
69      break;
70    }
71
72    if (RE.RelType == MachO::X86_64_RELOC_GOT ||
73        RE.RelType == MachO::X86_64_RELOC_GOT_LOAD)
74      processGOTRelocation(RE, Value, Stubs);
75    else {
76      RE.Addend = Value.Offset;
77      if (Value.SymbolName)
78        addRelocationForSymbol(RE, Value.SymbolName);
79      else
80        addRelocationForSection(RE, Value.SectionID);
81    }
82
83    return ++RelI;
84  }
85
86  void resolveRelocation(const RelocationEntry &RE, uint64_t Value) override {
87    LLVM_DEBUG(dumpRelocationToResolve(RE, Value));
88    const SectionEntry &Section = Sections[RE.SectionID];
89    uint8_t *LocalAddress = Section.getAddressWithOffset(RE.Offset);
90
91    // If the relocation is PC-relative, the value to be encoded is the
92    // pointer difference.
93    if (RE.IsPCRel) {
94      // FIXME: It seems this value needs to be adjusted by 4 for an effective
95      // PC address. Is that expected? Only for branches, perhaps?
96      uint64_t FinalAddress = Section.getLoadAddressWithOffset(RE.Offset);
97      Value -= FinalAddress + 4;
98    }
99
100    switch (RE.RelType) {
101    default:
102      llvm_unreachable("Invalid relocation type!");
103    case MachO::X86_64_RELOC_SIGNED_1:
104    case MachO::X86_64_RELOC_SIGNED_2:
105    case MachO::X86_64_RELOC_SIGNED_4:
106    case MachO::X86_64_RELOC_SIGNED:
107    case MachO::X86_64_RELOC_UNSIGNED:
108    case MachO::X86_64_RELOC_BRANCH:
109      writeBytesUnaligned(Value + RE.Addend, LocalAddress, 1 << RE.Size);
110      break;
111    case MachO::X86_64_RELOC_SUBTRACTOR: {
112      uint64_t SectionABase = Sections[RE.Sections.SectionA].getLoadAddress();
113      uint64_t SectionBBase = Sections[RE.Sections.SectionB].getLoadAddress();
114      assert((Value == SectionABase || Value == SectionBBase) &&
115             "Unexpected SUBTRACTOR relocation value.");
116      Value = SectionABase - SectionBBase + RE.Addend;
117      writeBytesUnaligned(Value, LocalAddress, 1 << RE.Size);
118      break;
119    }
120    }
121  }
122
123  Error finalizeSection(const ObjectFile &Obj, unsigned SectionID,
124                        const SectionRef &Section) {
125    return Error::success();
126  }
127
128private:
129  void processGOTRelocation(const RelocationEntry &RE,
130                            RelocationValueRef &Value, StubMap &Stubs) {
131    SectionEntry &Section = Sections[RE.SectionID];
132    assert(RE.IsPCRel);
133    assert(RE.Size == 2);
134    Value.Offset -= RE.Addend;
135    RuntimeDyldMachO::StubMap::const_iterator i = Stubs.find(Value);
136    uint8_t *Addr;
137    if (i != Stubs.end()) {
138      Addr = Section.getAddressWithOffset(i->second);
139    } else {
140      Stubs[Value] = Section.getStubOffset();
141      uint8_t *GOTEntry = Section.getAddressWithOffset(Section.getStubOffset());
142      RelocationEntry GOTRE(RE.SectionID, Section.getStubOffset(),
143                            MachO::X86_64_RELOC_UNSIGNED, Value.Offset, false,
144                            3);
145      if (Value.SymbolName)
146        addRelocationForSymbol(GOTRE, Value.SymbolName);
147      else
148        addRelocationForSection(GOTRE, Value.SectionID);
149      Section.advanceStubOffset(8);
150      Addr = GOTEntry;
151    }
152    RelocationEntry TargetRE(RE.SectionID, RE.Offset,
153                             MachO::X86_64_RELOC_UNSIGNED, RE.Addend, true, 2);
154    resolveRelocation(TargetRE, (uint64_t)Addr);
155  }
156
157  Expected<relocation_iterator>
158  processSubtractRelocation(unsigned SectionID, relocation_iterator RelI,
159                            const MachOObjectFile &BaseObj,
160                            ObjSectionToIDMap &ObjSectionToID) {
161    const MachOObjectFile &Obj =
162        static_cast<const MachOObjectFile&>(BaseObj);
163    MachO::any_relocation_info RE =
164        Obj.getRelocation(RelI->getRawDataRefImpl());
165
166    unsigned Size = Obj.getAnyRelocationLength(RE);
167    uint64_t Offset = RelI->getOffset();
168    uint8_t *LocalAddress = Sections[SectionID].getAddressWithOffset(Offset);
169    unsigned NumBytes = 1 << Size;
170    int64_t Addend =
171      SignExtend64(readBytesUnaligned(LocalAddress, NumBytes), NumBytes * 8);
172
173    unsigned SectionBID = ~0U;
174    uint64_t SectionBOffset = 0;
175
176    MachO::any_relocation_info RelInfo =
177      Obj.getRelocation(RelI->getRawDataRefImpl());
178
179    bool AIsExternal = BaseObj.getPlainRelocationExternal(RelInfo);
180
181    if (AIsExternal) {
182      Expected<StringRef> SubtrahendNameOrErr = RelI->getSymbol()->getName();
183      if (!SubtrahendNameOrErr)
184        return SubtrahendNameOrErr.takeError();
185      auto SubtrahendI = GlobalSymbolTable.find(*SubtrahendNameOrErr);
186      SectionBID = SubtrahendI->second.getSectionID();
187      SectionBOffset = SubtrahendI->second.getOffset();
188    } else {
189      SectionRef SecB = Obj.getAnyRelocationSection(RelInfo);
190      bool IsCode = SecB.isText();
191      Expected<unsigned> SectionBIDOrErr =
192        findOrEmitSection(Obj, SecB, IsCode, ObjSectionToID);
193      if (!SectionBIDOrErr)
194        return SectionBIDOrErr.takeError();
195      SectionBID = *SectionBIDOrErr;
196      Addend += SecB.getAddress();
197    }
198
199    ++RelI;
200
201    unsigned SectionAID = ~0U;
202    uint64_t SectionAOffset = 0;
203
204    RelInfo = Obj.getRelocation(RelI->getRawDataRefImpl());
205
206    bool BIsExternal = BaseObj.getPlainRelocationExternal(RelInfo);
207    if (BIsExternal) {
208      Expected<StringRef> MinuendNameOrErr = RelI->getSymbol()->getName();
209      if (!MinuendNameOrErr)
210        return MinuendNameOrErr.takeError();
211      auto MinuendI = GlobalSymbolTable.find(*MinuendNameOrErr);
212      SectionAID = MinuendI->second.getSectionID();
213      SectionAOffset = MinuendI->second.getOffset();
214    } else {
215      SectionRef SecA = Obj.getAnyRelocationSection(RelInfo);
216      bool IsCode = SecA.isText();
217      Expected<unsigned> SectionAIDOrErr =
218        findOrEmitSection(Obj, SecA, IsCode, ObjSectionToID);
219      if (!SectionAIDOrErr)
220        return SectionAIDOrErr.takeError();
221      SectionAID = *SectionAIDOrErr;
222      Addend -= SecA.getAddress();
223    }
224
225    RelocationEntry R(SectionID, Offset, MachO::X86_64_RELOC_SUBTRACTOR, (uint64_t)Addend,
226                      SectionAID, SectionAOffset, SectionBID, SectionBOffset,
227                      false, Size);
228
229    addRelocationForSection(R, SectionAID);
230
231    return ++RelI;
232  }
233
234};
235}
236
237#undef DEBUG_TYPE
238
239#endif
240