1 //===----- RuntimeDyldMachOARM.h ---- MachO/ARM 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_RUNTIMEDYLDMACHOARM_H
11 #define LLVM_LIB_EXECUTIONENGINE_RUNTIMEDYLD_TARGETS_RUNTIMEDYLDMACHOARM_H
13 #include "../RuntimeDyldMachO.h"
15 #define DEBUG_TYPE "dyld"
19 class RuntimeDyldMachOARM
20 : public RuntimeDyldMachOCRTPBase<RuntimeDyldMachOARM> {
22 typedef RuntimeDyldMachOCRTPBase<RuntimeDyldMachOARM> ParentT;
26 typedef uint32_t TargetPtrT;
28 RuntimeDyldMachOARM(RTDyldMemoryManager *MM) : RuntimeDyldMachOCRTPBase(MM) {}
30 unsigned getMaxStubSize() override { return 8; }
32 unsigned getStubAlignment() override { return 4; }
34 int64_t decodeAddend(const RelocationEntry &RE) const {
35 const SectionEntry &Section = Sections[RE.SectionID];
36 uint8_t *LocalAddress = Section.Address + RE.Offset;
40 return memcpyAddend(RE);
41 case MachO::ARM_RELOC_BR24: {
43 memcpy(&Temp, LocalAddress, 4);
44 Temp &= 0x00ffffff; // Mask out the opcode.
45 // Now we've got the shifted immediate, shift by 2, sign extend and ret.
46 return SignExtend32<26>(Temp << 2);
52 processRelocationRef(unsigned SectionID, relocation_iterator RelI,
53 ObjectImage &ObjImg, ObjSectionToIDMap &ObjSectionToID,
54 const SymbolTableMap &Symbols, StubMap &Stubs) override {
55 const MachOObjectFile &Obj =
56 static_cast<const MachOObjectFile &>(*ObjImg.getObjectFile());
57 MachO::any_relocation_info RelInfo =
58 Obj.getRelocation(RelI->getRawDataRefImpl());
59 uint32_t RelType = Obj.getAnyRelocationType(RelInfo);
61 if (Obj.isRelocationScattered(RelInfo)) {
62 if (RelType == MachO::ARM_RELOC_HALF_SECTDIFF)
63 return processHALFSECTDIFFRelocation(SectionID, RelI, ObjImg,
69 RelocationEntry RE(getRelocationEntry(SectionID, ObjImg, RelI));
70 RE.Addend = decodeAddend(RE);
71 RelocationValueRef Value(
72 getRelocationValueRef(ObjImg, RelI, RE, ObjSectionToID, Symbols));
75 makeValueAddendPCRel(Value, ObjImg, RelI, 8);
77 if ((RE.RelType & 0xf) == MachO::ARM_RELOC_BR24)
78 processBranchRelocation(RE, Value, Stubs);
80 RE.Addend = Value.Offset;
82 addRelocationForSymbol(RE, Value.SymbolName);
84 addRelocationForSection(RE, Value.SectionID);
90 void resolveRelocation(const RelocationEntry &RE, uint64_t Value) override {
91 DEBUG(dumpRelocationToResolve(RE, Value));
92 const SectionEntry &Section = Sections[RE.SectionID];
93 uint8_t *LocalAddress = Section.Address + RE.Offset;
95 // If the relocation is PC-relative, the value to be encoded is the
96 // pointer difference.
98 uint64_t FinalAddress = Section.LoadAddress + RE.Offset;
99 Value -= FinalAddress;
100 // ARM PCRel relocations have an effective-PC offset of two instructions
101 // (four bytes in Thumb mode, 8 bytes in ARM mode).
102 // FIXME: For now, assume ARM mode.
106 switch (RE.RelType) {
108 llvm_unreachable("Invalid relocation type!");
109 case MachO::ARM_RELOC_VANILLA:
110 writeBytesUnaligned(Value + RE.Addend, LocalAddress, 1 << RE.Size);
112 case MachO::ARM_RELOC_BR24: {
113 // Mask the value into the target address. We know instructions are
114 // 32-bit aligned, so we can do it all at once.
115 uint32_t *p = (uint32_t *)LocalAddress;
117 // The low two bits of the value are not encoded.
119 // Mask the value to 24 bits.
120 uint64_t FinalValue = Value & 0xffffff;
121 // FIXME: If the destination is a Thumb function (and the instruction
122 // is a non-predicated BL instruction), we need to change it to a BLX
123 // instruction instead.
125 // Insert the value into the instruction.
126 *p = (*p & ~0xffffff) | FinalValue;
129 case MachO::ARM_RELOC_HALF_SECTDIFF: {
130 uint64_t SectionABase = Sections[RE.Sections.SectionA].LoadAddress;
131 uint64_t SectionBBase = Sections[RE.Sections.SectionB].LoadAddress;
132 assert((Value == SectionABase || Value == SectionBBase) &&
133 "Unexpected HALFSECTDIFF relocation value.");
134 Value = SectionABase - SectionBBase + RE.Addend;
135 if (RE.Size & 0x1) // :upper16:
136 Value = (Value >> 16);
140 memcpy(&Insn, LocalAddress, 4);
141 Insn = (Insn & 0xfff0f000) | ((Value & 0xf000) << 4) | (Value & 0x0fff);
142 memcpy(LocalAddress, &Insn, 4);
146 case MachO::ARM_THUMB_RELOC_BR22:
147 case MachO::ARM_THUMB_32BIT_BRANCH:
148 case MachO::ARM_RELOC_HALF:
149 case MachO::ARM_RELOC_PAIR:
150 case MachO::ARM_RELOC_SECTDIFF:
151 case MachO::ARM_RELOC_LOCAL_SECTDIFF:
152 case MachO::ARM_RELOC_PB_LA_PTR:
153 Error("Relocation type not implemented yet!");
158 void finalizeSection(ObjectImage &ObjImg, unsigned SectionID,
159 const SectionRef &Section) {
161 Section.getName(Name);
163 if (Name == "__nl_symbol_ptr")
164 populateIndirectSymbolPointersSection(
165 cast<MachOObjectFile>(*ObjImg.getObjectFile()),
171 void processBranchRelocation(const RelocationEntry &RE,
172 const RelocationValueRef &Value,
174 // This is an ARM branch relocation, need to use a stub function.
175 // Look up for existing stub.
176 SectionEntry &Section = Sections[RE.SectionID];
177 RuntimeDyldMachO::StubMap::const_iterator i = Stubs.find(Value);
179 if (i != Stubs.end()) {
180 Addr = Section.Address + i->second;
182 // Create a new stub function.
183 Stubs[Value] = Section.StubOffset;
184 uint8_t *StubTargetAddr =
185 createStubFunction(Section.Address + Section.StubOffset);
186 RelocationEntry StubRE(RE.SectionID, StubTargetAddr - Section.Address,
187 MachO::GENERIC_RELOC_VANILLA, Value.Offset, false,
189 if (Value.SymbolName)
190 addRelocationForSymbol(StubRE, Value.SymbolName);
192 addRelocationForSection(StubRE, Value.SectionID);
193 Addr = Section.Address + Section.StubOffset;
194 Section.StubOffset += getMaxStubSize();
196 RelocationEntry TargetRE(RE.SectionID, RE.Offset, RE.RelType, 0,
197 RE.IsPCRel, RE.Size);
198 resolveRelocation(TargetRE, (uint64_t)Addr);
202 processHALFSECTDIFFRelocation(unsigned SectionID, relocation_iterator RelI,
204 ObjSectionToIDMap &ObjSectionToID) {
205 const MachOObjectFile *MachO =
206 static_cast<const MachOObjectFile *>(Obj.getObjectFile());
207 MachO::any_relocation_info RE =
208 MachO->getRelocation(RelI->getRawDataRefImpl());
211 // For a half-diff relocation the length bits actually record whether this
212 // is a movw/movt, and whether this is arm or thumb.
213 // Bit 0 indicates movw (b0 == 0) or movt (b0 == 1).
214 // Bit 1 indicates arm (b1 == 0) or thumb (b1 == 1).
215 unsigned HalfDiffKindBits = MachO->getAnyRelocationLength(RE);
216 if (HalfDiffKindBits & 0x2)
217 llvm_unreachable("Thumb not yet supported.");
219 SectionEntry &Section = Sections[SectionID];
220 uint32_t RelocType = MachO->getAnyRelocationType(RE);
221 bool IsPCRel = MachO->getAnyRelocationPCRel(RE);
223 RelI->getOffset(Offset);
224 uint8_t *LocalAddress = Section.Address + Offset;
225 int64_t Immediate = 0;
226 memcpy(&Immediate, LocalAddress, 4); // Copy the whole instruction out.
227 Immediate = ((Immediate >> 4) & 0xf000) | (Immediate & 0xfff);
230 MachO::any_relocation_info RE2 =
231 MachO->getRelocation(RelI->getRawDataRefImpl());
232 uint32_t AddrA = MachO->getScatteredRelocationValue(RE);
233 section_iterator SAI = getSectionByAddress(*MachO, AddrA);
234 assert(SAI != MachO->section_end() && "Can't find section for address A");
235 uint64_t SectionABase;
236 SAI->getAddress(SectionABase);
237 uint64_t SectionAOffset = AddrA - SectionABase;
238 SectionRef SectionA = *SAI;
240 SectionA.isText(IsCode);
241 uint32_t SectionAID =
242 findOrEmitSection(Obj, SectionA, IsCode, ObjSectionToID);
244 uint32_t AddrB = MachO->getScatteredRelocationValue(RE2);
245 section_iterator SBI = getSectionByAddress(*MachO, AddrB);
246 assert(SBI != MachO->section_end() && "Can't find section for address B");
247 uint64_t SectionBBase;
248 SBI->getAddress(SectionBBase);
249 uint64_t SectionBOffset = AddrB - SectionBBase;
250 SectionRef SectionB = *SBI;
251 uint32_t SectionBID =
252 findOrEmitSection(Obj, SectionB, IsCode, ObjSectionToID);
254 uint32_t OtherHalf = MachO->getAnyRelocationAddress(RE2) & 0xffff;
255 unsigned Shift = (HalfDiffKindBits & 0x1) ? 16 : 0;
256 uint32_t FullImmVal = (Immediate << Shift) | (OtherHalf << (16 - Shift));
257 int64_t Addend = FullImmVal - (AddrA - AddrB);
259 // addend = Encoded - Expected
260 // = Encoded - (AddrA - AddrB)
262 DEBUG(dbgs() << "Found SECTDIFF: AddrA: " << AddrA << ", AddrB: " << AddrB
263 << ", Addend: " << Addend << ", SectionA ID: " << SectionAID
264 << ", SectionAOffset: " << SectionAOffset
265 << ", SectionB ID: " << SectionBID
266 << ", SectionBOffset: " << SectionBOffset << "\n");
267 RelocationEntry R(SectionID, Offset, RelocType, Addend, SectionAID,
268 SectionAOffset, SectionBID, SectionBOffset, IsPCRel,
271 addRelocationForSection(R, SectionAID);
272 addRelocationForSection(R, SectionBID);