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) 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 SectionEntry &Section, 564 uint64_t Offset, 565 uint64_t Value, 566 uint32_t Type, 567 int64_t Addend) { 568 switch (Arch) { 569 case Triple::x86_64: 570 resolveX86_64Relocation(Section, Offset, Value, Type, Addend); 571 break; 572 case Triple::x86: 573 resolveX86Relocation(Section, Offset, 574 (uint32_t)(Value & 0xffffffffL), Type, 575 (uint32_t)(Addend & 0xffffffffL)); 576 break; 577 case Triple::arm: // Fall through. 578 case Triple::thumb: 579 resolveARMRelocation(Section, Offset, 580 (uint32_t)(Value & 0xffffffffL), Type, 581 (uint32_t)(Addend & 0xffffffffL)); 582 break; 583 case Triple::mips: // Fall through. 584 case Triple::mipsel: 585 resolveMIPSRelocation(Section, Offset, 586 (uint32_t)(Value & 0xffffffffL), Type, 587 (uint32_t)(Addend & 0xffffffffL)); 588 break; 589 case Triple::ppc64: 590 resolvePPC64Relocation(Section, Offset, Value, Type, Addend); 591 break; 592 default: llvm_unreachable("Unsupported CPU type!"); 593 } 594 } 595 596 void RuntimeDyldELF::processRelocationRef(const ObjRelocationInfo &Rel, 597 ObjectImage &Obj, 598 ObjSectionToIDMap &ObjSectionToID, 599 const SymbolTableMap &Symbols, 600 StubMap &Stubs) { 601 602 uint32_t RelType = (uint32_t)(Rel.Type & 0xffffffffL); 603 intptr_t Addend = (intptr_t)Rel.AdditionalInfo; 604 const SymbolRef &Symbol = Rel.Symbol; 605 606 // Obtain the symbol name which is referenced in the relocation 607 StringRef TargetName; 608 Symbol.getName(TargetName); 609 DEBUG(dbgs() << "\t\tRelType: " << RelType 610 << " Addend: " << Addend 611 << " TargetName: " << TargetName 612 << "\n"); 613 RelocationValueRef Value; 614 // First search for the symbol in the local symbol table 615 SymbolTableMap::const_iterator lsi = Symbols.find(TargetName.data()); 616 SymbolRef::Type SymType; 617 Symbol.getType(SymType); 618 if (lsi != Symbols.end()) { 619 Value.SectionID = lsi->second.first; 620 Value.Addend = lsi->second.second; 621 } else { 622 // Search for the symbol in the global symbol table 623 SymbolTableMap::const_iterator gsi = 624 GlobalSymbolTable.find(TargetName.data()); 625 if (gsi != GlobalSymbolTable.end()) { 626 Value.SectionID = gsi->second.first; 627 Value.Addend = gsi->second.second; 628 } else { 629 switch (SymType) { 630 case SymbolRef::ST_Debug: { 631 // TODO: Now ELF SymbolRef::ST_Debug = STT_SECTION, it's not obviously 632 // and can be changed by another developers. Maybe best way is add 633 // a new symbol type ST_Section to SymbolRef and use it. 634 section_iterator si(Obj.end_sections()); 635 Symbol.getSection(si); 636 if (si == Obj.end_sections()) 637 llvm_unreachable("Symbol section not found, bad object file format!"); 638 DEBUG(dbgs() << "\t\tThis is section symbol\n"); 639 // Default to 'true' in case isText fails (though it never does). 640 bool isCode = true; 641 si->isText(isCode); 642 Value.SectionID = findOrEmitSection(Obj, 643 (*si), 644 isCode, 645 ObjSectionToID); 646 Value.Addend = Addend; 647 break; 648 } 649 case SymbolRef::ST_Unknown: { 650 Value.SymbolName = TargetName.data(); 651 Value.Addend = Addend; 652 break; 653 } 654 default: 655 llvm_unreachable("Unresolved symbol type!"); 656 break; 657 } 658 } 659 } 660 DEBUG(dbgs() << "\t\tRel.SectionID: " << Rel.SectionID 661 << " Rel.Offset: " << Rel.Offset 662 << "\n"); 663 if (Arch == Triple::arm && 664 (RelType == ELF::R_ARM_PC24 || 665 RelType == ELF::R_ARM_CALL || 666 RelType == ELF::R_ARM_JUMP24)) { 667 // This is an ARM branch relocation, need to use a stub function. 668 DEBUG(dbgs() << "\t\tThis is an ARM branch relocation."); 669 SectionEntry &Section = Sections[Rel.SectionID]; 670 671 // Look for an existing stub. 672 StubMap::const_iterator i = Stubs.find(Value); 673 if (i != Stubs.end()) { 674 resolveRelocation(Section, Rel.Offset, 675 (uint64_t)Section.Address + i->second, RelType, 0); 676 DEBUG(dbgs() << " Stub function found\n"); 677 } else { 678 // Create a new stub function. 679 DEBUG(dbgs() << " Create a new stub function\n"); 680 Stubs[Value] = Section.StubOffset; 681 uint8_t *StubTargetAddr = createStubFunction(Section.Address + 682 Section.StubOffset); 683 RelocationEntry RE(Rel.SectionID, StubTargetAddr - Section.Address, 684 ELF::R_ARM_ABS32, Value.Addend); 685 if (Value.SymbolName) 686 addRelocationForSymbol(RE, Value.SymbolName); 687 else 688 addRelocationForSection(RE, Value.SectionID); 689 690 resolveRelocation(Section, Rel.Offset, 691 (uint64_t)Section.Address + Section.StubOffset, 692 RelType, 0); 693 Section.StubOffset += getMaxStubSize(); 694 } 695 } else if ((Arch == Triple::mipsel || Arch == Triple::mips) && 696 RelType == ELF::R_MIPS_26) { 697 // This is an Mips branch relocation, need to use a stub function. 698 DEBUG(dbgs() << "\t\tThis is a Mips branch relocation."); 699 SectionEntry &Section = Sections[Rel.SectionID]; 700 uint8_t *Target = Section.Address + Rel.Offset; 701 uint32_t *TargetAddress = (uint32_t *)Target; 702 703 // Extract the addend from the instruction. 704 uint32_t Addend = ((*TargetAddress) & 0x03ffffff) << 2; 705 706 Value.Addend += Addend; 707 708 // Look up for existing stub. 709 StubMap::const_iterator i = Stubs.find(Value); 710 if (i != Stubs.end()) { 711 resolveRelocation(Section, Rel.Offset, 712 (uint64_t)Section.Address + i->second, RelType, 0); 713 DEBUG(dbgs() << " Stub function found\n"); 714 } else { 715 // Create a new stub function. 716 DEBUG(dbgs() << " Create a new stub function\n"); 717 Stubs[Value] = Section.StubOffset; 718 uint8_t *StubTargetAddr = createStubFunction(Section.Address + 719 Section.StubOffset); 720 721 // Creating Hi and Lo relocations for the filled stub instructions. 722 RelocationEntry REHi(Rel.SectionID, 723 StubTargetAddr - Section.Address, 724 ELF::R_MIPS_HI16, Value.Addend); 725 RelocationEntry RELo(Rel.SectionID, 726 StubTargetAddr - Section.Address + 4, 727 ELF::R_MIPS_LO16, Value.Addend); 728 729 if (Value.SymbolName) { 730 addRelocationForSymbol(REHi, Value.SymbolName); 731 addRelocationForSymbol(RELo, Value.SymbolName); 732 } else { 733 addRelocationForSection(REHi, Value.SectionID); 734 addRelocationForSection(RELo, Value.SectionID); 735 } 736 737 resolveRelocation(Section, Rel.Offset, 738 (uint64_t)Section.Address + Section.StubOffset, 739 RelType, 0); 740 Section.StubOffset += getMaxStubSize(); 741 } 742 } else if (Arch == Triple::ppc64) { 743 if (RelType == ELF::R_PPC64_REL24) { 744 // A PPC branch relocation will need a stub function if the target is 745 // an external symbol (Symbol::ST_Unknown) or if the target address 746 // is not within the signed 24-bits branch address. 747 SectionEntry &Section = Sections[Rel.SectionID]; 748 uint8_t *Target = Section.Address + Rel.Offset; 749 bool RangeOverflow = false; 750 if (SymType != SymbolRef::ST_Unknown) { 751 // A function call may points to the .opd entry, so the final symbol value 752 // in calculated based in the relocation values in .opd section. 753 findOPDEntrySection(Obj, ObjSectionToID, Value); 754 uint8_t *RelocTarget = Sections[Value.SectionID].Address + Value.Addend; 755 int32_t delta = static_cast<int32_t>(Target - RelocTarget); 756 // If it is within 24-bits branch range, just set the branch target 757 if (SignExtend32<24>(delta) == delta) { 758 RelocationEntry RE(Rel.SectionID, Rel.Offset, RelType, Value.Addend); 759 if (Value.SymbolName) 760 addRelocationForSymbol(RE, Value.SymbolName); 761 else 762 addRelocationForSection(RE, Value.SectionID); 763 } else { 764 RangeOverflow = true; 765 } 766 } 767 if (SymType == SymbolRef::ST_Unknown || RangeOverflow == true) { 768 // It is an external symbol (SymbolRef::ST_Unknown) or within a range 769 // larger than 24-bits. 770 StubMap::const_iterator i = Stubs.find(Value); 771 if (i != Stubs.end()) { 772 // Symbol function stub already created, just relocate to it 773 resolveRelocation(Section, Rel.Offset, 774 (uint64_t)Section.Address + i->second, RelType, 0); 775 DEBUG(dbgs() << " Stub function found\n"); 776 } else { 777 // Create a new stub function. 778 DEBUG(dbgs() << " Create a new stub function\n"); 779 Stubs[Value] = Section.StubOffset; 780 uint8_t *StubTargetAddr = createStubFunction(Section.Address + 781 Section.StubOffset); 782 RelocationEntry RE(Rel.SectionID, StubTargetAddr - Section.Address, 783 ELF::R_PPC64_ADDR64, Value.Addend); 784 785 // Generates the 64-bits address loads as exemplified in section 786 // 4.5.1 in PPC64 ELF ABI. 787 RelocationEntry REhst(Rel.SectionID, 788 StubTargetAddr - Section.Address + 2, 789 ELF::R_PPC64_ADDR16_HIGHEST, Value.Addend); 790 RelocationEntry REhr(Rel.SectionID, 791 StubTargetAddr - Section.Address + 6, 792 ELF::R_PPC64_ADDR16_HIGHER, Value.Addend); 793 RelocationEntry REh(Rel.SectionID, 794 StubTargetAddr - Section.Address + 14, 795 ELF::R_PPC64_ADDR16_HI, Value.Addend); 796 RelocationEntry REl(Rel.SectionID, 797 StubTargetAddr - Section.Address + 18, 798 ELF::R_PPC64_ADDR16_LO, Value.Addend); 799 800 if (Value.SymbolName) { 801 addRelocationForSymbol(REhst, Value.SymbolName); 802 addRelocationForSymbol(REhr, Value.SymbolName); 803 addRelocationForSymbol(REh, Value.SymbolName); 804 addRelocationForSymbol(REl, Value.SymbolName); 805 } else { 806 addRelocationForSection(REhst, Value.SectionID); 807 addRelocationForSection(REhr, Value.SectionID); 808 addRelocationForSection(REh, Value.SectionID); 809 addRelocationForSection(REl, Value.SectionID); 810 } 811 812 resolveRelocation(Section, Rel.Offset, 813 (uint64_t)Section.Address + Section.StubOffset, 814 RelType, 0); 815 if (SymType == SymbolRef::ST_Unknown) 816 // Restore the TOC for external calls 817 writeInt32BE(Target+4, 0xE8410028); // ld r2,40(r1) 818 Section.StubOffset += getMaxStubSize(); 819 } 820 } 821 } else { 822 RelocationEntry RE(Rel.SectionID, Rel.Offset, RelType, Value.Addend); 823 // Extra check to avoid relocation againt empty symbols (usually 824 // the R_PPC64_TOC). 825 if (Value.SymbolName && !TargetName.empty()) 826 addRelocationForSymbol(RE, Value.SymbolName); 827 else 828 addRelocationForSection(RE, Value.SectionID); 829 } 830 } else { 831 RelocationEntry RE(Rel.SectionID, Rel.Offset, RelType, Value.Addend); 832 if (Value.SymbolName) 833 addRelocationForSymbol(RE, Value.SymbolName); 834 else 835 addRelocationForSection(RE, Value.SectionID); 836 } 837 } 838 839 unsigned RuntimeDyldELF::getCommonSymbolAlignment(const SymbolRef &Sym) { 840 // In ELF, the value of an SHN_COMMON symbol is its alignment requirement. 841 uint64_t Align; 842 Check(Sym.getValue(Align)); 843 return Align; 844 } 845 846 bool RuntimeDyldELF::isCompatibleFormat(const ObjectBuffer *Buffer) const { 847 if (Buffer->getBufferSize() < strlen(ELF::ElfMagic)) 848 return false; 849 return (memcmp(Buffer->getBufferStart(), ELF::ElfMagic, strlen(ELF::ElfMagic))) == 0; 850 } 851 } // namespace llvm 852
