1//===---- RuntimeDyldMachOI386.h ---- MachO/I386 specific code. ---*- C++ -*-=//
2//
3//                     The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9
10#ifndef LLVM_LIB_EXECUTIONENGINE_RUNTIMEDYLD_TARGETS_RUNTIMEDYLDMACHOI386_H
11#define LLVM_LIB_EXECUTIONENGINE_RUNTIMEDYLD_TARGETS_RUNTIMEDYLDMACHOI386_H
12
13#include "../RuntimeDyldMachO.h"
14
15#define DEBUG_TYPE "dyld"
16
17namespace llvm {
18
19class RuntimeDyldMachOI386
20    : public RuntimeDyldMachOCRTPBase<RuntimeDyldMachOI386> {
21public:
22
23  typedef uint32_t TargetPtrT;
24
25  RuntimeDyldMachOI386(RuntimeDyld::MemoryManager &MM,
26                       RuntimeDyld::SymbolResolver &Resolver)
27      : RuntimeDyldMachOCRTPBase(MM, Resolver) {}
28
29  unsigned getMaxStubSize() override { return 0; }
30
31  unsigned getStubAlignment() override { return 1; }
32
33  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 (Obj.isRelocationScattered(RelInfo)) {
45      if (RelType == MachO::GENERIC_RELOC_SECTDIFF ||
46          RelType == MachO::GENERIC_RELOC_LOCAL_SECTDIFF)
47        return processSECTDIFFRelocation(SectionID, RelI, Obj,
48                                         ObjSectionToID);
49      else if (RelType == MachO::GENERIC_RELOC_VANILLA)
50        return processScatteredVANILLA(SectionID, RelI, Obj, ObjSectionToID);
51      llvm_unreachable("Unhandled scattered relocation.");
52    }
53
54    RelocationEntry RE(getRelocationEntry(SectionID, Obj, RelI));
55    RE.Addend = memcpyAddend(RE);
56    RelocationValueRef Value(
57        getRelocationValueRef(Obj, RelI, RE, ObjSectionToID));
58
59    // Addends for external, PC-rel relocations on i386 point back to the zero
60    // offset. Calculate the final offset from the relocation target instead.
61    // This allows us to use the same logic for both external and internal
62    // relocations in resolveI386RelocationRef.
63    // bool IsExtern = Obj.getPlainRelocationExternal(RelInfo);
64    // if (IsExtern && RE.IsPCRel) {
65    //   uint64_t RelocAddr = 0;
66    //   RelI->getAddress(RelocAddr);
67    //   Value.Addend += RelocAddr + 4;
68    // }
69    if (RE.IsPCRel)
70      makeValueAddendPCRel(Value, RelI, 1 << RE.Size);
71
72    RE.Addend = Value.Offset;
73
74    if (Value.SymbolName)
75      addRelocationForSymbol(RE, Value.SymbolName);
76    else
77      addRelocationForSection(RE, Value.SectionID);
78
79    return ++RelI;
80  }
81
82  void resolveRelocation(const RelocationEntry &RE, uint64_t Value) override {
83    DEBUG(dumpRelocationToResolve(RE, Value));
84
85    const SectionEntry &Section = Sections[RE.SectionID];
86    uint8_t *LocalAddress = Section.getAddressWithOffset(RE.Offset);
87
88    if (RE.IsPCRel) {
89      uint64_t FinalAddress = Section.getLoadAddressWithOffset(RE.Offset);
90      Value -= FinalAddress + 4; // see MachOX86_64::resolveRelocation.
91    }
92
93    switch (RE.RelType) {
94    default:
95      llvm_unreachable("Invalid relocation type!");
96    case MachO::GENERIC_RELOC_VANILLA:
97      writeBytesUnaligned(Value + RE.Addend, LocalAddress, 1 << RE.Size);
98      break;
99    case MachO::GENERIC_RELOC_SECTDIFF:
100    case MachO::GENERIC_RELOC_LOCAL_SECTDIFF: {
101      uint64_t SectionABase = Sections[RE.Sections.SectionA].getLoadAddress();
102      uint64_t SectionBBase = Sections[RE.Sections.SectionB].getLoadAddress();
103      assert((Value == SectionABase || Value == SectionBBase) &&
104             "Unexpected SECTDIFF relocation value.");
105      Value = SectionABase - SectionBBase + RE.Addend;
106      writeBytesUnaligned(Value, LocalAddress, 1 << RE.Size);
107      break;
108    }
109    case MachO::GENERIC_RELOC_PB_LA_PTR:
110      Error("Relocation type not implemented yet!");
111    }
112  }
113
114  void finalizeSection(const ObjectFile &Obj, unsigned SectionID,
115                       const SectionRef &Section) {
116    StringRef Name;
117    Section.getName(Name);
118
119    if (Name == "__jump_table")
120      populateJumpTable(cast<MachOObjectFile>(Obj), Section, SectionID);
121    else if (Name == "__pointers")
122      populateIndirectSymbolPointersSection(cast<MachOObjectFile>(Obj),
123                                            Section, SectionID);
124  }
125
126private:
127  relocation_iterator
128  processSECTDIFFRelocation(unsigned SectionID, relocation_iterator RelI,
129                            const ObjectFile &BaseObjT,
130                            ObjSectionToIDMap &ObjSectionToID) {
131    const MachOObjectFile &Obj =
132        static_cast<const MachOObjectFile&>(BaseObjT);
133    MachO::any_relocation_info RE =
134        Obj.getRelocation(RelI->getRawDataRefImpl());
135
136    SectionEntry &Section = Sections[SectionID];
137    uint32_t RelocType = Obj.getAnyRelocationType(RE);
138    bool IsPCRel = Obj.getAnyRelocationPCRel(RE);
139    unsigned Size = Obj.getAnyRelocationLength(RE);
140    uint64_t Offset = RelI->getOffset();
141    uint8_t *LocalAddress = Section.getAddressWithOffset(Offset);
142    unsigned NumBytes = 1 << Size;
143    uint64_t Addend = readBytesUnaligned(LocalAddress, NumBytes);
144
145    ++RelI;
146    MachO::any_relocation_info RE2 =
147        Obj.getRelocation(RelI->getRawDataRefImpl());
148
149    uint32_t AddrA = Obj.getScatteredRelocationValue(RE);
150    section_iterator SAI = getSectionByAddress(Obj, AddrA);
151    assert(SAI != Obj.section_end() && "Can't find section for address A");
152    uint64_t SectionABase = SAI->getAddress();
153    uint64_t SectionAOffset = AddrA - SectionABase;
154    SectionRef SectionA = *SAI;
155    bool IsCode = SectionA.isText();
156    uint32_t SectionAID =
157        findOrEmitSection(Obj, SectionA, IsCode, ObjSectionToID);
158
159    uint32_t AddrB = Obj.getScatteredRelocationValue(RE2);
160    section_iterator SBI = getSectionByAddress(Obj, AddrB);
161    assert(SBI != Obj.section_end() && "Can't find section for address B");
162    uint64_t SectionBBase = SBI->getAddress();
163    uint64_t SectionBOffset = AddrB - SectionBBase;
164    SectionRef SectionB = *SBI;
165    uint32_t SectionBID =
166        findOrEmitSection(Obj, SectionB, IsCode, ObjSectionToID);
167
168    // Compute the addend 'C' from the original expression 'A - B + C'.
169    Addend -= AddrA - AddrB;
170
171    DEBUG(dbgs() << "Found SECTDIFF: AddrA: " << AddrA << ", AddrB: " << AddrB
172                 << ", Addend: " << Addend << ", SectionA ID: " << SectionAID
173                 << ", SectionAOffset: " << SectionAOffset
174                 << ", SectionB ID: " << SectionBID
175                 << ", SectionBOffset: " << SectionBOffset << "\n");
176    RelocationEntry R(SectionID, Offset, RelocType, Addend, SectionAID,
177                      SectionAOffset, SectionBID, SectionBOffset,
178                      IsPCRel, Size);
179
180    addRelocationForSection(R, SectionAID);
181
182    return ++RelI;
183  }
184
185  // Populate stubs in __jump_table section.
186  void populateJumpTable(const MachOObjectFile &Obj, const SectionRef &JTSection,
187                         unsigned JTSectionID) {
188    assert(!Obj.is64Bit() &&
189           "__jump_table section not supported in 64-bit MachO.");
190
191    MachO::dysymtab_command DySymTabCmd = Obj.getDysymtabLoadCommand();
192    MachO::section Sec32 = Obj.getSection(JTSection.getRawDataRefImpl());
193    uint32_t JTSectionSize = Sec32.size;
194    unsigned FirstIndirectSymbol = Sec32.reserved1;
195    unsigned JTEntrySize = Sec32.reserved2;
196    unsigned NumJTEntries = JTSectionSize / JTEntrySize;
197    uint8_t *JTSectionAddr = getSectionAddress(JTSectionID);
198    unsigned JTEntryOffset = 0;
199
200    assert((JTSectionSize % JTEntrySize) == 0 &&
201           "Jump-table section does not contain a whole number of stubs?");
202
203    for (unsigned i = 0; i < NumJTEntries; ++i) {
204      unsigned SymbolIndex =
205          Obj.getIndirectSymbolTableEntry(DySymTabCmd, FirstIndirectSymbol + i);
206      symbol_iterator SI = Obj.getSymbolByIndex(SymbolIndex);
207      ErrorOr<StringRef> IndirectSymbolName = SI->getName();
208      if (std::error_code EC = IndirectSymbolName.getError())
209        report_fatal_error(EC.message());
210      uint8_t *JTEntryAddr = JTSectionAddr + JTEntryOffset;
211      createStubFunction(JTEntryAddr);
212      RelocationEntry RE(JTSectionID, JTEntryOffset + 1,
213                         MachO::GENERIC_RELOC_VANILLA, 0, true, 2);
214      addRelocationForSymbol(RE, *IndirectSymbolName);
215      JTEntryOffset += JTEntrySize;
216    }
217  }
218
219};
220}
221
222#undef DEBUG_TYPE
223
224#endif
225