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_RUNTIMEDYLDMACHOARM_H
11 #define LLVM_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(uint8_t *LocalAddress, unsigned NumBytes,
32 MachO::RelocationInfoType RelType) const {
35 return ParentT::decodeAddend(LocalAddress, NumBytes, RelType);
36 case MachO::ARM_RELOC_BR24: {
38 memcpy(&Temp, LocalAddress, 4);
39 Temp &= 0x00ffffff; // Mask out the opcode.
40 // Now we've got the shifted immediate, shift by 2, sign extend and ret.
41 return SignExtend32<26>(Temp << 2);
47 processRelocationRef(unsigned SectionID, relocation_iterator RelI,
48 ObjectImage &ObjImg, ObjSectionToIDMap &ObjSectionToID,
49 const SymbolTableMap &Symbols, StubMap &Stubs) override {
50 const MachOObjectFile &Obj =
51 static_cast<const MachOObjectFile &>(*ObjImg.getObjectFile());
52 MachO::any_relocation_info RelInfo =
53 Obj.getRelocation(RelI->getRawDataRefImpl());
55 if (Obj.isRelocationScattered(RelInfo))
58 RelocationEntry RE(getBasicRelocationEntry(SectionID, ObjImg, RelI));
59 RelocationValueRef Value(
60 getRelocationValueRef(ObjImg, RelI, RE, ObjSectionToID, Symbols));
63 makeValueAddendPCRel(Value, ObjImg, RelI, 8);
65 if ((RE.RelType & 0xf) == MachO::ARM_RELOC_BR24)
66 processBranchRelocation(RE, Value, Stubs);
68 RE.Addend = Value.Addend;
70 addRelocationForSymbol(RE, Value.SymbolName);
72 addRelocationForSection(RE, Value.SectionID);
78 void resolveRelocation(const RelocationEntry &RE, uint64_t Value) {
79 DEBUG(dumpRelocationToResolve(RE, Value));
80 const SectionEntry &Section = Sections[RE.SectionID];
81 uint8_t *LocalAddress = Section.Address + RE.Offset;
83 // If the relocation is PC-relative, the value to be encoded is the
84 // pointer difference.
86 uint64_t FinalAddress = Section.LoadAddress + RE.Offset;
87 Value -= FinalAddress;
88 // ARM PCRel relocations have an effective-PC offset of two instructions
89 // (four bytes in Thumb mode, 8 bytes in ARM mode).
90 // FIXME: For now, assume ARM mode.
96 llvm_unreachable("Invalid relocation type!");
97 case MachO::ARM_RELOC_VANILLA:
98 writeBytesUnaligned(LocalAddress, Value, 1 << RE.Size);
100 case MachO::ARM_RELOC_BR24: {
101 // Mask the value into the target address. We know instructions are
102 // 32-bit aligned, so we can do it all at once.
103 uint32_t *p = (uint32_t *)LocalAddress;
104 // The low two bits of the value are not encoded.
106 // Mask the value to 24 bits.
107 uint64_t FinalValue = Value & 0xffffff;
108 // FIXME: If the destination is a Thumb function (and the instruction
109 // is a non-predicated BL instruction), we need to change it to a BLX
110 // instruction instead.
112 // Insert the value into the instruction.
113 *p = (*p & ~0xffffff) | FinalValue;
116 case MachO::ARM_THUMB_RELOC_BR22:
117 case MachO::ARM_THUMB_32BIT_BRANCH:
118 case MachO::ARM_RELOC_HALF:
119 case MachO::ARM_RELOC_HALF_SECTDIFF:
120 case MachO::ARM_RELOC_PAIR:
121 case MachO::ARM_RELOC_SECTDIFF:
122 case MachO::ARM_RELOC_LOCAL_SECTDIFF:
123 case MachO::ARM_RELOC_PB_LA_PTR:
124 Error("Relocation type not implemented yet!");
129 void finalizeSection(ObjectImage &ObjImg, unsigned SectionID,
130 const SectionRef &Section) {}
133 void processBranchRelocation(const RelocationEntry &RE,
134 const RelocationValueRef &Value,
136 // This is an ARM branch relocation, need to use a stub function.
137 // Look up for existing stub.
138 SectionEntry &Section = Sections[RE.SectionID];
139 RuntimeDyldMachO::StubMap::const_iterator i = Stubs.find(Value);
141 if (i != Stubs.end()) {
142 Addr = Section.Address + i->second;
144 // Create a new stub function.
145 Stubs[Value] = Section.StubOffset;
146 uint8_t *StubTargetAddr =
147 createStubFunction(Section.Address + Section.StubOffset);
148 RelocationEntry StubRE(RE.SectionID, StubTargetAddr - Section.Address,
149 MachO::GENERIC_RELOC_VANILLA, Value.Addend, false,
151 if (Value.SymbolName)
152 addRelocationForSymbol(StubRE, Value.SymbolName);
154 addRelocationForSection(StubRE, Value.SectionID);
155 Addr = Section.Address + Section.StubOffset;
156 Section.StubOffset += getMaxStubSize();
158 RelocationEntry TargetRE(RE.SectionID, RE.Offset, RE.RelType, 0,
159 RE.IsPCRel, RE.Size);
160 resolveRelocation(TargetRE, (uint64_t)Addr);
167 #endif // LLVM_RUNTIMEDYLDMACHOARM_H