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;
25 RuntimeDyldMachOARM(RTDyldMemoryManager *MM) : RuntimeDyldMachOCRTPBase(MM) {}
27 unsigned getMaxStubSize() override { return 8; }
29 unsigned getStubAlignment() override { return 4; }
31 int64_t decodeAddend(const RelocationEntry &RE) const {
32 const SectionEntry &Section = Sections[RE.SectionID];
33 uint8_t *LocalAddress = Section.Address + RE.Offset;
37 return memcpyAddend(RE);
38 case MachO::ARM_RELOC_BR24: {
40 memcpy(&Temp, LocalAddress, 4);
41 Temp &= 0x00ffffff; // Mask out the opcode.
42 // Now we've got the shifted immediate, shift by 2, sign extend and ret.
43 return SignExtend32<26>(Temp << 2);
49 processRelocationRef(unsigned SectionID, relocation_iterator RelI,
50 ObjectImage &ObjImg, ObjSectionToIDMap &ObjSectionToID,
51 const SymbolTableMap &Symbols, StubMap &Stubs) override {
52 const MachOObjectFile &Obj =
53 static_cast<const MachOObjectFile &>(*ObjImg.getObjectFile());
54 MachO::any_relocation_info RelInfo =
55 Obj.getRelocation(RelI->getRawDataRefImpl());
57 if (Obj.isRelocationScattered(RelInfo))
60 RelocationEntry RE(getRelocationEntry(SectionID, ObjImg, RelI));
61 RE.Addend = decodeAddend(RE);
62 RelocationValueRef Value(
63 getRelocationValueRef(ObjImg, RelI, RE, ObjSectionToID, Symbols));
66 makeValueAddendPCRel(Value, ObjImg, RelI, 8);
68 if ((RE.RelType & 0xf) == MachO::ARM_RELOC_BR24)
69 processBranchRelocation(RE, Value, Stubs);
71 RE.Addend = Value.Addend;
73 addRelocationForSymbol(RE, Value.SymbolName);
75 addRelocationForSection(RE, Value.SectionID);
81 void resolveRelocation(const RelocationEntry &RE, uint64_t Value) {
82 DEBUG(dumpRelocationToResolve(RE, Value));
83 const SectionEntry &Section = Sections[RE.SectionID];
84 uint8_t *LocalAddress = Section.Address + RE.Offset;
86 // If the relocation is PC-relative, the value to be encoded is the
87 // pointer difference.
89 uint64_t FinalAddress = Section.LoadAddress + RE.Offset;
90 Value -= FinalAddress;
91 // ARM PCRel relocations have an effective-PC offset of two instructions
92 // (four bytes in Thumb mode, 8 bytes in ARM mode).
93 // FIXME: For now, assume ARM mode.
99 llvm_unreachable("Invalid relocation type!");
100 case MachO::ARM_RELOC_VANILLA:
101 writeBytesUnaligned(LocalAddress, Value, 1 << RE.Size);
103 case MachO::ARM_RELOC_BR24: {
104 // Mask the value into the target address. We know instructions are
105 // 32-bit aligned, so we can do it all at once.
106 uint32_t *p = (uint32_t *)LocalAddress;
107 // The low two bits of the value are not encoded.
109 // Mask the value to 24 bits.
110 uint64_t FinalValue = Value & 0xffffff;
111 // FIXME: If the destination is a Thumb function (and the instruction
112 // is a non-predicated BL instruction), we need to change it to a BLX
113 // instruction instead.
115 // Insert the value into the instruction.
116 *p = (*p & ~0xffffff) | FinalValue;
119 case MachO::ARM_THUMB_RELOC_BR22:
120 case MachO::ARM_THUMB_32BIT_BRANCH:
121 case MachO::ARM_RELOC_HALF:
122 case MachO::ARM_RELOC_HALF_SECTDIFF:
123 case MachO::ARM_RELOC_PAIR:
124 case MachO::ARM_RELOC_SECTDIFF:
125 case MachO::ARM_RELOC_LOCAL_SECTDIFF:
126 case MachO::ARM_RELOC_PB_LA_PTR:
127 Error("Relocation type not implemented yet!");
132 void finalizeSection(ObjectImage &ObjImg, unsigned SectionID,
133 const SectionRef &Section) {}
136 void processBranchRelocation(const RelocationEntry &RE,
137 const RelocationValueRef &Value,
139 // This is an ARM branch relocation, need to use a stub function.
140 // Look up for existing stub.
141 SectionEntry &Section = Sections[RE.SectionID];
142 RuntimeDyldMachO::StubMap::const_iterator i = Stubs.find(Value);
144 if (i != Stubs.end()) {
145 Addr = Section.Address + i->second;
147 // Create a new stub function.
148 Stubs[Value] = Section.StubOffset;
149 uint8_t *StubTargetAddr =
150 createStubFunction(Section.Address + Section.StubOffset);
151 RelocationEntry StubRE(RE.SectionID, StubTargetAddr - Section.Address,
152 MachO::GENERIC_RELOC_VANILLA, Value.Addend, false,
154 if (Value.SymbolName)
155 addRelocationForSymbol(StubRE, Value.SymbolName);
157 addRelocationForSection(StubRE, Value.SectionID);
158 Addr = Section.Address + Section.StubOffset;
159 Section.StubOffset += getMaxStubSize();
161 RelocationEntry TargetRE(RE.SectionID, RE.Offset, RE.RelType, 0,
162 RE.IsPCRel, RE.Size);
163 resolveRelocation(TargetRE, (uint64_t)Addr);