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(RuntimeDyld::MemoryManager &MM,
29 RuntimeDyld::SymbolResolver &Resolver)
30 : RuntimeDyldMachOCRTPBase(MM, Resolver) {}
32 unsigned getMaxStubSize() override { return 8; }
34 unsigned getStubAlignment() override { return 4; }
36 int64_t decodeAddend(const RelocationEntry &RE) const {
37 const SectionEntry &Section = Sections[RE.SectionID];
38 uint8_t *LocalAddress = Section.Address + RE.Offset;
42 return memcpyAddend(RE);
43 case MachO::ARM_RELOC_BR24: {
44 uint32_t Temp = readBytesUnaligned(LocalAddress, 4);
45 Temp &= 0x00ffffff; // Mask out the opcode.
46 // Now we've got the shifted immediate, shift by 2, sign extend and ret.
47 return SignExtend32<26>(Temp << 2);
53 processRelocationRef(unsigned SectionID, relocation_iterator RelI,
54 const ObjectFile &BaseObjT,
55 ObjSectionToIDMap &ObjSectionToID,
56 StubMap &Stubs) override {
57 const MachOObjectFile &Obj =
58 static_cast<const MachOObjectFile &>(BaseObjT);
59 MachO::any_relocation_info RelInfo =
60 Obj.getRelocation(RelI->getRawDataRefImpl());
61 uint32_t RelType = Obj.getAnyRelocationType(RelInfo);
63 if (Obj.isRelocationScattered(RelInfo)) {
64 if (RelType == MachO::ARM_RELOC_HALF_SECTDIFF)
65 return processHALFSECTDIFFRelocation(SectionID, RelI, Obj,
67 else if (RelType == MachO::GENERIC_RELOC_VANILLA)
68 return processScatteredVANILLA(SectionID, RelI, Obj, ObjSectionToID);
73 RelocationEntry RE(getRelocationEntry(SectionID, Obj, RelI));
74 RE.Addend = decodeAddend(RE);
75 RelocationValueRef Value(
76 getRelocationValueRef(Obj, RelI, RE, ObjSectionToID));
79 makeValueAddendPCRel(Value, RelI, 8);
81 if ((RE.RelType & 0xf) == MachO::ARM_RELOC_BR24)
82 processBranchRelocation(RE, Value, Stubs);
84 RE.Addend = Value.Offset;
86 addRelocationForSymbol(RE, Value.SymbolName);
88 addRelocationForSection(RE, Value.SectionID);
94 void resolveRelocation(const RelocationEntry &RE, uint64_t Value) override {
95 DEBUG(dumpRelocationToResolve(RE, Value));
96 const SectionEntry &Section = Sections[RE.SectionID];
97 uint8_t *LocalAddress = Section.Address + RE.Offset;
99 // If the relocation is PC-relative, the value to be encoded is the
100 // pointer difference.
102 uint64_t FinalAddress = Section.LoadAddress + RE.Offset;
103 Value -= FinalAddress;
104 // ARM PCRel relocations have an effective-PC offset of two instructions
105 // (four bytes in Thumb mode, 8 bytes in ARM mode).
106 // FIXME: For now, assume ARM mode.
110 switch (RE.RelType) {
112 llvm_unreachable("Invalid relocation type!");
113 case MachO::ARM_RELOC_VANILLA:
114 writeBytesUnaligned(Value + RE.Addend, LocalAddress, 1 << RE.Size);
116 case MachO::ARM_RELOC_BR24: {
117 // Mask the value into the target address. We know instructions are
118 // 32-bit aligned, so we can do it all at once.
120 // The low two bits of the value are not encoded.
122 // Mask the value to 24 bits.
123 uint64_t FinalValue = Value & 0xffffff;
124 // FIXME: If the destination is a Thumb function (and the instruction
125 // is a non-predicated BL instruction), we need to change it to a BLX
126 // instruction instead.
128 // Insert the value into the instruction.
129 uint32_t Temp = readBytesUnaligned(LocalAddress, 4);
130 writeBytesUnaligned((Temp & ~0xffffff) | FinalValue, LocalAddress, 4);
134 case MachO::ARM_RELOC_HALF_SECTDIFF: {
135 uint64_t SectionABase = Sections[RE.Sections.SectionA].LoadAddress;
136 uint64_t SectionBBase = Sections[RE.Sections.SectionB].LoadAddress;
137 assert((Value == SectionABase || Value == SectionBBase) &&
138 "Unexpected HALFSECTDIFF relocation value.");
139 Value = SectionABase - SectionBBase + RE.Addend;
140 if (RE.Size & 0x1) // :upper16:
141 Value = (Value >> 16);
144 uint32_t Insn = readBytesUnaligned(LocalAddress, 4);
145 Insn = (Insn & 0xfff0f000) | ((Value & 0xf000) << 4) | (Value & 0x0fff);
146 writeBytesUnaligned(Insn, LocalAddress, 4);
150 case MachO::ARM_THUMB_RELOC_BR22:
151 case MachO::ARM_THUMB_32BIT_BRANCH:
152 case MachO::ARM_RELOC_HALF:
153 case MachO::ARM_RELOC_PAIR:
154 case MachO::ARM_RELOC_SECTDIFF:
155 case MachO::ARM_RELOC_LOCAL_SECTDIFF:
156 case MachO::ARM_RELOC_PB_LA_PTR:
157 Error("Relocation type not implemented yet!");
162 void finalizeSection(const ObjectFile &Obj, unsigned SectionID,
163 const SectionRef &Section) {
165 Section.getName(Name);
167 if (Name == "__nl_symbol_ptr")
168 populateIndirectSymbolPointersSection(cast<MachOObjectFile>(Obj),
174 void processBranchRelocation(const RelocationEntry &RE,
175 const RelocationValueRef &Value,
177 // This is an ARM branch relocation, need to use a stub function.
178 // Look up for existing stub.
179 SectionEntry &Section = Sections[RE.SectionID];
180 RuntimeDyldMachO::StubMap::const_iterator i = Stubs.find(Value);
182 if (i != Stubs.end()) {
183 Addr = Section.Address + i->second;
185 // Create a new stub function.
186 Stubs[Value] = Section.StubOffset;
187 uint8_t *StubTargetAddr =
188 createStubFunction(Section.Address + Section.StubOffset);
189 RelocationEntry StubRE(RE.SectionID, StubTargetAddr - Section.Address,
190 MachO::GENERIC_RELOC_VANILLA, Value.Offset, false,
192 if (Value.SymbolName)
193 addRelocationForSymbol(StubRE, Value.SymbolName);
195 addRelocationForSection(StubRE, Value.SectionID);
196 Addr = Section.Address + Section.StubOffset;
197 Section.StubOffset += getMaxStubSize();
199 RelocationEntry TargetRE(RE.SectionID, RE.Offset, RE.RelType, 0,
200 RE.IsPCRel, RE.Size);
201 resolveRelocation(TargetRE, (uint64_t)Addr);
205 processHALFSECTDIFFRelocation(unsigned SectionID, relocation_iterator RelI,
206 const ObjectFile &BaseTObj,
207 ObjSectionToIDMap &ObjSectionToID) {
208 const MachOObjectFile &MachO =
209 static_cast<const MachOObjectFile&>(BaseTObj);
210 MachO::any_relocation_info RE =
211 MachO.getRelocation(RelI->getRawDataRefImpl());
214 // For a half-diff relocation the length bits actually record whether this
215 // is a movw/movt, and whether this is arm or thumb.
216 // Bit 0 indicates movw (b0 == 0) or movt (b0 == 1).
217 // Bit 1 indicates arm (b1 == 0) or thumb (b1 == 1).
218 unsigned HalfDiffKindBits = MachO.getAnyRelocationLength(RE);
219 if (HalfDiffKindBits & 0x2)
220 llvm_unreachable("Thumb not yet supported.");
222 SectionEntry &Section = Sections[SectionID];
223 uint32_t RelocType = MachO.getAnyRelocationType(RE);
224 bool IsPCRel = MachO.getAnyRelocationPCRel(RE);
225 uint64_t Offset = RelI->getOffset();
226 uint8_t *LocalAddress = Section.Address + Offset;
227 int64_t Immediate = readBytesUnaligned(LocalAddress, 4); // Copy the whole instruction out.
228 Immediate = ((Immediate >> 4) & 0xf000) | (Immediate & 0xfff);
231 MachO::any_relocation_info RE2 =
232 MachO.getRelocation(RelI->getRawDataRefImpl());
233 uint32_t AddrA = MachO.getScatteredRelocationValue(RE);
234 section_iterator SAI = getSectionByAddress(MachO, AddrA);
235 assert(SAI != MachO.section_end() && "Can't find section for address A");
236 uint64_t SectionABase = SAI->getAddress();
237 uint64_t SectionAOffset = AddrA - SectionABase;
238 SectionRef SectionA = *SAI;
239 bool IsCode = SectionA.isText();
240 uint32_t SectionAID =
241 findOrEmitSection(MachO, SectionA, IsCode, ObjSectionToID);
243 uint32_t AddrB = MachO.getScatteredRelocationValue(RE2);
244 section_iterator SBI = getSectionByAddress(MachO, AddrB);
245 assert(SBI != MachO.section_end() && "Can't find section for address B");
246 uint64_t SectionBBase = SBI->getAddress();
247 uint64_t SectionBOffset = AddrB - SectionBBase;
248 SectionRef SectionB = *SBI;
249 uint32_t SectionBID =
250 findOrEmitSection(MachO, SectionB, IsCode, ObjSectionToID);
252 uint32_t OtherHalf = MachO.getAnyRelocationAddress(RE2) & 0xffff;
253 unsigned Shift = (HalfDiffKindBits & 0x1) ? 16 : 0;
254 uint32_t FullImmVal = (Immediate << Shift) | (OtherHalf << (16 - Shift));
255 int64_t Addend = FullImmVal - (AddrA - AddrB);
257 // addend = Encoded - Expected
258 // = Encoded - (AddrA - AddrB)
260 DEBUG(dbgs() << "Found SECTDIFF: AddrA: " << AddrA << ", AddrB: " << AddrB
261 << ", Addend: " << Addend << ", SectionA ID: " << SectionAID
262 << ", SectionAOffset: " << SectionAOffset
263 << ", SectionB ID: " << SectionBID
264 << ", SectionBOffset: " << SectionBOffset << "\n");
265 RelocationEntry R(SectionID, Offset, RelocType, Addend, SectionAID,
266 SectionAOffset, SectionBID, SectionBOffset, IsPCRel,
269 addRelocationForSection(R, SectionAID);
270 addRelocationForSection(R, SectionBID);