1 //===-- RuntimeDyldELF.cpp - Run-time dynamic linker for MC-JIT -*- 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 // Implementation of ELF support for the MC-JIT runtime dynamic linker. 11 // 12 //===----------------------------------------------------------------------===// 13 14 #include "RuntimeDyldELF.h" 15 #include "JITRegistrar.h" 16 #include "ObjectImageCommon.h" 17 #include "llvm/ADT/IntervalMap.h" 18 #include "llvm/ADT/STLExtras.h" 19 #include "llvm/ADT/StringRef.h" 20 #include "llvm/ADT/Triple.h" 21 #include "llvm/ExecutionEngine/ObjectBuffer.h" 22 #include "llvm/ExecutionEngine/ObjectImage.h" 23 #include "llvm/Object/ELFObjectFile.h" 24 #include "llvm/Object/ObjectFile.h" 25 #include "llvm/Support/ELF.h" 26 #include "llvm/Support/MemoryBuffer.h" 27 28 using namespace llvm; 29 using namespace llvm::object; 30 31 #define DEBUG_TYPE "dyld" 32 33 namespace { 34 35 static inline std::error_code check(std::error_code Err) { 36 if (Err) { 37 report_fatal_error(Err.message()); 38 } 39 return Err; 40 } 41 42 template <class ELFT> class DyldELFObject : public ELFObjectFile<ELFT> { 43 LLVM_ELF_IMPORT_TYPES_ELFT(ELFT) 44 45 typedef Elf_Shdr_Impl<ELFT> Elf_Shdr; 46 typedef Elf_Sym_Impl<ELFT> Elf_Sym; 47 typedef Elf_Rel_Impl<ELFT, false> Elf_Rel; 48 typedef Elf_Rel_Impl<ELFT, true> Elf_Rela; 49 50 typedef Elf_Ehdr_Impl<ELFT> Elf_Ehdr; 51 52 typedef typename ELFDataTypeTypedefHelper<ELFT>::value_type addr_type; 53 54 std::unique_ptr<ObjectFile> UnderlyingFile; 55 56 public: 57 DyldELFObject(std::unique_ptr<ObjectFile> UnderlyingFile, 58 std::unique_ptr<MemoryBuffer> Wrapper, std::error_code &ec); 59 60 DyldELFObject(std::unique_ptr<MemoryBuffer> Wrapper, std::error_code &ec); 61 62 void updateSectionAddress(const SectionRef &Sec, uint64_t Addr); 63 void updateSymbolAddress(const SymbolRef &Sym, uint64_t Addr); 64 65 // Methods for type inquiry through isa, cast and dyn_cast 66 static inline bool classof(const Binary *v) { 67 return (isa<ELFObjectFile<ELFT>>(v) && 68 classof(cast<ELFObjectFile<ELFT>>(v))); 69 } 70 static inline bool classof(const ELFObjectFile<ELFT> *v) { 71 return v->isDyldType(); 72 } 73 }; 74 75 template <class ELFT> class ELFObjectImage : public ObjectImageCommon { 76 bool Registered; 77 78 public: 79 ELFObjectImage(ObjectBuffer *Input, std::unique_ptr<DyldELFObject<ELFT>> Obj) 80 : ObjectImageCommon(Input, std::move(Obj)), Registered(false) {} 81 82 virtual ~ELFObjectImage() { 83 if (Registered) 84 deregisterWithDebugger(); 85 } 86 87 // Subclasses can override these methods to update the image with loaded 88 // addresses for sections and common symbols 89 void updateSectionAddress(const SectionRef &Sec, uint64_t Addr) override { 90 static_cast<DyldELFObject<ELFT>*>(getObjectFile()) 91 ->updateSectionAddress(Sec, Addr); 92 } 93 94 void updateSymbolAddress(const SymbolRef &Sym, uint64_t Addr) override { 95 static_cast<DyldELFObject<ELFT>*>(getObjectFile()) 96 ->updateSymbolAddress(Sym, Addr); 97 } 98 99 void registerWithDebugger() override { 100 JITRegistrar::getGDBRegistrar().registerObject(*Buffer); 101 Registered = true; 102 } 103 void deregisterWithDebugger() override { 104 JITRegistrar::getGDBRegistrar().deregisterObject(*Buffer); 105 } 106 }; 107 108 // The MemoryBuffer passed into this constructor is just a wrapper around the 109 // actual memory. Ultimately, the Binary parent class will take ownership of 110 // this MemoryBuffer object but not the underlying memory. 111 template <class ELFT> 112 DyldELFObject<ELFT>::DyldELFObject(std::unique_ptr<MemoryBuffer> Wrapper, 113 std::error_code &EC) 114 : ELFObjectFile<ELFT>(std::move(Wrapper), EC) { 115 this->isDyldELFObject = true; 116 } 117 118 template <class ELFT> 119 DyldELFObject<ELFT>::DyldELFObject(std::unique_ptr<ObjectFile> UnderlyingFile, 120 std::unique_ptr<MemoryBuffer> Wrapper, 121 std::error_code &EC) 122 : ELFObjectFile<ELFT>(std::move(Wrapper), EC), 123 UnderlyingFile(std::move(UnderlyingFile)) { 124 this->isDyldELFObject = true; 125 } 126 127 template <class ELFT> 128 void DyldELFObject<ELFT>::updateSectionAddress(const SectionRef &Sec, 129 uint64_t Addr) { 130 DataRefImpl ShdrRef = Sec.getRawDataRefImpl(); 131 Elf_Shdr *shdr = 132 const_cast<Elf_Shdr *>(reinterpret_cast<const Elf_Shdr *>(ShdrRef.p)); 133 134 // This assumes the address passed in matches the target address bitness 135 // The template-based type cast handles everything else. 136 shdr->sh_addr = static_cast<addr_type>(Addr); 137 } 138 139 template <class ELFT> 140 void DyldELFObject<ELFT>::updateSymbolAddress(const SymbolRef &SymRef, 141 uint64_t Addr) { 142 143 Elf_Sym *sym = const_cast<Elf_Sym *>( 144 ELFObjectFile<ELFT>::getSymbol(SymRef.getRawDataRefImpl())); 145 146 // This assumes the address passed in matches the target address bitness 147 // The template-based type cast handles everything else. 148 sym->st_value = static_cast<addr_type>(Addr); 149 } 150 151 } // namespace 152 153 namespace llvm { 154 155 void RuntimeDyldELF::registerEHFrames() { 156 if (!MemMgr) 157 return; 158 for (int i = 0, e = UnregisteredEHFrameSections.size(); i != e; ++i) { 159 SID EHFrameSID = UnregisteredEHFrameSections[i]; 160 uint8_t *EHFrameAddr = Sections[EHFrameSID].Address; 161 uint64_t EHFrameLoadAddr = Sections[EHFrameSID].LoadAddress; 162 size_t EHFrameSize = Sections[EHFrameSID].Size; 163 MemMgr->registerEHFrames(EHFrameAddr, EHFrameLoadAddr, EHFrameSize); 164 RegisteredEHFrameSections.push_back(EHFrameSID); 165 } 166 UnregisteredEHFrameSections.clear(); 167 } 168 169 void RuntimeDyldELF::deregisterEHFrames() { 170 if (!MemMgr) 171 return; 172 for (int i = 0, e = RegisteredEHFrameSections.size(); i != e; ++i) { 173 SID EHFrameSID = RegisteredEHFrameSections[i]; 174 uint8_t *EHFrameAddr = Sections[EHFrameSID].Address; 175 uint64_t EHFrameLoadAddr = Sections[EHFrameSID].LoadAddress; 176 size_t EHFrameSize = Sections[EHFrameSID].Size; 177 MemMgr->deregisterEHFrames(EHFrameAddr, EHFrameLoadAddr, EHFrameSize); 178 } 179 RegisteredEHFrameSections.clear(); 180 } 181 182 ObjectImage * 183 RuntimeDyldELF::createObjectImageFromFile(std::unique_ptr<object::ObjectFile> ObjFile) { 184 if (!ObjFile) 185 return nullptr; 186 187 std::error_code ec; 188 std::unique_ptr<MemoryBuffer> Buffer( 189 MemoryBuffer::getMemBuffer(ObjFile->getData(), "", false)); 190 191 if (ObjFile->getBytesInAddress() == 4 && ObjFile->isLittleEndian()) { 192 auto Obj = 193 llvm::make_unique<DyldELFObject<ELFType<support::little, 2, false>>>( 194 std::move(ObjFile), std::move(Buffer), ec); 195 return new ELFObjectImage<ELFType<support::little, 2, false>>( 196 nullptr, std::move(Obj)); 197 } else if (ObjFile->getBytesInAddress() == 4 && !ObjFile->isLittleEndian()) { 198 auto Obj = 199 llvm::make_unique<DyldELFObject<ELFType<support::big, 2, false>>>( 200 std::move(ObjFile), std::move(Buffer), ec); 201 return new ELFObjectImage<ELFType<support::big, 2, false>>(nullptr, std::move(Obj)); 202 } else if (ObjFile->getBytesInAddress() == 8 && !ObjFile->isLittleEndian()) { 203 auto Obj = llvm::make_unique<DyldELFObject<ELFType<support::big, 2, true>>>( 204 std::move(ObjFile), std::move(Buffer), ec); 205 return new ELFObjectImage<ELFType<support::big, 2, true>>(nullptr, 206 std::move(Obj)); 207 } else if (ObjFile->getBytesInAddress() == 8 && ObjFile->isLittleEndian()) { 208 auto Obj = 209 llvm::make_unique<DyldELFObject<ELFType<support::little, 2, true>>>( 210 std::move(ObjFile), std::move(Buffer), ec); 211 return new ELFObjectImage<ELFType<support::little, 2, true>>( 212 nullptr, std::move(Obj)); 213 } else 214 llvm_unreachable("Unexpected ELF format"); 215 } 216 217 ObjectImage *RuntimeDyldELF::createObjectImage(ObjectBuffer *Buffer) { 218 if (Buffer->getBufferSize() < ELF::EI_NIDENT) 219 llvm_unreachable("Unexpected ELF object size"); 220 std::pair<unsigned char, unsigned char> Ident = 221 std::make_pair((uint8_t)Buffer->getBufferStart()[ELF::EI_CLASS], 222 (uint8_t)Buffer->getBufferStart()[ELF::EI_DATA]); 223 std::error_code ec; 224 225 std::unique_ptr<MemoryBuffer> Buf(Buffer->getMemBuffer()); 226 227 if (Ident.first == ELF::ELFCLASS32 && Ident.second == ELF::ELFDATA2LSB) { 228 auto Obj = 229 llvm::make_unique<DyldELFObject<ELFType<support::little, 4, false>>>( 230 std::move(Buf), ec); 231 return new ELFObjectImage<ELFType<support::little, 4, false>>( 232 Buffer, std::move(Obj)); 233 } else if (Ident.first == ELF::ELFCLASS32 && 234 Ident.second == ELF::ELFDATA2MSB) { 235 auto Obj = 236 llvm::make_unique<DyldELFObject<ELFType<support::big, 4, false>>>( 237 std::move(Buf), ec); 238 return new ELFObjectImage<ELFType<support::big, 4, false>>(Buffer, 239 std::move(Obj)); 240 } else if (Ident.first == ELF::ELFCLASS64 && 241 Ident.second == ELF::ELFDATA2MSB) { 242 auto Obj = llvm::make_unique<DyldELFObject<ELFType<support::big, 8, true>>>( 243 std::move(Buf), ec); 244 return new ELFObjectImage<ELFType<support::big, 8, true>>(Buffer, std::move(Obj)); 245 } else if (Ident.first == ELF::ELFCLASS64 && 246 Ident.second == ELF::ELFDATA2LSB) { 247 auto Obj = 248 llvm::make_unique<DyldELFObject<ELFType<support::little, 8, true>>>( 249 std::move(Buf), ec); 250 return new ELFObjectImage<ELFType<support::little, 8, true>>(Buffer, std::move(Obj)); 251 } else 252 llvm_unreachable("Unexpected ELF format"); 253 } 254 255 RuntimeDyldELF::~RuntimeDyldELF() {} 256 257 void RuntimeDyldELF::resolveX86_64Relocation(const SectionEntry &Section, 258 uint64_t Offset, uint64_t Value, 259 uint32_t Type, int64_t Addend, 260 uint64_t SymOffset) { 261 switch (Type) { 262 default: 263 llvm_unreachable("Relocation type not implemented yet!"); 264 break; 265 case ELF::R_X86_64_64: { 266 uint64_t *Target = reinterpret_cast<uint64_t *>(Section.Address + Offset); 267 *Target = Value + Addend; 268 DEBUG(dbgs() << "Writing " << format("%p", (Value + Addend)) << " at " 269 << format("%p\n", Target)); 270 break; 271 } 272 case ELF::R_X86_64_32: 273 case ELF::R_X86_64_32S: { 274 Value += Addend; 275 assert((Type == ELF::R_X86_64_32 && (Value <= UINT32_MAX)) || 276 (Type == ELF::R_X86_64_32S && 277 ((int64_t)Value <= INT32_MAX && (int64_t)Value >= INT32_MIN))); 278 uint32_t TruncatedAddr = (Value & 0xFFFFFFFF); 279 uint32_t *Target = reinterpret_cast<uint32_t *>(Section.Address + Offset); 280 *Target = TruncatedAddr; 281 DEBUG(dbgs() << "Writing " << format("%p", TruncatedAddr) << " at " 282 << format("%p\n", Target)); 283 break; 284 } 285 case ELF::R_X86_64_GOTPCREL: { 286 // findGOTEntry returns the 'G + GOT' part of the relocation calculation 287 // based on the load/target address of the GOT (not the current/local addr). 288 uint64_t GOTAddr = findGOTEntry(Value, SymOffset); 289 uint32_t *Target = reinterpret_cast<uint32_t *>(Section.Address + Offset); 290 uint64_t FinalAddress = Section.LoadAddress + Offset; 291 // The processRelocationRef method combines the symbol offset and the addend 292 // and in most cases that's what we want. For this relocation type, we need 293 // the raw addend, so we subtract the symbol offset to get it. 294 int64_t RealOffset = GOTAddr + Addend - SymOffset - FinalAddress; 295 assert(RealOffset <= INT32_MAX && RealOffset >= INT32_MIN); 296 int32_t TruncOffset = (RealOffset & 0xFFFFFFFF); 297 *Target = TruncOffset; 298 break; 299 } 300 case ELF::R_X86_64_PC32: { 301 // Get the placeholder value from the generated object since 302 // a previous relocation attempt may have overwritten the loaded version 303 uint32_t *Placeholder = 304 reinterpret_cast<uint32_t *>(Section.ObjAddress + Offset); 305 uint32_t *Target = reinterpret_cast<uint32_t *>(Section.Address + Offset); 306 uint64_t FinalAddress = Section.LoadAddress + Offset; 307 int64_t RealOffset = *Placeholder + Value + Addend - FinalAddress; 308 assert(RealOffset <= INT32_MAX && RealOffset >= INT32_MIN); 309 int32_t TruncOffset = (RealOffset & 0xFFFFFFFF); 310 *Target = TruncOffset; 311 break; 312 } 313 case ELF::R_X86_64_PC64: { 314 // Get the placeholder value from the generated object since 315 // a previous relocation attempt may have overwritten the loaded version 316 uint64_t *Placeholder = 317 reinterpret_cast<uint64_t *>(Section.ObjAddress + Offset); 318 uint64_t *Target = reinterpret_cast<uint64_t *>(Section.Address + Offset); 319 uint64_t FinalAddress = Section.LoadAddress + Offset; 320 *Target = *Placeholder + Value + Addend - FinalAddress; 321 break; 322 } 323 } 324 } 325 326 void RuntimeDyldELF::resolveX86Relocation(const SectionEntry &Section, 327 uint64_t Offset, uint32_t Value, 328 uint32_t Type, int32_t Addend) { 329 switch (Type) { 330 case ELF::R_386_32: { 331 // Get the placeholder value from the generated object since 332 // a previous relocation attempt may have overwritten the loaded version 333 uint32_t *Placeholder = 334 reinterpret_cast<uint32_t *>(Section.ObjAddress + Offset); 335 uint32_t *Target = reinterpret_cast<uint32_t *>(Section.Address + Offset); 336 *Target = *Placeholder + Value + Addend; 337 break; 338 } 339 case ELF::R_386_PC32: { 340 // Get the placeholder value from the generated object since 341 // a previous relocation attempt may have overwritten the loaded version 342 uint32_t *Placeholder = 343 reinterpret_cast<uint32_t *>(Section.ObjAddress + Offset); 344 uint32_t *Target = reinterpret_cast<uint32_t *>(Section.Address + Offset); 345 uint32_t FinalAddress = ((Section.LoadAddress + Offset) & 0xFFFFFFFF); 346 uint32_t RealOffset = *Placeholder + Value + Addend - FinalAddress; 347 *Target = RealOffset; 348 break; 349 } 350 default: 351 // There are other relocation types, but it appears these are the 352 // only ones currently used by the LLVM ELF object writer 353 llvm_unreachable("Relocation type not implemented yet!"); 354 break; 355 } 356 } 357 358 void RuntimeDyldELF::resolveAArch64Relocation(const SectionEntry &Section, 359 uint64_t Offset, uint64_t Value, 360 uint32_t Type, int64_t Addend) { 361 uint32_t *TargetPtr = reinterpret_cast<uint32_t *>(Section.Address + Offset); 362 uint64_t FinalAddress = Section.LoadAddress + Offset; 363 364 DEBUG(dbgs() << "resolveAArch64Relocation, LocalAddress: 0x" 365 << format("%llx", Section.Address + Offset) 366 << " FinalAddress: 0x" << format("%llx", FinalAddress) 367 << " Value: 0x" << format("%llx", Value) << " Type: 0x" 368 << format("%x", Type) << " Addend: 0x" << format("%llx", Addend) 369 << "\n"); 370 371 switch (Type) { 372 default: 373 llvm_unreachable("Relocation type not implemented yet!"); 374 break; 375 case ELF::R_AARCH64_ABS64: { 376 uint64_t *TargetPtr = 377 reinterpret_cast<uint64_t *>(Section.Address + Offset); 378 *TargetPtr = Value + Addend; 379 break; 380 } 381 case ELF::R_AARCH64_PREL32: { 382 uint64_t Result = Value + Addend - FinalAddress; 383 assert(static_cast<int64_t>(Result) >= INT32_MIN && 384 static_cast<int64_t>(Result) <= UINT32_MAX); 385 *TargetPtr = static_cast<uint32_t>(Result & 0xffffffffU); 386 break; 387 } 388 case ELF::R_AARCH64_CALL26: // fallthrough 389 case ELF::R_AARCH64_JUMP26: { 390 // Operation: S+A-P. Set Call or B immediate value to bits fff_fffc of the 391 // calculation. 392 uint64_t BranchImm = Value + Addend - FinalAddress; 393 394 // "Check that -2^27 <= result < 2^27". 395 assert(-(1LL << 27) <= static_cast<int64_t>(BranchImm) && 396 static_cast<int64_t>(BranchImm) < (1LL << 27)); 397 398 // AArch64 code is emitted with .rela relocations. The data already in any 399 // bits affected by the relocation on entry is garbage. 400 *TargetPtr &= 0xfc000000U; 401 // Immediate goes in bits 25:0 of B and BL. 402 *TargetPtr |= static_cast<uint32_t>(BranchImm & 0xffffffcU) >> 2; 403 break; 404 } 405 case ELF::R_AARCH64_MOVW_UABS_G3: { 406 uint64_t Result = Value + Addend; 407 408 // AArch64 code is emitted with .rela relocations. The data already in any 409 // bits affected by the relocation on entry is garbage. 410 *TargetPtr &= 0xffe0001fU; 411 // Immediate goes in bits 20:5 of MOVZ/MOVK instruction 412 *TargetPtr |= Result >> (48 - 5); 413 // Shift must be "lsl #48", in bits 22:21 414 assert((*TargetPtr >> 21 & 0x3) == 3 && "invalid shift for relocation"); 415 break; 416 } 417 case ELF::R_AARCH64_MOVW_UABS_G2_NC: { 418 uint64_t Result = Value + Addend; 419 420 // AArch64 code is emitted with .rela relocations. The data already in any 421 // bits affected by the relocation on entry is garbage. 422 *TargetPtr &= 0xffe0001fU; 423 // Immediate goes in bits 20:5 of MOVZ/MOVK instruction 424 *TargetPtr |= ((Result & 0xffff00000000ULL) >> (32 - 5)); 425 // Shift must be "lsl #32", in bits 22:21 426 assert((*TargetPtr >> 21 & 0x3) == 2 && "invalid shift for relocation"); 427 break; 428 } 429 case ELF::R_AARCH64_MOVW_UABS_G1_NC: { 430 uint64_t Result = Value + Addend; 431 432 // AArch64 code is emitted with .rela relocations. The data already in any 433 // bits affected by the relocation on entry is garbage. 434 *TargetPtr &= 0xffe0001fU; 435 // Immediate goes in bits 20:5 of MOVZ/MOVK instruction 436 *TargetPtr |= ((Result & 0xffff0000U) >> (16 - 5)); 437 // Shift must be "lsl #16", in bits 22:2 438 assert((*TargetPtr >> 21 & 0x3) == 1 && "invalid shift for relocation"); 439 break; 440 } 441 case ELF::R_AARCH64_MOVW_UABS_G0_NC: { 442 uint64_t Result = Value + Addend; 443 444 // AArch64 code is emitted with .rela relocations. The data already in any 445 // bits affected by the relocation on entry is garbage. 446 *TargetPtr &= 0xffe0001fU; 447 // Immediate goes in bits 20:5 of MOVZ/MOVK instruction 448 *TargetPtr |= ((Result & 0xffffU) << 5); 449 // Shift must be "lsl #0", in bits 22:21. 450 assert((*TargetPtr >> 21 & 0x3) == 0 && "invalid shift for relocation"); 451 break; 452 } 453 case ELF::R_AARCH64_ADR_PREL_PG_HI21: { 454 // Operation: Page(S+A) - Page(P) 455 uint64_t Result = 456 ((Value + Addend) & ~0xfffULL) - (FinalAddress & ~0xfffULL); 457 458 // Check that -2^32 <= X < 2^32 459 assert(static_cast<int64_t>(Result) >= (-1LL << 32) && 460 static_cast<int64_t>(Result) < (1LL << 32) && 461 "overflow check failed for relocation"); 462 463 // AArch64 code is emitted with .rela relocations. The data already in any 464 // bits affected by the relocation on entry is garbage. 465 *TargetPtr &= 0x9f00001fU; 466 // Immediate goes in bits 30:29 + 5:23 of ADRP instruction, taken 467 // from bits 32:12 of X. 468 *TargetPtr |= ((Result & 0x3000U) << (29 - 12)); 469 *TargetPtr |= ((Result & 0x1ffffc000ULL) >> (14 - 5)); 470 break; 471 } 472 case ELF::R_AARCH64_LDST32_ABS_LO12_NC: { 473 // Operation: S + A 474 uint64_t Result = Value + Addend; 475 476 // AArch64 code is emitted with .rela relocations. The data already in any 477 // bits affected by the relocation on entry is garbage. 478 *TargetPtr &= 0xffc003ffU; 479 // Immediate goes in bits 21:10 of LD/ST instruction, taken 480 // from bits 11:2 of X 481 *TargetPtr |= ((Result & 0xffc) << (10 - 2)); 482 break; 483 } 484 case ELF::R_AARCH64_LDST64_ABS_LO12_NC: { 485 // Operation: S + A 486 uint64_t Result = Value + Addend; 487 488 // AArch64 code is emitted with .rela relocations. The data already in any 489 // bits affected by the relocation on entry is garbage. 490 *TargetPtr &= 0xffc003ffU; 491 // Immediate goes in bits 21:10 of LD/ST instruction, taken 492 // from bits 11:3 of X 493 *TargetPtr |= ((Result & 0xff8) << (10 - 3)); 494 break; 495 } 496 } 497 } 498 499 void RuntimeDyldELF::resolveARMRelocation(const SectionEntry &Section, 500 uint64_t Offset, uint32_t Value, 501 uint32_t Type, int32_t Addend) { 502 // TODO: Add Thumb relocations. 503 uint32_t *Placeholder = 504 reinterpret_cast<uint32_t *>(Section.ObjAddress + Offset); 505 uint32_t *TargetPtr = (uint32_t *)(Section.Address + Offset); 506 uint32_t FinalAddress = ((Section.LoadAddress + Offset) & 0xFFFFFFFF); 507 Value += Addend; 508 509 DEBUG(dbgs() << "resolveARMRelocation, LocalAddress: " 510 << Section.Address + Offset 511 << " FinalAddress: " << format("%p", FinalAddress) << " Value: " 512 << format("%x", Value) << " Type: " << format("%x", Type) 513 << " Addend: " << format("%x", Addend) << "\n"); 514 515 switch (Type) { 516 default: 517 llvm_unreachable("Not implemented relocation type!"); 518 519 case ELF::R_ARM_NONE: 520 break; 521 // Write a 32bit value to relocation address, taking into account the 522 // implicit addend encoded in the target. 523 case ELF::R_ARM_PREL31: 524 case ELF::R_ARM_TARGET1: 525 case ELF::R_ARM_ABS32: 526 *TargetPtr = *Placeholder + Value; 527 break; 528 // Write first 16 bit of 32 bit value to the mov instruction. 529 // Last 4 bit should be shifted. 530 case ELF::R_ARM_MOVW_ABS_NC: 531 // We are not expecting any other addend in the relocation address. 532 // Using 0x000F0FFF because MOVW has its 16 bit immediate split into 2 533 // non-contiguous fields. 534 assert((*Placeholder & 0x000F0FFF) == 0); 535 Value = Value & 0xFFFF; 536 *TargetPtr = *Placeholder | (Value & 0xFFF); 537 *TargetPtr |= ((Value >> 12) & 0xF) << 16; 538 break; 539 // Write last 16 bit of 32 bit value to the mov instruction. 540 // Last 4 bit should be shifted. 541 case ELF::R_ARM_MOVT_ABS: 542 // We are not expecting any other addend in the relocation address. 543 // Use 0x000F0FFF for the same reason as R_ARM_MOVW_ABS_NC. 544 assert((*Placeholder & 0x000F0FFF) == 0); 545 546 Value = (Value >> 16) & 0xFFFF; 547 *TargetPtr = *Placeholder | (Value & 0xFFF); 548 *TargetPtr |= ((Value >> 12) & 0xF) << 16; 549 break; 550 // Write 24 bit relative value to the branch instruction. 551 case ELF::R_ARM_PC24: // Fall through. 552 case ELF::R_ARM_CALL: // Fall through. 553 case ELF::R_ARM_JUMP24: { 554 int32_t RelValue = static_cast<int32_t>(Value - FinalAddress - 8); 555 RelValue = (RelValue & 0x03FFFFFC) >> 2; 556 assert((*TargetPtr & 0xFFFFFF) == 0xFFFFFE); 557 *TargetPtr &= 0xFF000000; 558 *TargetPtr |= RelValue; 559 break; 560 } 561 case ELF::R_ARM_PRIVATE_0: 562 // This relocation is reserved by the ARM ELF ABI for internal use. We 563 // appropriate it here to act as an R_ARM_ABS32 without any addend for use 564 // in the stubs created during JIT (which can't put an addend into the 565 // original object file). 566 *TargetPtr = Value; 567 break; 568 } 569 } 570 571 void RuntimeDyldELF::resolveMIPSRelocation(const SectionEntry &Section, 572 uint64_t Offset, uint32_t Value, 573 uint32_t Type, int32_t Addend) { 574 uint32_t *Placeholder = 575 reinterpret_cast<uint32_t *>(Section.ObjAddress + Offset); 576 uint32_t *TargetPtr = (uint32_t *)(Section.Address + Offset); 577 Value += Addend; 578 579 DEBUG(dbgs() << "resolveMipselocation, LocalAddress: " 580 << Section.Address + Offset << " FinalAddress: " 581 << format("%p", Section.LoadAddress + Offset) << " Value: " 582 << format("%x", Value) << " Type: " << format("%x", Type) 583 << " Addend: " << format("%x", Addend) << "\n"); 584 585 switch (Type) { 586 default: 587 llvm_unreachable("Not implemented relocation type!"); 588 break; 589 case ELF::R_MIPS_32: 590 *TargetPtr = Value + (*Placeholder); 591 break; 592 case ELF::R_MIPS_26: 593 *TargetPtr = ((*Placeholder) & 0xfc000000) | ((Value & 0x0fffffff) >> 2); 594 break; 595 case ELF::R_MIPS_HI16: 596 // Get the higher 16-bits. Also add 1 if bit 15 is 1. 597 Value += ((*Placeholder) & 0x0000ffff) << 16; 598 *TargetPtr = 599 ((*Placeholder) & 0xffff0000) | (((Value + 0x8000) >> 16) & 0xffff); 600 break; 601 case ELF::R_MIPS_LO16: 602 Value += ((*Placeholder) & 0x0000ffff); 603 *TargetPtr = ((*Placeholder) & 0xffff0000) | (Value & 0xffff); 604 break; 605 case ELF::R_MIPS_UNUSED1: 606 // Similar to ELF::R_ARM_PRIVATE_0, R_MIPS_UNUSED1 and R_MIPS_UNUSED2 607 // are used for internal JIT purpose. These relocations are similar to 608 // R_MIPS_HI16 and R_MIPS_LO16, but they do not take any addend into 609 // account. 610 *TargetPtr = 611 ((*TargetPtr) & 0xffff0000) | (((Value + 0x8000) >> 16) & 0xffff); 612 break; 613 case ELF::R_MIPS_UNUSED2: 614 *TargetPtr = ((*TargetPtr) & 0xffff0000) | (Value & 0xffff); 615 break; 616 } 617 } 618 619 // Return the .TOC. section and offset. 620 void RuntimeDyldELF::findPPC64TOCSection(ObjectImage &Obj, 621 ObjSectionToIDMap &LocalSections, 622 RelocationValueRef &Rel) { 623 // Set a default SectionID in case we do not find a TOC section below. 624 // This may happen for references to TOC base base (sym@toc, .odp 625 // relocation) without a .toc directive. In this case just use the 626 // first section (which is usually the .odp) since the code won't 627 // reference the .toc base directly. 628 Rel.SymbolName = NULL; 629 Rel.SectionID = 0; 630 631 // The TOC consists of sections .got, .toc, .tocbss, .plt in that 632 // order. The TOC starts where the first of these sections starts. 633 for (section_iterator si = Obj.begin_sections(), se = Obj.end_sections(); 634 si != se; ++si) { 635 636 StringRef SectionName; 637 check(si->getName(SectionName)); 638 639 if (SectionName == ".got" 640 || SectionName == ".toc" 641 || SectionName == ".tocbss" 642 || SectionName == ".plt") { 643 Rel.SectionID = findOrEmitSection(Obj, *si, false, LocalSections); 644 break; 645 } 646 } 647 648 // Per the ppc64-elf-linux ABI, The TOC base is TOC value plus 0x8000 649 // thus permitting a full 64 Kbytes segment. 650 Rel.Addend = 0x8000; 651 } 652 653 // Returns the sections and offset associated with the ODP entry referenced 654 // by Symbol. 655 void RuntimeDyldELF::findOPDEntrySection(ObjectImage &Obj, 656 ObjSectionToIDMap &LocalSections, 657 RelocationValueRef &Rel) { 658 // Get the ELF symbol value (st_value) to compare with Relocation offset in 659 // .opd entries 660 for (section_iterator si = Obj.begin_sections(), se = Obj.end_sections(); 661 si != se; ++si) { 662 section_iterator RelSecI = si->getRelocatedSection(); 663 if (RelSecI == Obj.end_sections()) 664 continue; 665 666 StringRef RelSectionName; 667 check(RelSecI->getName(RelSectionName)); 668 if (RelSectionName != ".opd") 669 continue; 670 671 for (relocation_iterator i = si->relocation_begin(), 672 e = si->relocation_end(); 673 i != e;) { 674 // The R_PPC64_ADDR64 relocation indicates the first field 675 // of a .opd entry 676 uint64_t TypeFunc; 677 check(i->getType(TypeFunc)); 678 if (TypeFunc != ELF::R_PPC64_ADDR64) { 679 ++i; 680 continue; 681 } 682 683 uint64_t TargetSymbolOffset; 684 symbol_iterator TargetSymbol = i->getSymbol(); 685 check(i->getOffset(TargetSymbolOffset)); 686 int64_t Addend; 687 check(getELFRelocationAddend(*i, Addend)); 688 689 ++i; 690 if (i == e) 691 break; 692 693 // Just check if following relocation is a R_PPC64_TOC 694 uint64_t TypeTOC; 695 check(i->getType(TypeTOC)); 696 if (TypeTOC != ELF::R_PPC64_TOC) 697 continue; 698 699 // Finally compares the Symbol value and the target symbol offset 700 // to check if this .opd entry refers to the symbol the relocation 701 // points to. 702 if (Rel.Addend != (int64_t)TargetSymbolOffset) 703 continue; 704 705 section_iterator tsi(Obj.end_sections()); 706 check(TargetSymbol->getSection(tsi)); 707 bool IsCode = false; 708 tsi->isText(IsCode); 709 Rel.SectionID = findOrEmitSection(Obj, (*tsi), IsCode, LocalSections); 710 Rel.Addend = (intptr_t)Addend; 711 return; 712 } 713 } 714 llvm_unreachable("Attempting to get address of ODP entry!"); 715 } 716 717 // Relocation masks following the #lo(value), #hi(value), #ha(value), 718 // #higher(value), #highera(value), #highest(value), and #highesta(value) 719 // macros defined in section 4.5.1. Relocation Types of the PPC-elf64abi 720 // document. 721 722 static inline uint16_t applyPPClo(uint64_t value) { return value & 0xffff; } 723 724 static inline uint16_t applyPPChi(uint64_t value) { 725 return (value >> 16) & 0xffff; 726 } 727 728 static inline uint16_t applyPPCha (uint64_t value) { 729 return ((value + 0x8000) >> 16) & 0xffff; 730 } 731 732 static inline uint16_t applyPPChigher(uint64_t value) { 733 return (value >> 32) & 0xffff; 734 } 735 736 static inline uint16_t applyPPChighera (uint64_t value) { 737 return ((value + 0x8000) >> 32) & 0xffff; 738 } 739 740 static inline uint16_t applyPPChighest(uint64_t value) { 741 return (value >> 48) & 0xffff; 742 } 743 744 static inline uint16_t applyPPChighesta (uint64_t value) { 745 return ((value + 0x8000) >> 48) & 0xffff; 746 } 747 748 void RuntimeDyldELF::resolvePPC64Relocation(const SectionEntry &Section, 749 uint64_t Offset, uint64_t Value, 750 uint32_t Type, int64_t Addend) { 751 uint8_t *LocalAddress = Section.Address + Offset; 752 switch (Type) { 753 default: 754 llvm_unreachable("Relocation type not implemented yet!"); 755 break; 756 case ELF::R_PPC64_ADDR16: 757 writeInt16BE(LocalAddress, applyPPClo(Value + Addend)); 758 break; 759 case ELF::R_PPC64_ADDR16_DS: 760 writeInt16BE(LocalAddress, applyPPClo(Value + Addend) & ~3); 761 break; 762 case ELF::R_PPC64_ADDR16_LO: 763 writeInt16BE(LocalAddress, applyPPClo(Value + Addend)); 764 break; 765 case ELF::R_PPC64_ADDR16_LO_DS: 766 writeInt16BE(LocalAddress, applyPPClo(Value + Addend) & ~3); 767 break; 768 case ELF::R_PPC64_ADDR16_HI: 769 writeInt16BE(LocalAddress, applyPPChi(Value + Addend)); 770 break; 771 case ELF::R_PPC64_ADDR16_HA: 772 writeInt16BE(LocalAddress, applyPPCha(Value + Addend)); 773 break; 774 case ELF::R_PPC64_ADDR16_HIGHER: 775 writeInt16BE(LocalAddress, applyPPChigher(Value + Addend)); 776 break; 777 case ELF::R_PPC64_ADDR16_HIGHERA: 778 writeInt16BE(LocalAddress, applyPPChighera(Value + Addend)); 779 break; 780 case ELF::R_PPC64_ADDR16_HIGHEST: 781 writeInt16BE(LocalAddress, applyPPChighest(Value + Addend)); 782 break; 783 case ELF::R_PPC64_ADDR16_HIGHESTA: 784 writeInt16BE(LocalAddress, applyPPChighesta(Value + Addend)); 785 break; 786 case ELF::R_PPC64_ADDR14: { 787 assert(((Value + Addend) & 3) == 0); 788 // Preserve the AA/LK bits in the branch instruction 789 uint8_t aalk = *(LocalAddress + 3); 790 writeInt16BE(LocalAddress + 2, (aalk & 3) | ((Value + Addend) & 0xfffc)); 791 } break; 792 case ELF::R_PPC64_REL16_LO: { 793 uint64_t FinalAddress = (Section.LoadAddress + Offset); 794 uint64_t Delta = Value - FinalAddress + Addend; 795 writeInt16BE(LocalAddress, applyPPClo(Delta)); 796 } break; 797 case ELF::R_PPC64_REL16_HI: { 798 uint64_t FinalAddress = (Section.LoadAddress + Offset); 799 uint64_t Delta = Value - FinalAddress + Addend; 800 writeInt16BE(LocalAddress, applyPPChi(Delta)); 801 } break; 802 case ELF::R_PPC64_REL16_HA: { 803 uint64_t FinalAddress = (Section.LoadAddress + Offset); 804 uint64_t Delta = Value - FinalAddress + Addend; 805 writeInt16BE(LocalAddress, applyPPCha(Delta)); 806 } break; 807 case ELF::R_PPC64_ADDR32: { 808 int32_t Result = static_cast<int32_t>(Value + Addend); 809 if (SignExtend32<32>(Result) != Result) 810 llvm_unreachable("Relocation R_PPC64_ADDR32 overflow"); 811 writeInt32BE(LocalAddress, Result); 812 } break; 813 case ELF::R_PPC64_REL24: { 814 uint64_t FinalAddress = (Section.LoadAddress + Offset); 815 int32_t delta = static_cast<int32_t>(Value - FinalAddress + Addend); 816 if (SignExtend32<24>(delta) != delta) 817 llvm_unreachable("Relocation R_PPC64_REL24 overflow"); 818 // Generates a 'bl <address>' instruction 819 writeInt32BE(LocalAddress, 0x48000001 | (delta & 0x03FFFFFC)); 820 } break; 821 case ELF::R_PPC64_REL32: { 822 uint64_t FinalAddress = (Section.LoadAddress + Offset); 823 int32_t delta = static_cast<int32_t>(Value - FinalAddress + Addend); 824 if (SignExtend32<32>(delta) != delta) 825 llvm_unreachable("Relocation R_PPC64_REL32 overflow"); 826 writeInt32BE(LocalAddress, delta); 827 } break; 828 case ELF::R_PPC64_REL64: { 829 uint64_t FinalAddress = (Section.LoadAddress + Offset); 830 uint64_t Delta = Value - FinalAddress + Addend; 831 writeInt64BE(LocalAddress, Delta); 832 } break; 833 case ELF::R_PPC64_ADDR64: 834 writeInt64BE(LocalAddress, Value + Addend); 835 break; 836 } 837 } 838 839 void RuntimeDyldELF::resolveSystemZRelocation(const SectionEntry &Section, 840 uint64_t Offset, uint64_t Value, 841 uint32_t Type, int64_t Addend) { 842 uint8_t *LocalAddress = Section.Address + Offset; 843 switch (Type) { 844 default: 845 llvm_unreachable("Relocation type not implemented yet!"); 846 break; 847 case ELF::R_390_PC16DBL: 848 case ELF::R_390_PLT16DBL: { 849 int64_t Delta = (Value + Addend) - (Section.LoadAddress + Offset); 850 assert(int16_t(Delta / 2) * 2 == Delta && "R_390_PC16DBL overflow"); 851 writeInt16BE(LocalAddress, Delta / 2); 852 break; 853 } 854 case ELF::R_390_PC32DBL: 855 case ELF::R_390_PLT32DBL: { 856 int64_t Delta = (Value + Addend) - (Section.LoadAddress + Offset); 857 assert(int32_t(Delta / 2) * 2 == Delta && "R_390_PC32DBL overflow"); 858 writeInt32BE(LocalAddress, Delta / 2); 859 break; 860 } 861 case ELF::R_390_PC32: { 862 int64_t Delta = (Value + Addend) - (Section.LoadAddress + Offset); 863 assert(int32_t(Delta) == Delta && "R_390_PC32 overflow"); 864 writeInt32BE(LocalAddress, Delta); 865 break; 866 } 867 case ELF::R_390_64: 868 writeInt64BE(LocalAddress, Value + Addend); 869 break; 870 } 871 } 872 873 // The target location for the relocation is described by RE.SectionID and 874 // RE.Offset. RE.SectionID can be used to find the SectionEntry. Each 875 // SectionEntry has three members describing its location. 876 // SectionEntry::Address is the address at which the section has been loaded 877 // into memory in the current (host) process. SectionEntry::LoadAddress is the 878 // address that the section will have in the target process. 879 // SectionEntry::ObjAddress is the address of the bits for this section in the 880 // original emitted object image (also in the current address space). 881 // 882 // Relocations will be applied as if the section were loaded at 883 // SectionEntry::LoadAddress, but they will be applied at an address based 884 // on SectionEntry::Address. SectionEntry::ObjAddress will be used to refer to 885 // Target memory contents if they are required for value calculations. 886 // 887 // The Value parameter here is the load address of the symbol for the 888 // relocation to be applied. For relocations which refer to symbols in the 889 // current object Value will be the LoadAddress of the section in which 890 // the symbol resides (RE.Addend provides additional information about the 891 // symbol location). For external symbols, Value will be the address of the 892 // symbol in the target address space. 893 void RuntimeDyldELF::resolveRelocation(const RelocationEntry &RE, 894 uint64_t Value) { 895 const SectionEntry &Section = Sections[RE.SectionID]; 896 return resolveRelocation(Section, RE.Offset, Value, RE.RelType, RE.Addend, 897 RE.SymOffset); 898 } 899 900 void RuntimeDyldELF::resolveRelocation(const SectionEntry &Section, 901 uint64_t Offset, uint64_t Value, 902 uint32_t Type, int64_t Addend, 903 uint64_t SymOffset) { 904 switch (Arch) { 905 case Triple::x86_64: 906 resolveX86_64Relocation(Section, Offset, Value, Type, Addend, SymOffset); 907 break; 908 case Triple::x86: 909 resolveX86Relocation(Section, Offset, (uint32_t)(Value & 0xffffffffL), Type, 910 (uint32_t)(Addend & 0xffffffffL)); 911 break; 912 case Triple::aarch64: 913 case Triple::aarch64_be: 914 case Triple::arm64: 915 case Triple::arm64_be: 916 resolveAArch64Relocation(Section, Offset, Value, Type, Addend); 917 break; 918 case Triple::arm: // Fall through. 919 case Triple::armeb: 920 case Triple::thumb: 921 case Triple::thumbeb: 922 resolveARMRelocation(Section, Offset, (uint32_t)(Value & 0xffffffffL), Type, 923 (uint32_t)(Addend & 0xffffffffL)); 924 break; 925 case Triple::mips: // Fall through. 926 case Triple::mipsel: 927 resolveMIPSRelocation(Section, Offset, (uint32_t)(Value & 0xffffffffL), 928 Type, (uint32_t)(Addend & 0xffffffffL)); 929 break; 930 case Triple::ppc64: // Fall through. 931 case Triple::ppc64le: 932 resolvePPC64Relocation(Section, Offset, Value, Type, Addend); 933 break; 934 case Triple::systemz: 935 resolveSystemZRelocation(Section, Offset, Value, Type, Addend); 936 break; 937 default: 938 llvm_unreachable("Unsupported CPU type!"); 939 } 940 } 941 942 relocation_iterator RuntimeDyldELF::processRelocationRef( 943 unsigned SectionID, relocation_iterator RelI, ObjectImage &Obj, 944 ObjSectionToIDMap &ObjSectionToID, const SymbolTableMap &Symbols, 945 StubMap &Stubs) { 946 uint64_t RelType; 947 Check(RelI->getType(RelType)); 948 int64_t Addend; 949 Check(getELFRelocationAddend(*RelI, Addend)); 950 symbol_iterator Symbol = RelI->getSymbol(); 951 952 // Obtain the symbol name which is referenced in the relocation 953 StringRef TargetName; 954 if (Symbol != Obj.end_symbols()) 955 Symbol->getName(TargetName); 956 DEBUG(dbgs() << "\t\tRelType: " << RelType << " Addend: " << Addend 957 << " TargetName: " << TargetName << "\n"); 958 RelocationValueRef Value; 959 // First search for the symbol in the local symbol table 960 SymbolTableMap::const_iterator lsi = Symbols.end(); 961 SymbolRef::Type SymType = SymbolRef::ST_Unknown; 962 if (Symbol != Obj.end_symbols()) { 963 lsi = Symbols.find(TargetName.data()); 964 Symbol->getType(SymType); 965 } 966 if (lsi != Symbols.end()) { 967 Value.SectionID = lsi->second.first; 968 Value.Offset = lsi->second.second; 969 Value.Addend = lsi->second.second + Addend; 970 } else { 971 // Search for the symbol in the global symbol table 972 SymbolTableMap::const_iterator gsi = GlobalSymbolTable.end(); 973 if (Symbol != Obj.end_symbols()) 974 gsi = GlobalSymbolTable.find(TargetName.data()); 975 if (gsi != GlobalSymbolTable.end()) { 976 Value.SectionID = gsi->second.first; 977 Value.Offset = gsi->second.second; 978 Value.Addend = gsi->second.second + Addend; 979 } else { 980 switch (SymType) { 981 case SymbolRef::ST_Debug: { 982 // TODO: Now ELF SymbolRef::ST_Debug = STT_SECTION, it's not obviously 983 // and can be changed by another developers. Maybe best way is add 984 // a new symbol type ST_Section to SymbolRef and use it. 985 section_iterator si(Obj.end_sections()); 986 Symbol->getSection(si); 987 if (si == Obj.end_sections()) 988 llvm_unreachable("Symbol section not found, bad object file format!"); 989 DEBUG(dbgs() << "\t\tThis is section symbol\n"); 990 // Default to 'true' in case isText fails (though it never does). 991 bool isCode = true; 992 si->isText(isCode); 993 Value.SectionID = findOrEmitSection(Obj, (*si), isCode, ObjSectionToID); 994 Value.Addend = Addend; 995 break; 996 } 997 case SymbolRef::ST_Data: 998 case SymbolRef::ST_Unknown: { 999 Value.SymbolName = TargetName.data(); 1000 Value.Addend = Addend; 1001 1002 // Absolute relocations will have a zero symbol ID (STN_UNDEF), which 1003 // will manifest here as a NULL symbol name. 1004 // We can set this as a valid (but empty) symbol name, and rely 1005 // on addRelocationForSymbol to handle this. 1006 if (!Value.SymbolName) 1007 Value.SymbolName = ""; 1008 break; 1009 } 1010 default: 1011 llvm_unreachable("Unresolved symbol type!"); 1012 break; 1013 } 1014 } 1015 } 1016 uint64_t Offset; 1017 Check(RelI->getOffset(Offset)); 1018 1019 DEBUG(dbgs() << "\t\tSectionID: " << SectionID << " Offset: " << Offset 1020 << "\n"); 1021 if ((Arch == Triple::aarch64 || Arch == Triple::aarch64_be || 1022 Arch == Triple::arm64 || Arch == Triple::arm64_be) && 1023 (RelType == ELF::R_AARCH64_CALL26 || RelType == ELF::R_AARCH64_JUMP26)) { 1024 // This is an AArch64 branch relocation, need to use a stub function. 1025 DEBUG(dbgs() << "\t\tThis is an AArch64 branch relocation."); 1026 SectionEntry &Section = Sections[SectionID]; 1027 1028 // Look for an existing stub. 1029 StubMap::const_iterator i = Stubs.find(Value); 1030 if (i != Stubs.end()) { 1031 resolveRelocation(Section, Offset, (uint64_t)Section.Address + i->second, 1032 RelType, 0); 1033 DEBUG(dbgs() << " Stub function found\n"); 1034 } else { 1035 // Create a new stub function. 1036 DEBUG(dbgs() << " Create a new stub function\n"); 1037 Stubs[Value] = Section.StubOffset; 1038 uint8_t *StubTargetAddr = 1039 createStubFunction(Section.Address + Section.StubOffset); 1040 1041 RelocationEntry REmovz_g3(SectionID, StubTargetAddr - Section.Address, 1042 ELF::R_AARCH64_MOVW_UABS_G3, Value.Addend); 1043 RelocationEntry REmovk_g2(SectionID, StubTargetAddr - Section.Address + 4, 1044 ELF::R_AARCH64_MOVW_UABS_G2_NC, Value.Addend); 1045 RelocationEntry REmovk_g1(SectionID, StubTargetAddr - Section.Address + 8, 1046 ELF::R_AARCH64_MOVW_UABS_G1_NC, Value.Addend); 1047 RelocationEntry REmovk_g0(SectionID, 1048 StubTargetAddr - Section.Address + 12, 1049 ELF::R_AARCH64_MOVW_UABS_G0_NC, Value.Addend); 1050 1051 if (Value.SymbolName) { 1052 addRelocationForSymbol(REmovz_g3, Value.SymbolName); 1053 addRelocationForSymbol(REmovk_g2, Value.SymbolName); 1054 addRelocationForSymbol(REmovk_g1, Value.SymbolName); 1055 addRelocationForSymbol(REmovk_g0, Value.SymbolName); 1056 } else { 1057 addRelocationForSection(REmovz_g3, Value.SectionID); 1058 addRelocationForSection(REmovk_g2, Value.SectionID); 1059 addRelocationForSection(REmovk_g1, Value.SectionID); 1060 addRelocationForSection(REmovk_g0, Value.SectionID); 1061 } 1062 resolveRelocation(Section, Offset, 1063 (uint64_t)Section.Address + Section.StubOffset, RelType, 1064 0); 1065 Section.StubOffset += getMaxStubSize(); 1066 } 1067 } else if (Arch == Triple::arm && 1068 (RelType == ELF::R_ARM_PC24 || RelType == ELF::R_ARM_CALL || 1069 RelType == ELF::R_ARM_JUMP24)) { 1070 // This is an ARM branch relocation, need to use a stub function. 1071 DEBUG(dbgs() << "\t\tThis is an ARM branch relocation."); 1072 SectionEntry &Section = Sections[SectionID]; 1073 1074 // Look for an existing stub. 1075 StubMap::const_iterator i = Stubs.find(Value); 1076 if (i != Stubs.end()) { 1077 resolveRelocation(Section, Offset, (uint64_t)Section.Address + i->second, 1078 RelType, 0); 1079 DEBUG(dbgs() << " Stub function found\n"); 1080 } else { 1081 // Create a new stub function. 1082 DEBUG(dbgs() << " Create a new stub function\n"); 1083 Stubs[Value] = Section.StubOffset; 1084 uint8_t *StubTargetAddr = 1085 createStubFunction(Section.Address + Section.StubOffset); 1086 RelocationEntry RE(SectionID, StubTargetAddr - Section.Address, 1087 ELF::R_ARM_PRIVATE_0, Value.Addend); 1088 if (Value.SymbolName) 1089 addRelocationForSymbol(RE, Value.SymbolName); 1090 else 1091 addRelocationForSection(RE, Value.SectionID); 1092 1093 resolveRelocation(Section, Offset, 1094 (uint64_t)Section.Address + Section.StubOffset, RelType, 1095 0); 1096 Section.StubOffset += getMaxStubSize(); 1097 } 1098 } else if ((Arch == Triple::mipsel || Arch == Triple::mips) && 1099 RelType == ELF::R_MIPS_26) { 1100 // This is an Mips branch relocation, need to use a stub function. 1101 DEBUG(dbgs() << "\t\tThis is a Mips branch relocation."); 1102 SectionEntry &Section = Sections[SectionID]; 1103 uint8_t *Target = Section.Address + Offset; 1104 uint32_t *TargetAddress = (uint32_t *)Target; 1105 1106 // Extract the addend from the instruction. 1107 uint32_t Addend = ((*TargetAddress) & 0x03ffffff) << 2; 1108 1109 Value.Addend += Addend; 1110 1111 // Look up for existing stub. 1112 StubMap::const_iterator i = Stubs.find(Value); 1113 if (i != Stubs.end()) { 1114 RelocationEntry RE(SectionID, Offset, RelType, i->second); 1115 addRelocationForSection(RE, SectionID); 1116 DEBUG(dbgs() << " Stub function found\n"); 1117 } else { 1118 // Create a new stub function. 1119 DEBUG(dbgs() << " Create a new stub function\n"); 1120 Stubs[Value] = Section.StubOffset; 1121 uint8_t *StubTargetAddr = 1122 createStubFunction(Section.Address + Section.StubOffset); 1123 1124 // Creating Hi and Lo relocations for the filled stub instructions. 1125 RelocationEntry REHi(SectionID, StubTargetAddr - Section.Address, 1126 ELF::R_MIPS_UNUSED1, Value.Addend); 1127 RelocationEntry RELo(SectionID, StubTargetAddr - Section.Address + 4, 1128 ELF::R_MIPS_UNUSED2, Value.Addend); 1129 1130 if (Value.SymbolName) { 1131 addRelocationForSymbol(REHi, Value.SymbolName); 1132 addRelocationForSymbol(RELo, Value.SymbolName); 1133 } else { 1134 addRelocationForSection(REHi, Value.SectionID); 1135 addRelocationForSection(RELo, Value.SectionID); 1136 } 1137 1138 RelocationEntry RE(SectionID, Offset, RelType, Section.StubOffset); 1139 addRelocationForSection(RE, SectionID); 1140 Section.StubOffset += getMaxStubSize(); 1141 } 1142 } else if (Arch == Triple::ppc64 || Arch == Triple::ppc64le) { 1143 if (RelType == ELF::R_PPC64_REL24) { 1144 // A PPC branch relocation will need a stub function if the target is 1145 // an external symbol (Symbol::ST_Unknown) or if the target address 1146 // is not within the signed 24-bits branch address. 1147 SectionEntry &Section = Sections[SectionID]; 1148 uint8_t *Target = Section.Address + Offset; 1149 bool RangeOverflow = false; 1150 if (SymType != SymbolRef::ST_Unknown) { 1151 // A function call may points to the .opd entry, so the final symbol 1152 // value 1153 // in calculated based in the relocation values in .opd section. 1154 findOPDEntrySection(Obj, ObjSectionToID, Value); 1155 uint8_t *RelocTarget = Sections[Value.SectionID].Address + Value.Addend; 1156 int32_t delta = static_cast<int32_t>(Target - RelocTarget); 1157 // If it is within 24-bits branch range, just set the branch target 1158 if (SignExtend32<24>(delta) == delta) { 1159 RelocationEntry RE(SectionID, Offset, RelType, Value.Addend); 1160 if (Value.SymbolName) 1161 addRelocationForSymbol(RE, Value.SymbolName); 1162 else 1163 addRelocationForSection(RE, Value.SectionID); 1164 } else { 1165 RangeOverflow = true; 1166 } 1167 } 1168 if (SymType == SymbolRef::ST_Unknown || RangeOverflow == true) { 1169 // It is an external symbol (SymbolRef::ST_Unknown) or within a range 1170 // larger than 24-bits. 1171 StubMap::const_iterator i = Stubs.find(Value); 1172 if (i != Stubs.end()) { 1173 // Symbol function stub already created, just relocate to it 1174 resolveRelocation(Section, Offset, 1175 (uint64_t)Section.Address + i->second, RelType, 0); 1176 DEBUG(dbgs() << " Stub function found\n"); 1177 } else { 1178 // Create a new stub function. 1179 DEBUG(dbgs() << " Create a new stub function\n"); 1180 Stubs[Value] = Section.StubOffset; 1181 uint8_t *StubTargetAddr = 1182 createStubFunction(Section.Address + Section.StubOffset); 1183 RelocationEntry RE(SectionID, StubTargetAddr - Section.Address, 1184 ELF::R_PPC64_ADDR64, Value.Addend); 1185 1186 // Generates the 64-bits address loads as exemplified in section 1187 // 4.5.1 in PPC64 ELF ABI. Note that the relocations need to 1188 // apply to the low part of the instructions, so we have to update 1189 // the offset according to the target endianness. 1190 uint64_t StubRelocOffset = StubTargetAddr - Section.Address; 1191 if (!IsTargetLittleEndian) 1192 StubRelocOffset += 2; 1193 1194 RelocationEntry REhst(SectionID, StubRelocOffset + 0, 1195 ELF::R_PPC64_ADDR16_HIGHEST, Value.Addend); 1196 RelocationEntry REhr(SectionID, StubRelocOffset + 4, 1197 ELF::R_PPC64_ADDR16_HIGHER, Value.Addend); 1198 RelocationEntry REh(SectionID, StubRelocOffset + 12, 1199 ELF::R_PPC64_ADDR16_HI, Value.Addend); 1200 RelocationEntry REl(SectionID, StubRelocOffset + 16, 1201 ELF::R_PPC64_ADDR16_LO, Value.Addend); 1202 1203 if (Value.SymbolName) { 1204 addRelocationForSymbol(REhst, Value.SymbolName); 1205 addRelocationForSymbol(REhr, Value.SymbolName); 1206 addRelocationForSymbol(REh, Value.SymbolName); 1207 addRelocationForSymbol(REl, Value.SymbolName); 1208 } else { 1209 addRelocationForSection(REhst, Value.SectionID); 1210 addRelocationForSection(REhr, Value.SectionID); 1211 addRelocationForSection(REh, Value.SectionID); 1212 addRelocationForSection(REl, Value.SectionID); 1213 } 1214 1215 resolveRelocation(Section, Offset, 1216 (uint64_t)Section.Address + Section.StubOffset, 1217 RelType, 0); 1218 Section.StubOffset += getMaxStubSize(); 1219 } 1220 if (SymType == SymbolRef::ST_Unknown) 1221 // Restore the TOC for external calls 1222 writeInt32BE(Target + 4, 0xE8410028); // ld r2,40(r1) 1223 } 1224 } else if (RelType == ELF::R_PPC64_TOC16 || 1225 RelType == ELF::R_PPC64_TOC16_DS || 1226 RelType == ELF::R_PPC64_TOC16_LO || 1227 RelType == ELF::R_PPC64_TOC16_LO_DS || 1228 RelType == ELF::R_PPC64_TOC16_HI || 1229 RelType == ELF::R_PPC64_TOC16_HA) { 1230 // These relocations are supposed to subtract the TOC address from 1231 // the final value. This does not fit cleanly into the RuntimeDyld 1232 // scheme, since there may be *two* sections involved in determining 1233 // the relocation value (the section of the symbol refered to by the 1234 // relocation, and the TOC section associated with the current module). 1235 // 1236 // Fortunately, these relocations are currently only ever generated 1237 // refering to symbols that themselves reside in the TOC, which means 1238 // that the two sections are actually the same. Thus they cancel out 1239 // and we can immediately resolve the relocation right now. 1240 switch (RelType) { 1241 case ELF::R_PPC64_TOC16: RelType = ELF::R_PPC64_ADDR16; break; 1242 case ELF::R_PPC64_TOC16_DS: RelType = ELF::R_PPC64_ADDR16_DS; break; 1243 case ELF::R_PPC64_TOC16_LO: RelType = ELF::R_PPC64_ADDR16_LO; break; 1244 case ELF::R_PPC64_TOC16_LO_DS: RelType = ELF::R_PPC64_ADDR16_LO_DS; break; 1245 case ELF::R_PPC64_TOC16_HI: RelType = ELF::R_PPC64_ADDR16_HI; break; 1246 case ELF::R_PPC64_TOC16_HA: RelType = ELF::R_PPC64_ADDR16_HA; break; 1247 default: llvm_unreachable("Wrong relocation type."); 1248 } 1249 1250 RelocationValueRef TOCValue; 1251 findPPC64TOCSection(Obj, ObjSectionToID, TOCValue); 1252 if (Value.SymbolName || Value.SectionID != TOCValue.SectionID) 1253 llvm_unreachable("Unsupported TOC relocation."); 1254 Value.Addend -= TOCValue.Addend; 1255 resolveRelocation(Sections[SectionID], Offset, Value.Addend, RelType, 0); 1256 } else { 1257 // There are two ways to refer to the TOC address directly: either 1258 // via a ELF::R_PPC64_TOC relocation (where both symbol and addend are 1259 // ignored), or via any relocation that refers to the magic ".TOC." 1260 // symbols (in which case the addend is respected). 1261 if (RelType == ELF::R_PPC64_TOC) { 1262 RelType = ELF::R_PPC64_ADDR64; 1263 findPPC64TOCSection(Obj, ObjSectionToID, Value); 1264 } else if (TargetName == ".TOC.") { 1265 findPPC64TOCSection(Obj, ObjSectionToID, Value); 1266 Value.Addend += Addend; 1267 } 1268 1269 RelocationEntry RE(SectionID, Offset, RelType, Value.Addend); 1270 1271 if (Value.SymbolName) 1272 addRelocationForSymbol(RE, Value.SymbolName); 1273 else 1274 addRelocationForSection(RE, Value.SectionID); 1275 } 1276 } else if (Arch == Triple::systemz && 1277 (RelType == ELF::R_390_PLT32DBL || RelType == ELF::R_390_GOTENT)) { 1278 // Create function stubs for both PLT and GOT references, regardless of 1279 // whether the GOT reference is to data or code. The stub contains the 1280 // full address of the symbol, as needed by GOT references, and the 1281 // executable part only adds an overhead of 8 bytes. 1282 // 1283 // We could try to conserve space by allocating the code and data 1284 // parts of the stub separately. However, as things stand, we allocate 1285 // a stub for every relocation, so using a GOT in JIT code should be 1286 // no less space efficient than using an explicit constant pool. 1287 DEBUG(dbgs() << "\t\tThis is a SystemZ indirect relocation."); 1288 SectionEntry &Section = Sections[SectionID]; 1289 1290 // Look for an existing stub. 1291 StubMap::const_iterator i = Stubs.find(Value); 1292 uintptr_t StubAddress; 1293 if (i != Stubs.end()) { 1294 StubAddress = uintptr_t(Section.Address) + i->second; 1295 DEBUG(dbgs() << " Stub function found\n"); 1296 } else { 1297 // Create a new stub function. 1298 DEBUG(dbgs() << " Create a new stub function\n"); 1299 1300 uintptr_t BaseAddress = uintptr_t(Section.Address); 1301 uintptr_t StubAlignment = getStubAlignment(); 1302 StubAddress = (BaseAddress + Section.StubOffset + StubAlignment - 1) & 1303 -StubAlignment; 1304 unsigned StubOffset = StubAddress - BaseAddress; 1305 1306 Stubs[Value] = StubOffset; 1307 createStubFunction((uint8_t *)StubAddress); 1308 RelocationEntry RE(SectionID, StubOffset + 8, ELF::R_390_64, 1309 Value.Addend - Addend); 1310 if (Value.SymbolName) 1311 addRelocationForSymbol(RE, Value.SymbolName); 1312 else 1313 addRelocationForSection(RE, Value.SectionID); 1314 Section.StubOffset = StubOffset + getMaxStubSize(); 1315 } 1316 1317 if (RelType == ELF::R_390_GOTENT) 1318 resolveRelocation(Section, Offset, StubAddress + 8, ELF::R_390_PC32DBL, 1319 Addend); 1320 else 1321 resolveRelocation(Section, Offset, StubAddress, RelType, Addend); 1322 } else if (Arch == Triple::x86_64 && RelType == ELF::R_X86_64_PLT32) { 1323 // The way the PLT relocations normally work is that the linker allocates 1324 // the 1325 // PLT and this relocation makes a PC-relative call into the PLT. The PLT 1326 // entry will then jump to an address provided by the GOT. On first call, 1327 // the 1328 // GOT address will point back into PLT code that resolves the symbol. After 1329 // the first call, the GOT entry points to the actual function. 1330 // 1331 // For local functions we're ignoring all of that here and just replacing 1332 // the PLT32 relocation type with PC32, which will translate the relocation 1333 // into a PC-relative call directly to the function. For external symbols we 1334 // can't be sure the function will be within 2^32 bytes of the call site, so 1335 // we need to create a stub, which calls into the GOT. This case is 1336 // equivalent to the usual PLT implementation except that we use the stub 1337 // mechanism in RuntimeDyld (which puts stubs at the end of the section) 1338 // rather than allocating a PLT section. 1339 if (Value.SymbolName) { 1340 // This is a call to an external function. 1341 // Look for an existing stub. 1342 SectionEntry &Section = Sections[SectionID]; 1343 StubMap::const_iterator i = Stubs.find(Value); 1344 uintptr_t StubAddress; 1345 if (i != Stubs.end()) { 1346 StubAddress = uintptr_t(Section.Address) + i->second; 1347 DEBUG(dbgs() << " Stub function found\n"); 1348 } else { 1349 // Create a new stub function (equivalent to a PLT entry). 1350 DEBUG(dbgs() << " Create a new stub function\n"); 1351 1352 uintptr_t BaseAddress = uintptr_t(Section.Address); 1353 uintptr_t StubAlignment = getStubAlignment(); 1354 StubAddress = (BaseAddress + Section.StubOffset + StubAlignment - 1) & 1355 -StubAlignment; 1356 unsigned StubOffset = StubAddress - BaseAddress; 1357 Stubs[Value] = StubOffset; 1358 createStubFunction((uint8_t *)StubAddress); 1359 1360 // Create a GOT entry for the external function. 1361 GOTEntries.push_back(Value); 1362 1363 // Make our stub function a relative call to the GOT entry. 1364 RelocationEntry RE(SectionID, StubOffset + 2, ELF::R_X86_64_GOTPCREL, 1365 -4); 1366 addRelocationForSymbol(RE, Value.SymbolName); 1367 1368 // Bump our stub offset counter 1369 Section.StubOffset = StubOffset + getMaxStubSize(); 1370 } 1371 1372 // Make the target call a call into the stub table. 1373 resolveRelocation(Section, Offset, StubAddress, ELF::R_X86_64_PC32, 1374 Addend); 1375 } else { 1376 RelocationEntry RE(SectionID, Offset, ELF::R_X86_64_PC32, Value.Addend, 1377 Value.Offset); 1378 addRelocationForSection(RE, Value.SectionID); 1379 } 1380 } else { 1381 if (Arch == Triple::x86_64 && RelType == ELF::R_X86_64_GOTPCREL) { 1382 GOTEntries.push_back(Value); 1383 } 1384 RelocationEntry RE(SectionID, Offset, RelType, Value.Addend, Value.Offset); 1385 if (Value.SymbolName) 1386 addRelocationForSymbol(RE, Value.SymbolName); 1387 else 1388 addRelocationForSection(RE, Value.SectionID); 1389 } 1390 return ++RelI; 1391 } 1392 1393 void RuntimeDyldELF::updateGOTEntries(StringRef Name, uint64_t Addr) { 1394 1395 SmallVectorImpl<std::pair<SID, GOTRelocations>>::iterator it; 1396 SmallVectorImpl<std::pair<SID, GOTRelocations>>::iterator end = GOTs.end(); 1397 1398 for (it = GOTs.begin(); it != end; ++it) { 1399 GOTRelocations &GOTEntries = it->second; 1400 for (int i = 0, e = GOTEntries.size(); i != e; ++i) { 1401 if (GOTEntries[i].SymbolName != nullptr && 1402 GOTEntries[i].SymbolName == Name) { 1403 GOTEntries[i].Offset = Addr; 1404 } 1405 } 1406 } 1407 } 1408 1409 size_t RuntimeDyldELF::getGOTEntrySize() { 1410 // We don't use the GOT in all of these cases, but it's essentially free 1411 // to put them all here. 1412 size_t Result = 0; 1413 switch (Arch) { 1414 case Triple::x86_64: 1415 case Triple::aarch64: 1416 case Triple::aarch64_be: 1417 case Triple::arm64: 1418 case Triple::arm64_be: 1419 case Triple::ppc64: 1420 case Triple::ppc64le: 1421 case Triple::systemz: 1422 Result = sizeof(uint64_t); 1423 break; 1424 case Triple::x86: 1425 case Triple::arm: 1426 case Triple::thumb: 1427 case Triple::mips: 1428 case Triple::mipsel: 1429 Result = sizeof(uint32_t); 1430 break; 1431 default: 1432 llvm_unreachable("Unsupported CPU type!"); 1433 } 1434 return Result; 1435 } 1436 1437 uint64_t RuntimeDyldELF::findGOTEntry(uint64_t LoadAddress, uint64_t Offset) { 1438 1439 const size_t GOTEntrySize = getGOTEntrySize(); 1440 1441 SmallVectorImpl<std::pair<SID, GOTRelocations>>::const_iterator it; 1442 SmallVectorImpl<std::pair<SID, GOTRelocations>>::const_iterator end = 1443 GOTs.end(); 1444 1445 int GOTIndex = -1; 1446 for (it = GOTs.begin(); it != end; ++it) { 1447 SID GOTSectionID = it->first; 1448 const GOTRelocations &GOTEntries = it->second; 1449 1450 // Find the matching entry in our vector. 1451 uint64_t SymbolOffset = 0; 1452 for (int i = 0, e = GOTEntries.size(); i != e; ++i) { 1453 if (!GOTEntries[i].SymbolName) { 1454 if (getSectionLoadAddress(GOTEntries[i].SectionID) == LoadAddress && 1455 GOTEntries[i].Offset == Offset) { 1456 GOTIndex = i; 1457 SymbolOffset = GOTEntries[i].Offset; 1458 break; 1459 } 1460 } else { 1461 // GOT entries for external symbols use the addend as the address when 1462 // the external symbol has been resolved. 1463 if (GOTEntries[i].Offset == LoadAddress) { 1464 GOTIndex = i; 1465 // Don't use the Addend here. The relocation handler will use it. 1466 break; 1467 } 1468 } 1469 } 1470 1471 if (GOTIndex != -1) { 1472 if (GOTEntrySize == sizeof(uint64_t)) { 1473 uint64_t *LocalGOTAddr = (uint64_t *)getSectionAddress(GOTSectionID); 1474 // Fill in this entry with the address of the symbol being referenced. 1475 LocalGOTAddr[GOTIndex] = LoadAddress + SymbolOffset; 1476 } else { 1477 uint32_t *LocalGOTAddr = (uint32_t *)getSectionAddress(GOTSectionID); 1478 // Fill in this entry with the address of the symbol being referenced. 1479 LocalGOTAddr[GOTIndex] = (uint32_t)(LoadAddress + SymbolOffset); 1480 } 1481 1482 // Calculate the load address of this entry 1483 return getSectionLoadAddress(GOTSectionID) + (GOTIndex * GOTEntrySize); 1484 } 1485 } 1486 1487 assert(GOTIndex != -1 && "Unable to find requested GOT entry."); 1488 return 0; 1489 } 1490 1491 void RuntimeDyldELF::finalizeLoad(ObjectImage &ObjImg, 1492 ObjSectionToIDMap &SectionMap) { 1493 // If necessary, allocate the global offset table 1494 if (MemMgr) { 1495 // Allocate the GOT if necessary 1496 size_t numGOTEntries = GOTEntries.size(); 1497 if (numGOTEntries != 0) { 1498 // Allocate memory for the section 1499 unsigned SectionID = Sections.size(); 1500 size_t TotalSize = numGOTEntries * getGOTEntrySize(); 1501 uint8_t *Addr = MemMgr->allocateDataSection(TotalSize, getGOTEntrySize(), 1502 SectionID, ".got", false); 1503 if (!Addr) 1504 report_fatal_error("Unable to allocate memory for GOT!"); 1505 1506 GOTs.push_back(std::make_pair(SectionID, GOTEntries)); 1507 Sections.push_back(SectionEntry(".got", Addr, TotalSize, 0)); 1508 // For now, initialize all GOT entries to zero. We'll fill them in as 1509 // needed when GOT-based relocations are applied. 1510 memset(Addr, 0, TotalSize); 1511 } 1512 } else { 1513 report_fatal_error("Unable to allocate memory for GOT!"); 1514 } 1515 1516 // Look for and record the EH frame section. 1517 ObjSectionToIDMap::iterator i, e; 1518 for (i = SectionMap.begin(), e = SectionMap.end(); i != e; ++i) { 1519 const SectionRef &Section = i->first; 1520 StringRef Name; 1521 Section.getName(Name); 1522 if (Name == ".eh_frame") { 1523 UnregisteredEHFrameSections.push_back(i->second); 1524 break; 1525 } 1526 } 1527 } 1528 1529 bool RuntimeDyldELF::isCompatibleFormat(const ObjectBuffer *Buffer) const { 1530 if (Buffer->getBufferSize() < strlen(ELF::ElfMagic)) 1531 return false; 1532 return (memcmp(Buffer->getBufferStart(), ELF::ElfMagic, 1533 strlen(ELF::ElfMagic))) == 0; 1534 } 1535 1536 bool RuntimeDyldELF::isCompatibleFile(const object::ObjectFile *Obj) const { 1537 return Obj->isELF(); 1538 } 1539 1540 } // namespace llvm 1541
