1 //===---- RuntimeDyldMachOI386.h ---- MachO/I386 specific code. ---*- C++ -*-=//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 #ifndef LLVM_LIB_EXECUTIONENGINE_RUNTIMEDYLD_TARGETS_RUNTIMEDYLDMACHOI386_H
11 #define LLVM_LIB_EXECUTIONENGINE_RUNTIMEDYLD_TARGETS_RUNTIMEDYLDMACHOI386_H
13 #include "../RuntimeDyldMachO.h"
15 #define DEBUG_TYPE "dyld"
19 class RuntimeDyldMachOI386
20 : public RuntimeDyldMachOCRTPBase<RuntimeDyldMachOI386> {
23 typedef uint32_t TargetPtrT;
25 RuntimeDyldMachOI386(RTDyldMemoryManager *MM)
26 : RuntimeDyldMachOCRTPBase(MM) {}
28 unsigned getMaxStubSize() override { return 0; }
30 unsigned getStubAlignment() override { return 1; }
33 processRelocationRef(unsigned SectionID, relocation_iterator RelI,
34 ObjectImage &ObjImg, ObjSectionToIDMap &ObjSectionToID,
35 const SymbolTableMap &Symbols, StubMap &Stubs) override {
36 const MachOObjectFile &Obj =
37 static_cast<const MachOObjectFile &>(*ObjImg.getObjectFile());
38 MachO::any_relocation_info RelInfo =
39 Obj.getRelocation(RelI->getRawDataRefImpl());
40 uint32_t RelType = Obj.getAnyRelocationType(RelInfo);
42 if (Obj.isRelocationScattered(RelInfo)) {
43 if (RelType == MachO::GENERIC_RELOC_SECTDIFF ||
44 RelType == MachO::GENERIC_RELOC_LOCAL_SECTDIFF)
45 return processSECTDIFFRelocation(SectionID, RelI, ObjImg,
47 else if (Arch == Triple::x86 && RelType == MachO::GENERIC_RELOC_VANILLA)
48 return processI386ScatteredVANILLA(SectionID, RelI, ObjImg,
50 llvm_unreachable("Unhandled scattered relocation.");
53 RelocationEntry RE(getRelocationEntry(SectionID, ObjImg, RelI));
54 RE.Addend = memcpyAddend(RE);
55 RelocationValueRef Value(
56 getRelocationValueRef(ObjImg, RelI, RE, ObjSectionToID, Symbols));
58 // Addends for external, PC-rel relocations on i386 point back to the zero
59 // offset. Calculate the final offset from the relocation target instead.
60 // This allows us to use the same logic for both external and internal
61 // relocations in resolveI386RelocationRef.
62 // bool IsExtern = Obj.getPlainRelocationExternal(RelInfo);
63 // if (IsExtern && RE.IsPCRel) {
64 // uint64_t RelocAddr = 0;
65 // RelI->getAddress(RelocAddr);
66 // Value.Addend += RelocAddr + 4;
69 makeValueAddendPCRel(Value, ObjImg, RelI, 1 << RE.Size);
71 RE.Addend = Value.Addend;
74 addRelocationForSymbol(RE, Value.SymbolName);
76 addRelocationForSection(RE, Value.SectionID);
81 void resolveRelocation(const RelocationEntry &RE, uint64_t Value) override {
82 DEBUG(dumpRelocationToResolve(RE, Value));
84 const SectionEntry &Section = Sections[RE.SectionID];
85 uint8_t *LocalAddress = Section.Address + RE.Offset;
88 uint64_t FinalAddress = Section.LoadAddress + RE.Offset;
89 Value -= FinalAddress + 4; // see MachOX86_64::resolveRelocation.
94 llvm_unreachable("Invalid relocation type!");
95 case MachO::GENERIC_RELOC_VANILLA:
96 writeBytesUnaligned(Value + RE.Addend, LocalAddress, 1 << RE.Size);
98 case MachO::GENERIC_RELOC_SECTDIFF:
99 case MachO::GENERIC_RELOC_LOCAL_SECTDIFF: {
100 uint64_t SectionABase = Sections[RE.Sections.SectionA].LoadAddress;
101 uint64_t SectionBBase = Sections[RE.Sections.SectionB].LoadAddress;
102 assert((Value == SectionABase || Value == SectionBBase) &&
103 "Unexpected SECTDIFF relocation value.");
104 Value = SectionABase - SectionBBase + RE.Addend;
105 writeBytesUnaligned(Value, LocalAddress, 1 << RE.Size);
108 case MachO::GENERIC_RELOC_PB_LA_PTR:
109 Error("Relocation type not implemented yet!");
113 void finalizeSection(ObjectImage &ObjImg, unsigned SectionID,
114 const SectionRef &Section) {
116 Section.getName(Name);
118 if (Name == "__jump_table")
119 populateJumpTable(cast<MachOObjectFile>(*ObjImg.getObjectFile()), Section,
121 else if (Name == "__pointers")
122 populatePointersSection(cast<MachOObjectFile>(*ObjImg.getObjectFile()),
128 processSECTDIFFRelocation(unsigned SectionID, relocation_iterator RelI,
130 ObjSectionToIDMap &ObjSectionToID) {
131 const MachOObjectFile *MachO =
132 static_cast<const MachOObjectFile *>(Obj.getObjectFile());
133 MachO::any_relocation_info RE =
134 MachO->getRelocation(RelI->getRawDataRefImpl());
136 SectionEntry &Section = Sections[SectionID];
137 uint32_t RelocType = MachO->getAnyRelocationType(RE);
138 bool IsPCRel = MachO->getAnyRelocationPCRel(RE);
139 unsigned Size = MachO->getAnyRelocationLength(RE);
141 RelI->getOffset(Offset);
142 uint8_t *LocalAddress = Section.Address + Offset;
143 unsigned NumBytes = 1 << Size;
145 memcpy(&Addend, LocalAddress, NumBytes);
148 MachO::any_relocation_info RE2 =
149 MachO->getRelocation(RelI->getRawDataRefImpl());
151 uint32_t AddrA = MachO->getScatteredRelocationValue(RE);
152 section_iterator SAI = getSectionByAddress(*MachO, AddrA);
153 assert(SAI != MachO->section_end() && "Can't find section for address A");
154 uint64_t SectionABase;
155 SAI->getAddress(SectionABase);
156 uint64_t SectionAOffset = AddrA - SectionABase;
157 SectionRef SectionA = *SAI;
159 SectionA.isText(IsCode);
160 uint32_t SectionAID =
161 findOrEmitSection(Obj, SectionA, IsCode, ObjSectionToID);
163 uint32_t AddrB = MachO->getScatteredRelocationValue(RE2);
164 section_iterator SBI = getSectionByAddress(*MachO, AddrB);
165 assert(SBI != MachO->section_end() && "Can't find section for address B");
166 uint64_t SectionBBase;
167 SBI->getAddress(SectionBBase);
168 uint64_t SectionBOffset = AddrB - SectionBBase;
169 SectionRef SectionB = *SBI;
170 uint32_t SectionBID =
171 findOrEmitSection(Obj, SectionB, IsCode, ObjSectionToID);
173 if (Addend != AddrA - AddrB)
174 Error("Unexpected SECTDIFF relocation addend.");
176 DEBUG(dbgs() << "Found SECTDIFF: AddrA: " << AddrA << ", AddrB: " << AddrB
177 << ", Addend: " << Addend << ", SectionA ID: " << SectionAID
178 << ", SectionAOffset: " << SectionAOffset
179 << ", SectionB ID: " << SectionBID
180 << ", SectionBOffset: " << SectionBOffset << "\n");
181 RelocationEntry R(SectionID, Offset, RelocType, 0, SectionAID,
182 SectionAOffset, SectionBID, SectionBOffset, IsPCRel,
185 addRelocationForSection(R, SectionAID);
186 addRelocationForSection(R, SectionBID);
191 relocation_iterator processI386ScatteredVANILLA(
192 unsigned SectionID, relocation_iterator RelI, ObjectImage &Obj,
193 RuntimeDyldMachO::ObjSectionToIDMap &ObjSectionToID) {
194 const MachOObjectFile *MachO =
195 static_cast<const MachOObjectFile *>(Obj.getObjectFile());
196 MachO::any_relocation_info RE =
197 MachO->getRelocation(RelI->getRawDataRefImpl());
199 SectionEntry &Section = Sections[SectionID];
200 uint32_t RelocType = MachO->getAnyRelocationType(RE);
201 bool IsPCRel = MachO->getAnyRelocationPCRel(RE);
202 unsigned Size = MachO->getAnyRelocationLength(RE);
204 RelI->getOffset(Offset);
205 uint8_t *LocalAddress = Section.Address + Offset;
206 unsigned NumBytes = 1 << Size;
208 memcpy(&Addend, LocalAddress, NumBytes);
210 unsigned SymbolBaseAddr = MachO->getScatteredRelocationValue(RE);
211 section_iterator TargetSI = getSectionByAddress(*MachO, SymbolBaseAddr);
212 assert(TargetSI != MachO->section_end() && "Can't find section for symbol");
213 uint64_t SectionBaseAddr;
214 TargetSI->getAddress(SectionBaseAddr);
215 SectionRef TargetSection = *TargetSI;
217 TargetSection.isText(IsCode);
218 uint32_t TargetSectionID =
219 findOrEmitSection(Obj, TargetSection, IsCode, ObjSectionToID);
221 Addend -= SectionBaseAddr;
222 RelocationEntry R(SectionID, Offset, RelocType, Addend, IsPCRel, Size);
224 addRelocationForSection(R, TargetSectionID);
229 // Populate stubs in __jump_table section.
230 void populateJumpTable(MachOObjectFile &Obj, const SectionRef &JTSection,
231 unsigned JTSectionID) {
232 assert(!Obj.is64Bit() &&
233 "__jump_table section not supported in 64-bit MachO.");
235 MachO::dysymtab_command DySymTabCmd = Obj.getDysymtabLoadCommand();
236 MachO::section Sec32 = Obj.getSection(JTSection.getRawDataRefImpl());
237 uint32_t JTSectionSize = Sec32.size;
238 unsigned FirstIndirectSymbol = Sec32.reserved1;
239 unsigned JTEntrySize = Sec32.reserved2;
240 unsigned NumJTEntries = JTSectionSize / JTEntrySize;
241 uint8_t *JTSectionAddr = getSectionAddress(JTSectionID);
242 unsigned JTEntryOffset = 0;
244 assert((JTSectionSize % JTEntrySize) == 0 &&
245 "Jump-table section does not contain a whole number of stubs?");
247 for (unsigned i = 0; i < NumJTEntries; ++i) {
248 unsigned SymbolIndex =
249 Obj.getIndirectSymbolTableEntry(DySymTabCmd, FirstIndirectSymbol + i);
250 symbol_iterator SI = Obj.getSymbolByIndex(SymbolIndex);
251 StringRef IndirectSymbolName;
252 SI->getName(IndirectSymbolName);
253 uint8_t *JTEntryAddr = JTSectionAddr + JTEntryOffset;
254 createStubFunction(JTEntryAddr);
255 RelocationEntry RE(JTSectionID, JTEntryOffset + 1,
256 MachO::GENERIC_RELOC_VANILLA, 0, true, 2);
257 addRelocationForSymbol(RE, IndirectSymbolName);
258 JTEntryOffset += JTEntrySize;
262 // Populate __pointers section.
263 void populatePointersSection(MachOObjectFile &Obj,
264 const SectionRef &PTSection,
265 unsigned PTSectionID) {
266 assert(!Obj.is64Bit() &&
267 "__pointers section not supported in 64-bit MachO.");
269 MachO::dysymtab_command DySymTabCmd = Obj.getDysymtabLoadCommand();
270 MachO::section Sec32 = Obj.getSection(PTSection.getRawDataRefImpl());
271 uint32_t PTSectionSize = Sec32.size;
272 unsigned FirstIndirectSymbol = Sec32.reserved1;
273 const unsigned PTEntrySize = 4;
274 unsigned NumPTEntries = PTSectionSize / PTEntrySize;
275 unsigned PTEntryOffset = 0;
277 assert((PTSectionSize % PTEntrySize) == 0 &&
278 "Pointers section does not contain a whole number of stubs?");
280 DEBUG(dbgs() << "Populating __pointers, Section ID " << PTSectionID << ", "
281 << NumPTEntries << " entries, " << PTEntrySize
282 << " bytes each:\n");
284 for (unsigned i = 0; i < NumPTEntries; ++i) {
285 unsigned SymbolIndex =
286 Obj.getIndirectSymbolTableEntry(DySymTabCmd, FirstIndirectSymbol + i);
287 symbol_iterator SI = Obj.getSymbolByIndex(SymbolIndex);
288 StringRef IndirectSymbolName;
289 SI->getName(IndirectSymbolName);
290 DEBUG(dbgs() << " " << IndirectSymbolName << ": index " << SymbolIndex
291 << ", PT offset: " << PTEntryOffset << "\n");
292 RelocationEntry RE(PTSectionID, PTEntryOffset,
293 MachO::GENERIC_RELOC_VANILLA, 0, false, 2);
294 addRelocationForSymbol(RE, IndirectSymbolName);
295 PTEntryOffset += PTEntrySize;
299 static section_iterator getSectionByAddress(const MachOObjectFile &Obj,
301 section_iterator SI = Obj.section_begin();
302 section_iterator SE = Obj.section_end();
304 for (; SI != SE; ++SI) {
305 uint64_t SAddr, SSize;
306 SI->getAddress(SAddr);
308 if ((Addr >= SAddr) && (Addr < SAddr + SSize))