1//===--- RuntimeDyldCOFFThumb.h --- COFF/Thumb specific code ---*- C++ --*-===// 2// 3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4// See https://llvm.org/LICENSE.txt for license information. 5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6// 7//===----------------------------------------------------------------------===// 8// 9// COFF thumb support for MC-JIT runtime dynamic linker. 10// 11//===----------------------------------------------------------------------===// 12 13#ifndef LLVM_LIB_EXECUTIONENGINE_RUNTIMEDYLD_TARGETS_RUNTIMEDYLDCOFFTHUMB_H 14#define LLVM_LIB_EXECUTIONENGINE_RUNTIMEDYLD_TARGETS_RUNTIMEDYLDCOFFTHUMB_H 15 16#include "../RuntimeDyldCOFF.h" 17#include "llvm/BinaryFormat/COFF.h" 18#include "llvm/Object/COFF.h" 19 20#define DEBUG_TYPE "dyld" 21 22namespace llvm { 23 24static bool isThumbFunc(object::symbol_iterator Symbol, 25 const object::ObjectFile &Obj, 26 object::section_iterator Section) { 27 Expected<object::SymbolRef::Type> SymTypeOrErr = Symbol->getType(); 28 if (!SymTypeOrErr) { 29 std::string Buf; 30 raw_string_ostream OS(Buf); 31 logAllUnhandledErrors(SymTypeOrErr.takeError(), OS); 32 OS.flush(); 33 report_fatal_error(Buf); 34 } 35 36 if (*SymTypeOrErr != object::SymbolRef::ST_Function) 37 return false; 38 39 // We check the IMAGE_SCN_MEM_16BIT flag in the section of the symbol to tell 40 // if it's thumb or not 41 return cast<object::COFFObjectFile>(Obj) 42 .getCOFFSection(*Section) 43 ->Characteristics & 44 COFF::IMAGE_SCN_MEM_16BIT; 45} 46 47class RuntimeDyldCOFFThumb : public RuntimeDyldCOFF { 48public: 49 RuntimeDyldCOFFThumb(RuntimeDyld::MemoryManager &MM, 50 JITSymbolResolver &Resolver) 51 : RuntimeDyldCOFF(MM, Resolver, 4, COFF::IMAGE_REL_ARM_ADDR32) {} 52 53 unsigned getMaxStubSize() const override { 54 return 16; // 8-byte load instructions, 4-byte jump, 4-byte padding 55 } 56 57 unsigned getStubAlignment() override { return 1; } 58 59 Expected<object::relocation_iterator> 60 processRelocationRef(unsigned SectionID, 61 object::relocation_iterator RelI, 62 const object::ObjectFile &Obj, 63 ObjSectionToIDMap &ObjSectionToID, 64 StubMap &Stubs) override { 65 auto Symbol = RelI->getSymbol(); 66 if (Symbol == Obj.symbol_end()) 67 report_fatal_error("Unknown symbol in relocation"); 68 69 Expected<StringRef> TargetNameOrErr = Symbol->getName(); 70 if (!TargetNameOrErr) 71 return TargetNameOrErr.takeError(); 72 StringRef TargetName = *TargetNameOrErr; 73 74 auto SectionOrErr = Symbol->getSection(); 75 if (!SectionOrErr) 76 return SectionOrErr.takeError(); 77 auto Section = *SectionOrErr; 78 79 uint64_t RelType = RelI->getType(); 80 uint64_t Offset = RelI->getOffset(); 81 82 // Determine the Addend used to adjust the relocation value. 83 uint64_t Addend = 0; 84 SectionEntry &AddendSection = Sections[SectionID]; 85 uintptr_t ObjTarget = AddendSection.getObjAddress() + Offset; 86 uint8_t *Displacement = (uint8_t *)ObjTarget; 87 88 switch (RelType) { 89 case COFF::IMAGE_REL_ARM_ADDR32: 90 case COFF::IMAGE_REL_ARM_ADDR32NB: 91 case COFF::IMAGE_REL_ARM_SECREL: 92 Addend = readBytesUnaligned(Displacement, 4); 93 break; 94 default: 95 break; 96 } 97 98#if !defined(NDEBUG) 99 SmallString<32> RelTypeName; 100 RelI->getTypeName(RelTypeName); 101#endif 102 LLVM_DEBUG(dbgs() << "\t\tIn Section " << SectionID << " Offset " << Offset 103 << " RelType: " << RelTypeName << " TargetName: " 104 << TargetName << " Addend " << Addend << "\n"); 105 106 bool IsExtern = Section == Obj.section_end(); 107 unsigned TargetSectionID = -1; 108 uint64_t TargetOffset = -1; 109 110 if (TargetName.startswith(getImportSymbolPrefix())) { 111 TargetSectionID = SectionID; 112 TargetOffset = getDLLImportOffset(SectionID, Stubs, TargetName, true); 113 TargetName = StringRef(); 114 IsExtern = false; 115 } else if (!IsExtern) { 116 if (auto TargetSectionIDOrErr = 117 findOrEmitSection(Obj, *Section, Section->isText(), ObjSectionToID)) 118 TargetSectionID = *TargetSectionIDOrErr; 119 else 120 return TargetSectionIDOrErr.takeError(); 121 if (RelType != COFF::IMAGE_REL_ARM_SECTION) 122 TargetOffset = getSymbolOffset(*Symbol); 123 } 124 125 if (IsExtern) { 126 RelocationEntry RE(SectionID, Offset, RelType, 0, -1, 0, 0, 0, false, 0); 127 addRelocationForSymbol(RE, TargetName); 128 } else { 129 130 // We need to find out if the relocation is relative to a thumb function 131 // so that we include the ISA selection bit when resolve the relocation 132 bool IsTargetThumbFunc = isThumbFunc(Symbol, Obj, Section); 133 134 switch (RelType) { 135 default: llvm_unreachable("unsupported relocation type"); 136 case COFF::IMAGE_REL_ARM_ABSOLUTE: 137 // This relocation is ignored. 138 break; 139 case COFF::IMAGE_REL_ARM_ADDR32: { 140 RelocationEntry RE = 141 RelocationEntry(SectionID, Offset, RelType, Addend, TargetSectionID, 142 TargetOffset, 0, 0, false, 0, IsTargetThumbFunc); 143 addRelocationForSection(RE, TargetSectionID); 144 break; 145 } 146 case COFF::IMAGE_REL_ARM_ADDR32NB: { 147 RelocationEntry RE = 148 RelocationEntry(SectionID, Offset, RelType, Addend, TargetSectionID, 149 TargetOffset, 0, 0, false, 0); 150 addRelocationForSection(RE, TargetSectionID); 151 break; 152 } 153 case COFF::IMAGE_REL_ARM_SECTION: { 154 RelocationEntry RE = 155 RelocationEntry(TargetSectionID, Offset, RelType, 0); 156 addRelocationForSection(RE, TargetSectionID); 157 break; 158 } 159 case COFF::IMAGE_REL_ARM_SECREL: { 160 RelocationEntry RE = 161 RelocationEntry(SectionID, Offset, RelType, TargetOffset + Addend); 162 addRelocationForSection(RE, TargetSectionID); 163 break; 164 } 165 case COFF::IMAGE_REL_ARM_MOV32T: { 166 RelocationEntry RE = 167 RelocationEntry(SectionID, Offset, RelType, Addend, TargetSectionID, 168 TargetOffset, 0, 0, false, 0, IsTargetThumbFunc); 169 addRelocationForSection(RE, TargetSectionID); 170 break; 171 } 172 case COFF::IMAGE_REL_ARM_BRANCH20T: 173 case COFF::IMAGE_REL_ARM_BRANCH24T: 174 case COFF::IMAGE_REL_ARM_BLX23T: { 175 RelocationEntry RE = RelocationEntry(SectionID, Offset, RelType, 176 TargetOffset + Addend, true, 0); 177 addRelocationForSection(RE, TargetSectionID); 178 break; 179 } 180 } 181 } 182 183 return ++RelI; 184 } 185 186 void resolveRelocation(const RelocationEntry &RE, uint64_t Value) override { 187 const auto Section = Sections[RE.SectionID]; 188 uint8_t *Target = Section.getAddressWithOffset(RE.Offset); 189 int ISASelectionBit = RE.IsTargetThumbFunc ? 1 : 0; 190 191 switch (RE.RelType) { 192 default: llvm_unreachable("unsupported relocation type"); 193 case COFF::IMAGE_REL_ARM_ABSOLUTE: 194 // This relocation is ignored. 195 break; 196 case COFF::IMAGE_REL_ARM_ADDR32: { 197 // The target's 32-bit VA. 198 uint64_t Result = 199 RE.Sections.SectionA == static_cast<uint32_t>(-1) 200 ? Value 201 : Sections[RE.Sections.SectionA].getLoadAddressWithOffset(RE.Addend); 202 Result |= ISASelectionBit; 203 assert(Result <= UINT32_MAX && "relocation overflow"); 204 LLVM_DEBUG(dbgs() << "\t\tOffset: " << RE.Offset 205 << " RelType: IMAGE_REL_ARM_ADDR32" 206 << " TargetSection: " << RE.Sections.SectionA 207 << " Value: " << format("0x%08" PRIx32, Result) 208 << '\n'); 209 writeBytesUnaligned(Result, Target, 4); 210 break; 211 } 212 case COFF::IMAGE_REL_ARM_ADDR32NB: { 213 // The target's 32-bit RVA. 214 // NOTE: use Section[0].getLoadAddress() as an approximation of ImageBase 215 uint64_t Result = Sections[RE.Sections.SectionA].getLoadAddress() - 216 Sections[0].getLoadAddress() + RE.Addend; 217 assert(Result <= UINT32_MAX && "relocation overflow"); 218 LLVM_DEBUG(dbgs() << "\t\tOffset: " << RE.Offset 219 << " RelType: IMAGE_REL_ARM_ADDR32NB" 220 << " TargetSection: " << RE.Sections.SectionA 221 << " Value: " << format("0x%08" PRIx32, Result) 222 << '\n'); 223 Result |= ISASelectionBit; 224 writeBytesUnaligned(Result, Target, 4); 225 break; 226 } 227 case COFF::IMAGE_REL_ARM_SECTION: 228 // 16-bit section index of the section that contains the target. 229 assert(static_cast<uint32_t>(RE.SectionID) <= UINT16_MAX && 230 "relocation overflow"); 231 LLVM_DEBUG(dbgs() << "\t\tOffset: " << RE.Offset 232 << " RelType: IMAGE_REL_ARM_SECTION Value: " 233 << RE.SectionID << '\n'); 234 writeBytesUnaligned(RE.SectionID, Target, 2); 235 break; 236 case COFF::IMAGE_REL_ARM_SECREL: 237 // 32-bit offset of the target from the beginning of its section. 238 assert(static_cast<uint64_t>(RE.Addend) <= UINT32_MAX && 239 "relocation overflow"); 240 LLVM_DEBUG(dbgs() << "\t\tOffset: " << RE.Offset 241 << " RelType: IMAGE_REL_ARM_SECREL Value: " << RE.Addend 242 << '\n'); 243 writeBytesUnaligned(RE.Addend, Target, 2); 244 break; 245 case COFF::IMAGE_REL_ARM_MOV32T: { 246 // 32-bit VA of the target applied to a contiguous MOVW+MOVT pair. 247 uint64_t Result = 248 Sections[RE.Sections.SectionA].getLoadAddressWithOffset(RE.Addend); 249 assert(Result <= UINT32_MAX && "relocation overflow"); 250 LLVM_DEBUG(dbgs() << "\t\tOffset: " << RE.Offset 251 << " RelType: IMAGE_REL_ARM_MOV32T" 252 << " TargetSection: " << RE.Sections.SectionA 253 << " Value: " << format("0x%08" PRIx32, Result) 254 << '\n'); 255 256 // MOVW(T3): |11110|i|10|0|1|0|0|imm4|0|imm3|Rd|imm8| 257 // imm32 = zext imm4:i:imm3:imm8 258 // MOVT(T1): |11110|i|10|1|1|0|0|imm4|0|imm3|Rd|imm8| 259 // imm16 = imm4:i:imm3:imm8 260 261 auto EncodeImmediate = [](uint8_t *Bytes, uint16_t Immediate) { 262 Bytes[0] |= ((Immediate & 0xf000) >> 12); 263 Bytes[1] |= ((Immediate & 0x0800) >> 11); 264 Bytes[2] |= ((Immediate & 0x00ff) >> 0); 265 Bytes[3] |= (((Immediate & 0x0700) >> 8) << 4); 266 }; 267 268 EncodeImmediate(&Target[0], 269 (static_cast<uint32_t>(Result) >> 00) | ISASelectionBit); 270 EncodeImmediate(&Target[4], static_cast<uint32_t>(Result) >> 16); 271 break; 272 } 273 case COFF::IMAGE_REL_ARM_BRANCH20T: { 274 // The most significant 20-bits of the signed 21-bit relative displacement 275 uint64_t Value = 276 RE.Addend - (Sections[RE.SectionID].getLoadAddress() + RE.Offset) - 4; 277 assert(static_cast<int64_t>(RE.Addend) <= INT32_MAX && 278 "relocation overflow"); 279 assert(static_cast<int64_t>(RE.Addend) >= INT32_MIN && 280 "relocation underflow"); 281 LLVM_DEBUG(dbgs() << "\t\tOffset: " << RE.Offset 282 << " RelType: IMAGE_REL_ARM_BRANCH20T" 283 << " Value: " << static_cast<int32_t>(Value) << '\n'); 284 static_cast<void>(Value); 285 llvm_unreachable("unimplemented relocation"); 286 break; 287 } 288 case COFF::IMAGE_REL_ARM_BRANCH24T: { 289 // The most significant 24-bits of the signed 25-bit relative displacement 290 uint64_t Value = 291 RE.Addend - (Sections[RE.SectionID].getLoadAddress() + RE.Offset) - 4; 292 assert(static_cast<int64_t>(RE.Addend) <= INT32_MAX && 293 "relocation overflow"); 294 assert(static_cast<int64_t>(RE.Addend) >= INT32_MIN && 295 "relocation underflow"); 296 LLVM_DEBUG(dbgs() << "\t\tOffset: " << RE.Offset 297 << " RelType: IMAGE_REL_ARM_BRANCH24T" 298 << " Value: " << static_cast<int32_t>(Value) << '\n'); 299 static_cast<void>(Value); 300 llvm_unreachable("unimplemented relocation"); 301 break; 302 } 303 case COFF::IMAGE_REL_ARM_BLX23T: { 304 // The most significant 24-bits of the signed 25-bit relative displacement 305 uint64_t Value = 306 RE.Addend - (Sections[RE.SectionID].getLoadAddress() + RE.Offset) - 4; 307 assert(static_cast<int64_t>(RE.Addend) <= INT32_MAX && 308 "relocation overflow"); 309 assert(static_cast<int64_t>(RE.Addend) >= INT32_MIN && 310 "relocation underflow"); 311 LLVM_DEBUG(dbgs() << "\t\tOffset: " << RE.Offset 312 << " RelType: IMAGE_REL_ARM_BLX23T" 313 << " Value: " << static_cast<int32_t>(Value) << '\n'); 314 static_cast<void>(Value); 315 llvm_unreachable("unimplemented relocation"); 316 break; 317 } 318 } 319 } 320 321 void registerEHFrames() override {} 322}; 323 324} 325 326#endif 327