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