[RuntimeDyld] Fix MachO i386 SECTDIFF relocation to support non-zero addends.
[oota-llvm.git] / lib / ExecutionEngine / RuntimeDyld / Targets / RuntimeDyldMachOI386.h
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
17 namespace llvm {
18
19 class RuntimeDyldMachOI386
20     : public RuntimeDyldMachOCRTPBase<RuntimeDyldMachOI386> {
21 public:
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 processI386ScatteredVANILLA(SectionID, RelI, Obj,
51                                            ObjSectionToID);
52       llvm_unreachable("Unhandled scattered relocation.");
53     }
54
55     RelocationEntry RE(getRelocationEntry(SectionID, Obj, RelI));
56     RE.Addend = memcpyAddend(RE);
57     RelocationValueRef Value(
58         getRelocationValueRef(Obj, RelI, RE, ObjSectionToID));
59
60     // Addends for external, PC-rel relocations on i386 point back to the zero
61     // offset. Calculate the final offset from the relocation target instead.
62     // This allows us to use the same logic for both external and internal
63     // relocations in resolveI386RelocationRef.
64     // bool IsExtern = Obj.getPlainRelocationExternal(RelInfo);
65     // if (IsExtern && RE.IsPCRel) {
66     //   uint64_t RelocAddr = 0;
67     //   RelI->getAddress(RelocAddr);
68     //   Value.Addend += RelocAddr + 4;
69     // }
70     if (RE.IsPCRel)
71       makeValueAddendPCRel(Value, Obj, RelI, 1 << RE.Size);
72
73     RE.Addend = Value.Offset;
74
75     if (Value.SymbolName)
76       addRelocationForSymbol(RE, Value.SymbolName);
77     else
78       addRelocationForSection(RE, Value.SectionID);
79
80     return ++RelI;
81   }
82
83   void resolveRelocation(const RelocationEntry &RE, uint64_t Value) override {
84     DEBUG(dumpRelocationToResolve(RE, Value));
85
86     const SectionEntry &Section = Sections[RE.SectionID];
87     uint8_t *LocalAddress = Section.Address + RE.Offset;
88
89     if (RE.IsPCRel) {
90       uint64_t FinalAddress = Section.LoadAddress + RE.Offset;
91       Value -= FinalAddress + 4; // see MachOX86_64::resolveRelocation.
92     }
93
94     switch (RE.RelType) {
95     default:
96       llvm_unreachable("Invalid relocation type!");
97     case MachO::GENERIC_RELOC_VANILLA:
98       writeBytesUnaligned(Value + RE.Addend, LocalAddress, 1 << RE.Size);
99       break;
100     case MachO::GENERIC_RELOC_SECTDIFF:
101     case MachO::GENERIC_RELOC_LOCAL_SECTDIFF: {
102       uint64_t SectionABase = Sections[RE.Sections.SectionA].LoadAddress;
103       uint64_t SectionBBase = Sections[RE.Sections.SectionB].LoadAddress;
104       assert((Value == SectionABase || Value == SectionBBase) &&
105              "Unexpected SECTDIFF relocation value.");
106       Value = SectionABase - SectionBBase + RE.Addend;
107       writeBytesUnaligned(Value, LocalAddress, 1 << RE.Size);
108       break;
109     }
110     case MachO::GENERIC_RELOC_PB_LA_PTR:
111       Error("Relocation type not implemented yet!");
112     }
113   }
114
115   void finalizeSection(const ObjectFile &Obj, unsigned SectionID,
116                        const SectionRef &Section) {
117     StringRef Name;
118     Section.getName(Name);
119
120     if (Name == "__jump_table")
121       populateJumpTable(cast<MachOObjectFile>(Obj), Section, SectionID);
122     else if (Name == "__pointers")
123       populateIndirectSymbolPointersSection(cast<MachOObjectFile>(Obj),
124                                             Section, SectionID);
125   }
126
127 private:
128   relocation_iterator
129   processSECTDIFFRelocation(unsigned SectionID, relocation_iterator RelI,
130                             const ObjectFile &BaseObjT,
131                             ObjSectionToIDMap &ObjSectionToID) {
132     const MachOObjectFile &Obj =
133         static_cast<const MachOObjectFile&>(BaseObjT);
134     MachO::any_relocation_info RE =
135         Obj.getRelocation(RelI->getRawDataRefImpl());
136
137     SectionEntry &Section = Sections[SectionID];
138     uint32_t RelocType = Obj.getAnyRelocationType(RE);
139     bool IsPCRel = Obj.getAnyRelocationPCRel(RE);
140     unsigned Size = Obj.getAnyRelocationLength(RE);
141     uint64_t Offset;
142     RelI->getOffset(Offset);
143     uint8_t *LocalAddress = Section.Address + Offset;
144     unsigned NumBytes = 1 << Size;
145     uint64_t Addend = readBytesUnaligned(LocalAddress, NumBytes);
146
147     ++RelI;
148     MachO::any_relocation_info RE2 =
149         Obj.getRelocation(RelI->getRawDataRefImpl());
150
151     uint32_t AddrA = Obj.getScatteredRelocationValue(RE);
152     section_iterator SAI = getSectionByAddress(Obj, AddrA);
153     assert(SAI != Obj.section_end() && "Can't find section for address A");
154     uint64_t SectionABase = SAI->getAddress();
155     uint64_t SectionAOffset = AddrA - SectionABase;
156     SectionRef SectionA = *SAI;
157     bool IsCode = SectionA.isText();
158     uint32_t SectionAID =
159         findOrEmitSection(Obj, SectionA, IsCode, ObjSectionToID);
160
161     uint32_t AddrB = Obj.getScatteredRelocationValue(RE2);
162     section_iterator SBI = getSectionByAddress(Obj, AddrB);
163     assert(SBI != Obj.section_end() && "Can't find section for address B");
164     uint64_t SectionBBase = SBI->getAddress();
165     uint64_t SectionBOffset = AddrB - SectionBBase;
166     SectionRef SectionB = *SBI;
167     uint32_t SectionBID =
168         findOrEmitSection(Obj, SectionB, IsCode, ObjSectionToID);
169
170     // Compute the addend 'C' from the original expression 'A - B + C'.
171     Addend -= AddrA - AddrB;
172
173     DEBUG(dbgs() << "Found SECTDIFF: AddrA: " << AddrA << ", AddrB: " << AddrB
174                  << ", Addend: " << Addend << ", SectionA ID: " << SectionAID
175                  << ", SectionAOffset: " << SectionAOffset
176                  << ", SectionB ID: " << SectionBID
177                  << ", SectionBOffset: " << SectionBOffset << "\n");
178     RelocationEntry R(SectionID, Offset, RelocType, Addend, SectionAID,
179                       SectionAOffset, SectionBID, SectionBOffset,
180                       IsPCRel, Size);
181
182     addRelocationForSection(R, SectionAID);
183
184     return ++RelI;
185   }
186
187   relocation_iterator processI386ScatteredVANILLA(
188       unsigned SectionID, relocation_iterator RelI,
189       const ObjectFile &BaseObjT,
190       RuntimeDyldMachO::ObjSectionToIDMap &ObjSectionToID) {
191     const MachOObjectFile &Obj =
192         static_cast<const MachOObjectFile&>(BaseObjT);
193     MachO::any_relocation_info RE =
194         Obj.getRelocation(RelI->getRawDataRefImpl());
195
196     SectionEntry &Section = Sections[SectionID];
197     uint32_t RelocType = Obj.getAnyRelocationType(RE);
198     bool IsPCRel = Obj.getAnyRelocationPCRel(RE);
199     unsigned Size = Obj.getAnyRelocationLength(RE);
200     uint64_t Offset;
201     RelI->getOffset(Offset);
202     uint8_t *LocalAddress = Section.Address + Offset;
203     unsigned NumBytes = 1 << Size;
204     int64_t Addend = readBytesUnaligned(LocalAddress, NumBytes);
205
206     unsigned SymbolBaseAddr = Obj.getScatteredRelocationValue(RE);
207     section_iterator TargetSI = getSectionByAddress(Obj, SymbolBaseAddr);
208     assert(TargetSI != Obj.section_end() && "Can't find section for symbol");
209     uint64_t SectionBaseAddr = TargetSI->getAddress();
210     SectionRef TargetSection = *TargetSI;
211     bool IsCode = TargetSection.isText();
212     uint32_t TargetSectionID =
213         findOrEmitSection(Obj, TargetSection, IsCode, ObjSectionToID);
214
215     Addend -= SectionBaseAddr;
216     RelocationEntry R(SectionID, Offset, RelocType, Addend, IsPCRel, Size);
217
218     addRelocationForSection(R, TargetSectionID);
219
220     return ++RelI;
221   }
222
223   // Populate stubs in __jump_table section.
224   void populateJumpTable(const MachOObjectFile &Obj, const SectionRef &JTSection,
225                          unsigned JTSectionID) {
226     assert(!Obj.is64Bit() &&
227            "__jump_table section not supported in 64-bit MachO.");
228
229     MachO::dysymtab_command DySymTabCmd = Obj.getDysymtabLoadCommand();
230     MachO::section Sec32 = Obj.getSection(JTSection.getRawDataRefImpl());
231     uint32_t JTSectionSize = Sec32.size;
232     unsigned FirstIndirectSymbol = Sec32.reserved1;
233     unsigned JTEntrySize = Sec32.reserved2;
234     unsigned NumJTEntries = JTSectionSize / JTEntrySize;
235     uint8_t *JTSectionAddr = getSectionAddress(JTSectionID);
236     unsigned JTEntryOffset = 0;
237
238     assert((JTSectionSize % JTEntrySize) == 0 &&
239            "Jump-table section does not contain a whole number of stubs?");
240
241     for (unsigned i = 0; i < NumJTEntries; ++i) {
242       unsigned SymbolIndex =
243           Obj.getIndirectSymbolTableEntry(DySymTabCmd, FirstIndirectSymbol + i);
244       symbol_iterator SI = Obj.getSymbolByIndex(SymbolIndex);
245       StringRef IndirectSymbolName;
246       SI->getName(IndirectSymbolName);
247       uint8_t *JTEntryAddr = JTSectionAddr + JTEntryOffset;
248       createStubFunction(JTEntryAddr);
249       RelocationEntry RE(JTSectionID, JTEntryOffset + 1,
250                          MachO::GENERIC_RELOC_VANILLA, 0, true, 2);
251       addRelocationForSymbol(RE, IndirectSymbolName);
252       JTEntryOffset += JTEntrySize;
253     }
254   }
255
256 };
257 }
258
259 #undef DEBUG_TYPE
260
261 #endif