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 #define DEBUG_TYPE "dyld" 15 #include "RuntimeDyldELF.h" 16 #include "JITRegistrar.h" 17 #include "ObjectImageCommon.h" 18 #include "llvm/ADT/IntervalMap.h" 19 #include "llvm/ADT/OwningPtr.h" 20 #include "llvm/ADT/STLExtras.h" 21 #include "llvm/ADT/StringRef.h" 22 #include "llvm/ADT/Triple.h" 23 #include "llvm/ExecutionEngine/ObjectBuffer.h" 24 #include "llvm/ExecutionEngine/ObjectImage.h" 25 #include "llvm/Object/ELF.h" 26 #include "llvm/Object/ObjectFile.h" 27 #include "llvm/Support/ELF.h" 28 using namespace llvm; 29 using namespace llvm::object; 30 31 namespace { 32 33 static inline 34 error_code check(error_code Err) { 35 if (Err) { 36 report_fatal_error(Err.message()); 37 } 38 return Err; 39 } 40 41 template<class ELFT> 42 class DyldELFObject 43 : public ELFObjectFile<ELFT> { 44 LLVM_ELF_IMPORT_TYPES_ELFT(ELFT) 45 46 typedef Elf_Shdr_Impl<ELFT> Elf_Shdr; 47 typedef Elf_Sym_Impl<ELFT> Elf_Sym; 48 typedef 49 Elf_Rel_Impl<ELFT, false> Elf_Rel; 50 typedef 51 Elf_Rel_Impl<ELFT, true> Elf_Rela; 52 53 typedef Elf_Ehdr_Impl<ELFT> Elf_Ehdr; 54 55 typedef typename ELFDataTypeTypedefHelper< 56 ELFT>::value_type addr_type; 57 58 public: 59 DyldELFObject(MemoryBuffer *Wrapper, error_code &ec); 60 61 void updateSectionAddress(const SectionRef &Sec, uint64_t Addr); 62 void updateSymbolAddress(const SymbolRef &Sym, uint64_t Addr); 63 64 // Methods for type inquiry through isa, cast and dyn_cast 65 static inline bool classof(const Binary *v) { 66 return (isa<ELFObjectFile<ELFT> >(v) 67 && classof(cast<ELFObjectFile 68 <ELFT> >(v))); 69 } 70 static inline bool classof( 71 const ELFObjectFile<ELFT> *v) { 72 return v->isDyldType(); 73 } 74 }; 75 76 template<class ELFT> 77 class ELFObjectImage : public ObjectImageCommon { 78 protected: 79 DyldELFObject<ELFT> *DyldObj; 80 bool Registered; 81 82 public: 83 ELFObjectImage(ObjectBuffer *Input, 84 DyldELFObject<ELFT> *Obj) 85 : ObjectImageCommon(Input, Obj), 86 DyldObj(Obj), 87 Registered(false) {} 88 89 virtual ~ELFObjectImage() { 90 if (Registered) 91 deregisterWithDebugger(); 92 } 93 94 // Subclasses can override these methods to update the image with loaded 95 // addresses for sections and common symbols 96 virtual void updateSectionAddress(const SectionRef &Sec, uint64_t Addr) 97 { 98 DyldObj->updateSectionAddress(Sec, Addr); 99 } 100 101 virtual void updateSymbolAddress(const SymbolRef &Sym, uint64_t Addr) 102 { 103 DyldObj->updateSymbolAddress(Sym, Addr); 104 } 105 106 virtual void registerWithDebugger() 107 { 108 JITRegistrar::getGDBRegistrar().registerObject(*Buffer); 109 Registered = true; 110 } 111 virtual void deregisterWithDebugger() 112 { 113 JITRegistrar::getGDBRegistrar().deregisterObject(*Buffer); 114 } 115 }; 116 117 // The MemoryBuffer passed into this constructor is just a wrapper around the 118 // actual memory. Ultimately, the Binary parent class will take ownership of 119 // this MemoryBuffer object but not the underlying memory. 120 template<class ELFT> 121 DyldELFObject<ELFT>::DyldELFObject(MemoryBuffer *Wrapper, error_code &ec) 122 : ELFObjectFile<ELFT>(Wrapper, ec) { 123 this->isDyldELFObject = true; 124 } 125 126 template<class ELFT> 127 void DyldELFObject<ELFT>::updateSectionAddress(const SectionRef &Sec, 128 uint64_t Addr) { 129 DataRefImpl ShdrRef = Sec.getRawDataRefImpl(); 130 Elf_Shdr *shdr = const_cast<Elf_Shdr*>( 131 reinterpret_cast<const Elf_Shdr *>(ShdrRef.p)); 132 133 // This assumes the address passed in matches the target address bitness 134 // The template-based type cast handles everything else. 135 shdr->sh_addr = static_cast<addr_type>(Addr); 136 } 137 138 template<class ELFT> 139 void DyldELFObject<ELFT>::updateSymbolAddress(const SymbolRef &SymRef, 140 uint64_t Addr) { 141 142 Elf_Sym *sym = const_cast<Elf_Sym*>( 143 ELFObjectFile<ELFT>::getSymbol(SymRef.getRawDataRefImpl())); 144 145 // This assumes the address passed in matches the target address bitness 146 // The template-based type cast handles everything else. 147 sym->st_value = static_cast<addr_type>(Addr); 148 } 149 150 } // namespace 151 152 namespace llvm { 153 154 ObjectImage *RuntimeDyldELF::createObjectImage(ObjectBuffer *Buffer) { 155 if (Buffer->getBufferSize() < ELF::EI_NIDENT) 156 llvm_unreachable("Unexpected ELF object size"); 157 std::pair<unsigned char, unsigned char> Ident = std::make_pair( 158 (uint8_t)Buffer->getBufferStart()[ELF::EI_CLASS], 159 (uint8_t)Buffer->getBufferStart()[ELF::EI_DATA]); 160 error_code ec; 161 162 if (Ident.first == ELF::ELFCLASS32 && Ident.second == ELF::ELFDATA2LSB) { 163 DyldELFObject<ELFType<support::little, 4, false> > *Obj = 164 new DyldELFObject<ELFType<support::little, 4, false> >( 165 Buffer->getMemBuffer(), ec); 166 return new ELFObjectImage<ELFType<support::little, 4, false> >(Buffer, Obj); 167 } 168 else if (Ident.first == ELF::ELFCLASS32 && Ident.second == ELF::ELFDATA2MSB) { 169 DyldELFObject<ELFType<support::big, 4, false> > *Obj = 170 new DyldELFObject<ELFType<support::big, 4, false> >( 171 Buffer->getMemBuffer(), ec); 172 return new ELFObjectImage<ELFType<support::big, 4, false> >(Buffer, Obj); 173 } 174 else if (Ident.first == ELF::ELFCLASS64 && Ident.second == ELF::ELFDATA2MSB) { 175 DyldELFObject<ELFType<support::big, 8, true> > *Obj = 176 new DyldELFObject<ELFType<support::big, 8, true> >( 177 Buffer->getMemBuffer(), ec); 178 return new ELFObjectImage<ELFType<support::big, 8, true> >(Buffer, Obj); 179 } 180 else if (Ident.first == ELF::ELFCLASS64 && Ident.second == ELF::ELFDATA2LSB) { 181 DyldELFObject<ELFType<support::little, 8, true> > *Obj = 182 new DyldELFObject<ELFType<support::little, 8, true> >( 183 Buffer->getMemBuffer(), ec); 184 return new ELFObjectImage<ELFType<support::little, 8, true> >(Buffer, Obj); 185 } 186 else 187 llvm_unreachable("Unexpected ELF format"); 188 } 189 190 RuntimeDyldELF::~RuntimeDyldELF() { 191 } 192 193 void RuntimeDyldELF::resolveX86_64Relocation(const SectionEntry &Section, 194 uint64_t Offset, 195 uint64_t Value, 196 uint32_t Type, 197 int64_t Addend) { 198 switch (Type) { 199 default: 200 llvm_unreachable("Relocation type not implemented yet!"); 201 break; 202 case ELF::R_X86_64_64: { 203 uint64_t *Target = reinterpret_cast<uint64_t*>(Section.Address + Offset); 204 *Target = Value + Addend; 205 DEBUG(dbgs() << "Writing " << format("%p", (Value + Addend)) 206 << " at " << format("%p\n",Target)); 207 break; 208 } 209 case ELF::R_X86_64_32: 210 case ELF::R_X86_64_32S: { 211 Value += Addend; 212 assert((Type == ELF::R_X86_64_32 && (Value <= UINT32_MAX)) || 213 (Type == ELF::R_X86_64_32S && 214 ((int64_t)Value <= INT32_MAX && (int64_t)Value >= INT32_MIN))); 215 uint32_t TruncatedAddr = (Value & 0xFFFFFFFF); 216 uint32_t *Target = reinterpret_cast<uint32_t*>(Section.Address + Offset); 217 *Target = TruncatedAddr; 218 DEBUG(dbgs() << "Writing " << format("%p", TruncatedAddr) 219 << " at " << format("%p\n",Target)); 220 break; 221 } 222 case ELF::R_X86_64_PC32: { 223 // Get the placeholder value from the generated object since 224 // a previous relocation attempt may have overwritten the loaded version 225 uint32_t *Placeholder = reinterpret_cast<uint32_t*>(Section.ObjAddress 226 + Offset); 227 uint32_t *Target = reinterpret_cast<uint32_t*>(Section.Address + Offset); 228 uint64_t FinalAddress = Section.LoadAddress + Offset; 229 int64_t RealOffset = *Placeholder + Value + Addend - FinalAddress; 230 assert(RealOffset <= INT32_MAX && RealOffset >= INT32_MIN); 231 int32_t TruncOffset = (RealOffset & 0xFFFFFFFF); 232 *Target = TruncOffset; 233 break; 234 } 235 } 236 } 237 238 void RuntimeDyldELF::resolveX86Relocation(const SectionEntry &Section, 239 uint64_t Offset, 240 uint32_t Value, 241 uint32_t Type, 242 int32_t Addend) { 243 switch (Type) { 244 case ELF::R_386_32: { 245 // Get the placeholder value from the generated object since 246 // a previous relocation attempt may have overwritten the loaded version 247 uint32_t *Placeholder = reinterpret_cast<uint32_t*>(Section.ObjAddress 248 + Offset); 249 uint32_t *Target = reinterpret_cast<uint32_t*>(Section.Address + Offset); 250 *Target = *Placeholder + Value + Addend; 251 break; 252 } 253 case ELF::R_386_PC32: { 254 // Get the placeholder value from the generated object since 255 // a previous relocation attempt may have overwritten the loaded version 256 uint32_t *Placeholder = reinterpret_cast<uint32_t*>(Section.ObjAddress 257 + Offset); 258 uint32_t *Target = reinterpret_cast<uint32_t*>(Section.Address + Offset); 259 uint32_t FinalAddress = ((Section.LoadAddress + Offset) & 0xFFFFFFFF); 260 uint32_t RealOffset = *Placeholder + Value + Addend - FinalAddress; 261 *Target = RealOffset; 262 break; 263 } 264 default: 265 // There are other relocation types, but it appears these are the 266 // only ones currently used by the LLVM ELF object writer 267 llvm_unreachable("Relocation type not implemented yet!"); 268 break; 269 } 270 } 271 272 void RuntimeDyldELF::resolveARMRelocation(const SectionEntry &Section, 273 uint64_t Offset, 274 uint32_t Value, 275 uint32_t Type, 276 int32_t Addend) { 277 // TODO: Add Thumb relocations. 278 uint32_t* TargetPtr = (uint32_t*)(Section.Address + Offset); 279 uint32_t FinalAddress = ((Section.LoadAddress + Offset) & 0xFFFFFFFF); 280 Value += Addend; 281 282 DEBUG(dbgs() << "resolveARMRelocation, LocalAddress: " 283 << Section.Address + Offset 284 << " FinalAddress: " << format("%p",FinalAddress) 285 << " Value: " << format("%x",Value) 286 << " Type: " << format("%x",Type) 287 << " Addend: " << format("%x",Addend) 288 << "\n"); 289 290 switch(Type) { 291 default: 292 llvm_unreachable("Not implemented relocation type!"); 293 294 // Write a 32bit value to relocation address, taking into account the 295 // implicit addend encoded in the target. 296 case ELF::R_ARM_TARGET1 : 297 case ELF::R_ARM_ABS32 : 298 *TargetPtr += Value; 299 break; 300 301 // Write first 16 bit of 32 bit value to the mov instruction. 302 // Last 4 bit should be shifted. 303 case ELF::R_ARM_MOVW_ABS_NC : 304 // We are not expecting any other addend in the relocation address. 305 // Using 0x000F0FFF because MOVW has its 16 bit immediate split into 2 306 // non-contiguous fields. 307 assert((*TargetPtr & 0x000F0FFF) == 0); 308 Value = Value & 0xFFFF; 309 *TargetPtr |= Value & 0xFFF; 310 *TargetPtr |= ((Value >> 12) & 0xF) << 16; 311 break; 312 313 // Write last 16 bit of 32 bit value to the mov instruction. 314 // Last 4 bit should be shifted. 315 case ELF::R_ARM_MOVT_ABS : 316 // We are not expecting any other addend in the relocation address. 317 // Use 0x000F0FFF for the same reason as R_ARM_MOVW_ABS_NC. 318 assert((*TargetPtr & 0x000F0FFF) == 0); 319 Value = (Value >> 16) & 0xFFFF; 320 *TargetPtr |= Value & 0xFFF; 321 *TargetPtr |= ((Value >> 12) & 0xF) << 16; 322 break; 323 324 // Write 24 bit relative value to the branch instruction. 325 case ELF::R_ARM_PC24 : // Fall through. 326 case ELF::R_ARM_CALL : // Fall through. 327 case ELF::R_ARM_JUMP24 : 328 int32_t RelValue = static_cast<int32_t>(Value - FinalAddress - 8); 329 RelValue = (RelValue & 0x03FFFFFC) >> 2; 330 *TargetPtr &= 0xFF000000; 331 *TargetPtr |= RelValue; 332 break; 333 } 334 } 335 336 void RuntimeDyldELF::resolveMIPSRelocation(const SectionEntry &Section, 337 uint64_t Offset, 338 uint32_t Value, 339 uint32_t Type, 340 int32_t Addend) { 341 uint32_t* TargetPtr = (uint32_t*)(Section.Address + Offset); 342 Value += Addend; 343 344 DEBUG(dbgs() << "resolveMipselocation, LocalAddress: " 345 << Section.Address + Offset 346 << " FinalAddress: " 347 << format("%p",Section.LoadAddress + Offset) 348 << " Value: " << format("%x",Value) 349 << " Type: " << format("%x",Type) 350 << " Addend: " << format("%x",Addend) 351 << "\n"); 352 353 switch(Type) { 354 default: 355 llvm_unreachable("Not implemented relocation type!"); 356 break; 357 case ELF::R_MIPS_32: 358 *TargetPtr = Value + (*TargetPtr); 359 break; 360 case ELF::R_MIPS_26: 361 *TargetPtr = ((*TargetPtr) & 0xfc000000) | (( Value & 0x0fffffff) >> 2); 362 break; 363 case ELF::R_MIPS_HI16: 364 // Get the higher 16-bits. Also add 1 if bit 15 is 1. 365 Value += ((*TargetPtr) & 0x0000ffff) << 16; 366 *TargetPtr = ((*TargetPtr) & 0xffff0000) | 367 (((Value + 0x8000) >> 16) & 0xffff); 368 break; 369 case ELF::R_MIPS_LO16: 370 Value += ((*TargetPtr) & 0x0000ffff); 371 *TargetPtr = ((*TargetPtr) & 0xffff0000) | (Value & 0xffff); 372 break; 373 } 374 } 375 376 // Return the .TOC. section address to R_PPC64_TOC relocations. 377 uint64_t RuntimeDyldELF::findPPC64TOC() const { 378 // The TOC consists of sections .got, .toc, .tocbss, .plt in that 379 // order. The TOC starts where the first of these sections starts. 380 SectionList::const_iterator it = Sections.begin(); 381 SectionList::const_iterator ite = Sections.end(); 382 for (; it != ite; ++it) { 383 if (it->Name == ".got" || 384 it->Name == ".toc" || 385 it->Name == ".tocbss" || 386 it->Name == ".plt") 387 break; 388 } 389 if (it == ite) { 390 // This may happen for 391 // * references to TOC base base (sym@toc, .odp relocation) without 392 // a .toc directive. 393 // In this case just use the first section (which is usually 394 // the .odp) since the code won't reference the .toc base 395 // directly. 396 it = Sections.begin(); 397 } 398 assert (it != ite); 399 // Per the ppc64-elf-linux ABI, The TOC base is TOC value plus 0x8000 400 // thus permitting a full 64 Kbytes segment. 401 return it->LoadAddress + 0x8000; 402 } 403 404 // Returns the sections and offset associated with the ODP entry referenced 405 // by Symbol. 406 void RuntimeDyldELF::findOPDEntrySection(ObjectImage &Obj, 407 ObjSectionToIDMap &LocalSections, 408 RelocationValueRef &Rel) { 409 // Get the ELF symbol value (st_value) to compare with Relocation offset in 410 // .opd entries 411 412 error_code err; 413 for (section_iterator si = Obj.begin_sections(), 414 se = Obj.end_sections(); si != se; si.increment(err)) { 415 StringRef SectionName; 416 check(si->getName(SectionName)); 417 if (SectionName != ".opd") 418 continue; 419 420 for (relocation_iterator i = si->begin_relocations(), 421 e = si->end_relocations(); i != e;) { 422 check(err); 423 424 // The R_PPC64_ADDR64 relocation indicates the first field 425 // of a .opd entry 426 uint64_t TypeFunc; 427 check(i->getType(TypeFunc)); 428 if (TypeFunc != ELF::R_PPC64_ADDR64) { 429 i.increment(err); 430 continue; 431 } 432 433 SymbolRef TargetSymbol; 434 uint64_t TargetSymbolOffset; 435 int64_t TargetAdditionalInfo; 436 check(i->getSymbol(TargetSymbol)); 437 check(i->getOffset(TargetSymbolOffset)); 438 check(i->getAdditionalInfo(TargetAdditionalInfo)); 439 440 i = i.increment(err); 441 if (i == e) 442 break; 443 check(err); 444 445 // Just check if following relocation is a R_PPC64_TOC 446 uint64_t TypeTOC; 447 check(i->getType(TypeTOC)); 448 if (TypeTOC != ELF::R_PPC64_TOC) 449 continue; 450 451 // Finally compares the Symbol value and the target symbol offset 452 // to check if this .opd entry refers to the symbol the relocation 453 // points to. 454 if (Rel.Addend != (intptr_t)TargetSymbolOffset) 455 continue; 456 457 section_iterator tsi(Obj.end_sections()); 458 check(TargetSymbol.getSection(tsi)); 459 Rel.SectionID = findOrEmitSection(Obj, (*tsi), true, LocalSections); 460 Rel.Addend = (intptr_t)TargetAdditionalInfo; 461 return; 462 } 463 } 464 llvm_unreachable("Attempting to get address of ODP entry!"); 465 } 466 467 // Relocation masks following the #lo(value), #hi(value), #higher(value), 468 // and #highest(value) macros defined in section 4.5.1. Relocation Types 469 // in PPC-elf64abi document. 470 // 471 static inline 472 uint16_t applyPPClo (uint64_t value) 473 { 474 return value & 0xffff; 475 } 476 477 static inline 478 uint16_t applyPPChi (uint64_t value) 479 { 480 return (value >> 16) & 0xffff; 481 } 482 483 static inline 484 uint16_t applyPPChigher (uint64_t value) 485 { 486 return (value >> 32) & 0xffff; 487 } 488 489 static inline 490 uint16_t applyPPChighest (uint64_t value) 491 { 492 return (value >> 48) & 0xffff; 493 } 494 495 void RuntimeDyldELF::resolvePPC64Relocation(const SectionEntry &Section, 496 uint64_t Offset, 497 uint64_t Value, 498 uint32_t Type, 499 int64_t Addend) { 500 uint8_t* LocalAddress = Section.Address + Offset; 501 switch (Type) { 502 default: 503 llvm_unreachable("Relocation type not implemented yet!"); 504 break; 505 case ELF::R_PPC64_ADDR16_LO : 506 writeInt16BE(LocalAddress, applyPPClo (Value + Addend)); 507 break; 508 case ELF::R_PPC64_ADDR16_HI : 509 writeInt16BE(LocalAddress, applyPPChi (Value + Addend)); 510 break; 511 case ELF::R_PPC64_ADDR16_HIGHER : 512 writeInt16BE(LocalAddress, applyPPChigher (Value + Addend)); 513 break; 514 case ELF::R_PPC64_ADDR16_HIGHEST : 515 writeInt16BE(LocalAddress, applyPPChighest (Value + Addend)); 516 break; 517 case ELF::R_PPC64_ADDR14 : { 518 assert(((Value + Addend) & 3) == 0); 519 // Preserve the AA/LK bits in the branch instruction 520 uint8_t aalk = *(LocalAddress+3); 521 writeInt16BE(LocalAddress + 2, (aalk & 3) | ((Value + Addend) & 0xfffc)); 522 } break; 523 case ELF::R_PPC64_ADDR32 : { 524 int32_t Result = static_cast<int32_t>(Value + Addend); 525 if (SignExtend32<32>(Result) != Result) 526 llvm_unreachable("Relocation R_PPC64_ADDR32 overflow"); 527 writeInt32BE(LocalAddress, Result); 528 } break; 529 case ELF::R_PPC64_REL24 : { 530 uint64_t FinalAddress = (Section.LoadAddress + Offset); 531 int32_t delta = static_cast<int32_t>(Value - FinalAddress + Addend); 532 if (SignExtend32<24>(delta) != delta) 533 llvm_unreachable("Relocation R_PPC64_REL24 overflow"); 534 // Generates a 'bl <address>' instruction 535 writeInt32BE(LocalAddress, 0x48000001 | (delta & 0x03FFFFFC)); 536 } break; 537 case ELF::R_PPC64_REL32 : { 538 uint64_t FinalAddress = (Section.LoadAddress + Offset); 539 int32_t delta = static_cast<int32_t>(Value - FinalAddress + Addend); 540 if (SignExtend32<32>(delta) != delta) 541 llvm_unreachable("Relocation R_PPC64_REL32 overflow"); 542 writeInt32BE(LocalAddress, delta); 543 } break; 544 case ELF::R_PPC64_ADDR64 : 545 writeInt64BE(LocalAddress, Value + Addend); 546 break; 547 case ELF::R_PPC64_TOC : 548 writeInt64BE(LocalAddress, findPPC64TOC()); 549 break; 550 case ELF::R_PPC64_TOC16 : { 551 uint64_t TOCStart = findPPC64TOC(); 552 Value = applyPPClo((Value + Addend) - TOCStart); 553 writeInt16BE(LocalAddress, applyPPClo(Value)); 554 } break; 555 case ELF::R_PPC64_TOC16_DS : { 556 uint64_t TOCStart = findPPC64TOC(); 557 Value = ((Value + Addend) - TOCStart); 558 writeInt16BE(LocalAddress, applyPPClo(Value)); 559 } break; 560 } 561 } 562 563 void RuntimeDyldELF::resolveRelocation(const RelocationEntry &RE, 564 uint64_t Value) { 565 const SectionEntry &Section = Sections[RE.SectionID]; 566 return resolveRelocation(Section, RE.Offset, Value, RE.RelType, RE.Addend); 567 } 568 569 void RuntimeDyldELF::resolveRelocation(const SectionEntry &Section, 570 uint64_t Offset, 571 uint64_t Value, 572 uint32_t Type, 573 int64_t Addend) { 574 switch (Arch) { 575 case Triple::x86_64: 576 resolveX86_64Relocation(Section, Offset, Value, Type, Addend); 577 break; 578 case Triple::x86: 579 resolveX86Relocation(Section, Offset, 580 (uint32_t)(Value & 0xffffffffL), Type, 581 (uint32_t)(Addend & 0xffffffffL)); 582 break; 583 case Triple::arm: // Fall through. 584 case Triple::thumb: 585 resolveARMRelocation(Section, Offset, 586 (uint32_t)(Value & 0xffffffffL), Type, 587 (uint32_t)(Addend & 0xffffffffL)); 588 break; 589 case Triple::mips: // Fall through. 590 case Triple::mipsel: 591 resolveMIPSRelocation(Section, Offset, 592 (uint32_t)(Value & 0xffffffffL), Type, 593 (uint32_t)(Addend & 0xffffffffL)); 594 break; 595 case Triple::ppc64: 596 resolvePPC64Relocation(Section, Offset, Value, Type, Addend); 597 break; 598 default: llvm_unreachable("Unsupported CPU type!"); 599 } 600 } 601 602 void RuntimeDyldELF::processRelocationRef(unsigned SectionID, 603 RelocationRef RelI, 604 ObjectImage &Obj, 605 ObjSectionToIDMap &ObjSectionToID, 606 const SymbolTableMap &Symbols, 607 StubMap &Stubs) { 608 uint64_t RelType; 609 Check(RelI.getType(RelType)); 610 int64_t Addend; 611 Check(RelI.getAdditionalInfo(Addend)); 612 SymbolRef Symbol; 613 Check(RelI.getSymbol(Symbol)); 614 615 // Obtain the symbol name which is referenced in the relocation 616 StringRef TargetName; 617 Symbol.getName(TargetName); 618 DEBUG(dbgs() << "\t\tRelType: " << RelType 619 << " Addend: " << Addend 620 << " TargetName: " << TargetName 621 << "\n"); 622 RelocationValueRef Value; 623 // First search for the symbol in the local symbol table 624 SymbolTableMap::const_iterator lsi = Symbols.find(TargetName.data()); 625 SymbolRef::Type SymType; 626 Symbol.getType(SymType); 627 if (lsi != Symbols.end()) { 628 Value.SectionID = lsi->second.first; 629 Value.Addend = lsi->second.second + Addend; 630 } else { 631 // Search for the symbol in the global symbol table 632 SymbolTableMap::const_iterator gsi = 633 GlobalSymbolTable.find(TargetName.data()); 634 if (gsi != GlobalSymbolTable.end()) { 635 Value.SectionID = gsi->second.first; 636 Value.Addend = gsi->second.second + Addend; 637 } else { 638 switch (SymType) { 639 case SymbolRef::ST_Debug: { 640 // TODO: Now ELF SymbolRef::ST_Debug = STT_SECTION, it's not obviously 641 // and can be changed by another developers. Maybe best way is add 642 // a new symbol type ST_Section to SymbolRef and use it. 643 section_iterator si(Obj.end_sections()); 644 Symbol.getSection(si); 645 if (si == Obj.end_sections()) 646 llvm_unreachable("Symbol section not found, bad object file format!"); 647 DEBUG(dbgs() << "\t\tThis is section symbol\n"); 648 // Default to 'true' in case isText fails (though it never does). 649 bool isCode = true; 650 si->isText(isCode); 651 Value.SectionID = findOrEmitSection(Obj, 652 (*si), 653 isCode, 654 ObjSectionToID); 655 Value.Addend = Addend; 656 break; 657 } 658 case SymbolRef::ST_Unknown: { 659 Value.SymbolName = TargetName.data(); 660 Value.Addend = Addend; 661 break; 662 } 663 default: 664 llvm_unreachable("Unresolved symbol type!"); 665 break; 666 } 667 } 668 } 669 uint64_t Offset; 670 Check(RelI.getOffset(Offset)); 671 672 DEBUG(dbgs() << "\t\tSectionID: " << SectionID 673 << " Offset: " << Offset 674 << "\n"); 675 if (Arch == Triple::arm && 676 (RelType == ELF::R_ARM_PC24 || 677 RelType == ELF::R_ARM_CALL || 678 RelType == ELF::R_ARM_JUMP24)) { 679 // This is an ARM branch relocation, need to use a stub function. 680 DEBUG(dbgs() << "\t\tThis is an ARM branch relocation."); 681 SectionEntry &Section = Sections[SectionID]; 682 683 // Look for an existing stub. 684 StubMap::const_iterator i = Stubs.find(Value); 685 if (i != Stubs.end()) { 686 resolveRelocation(Section, Offset, 687 (uint64_t)Section.Address + i->second, RelType, 0); 688 DEBUG(dbgs() << " Stub function found\n"); 689 } else { 690 // Create a new stub function. 691 DEBUG(dbgs() << " Create a new stub function\n"); 692 Stubs[Value] = Section.StubOffset; 693 uint8_t *StubTargetAddr = createStubFunction(Section.Address + 694 Section.StubOffset); 695 RelocationEntry RE(SectionID, StubTargetAddr - Section.Address, 696 ELF::R_ARM_ABS32, Value.Addend); 697 if (Value.SymbolName) 698 addRelocationForSymbol(RE, Value.SymbolName); 699 else 700 addRelocationForSection(RE, Value.SectionID); 701 702 resolveRelocation(Section, Offset, 703 (uint64_t)Section.Address + Section.StubOffset, 704 RelType, 0); 705 Section.StubOffset += getMaxStubSize(); 706 } 707 } else if ((Arch == Triple::mipsel || Arch == Triple::mips) && 708 RelType == ELF::R_MIPS_26) { 709 // This is an Mips branch relocation, need to use a stub function. 710 DEBUG(dbgs() << "\t\tThis is a Mips branch relocation."); 711 SectionEntry &Section = Sections[SectionID]; 712 uint8_t *Target = Section.Address + Offset; 713 uint32_t *TargetAddress = (uint32_t *)Target; 714 715 // Extract the addend from the instruction. 716 uint32_t Addend = ((*TargetAddress) & 0x03ffffff) << 2; 717 718 Value.Addend += Addend; 719 720 // Look up for existing stub. 721 StubMap::const_iterator i = Stubs.find(Value); 722 if (i != Stubs.end()) { 723 resolveRelocation(Section, Offset, 724 (uint64_t)Section.Address + i->second, RelType, 0); 725 DEBUG(dbgs() << " Stub function found\n"); 726 } else { 727 // Create a new stub function. 728 DEBUG(dbgs() << " Create a new stub function\n"); 729 Stubs[Value] = Section.StubOffset; 730 uint8_t *StubTargetAddr = createStubFunction(Section.Address + 731 Section.StubOffset); 732 733 // Creating Hi and Lo relocations for the filled stub instructions. 734 RelocationEntry REHi(SectionID, 735 StubTargetAddr - Section.Address, 736 ELF::R_MIPS_HI16, Value.Addend); 737 RelocationEntry RELo(SectionID, 738 StubTargetAddr - Section.Address + 4, 739 ELF::R_MIPS_LO16, Value.Addend); 740 741 if (Value.SymbolName) { 742 addRelocationForSymbol(REHi, Value.SymbolName); 743 addRelocationForSymbol(RELo, Value.SymbolName); 744 } else { 745 addRelocationForSection(REHi, Value.SectionID); 746 addRelocationForSection(RELo, Value.SectionID); 747 } 748 749 resolveRelocation(Section, Offset, 750 (uint64_t)Section.Address + Section.StubOffset, 751 RelType, 0); 752 Section.StubOffset += getMaxStubSize(); 753 } 754 } else if (Arch == Triple::ppc64) { 755 if (RelType == ELF::R_PPC64_REL24) { 756 // A PPC branch relocation will need a stub function if the target is 757 // an external symbol (Symbol::ST_Unknown) or if the target address 758 // is not within the signed 24-bits branch address. 759 SectionEntry &Section = Sections[SectionID]; 760 uint8_t *Target = Section.Address + Offset; 761 bool RangeOverflow = false; 762 if (SymType != SymbolRef::ST_Unknown) { 763 // A function call may points to the .opd entry, so the final symbol value 764 // in calculated based in the relocation values in .opd section. 765 findOPDEntrySection(Obj, ObjSectionToID, Value); 766 uint8_t *RelocTarget = Sections[Value.SectionID].Address + Value.Addend; 767 int32_t delta = static_cast<int32_t>(Target - RelocTarget); 768 // If it is within 24-bits branch range, just set the branch target 769 if (SignExtend32<24>(delta) == delta) { 770 RelocationEntry RE(SectionID, Offset, RelType, Value.Addend); 771 if (Value.SymbolName) 772 addRelocationForSymbol(RE, Value.SymbolName); 773 else 774 addRelocationForSection(RE, Value.SectionID); 775 } else { 776 RangeOverflow = true; 777 } 778 } 779 if (SymType == SymbolRef::ST_Unknown || RangeOverflow == true) { 780 // It is an external symbol (SymbolRef::ST_Unknown) or within a range 781 // larger than 24-bits. 782 StubMap::const_iterator i = Stubs.find(Value); 783 if (i != Stubs.end()) { 784 // Symbol function stub already created, just relocate to it 785 resolveRelocation(Section, Offset, 786 (uint64_t)Section.Address + i->second, RelType, 0); 787 DEBUG(dbgs() << " Stub function found\n"); 788 } else { 789 // Create a new stub function. 790 DEBUG(dbgs() << " Create a new stub function\n"); 791 Stubs[Value] = Section.StubOffset; 792 uint8_t *StubTargetAddr = createStubFunction(Section.Address + 793 Section.StubOffset); 794 RelocationEntry RE(SectionID, StubTargetAddr - Section.Address, 795 ELF::R_PPC64_ADDR64, Value.Addend); 796 797 // Generates the 64-bits address loads as exemplified in section 798 // 4.5.1 in PPC64 ELF ABI. 799 RelocationEntry REhst(SectionID, 800 StubTargetAddr - Section.Address + 2, 801 ELF::R_PPC64_ADDR16_HIGHEST, Value.Addend); 802 RelocationEntry REhr(SectionID, 803 StubTargetAddr - Section.Address + 6, 804 ELF::R_PPC64_ADDR16_HIGHER, Value.Addend); 805 RelocationEntry REh(SectionID, 806 StubTargetAddr - Section.Address + 14, 807 ELF::R_PPC64_ADDR16_HI, Value.Addend); 808 RelocationEntry REl(SectionID, 809 StubTargetAddr - Section.Address + 18, 810 ELF::R_PPC64_ADDR16_LO, Value.Addend); 811 812 if (Value.SymbolName) { 813 addRelocationForSymbol(REhst, Value.SymbolName); 814 addRelocationForSymbol(REhr, Value.SymbolName); 815 addRelocationForSymbol(REh, Value.SymbolName); 816 addRelocationForSymbol(REl, Value.SymbolName); 817 } else { 818 addRelocationForSection(REhst, Value.SectionID); 819 addRelocationForSection(REhr, Value.SectionID); 820 addRelocationForSection(REh, Value.SectionID); 821 addRelocationForSection(REl, Value.SectionID); 822 } 823 824 resolveRelocation(Section, Offset, 825 (uint64_t)Section.Address + Section.StubOffset, 826 RelType, 0); 827 if (SymType == SymbolRef::ST_Unknown) 828 // Restore the TOC for external calls 829 writeInt32BE(Target+4, 0xE8410028); // ld r2,40(r1) 830 Section.StubOffset += getMaxStubSize(); 831 } 832 } 833 } else { 834 RelocationEntry RE(SectionID, Offset, RelType, Value.Addend); 835 // Extra check to avoid relocation againt empty symbols (usually 836 // the R_PPC64_TOC). 837 if (Value.SymbolName && !TargetName.empty()) 838 addRelocationForSymbol(RE, Value.SymbolName); 839 else 840 addRelocationForSection(RE, Value.SectionID); 841 } 842 } else { 843 RelocationEntry RE(SectionID, Offset, RelType, Value.Addend); 844 if (Value.SymbolName) 845 addRelocationForSymbol(RE, Value.SymbolName); 846 else 847 addRelocationForSection(RE, Value.SectionID); 848 } 849 } 850 851 bool RuntimeDyldELF::isCompatibleFormat(const ObjectBuffer *Buffer) const { 852 if (Buffer->getBufferSize() < strlen(ELF::ElfMagic)) 853 return false; 854 return (memcmp(Buffer->getBufferStart(), ELF::ElfMagic, strlen(ELF::ElfMagic))) == 0; 855 } 856 } // namespace llvm 857