1 //===----- RuntimeDyldMachOARM.h ---- MachO/ARM specific code. ----*- C++ -*-=// 2 // 3 // The LLVM Compiler Infrastructure 4 // 5 // This file is distributed under the University of Illinois Open Source 6 // License. See LICENSE.TXT for details. 7 // 8 //===----------------------------------------------------------------------===// 9 10 #ifndef LLVM_LIB_EXECUTIONENGINE_RUNTIMEDYLD_TARGETS_RUNTIMEDYLDMACHOARM_H 11 #define LLVM_LIB_EXECUTIONENGINE_RUNTIMEDYLD_TARGETS_RUNTIMEDYLDMACHOARM_H 12 13 #include "../RuntimeDyldMachO.h" 14 15 #define DEBUG_TYPE "dyld" 16 17 namespace llvm { 18 19 class RuntimeDyldMachOARM 20 : public RuntimeDyldMachOCRTPBase<RuntimeDyldMachOARM> { 21 private: 22 typedef RuntimeDyldMachOCRTPBase<RuntimeDyldMachOARM> ParentT; 23 24 public: 25 26 typedef uint32_t TargetPtrT; 27 RuntimeDyldMachOARM(RTDyldMemoryManager * MM)28 RuntimeDyldMachOARM(RTDyldMemoryManager *MM) : RuntimeDyldMachOCRTPBase(MM) {} 29 getMaxStubSize()30 unsigned getMaxStubSize() override { return 8; } 31 getStubAlignment()32 unsigned getStubAlignment() override { return 4; } 33 decodeAddend(const RelocationEntry & RE)34 int64_t decodeAddend(const RelocationEntry &RE) const { 35 const SectionEntry &Section = Sections[RE.SectionID]; 36 uint8_t *LocalAddress = Section.Address + RE.Offset; 37 38 switch (RE.RelType) { 39 default: 40 return memcpyAddend(RE); 41 case MachO::ARM_RELOC_BR24: { 42 uint32_t Temp = readBytesUnaligned(LocalAddress, 4); 43 Temp &= 0x00ffffff; // Mask out the opcode. 44 // Now we've got the shifted immediate, shift by 2, sign extend and ret. 45 return SignExtend32<26>(Temp << 2); 46 } 47 } 48 } 49 50 relocation_iterator processRelocationRef(unsigned SectionID,relocation_iterator RelI,const ObjectFile & BaseObjT,ObjSectionToIDMap & ObjSectionToID,StubMap & Stubs)51 processRelocationRef(unsigned SectionID, relocation_iterator RelI, 52 const ObjectFile &BaseObjT, 53 ObjSectionToIDMap &ObjSectionToID, 54 StubMap &Stubs) override { 55 const MachOObjectFile &Obj = 56 static_cast<const MachOObjectFile &>(BaseObjT); 57 MachO::any_relocation_info RelInfo = 58 Obj.getRelocation(RelI->getRawDataRefImpl()); 59 uint32_t RelType = Obj.getAnyRelocationType(RelInfo); 60 61 if (Obj.isRelocationScattered(RelInfo)) { 62 if (RelType == MachO::ARM_RELOC_HALF_SECTDIFF) 63 return processHALFSECTDIFFRelocation(SectionID, RelI, Obj, 64 ObjSectionToID); 65 else 66 return ++++RelI; 67 } 68 69 RelocationEntry RE(getRelocationEntry(SectionID, Obj, RelI)); 70 RE.Addend = decodeAddend(RE); 71 RelocationValueRef Value( 72 getRelocationValueRef(Obj, RelI, RE, ObjSectionToID)); 73 74 if (RE.IsPCRel) 75 makeValueAddendPCRel(Value, Obj, RelI, 8); 76 77 if ((RE.RelType & 0xf) == MachO::ARM_RELOC_BR24) 78 processBranchRelocation(RE, Value, Stubs); 79 else { 80 RE.Addend = Value.Offset; 81 if (Value.SymbolName) 82 addRelocationForSymbol(RE, Value.SymbolName); 83 else 84 addRelocationForSection(RE, Value.SectionID); 85 } 86 87 return ++RelI; 88 } 89 resolveRelocation(const RelocationEntry & RE,uint64_t Value)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; 94 95 // If the relocation is PC-relative, the value to be encoded is the 96 // pointer difference. 97 if (RE.IsPCRel) { 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. 103 Value -= 8; 104 } 105 106 switch (RE.RelType) { 107 default: 108 llvm_unreachable("Invalid relocation type!"); 109 case MachO::ARM_RELOC_VANILLA: 110 writeBytesUnaligned(Value + RE.Addend, LocalAddress, 1 << RE.Size); 111 break; 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 Value += RE.Addend; 116 // The low two bits of the value are not encoded. 117 Value >>= 2; 118 // Mask the value to 24 bits. 119 uint64_t FinalValue = Value & 0xffffff; 120 // FIXME: If the destination is a Thumb function (and the instruction 121 // is a non-predicated BL instruction), we need to change it to a BLX 122 // instruction instead. 123 124 // Insert the value into the instruction. 125 uint32_t Temp = readBytesUnaligned(LocalAddress, 4); 126 writeBytesUnaligned((Temp & ~0xffffff) | FinalValue, LocalAddress, 4); 127 128 break; 129 } 130 case MachO::ARM_RELOC_HALF_SECTDIFF: { 131 uint64_t SectionABase = Sections[RE.Sections.SectionA].LoadAddress; 132 uint64_t SectionBBase = Sections[RE.Sections.SectionB].LoadAddress; 133 assert((Value == SectionABase || Value == SectionBBase) && 134 "Unexpected HALFSECTDIFF relocation value."); 135 Value = SectionABase - SectionBBase + RE.Addend; 136 if (RE.Size & 0x1) // :upper16: 137 Value = (Value >> 16); 138 Value &= 0xffff; 139 140 uint32_t Insn = readBytesUnaligned(LocalAddress, 4); 141 Insn = (Insn & 0xfff0f000) | ((Value & 0xf000) << 4) | (Value & 0x0fff); 142 writeBytesUnaligned(Insn, LocalAddress, 4); 143 break; 144 } 145 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!"); 154 return; 155 } 156 } 157 finalizeSection(const ObjectFile & Obj,unsigned SectionID,const SectionRef & Section)158 void finalizeSection(const ObjectFile &Obj, unsigned SectionID, 159 const SectionRef &Section) { 160 StringRef Name; 161 Section.getName(Name); 162 163 if (Name == "__nl_symbol_ptr") 164 populateIndirectSymbolPointersSection(cast<MachOObjectFile>(Obj), 165 Section, SectionID); 166 } 167 168 private: 169 processBranchRelocation(const RelocationEntry & RE,const RelocationValueRef & Value,StubMap & Stubs)170 void processBranchRelocation(const RelocationEntry &RE, 171 const RelocationValueRef &Value, 172 StubMap &Stubs) { 173 // This is an ARM branch relocation, need to use a stub function. 174 // Look up for existing stub. 175 SectionEntry &Section = Sections[RE.SectionID]; 176 RuntimeDyldMachO::StubMap::const_iterator i = Stubs.find(Value); 177 uint8_t *Addr; 178 if (i != Stubs.end()) { 179 Addr = Section.Address + i->second; 180 } else { 181 // Create a new stub function. 182 Stubs[Value] = Section.StubOffset; 183 uint8_t *StubTargetAddr = 184 createStubFunction(Section.Address + Section.StubOffset); 185 RelocationEntry StubRE(RE.SectionID, StubTargetAddr - Section.Address, 186 MachO::GENERIC_RELOC_VANILLA, Value.Offset, false, 187 2); 188 if (Value.SymbolName) 189 addRelocationForSymbol(StubRE, Value.SymbolName); 190 else 191 addRelocationForSection(StubRE, Value.SectionID); 192 Addr = Section.Address + Section.StubOffset; 193 Section.StubOffset += getMaxStubSize(); 194 } 195 RelocationEntry TargetRE(RE.SectionID, RE.Offset, RE.RelType, 0, 196 RE.IsPCRel, RE.Size); 197 resolveRelocation(TargetRE, (uint64_t)Addr); 198 } 199 200 relocation_iterator processHALFSECTDIFFRelocation(unsigned SectionID,relocation_iterator RelI,const ObjectFile & BaseTObj,ObjSectionToIDMap & ObjSectionToID)201 processHALFSECTDIFFRelocation(unsigned SectionID, relocation_iterator RelI, 202 const ObjectFile &BaseTObj, 203 ObjSectionToIDMap &ObjSectionToID) { 204 const MachOObjectFile &MachO = 205 static_cast<const MachOObjectFile&>(BaseTObj); 206 MachO::any_relocation_info RE = 207 MachO.getRelocation(RelI->getRawDataRefImpl()); 208 209 210 // For a half-diff relocation the length bits actually record whether this 211 // is a movw/movt, and whether this is arm or thumb. 212 // Bit 0 indicates movw (b0 == 0) or movt (b0 == 1). 213 // Bit 1 indicates arm (b1 == 0) or thumb (b1 == 1). 214 unsigned HalfDiffKindBits = MachO.getAnyRelocationLength(RE); 215 if (HalfDiffKindBits & 0x2) 216 llvm_unreachable("Thumb not yet supported."); 217 218 SectionEntry &Section = Sections[SectionID]; 219 uint32_t RelocType = MachO.getAnyRelocationType(RE); 220 bool IsPCRel = MachO.getAnyRelocationPCRel(RE); 221 uint64_t Offset; 222 RelI->getOffset(Offset); 223 uint8_t *LocalAddress = Section.Address + Offset; 224 int64_t Immediate = readBytesUnaligned(LocalAddress, 4); // Copy the whole instruction out. 225 Immediate = ((Immediate >> 4) & 0xf000) | (Immediate & 0xfff); 226 227 ++RelI; 228 MachO::any_relocation_info RE2 = 229 MachO.getRelocation(RelI->getRawDataRefImpl()); 230 uint32_t AddrA = MachO.getScatteredRelocationValue(RE); 231 section_iterator SAI = getSectionByAddress(MachO, AddrA); 232 assert(SAI != MachO.section_end() && "Can't find section for address A"); 233 uint64_t SectionABase = SAI->getAddress(); 234 uint64_t SectionAOffset = AddrA - SectionABase; 235 SectionRef SectionA = *SAI; 236 bool IsCode = SectionA.isText(); 237 uint32_t SectionAID = 238 findOrEmitSection(MachO, SectionA, IsCode, ObjSectionToID); 239 240 uint32_t AddrB = MachO.getScatteredRelocationValue(RE2); 241 section_iterator SBI = getSectionByAddress(MachO, AddrB); 242 assert(SBI != MachO.section_end() && "Can't find section for address B"); 243 uint64_t SectionBBase = SBI->getAddress(); 244 uint64_t SectionBOffset = AddrB - SectionBBase; 245 SectionRef SectionB = *SBI; 246 uint32_t SectionBID = 247 findOrEmitSection(MachO, SectionB, IsCode, ObjSectionToID); 248 249 uint32_t OtherHalf = MachO.getAnyRelocationAddress(RE2) & 0xffff; 250 unsigned Shift = (HalfDiffKindBits & 0x1) ? 16 : 0; 251 uint32_t FullImmVal = (Immediate << Shift) | (OtherHalf << (16 - Shift)); 252 int64_t Addend = FullImmVal - (AddrA - AddrB); 253 254 // addend = Encoded - Expected 255 // = Encoded - (AddrA - AddrB) 256 257 DEBUG(dbgs() << "Found SECTDIFF: AddrA: " << AddrA << ", AddrB: " << AddrB 258 << ", Addend: " << Addend << ", SectionA ID: " << SectionAID 259 << ", SectionAOffset: " << SectionAOffset 260 << ", SectionB ID: " << SectionBID 261 << ", SectionBOffset: " << SectionBOffset << "\n"); 262 RelocationEntry R(SectionID, Offset, RelocType, Addend, SectionAID, 263 SectionAOffset, SectionBID, SectionBOffset, IsPCRel, 264 HalfDiffKindBits); 265 266 addRelocationForSection(R, SectionAID); 267 addRelocationForSection(R, SectionBID); 268 269 return ++RelI; 270 } 271 272 }; 273 } 274 275 #undef DEBUG_TYPE 276 277 #endif 278