1 //===- ELF.cpp - ELF object file implementation ---------------------------===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 9 #include "llvm/Object/ELF.h" 10 #include "llvm/ADT/StringExtras.h" 11 #include "llvm/BinaryFormat/ELF.h" 12 #include "llvm/Support/DataExtractor.h" 13 14 using namespace llvm; 15 using namespace object; 16 17 #define STRINGIFY_ENUM_CASE(ns, name) \ 18 case ns::name: \ 19 return #name; 20 21 #define ELF_RELOC(name, value) STRINGIFY_ENUM_CASE(ELF, name) 22 23 StringRef llvm::object::getELFRelocationTypeName(uint32_t Machine, 24 uint32_t Type) { 25 switch (Machine) { 26 case ELF::EM_68K: 27 switch (Type) { 28 #include "llvm/BinaryFormat/ELFRelocs/M68k.def" 29 default: 30 break; 31 } 32 break; 33 case ELF::EM_X86_64: 34 switch (Type) { 35 #include "llvm/BinaryFormat/ELFRelocs/x86_64.def" 36 default: 37 break; 38 } 39 break; 40 case ELF::EM_386: 41 case ELF::EM_IAMCU: 42 switch (Type) { 43 #include "llvm/BinaryFormat/ELFRelocs/i386.def" 44 default: 45 break; 46 } 47 break; 48 case ELF::EM_MIPS: 49 switch (Type) { 50 #include "llvm/BinaryFormat/ELFRelocs/Mips.def" 51 default: 52 break; 53 } 54 break; 55 case ELF::EM_AARCH64: 56 switch (Type) { 57 #include "llvm/BinaryFormat/ELFRelocs/AArch64.def" 58 default: 59 break; 60 } 61 break; 62 case ELF::EM_ARM: 63 switch (Type) { 64 #include "llvm/BinaryFormat/ELFRelocs/ARM.def" 65 default: 66 break; 67 } 68 break; 69 case ELF::EM_ARC_COMPACT: 70 case ELF::EM_ARC_COMPACT2: 71 switch (Type) { 72 #include "llvm/BinaryFormat/ELFRelocs/ARC.def" 73 default: 74 break; 75 } 76 break; 77 case ELF::EM_AVR: 78 switch (Type) { 79 #include "llvm/BinaryFormat/ELFRelocs/AVR.def" 80 default: 81 break; 82 } 83 break; 84 case ELF::EM_HEXAGON: 85 switch (Type) { 86 #include "llvm/BinaryFormat/ELFRelocs/Hexagon.def" 87 default: 88 break; 89 } 90 break; 91 case ELF::EM_LANAI: 92 switch (Type) { 93 #include "llvm/BinaryFormat/ELFRelocs/Lanai.def" 94 default: 95 break; 96 } 97 break; 98 case ELF::EM_PPC: 99 switch (Type) { 100 #include "llvm/BinaryFormat/ELFRelocs/PowerPC.def" 101 default: 102 break; 103 } 104 break; 105 case ELF::EM_PPC64: 106 switch (Type) { 107 #include "llvm/BinaryFormat/ELFRelocs/PowerPC64.def" 108 default: 109 break; 110 } 111 break; 112 case ELF::EM_RISCV: 113 switch (Type) { 114 #include "llvm/BinaryFormat/ELFRelocs/RISCV.def" 115 default: 116 break; 117 } 118 break; 119 case ELF::EM_S390: 120 switch (Type) { 121 #include "llvm/BinaryFormat/ELFRelocs/SystemZ.def" 122 default: 123 break; 124 } 125 break; 126 case ELF::EM_SPARC: 127 case ELF::EM_SPARC32PLUS: 128 case ELF::EM_SPARCV9: 129 switch (Type) { 130 #include "llvm/BinaryFormat/ELFRelocs/Sparc.def" 131 default: 132 break; 133 } 134 break; 135 case ELF::EM_AMDGPU: 136 switch (Type) { 137 #include "llvm/BinaryFormat/ELFRelocs/AMDGPU.def" 138 default: 139 break; 140 } 141 break; 142 case ELF::EM_BPF: 143 switch (Type) { 144 #include "llvm/BinaryFormat/ELFRelocs/BPF.def" 145 default: 146 break; 147 } 148 break; 149 case ELF::EM_MSP430: 150 switch (Type) { 151 #include "llvm/BinaryFormat/ELFRelocs/MSP430.def" 152 default: 153 break; 154 } 155 break; 156 case ELF::EM_VE: 157 switch (Type) { 158 #include "llvm/BinaryFormat/ELFRelocs/VE.def" 159 default: 160 break; 161 } 162 break; 163 case ELF::EM_CSKY: 164 switch (Type) { 165 #include "llvm/BinaryFormat/ELFRelocs/CSKY.def" 166 default: 167 break; 168 } 169 break; 170 case ELF::EM_LOONGARCH: 171 switch (Type) { 172 #include "llvm/BinaryFormat/ELFRelocs/LoongArch.def" 173 default: 174 break; 175 } 176 break; 177 case ELF::EM_XTENSA: 178 switch (Type) { 179 #include "llvm/BinaryFormat/ELFRelocs/Xtensa.def" 180 default: 181 break; 182 } 183 break; 184 default: 185 break; 186 } 187 return "Unknown"; 188 } 189 190 #undef ELF_RELOC 191 192 uint32_t llvm::object::getELFRelativeRelocationType(uint32_t Machine) { 193 switch (Machine) { 194 case ELF::EM_X86_64: 195 return ELF::R_X86_64_RELATIVE; 196 case ELF::EM_386: 197 case ELF::EM_IAMCU: 198 return ELF::R_386_RELATIVE; 199 case ELF::EM_MIPS: 200 break; 201 case ELF::EM_AARCH64: 202 return ELF::R_AARCH64_RELATIVE; 203 case ELF::EM_ARM: 204 return ELF::R_ARM_RELATIVE; 205 case ELF::EM_ARC_COMPACT: 206 case ELF::EM_ARC_COMPACT2: 207 return ELF::R_ARC_RELATIVE; 208 case ELF::EM_AVR: 209 break; 210 case ELF::EM_HEXAGON: 211 return ELF::R_HEX_RELATIVE; 212 case ELF::EM_LANAI: 213 break; 214 case ELF::EM_PPC: 215 break; 216 case ELF::EM_PPC64: 217 return ELF::R_PPC64_RELATIVE; 218 case ELF::EM_RISCV: 219 return ELF::R_RISCV_RELATIVE; 220 case ELF::EM_S390: 221 return ELF::R_390_RELATIVE; 222 case ELF::EM_SPARC: 223 case ELF::EM_SPARC32PLUS: 224 case ELF::EM_SPARCV9: 225 return ELF::R_SPARC_RELATIVE; 226 case ELF::EM_CSKY: 227 return ELF::R_CKCORE_RELATIVE; 228 case ELF::EM_VE: 229 return ELF::R_VE_RELATIVE; 230 case ELF::EM_AMDGPU: 231 break; 232 case ELF::EM_BPF: 233 break; 234 case ELF::EM_LOONGARCH: 235 return ELF::R_LARCH_RELATIVE; 236 default: 237 break; 238 } 239 return 0; 240 } 241 242 StringRef llvm::object::getELFSectionTypeName(uint32_t Machine, unsigned Type) { 243 switch (Machine) { 244 case ELF::EM_ARM: 245 switch (Type) { 246 STRINGIFY_ENUM_CASE(ELF, SHT_ARM_EXIDX); 247 STRINGIFY_ENUM_CASE(ELF, SHT_ARM_PREEMPTMAP); 248 STRINGIFY_ENUM_CASE(ELF, SHT_ARM_ATTRIBUTES); 249 STRINGIFY_ENUM_CASE(ELF, SHT_ARM_DEBUGOVERLAY); 250 STRINGIFY_ENUM_CASE(ELF, SHT_ARM_OVERLAYSECTION); 251 } 252 break; 253 case ELF::EM_HEXAGON: 254 switch (Type) { STRINGIFY_ENUM_CASE(ELF, SHT_HEX_ORDERED); } 255 break; 256 case ELF::EM_X86_64: 257 switch (Type) { STRINGIFY_ENUM_CASE(ELF, SHT_X86_64_UNWIND); } 258 break; 259 case ELF::EM_MIPS: 260 case ELF::EM_MIPS_RS3_LE: 261 switch (Type) { 262 STRINGIFY_ENUM_CASE(ELF, SHT_MIPS_REGINFO); 263 STRINGIFY_ENUM_CASE(ELF, SHT_MIPS_OPTIONS); 264 STRINGIFY_ENUM_CASE(ELF, SHT_MIPS_DWARF); 265 STRINGIFY_ENUM_CASE(ELF, SHT_MIPS_ABIFLAGS); 266 } 267 break; 268 case ELF::EM_MSP430: 269 switch (Type) { STRINGIFY_ENUM_CASE(ELF, SHT_MSP430_ATTRIBUTES); } 270 break; 271 case ELF::EM_RISCV: 272 switch (Type) { STRINGIFY_ENUM_CASE(ELF, SHT_RISCV_ATTRIBUTES); } 273 break; 274 case ELF::EM_AARCH64: 275 switch (Type) { 276 STRINGIFY_ENUM_CASE(ELF, SHT_AARCH64_AUTH_RELR); 277 STRINGIFY_ENUM_CASE(ELF, SHT_AARCH64_MEMTAG_GLOBALS_DYNAMIC); 278 STRINGIFY_ENUM_CASE(ELF, SHT_AARCH64_MEMTAG_GLOBALS_STATIC); 279 } 280 default: 281 break; 282 } 283 284 switch (Type) { 285 STRINGIFY_ENUM_CASE(ELF, SHT_NULL); 286 STRINGIFY_ENUM_CASE(ELF, SHT_PROGBITS); 287 STRINGIFY_ENUM_CASE(ELF, SHT_SYMTAB); 288 STRINGIFY_ENUM_CASE(ELF, SHT_STRTAB); 289 STRINGIFY_ENUM_CASE(ELF, SHT_RELA); 290 STRINGIFY_ENUM_CASE(ELF, SHT_HASH); 291 STRINGIFY_ENUM_CASE(ELF, SHT_DYNAMIC); 292 STRINGIFY_ENUM_CASE(ELF, SHT_NOTE); 293 STRINGIFY_ENUM_CASE(ELF, SHT_NOBITS); 294 STRINGIFY_ENUM_CASE(ELF, SHT_REL); 295 STRINGIFY_ENUM_CASE(ELF, SHT_SHLIB); 296 STRINGIFY_ENUM_CASE(ELF, SHT_DYNSYM); 297 STRINGIFY_ENUM_CASE(ELF, SHT_INIT_ARRAY); 298 STRINGIFY_ENUM_CASE(ELF, SHT_FINI_ARRAY); 299 STRINGIFY_ENUM_CASE(ELF, SHT_PREINIT_ARRAY); 300 STRINGIFY_ENUM_CASE(ELF, SHT_GROUP); 301 STRINGIFY_ENUM_CASE(ELF, SHT_SYMTAB_SHNDX); 302 STRINGIFY_ENUM_CASE(ELF, SHT_RELR); 303 STRINGIFY_ENUM_CASE(ELF, SHT_ANDROID_REL); 304 STRINGIFY_ENUM_CASE(ELF, SHT_ANDROID_RELA); 305 STRINGIFY_ENUM_CASE(ELF, SHT_ANDROID_RELR); 306 STRINGIFY_ENUM_CASE(ELF, SHT_LLVM_ODRTAB); 307 STRINGIFY_ENUM_CASE(ELF, SHT_LLVM_LINKER_OPTIONS); 308 STRINGIFY_ENUM_CASE(ELF, SHT_LLVM_CALL_GRAPH_PROFILE); 309 STRINGIFY_ENUM_CASE(ELF, SHT_LLVM_ADDRSIG); 310 STRINGIFY_ENUM_CASE(ELF, SHT_LLVM_DEPENDENT_LIBRARIES); 311 STRINGIFY_ENUM_CASE(ELF, SHT_LLVM_SYMPART); 312 STRINGIFY_ENUM_CASE(ELF, SHT_LLVM_PART_EHDR); 313 STRINGIFY_ENUM_CASE(ELF, SHT_LLVM_PART_PHDR); 314 STRINGIFY_ENUM_CASE(ELF, SHT_LLVM_BB_ADDR_MAP_V0); 315 STRINGIFY_ENUM_CASE(ELF, SHT_LLVM_BB_ADDR_MAP); 316 STRINGIFY_ENUM_CASE(ELF, SHT_LLVM_OFFLOADING); 317 STRINGIFY_ENUM_CASE(ELF, SHT_LLVM_LTO); 318 STRINGIFY_ENUM_CASE(ELF, SHT_GNU_ATTRIBUTES); 319 STRINGIFY_ENUM_CASE(ELF, SHT_GNU_HASH); 320 STRINGIFY_ENUM_CASE(ELF, SHT_GNU_verdef); 321 STRINGIFY_ENUM_CASE(ELF, SHT_GNU_verneed); 322 STRINGIFY_ENUM_CASE(ELF, SHT_GNU_versym); 323 default: 324 return "Unknown"; 325 } 326 } 327 328 template <class ELFT> 329 std::vector<typename ELFT::Rel> 330 ELFFile<ELFT>::decode_relrs(Elf_Relr_Range relrs) const { 331 // This function decodes the contents of an SHT_RELR packed relocation 332 // section. 333 // 334 // Proposal for adding SHT_RELR sections to generic-abi is here: 335 // https://groups.google.com/forum/#!topic/generic-abi/bX460iggiKg 336 // 337 // The encoded sequence of Elf64_Relr entries in a SHT_RELR section looks 338 // like [ AAAAAAAA BBBBBBB1 BBBBBBB1 ... AAAAAAAA BBBBBB1 ... ] 339 // 340 // i.e. start with an address, followed by any number of bitmaps. The address 341 // entry encodes 1 relocation. The subsequent bitmap entries encode up to 63 342 // relocations each, at subsequent offsets following the last address entry. 343 // 344 // The bitmap entries must have 1 in the least significant bit. The assumption 345 // here is that an address cannot have 1 in lsb. Odd addresses are not 346 // supported. 347 // 348 // Excluding the least significant bit in the bitmap, each non-zero bit in 349 // the bitmap represents a relocation to be applied to a corresponding machine 350 // word that follows the base address word. The second least significant bit 351 // represents the machine word immediately following the initial address, and 352 // each bit that follows represents the next word, in linear order. As such, 353 // a single bitmap can encode up to 31 relocations in a 32-bit object, and 354 // 63 relocations in a 64-bit object. 355 // 356 // This encoding has a couple of interesting properties: 357 // 1. Looking at any entry, it is clear whether it's an address or a bitmap: 358 // even means address, odd means bitmap. 359 // 2. Just a simple list of addresses is a valid encoding. 360 361 Elf_Rel Rel; 362 Rel.r_info = 0; 363 Rel.setType(getRelativeRelocationType(), false); 364 std::vector<Elf_Rel> Relocs; 365 366 // Word type: uint32_t for Elf32, and uint64_t for Elf64. 367 using Addr = typename ELFT::uint; 368 369 Addr Base = 0; 370 for (Elf_Relr R : relrs) { 371 typename ELFT::uint Entry = R; 372 if ((Entry & 1) == 0) { 373 // Even entry: encodes the offset for next relocation. 374 Rel.r_offset = Entry; 375 Relocs.push_back(Rel); 376 // Set base offset for subsequent bitmap entries. 377 Base = Entry + sizeof(Addr); 378 } else { 379 // Odd entry: encodes bitmap for relocations starting at base. 380 for (Addr Offset = Base; (Entry >>= 1) != 0; Offset += sizeof(Addr)) 381 if ((Entry & 1) != 0) { 382 Rel.r_offset = Offset; 383 Relocs.push_back(Rel); 384 } 385 Base += (CHAR_BIT * sizeof(Entry) - 1) * sizeof(Addr); 386 } 387 } 388 389 return Relocs; 390 } 391 392 template <class ELFT> 393 Expected<std::vector<typename ELFT::Rela>> 394 ELFFile<ELFT>::android_relas(const Elf_Shdr &Sec) const { 395 // This function reads relocations in Android's packed relocation format, 396 // which is based on SLEB128 and delta encoding. 397 Expected<ArrayRef<uint8_t>> ContentsOrErr = getSectionContents(Sec); 398 if (!ContentsOrErr) 399 return ContentsOrErr.takeError(); 400 ArrayRef<uint8_t> Content = *ContentsOrErr; 401 if (Content.size() < 4 || Content[0] != 'A' || Content[1] != 'P' || 402 Content[2] != 'S' || Content[3] != '2') 403 return createError("invalid packed relocation header"); 404 DataExtractor Data(Content, isLE(), ELFT::Is64Bits ? 8 : 4); 405 DataExtractor::Cursor Cur(/*Offset=*/4); 406 407 uint64_t NumRelocs = Data.getSLEB128(Cur); 408 uint64_t Offset = Data.getSLEB128(Cur); 409 uint64_t Addend = 0; 410 411 if (!Cur) 412 return std::move(Cur.takeError()); 413 414 std::vector<Elf_Rela> Relocs; 415 Relocs.reserve(NumRelocs); 416 while (NumRelocs) { 417 uint64_t NumRelocsInGroup = Data.getSLEB128(Cur); 418 if (!Cur) 419 return std::move(Cur.takeError()); 420 if (NumRelocsInGroup > NumRelocs) 421 return createError("relocation group unexpectedly large"); 422 NumRelocs -= NumRelocsInGroup; 423 424 uint64_t GroupFlags = Data.getSLEB128(Cur); 425 bool GroupedByInfo = GroupFlags & ELF::RELOCATION_GROUPED_BY_INFO_FLAG; 426 bool GroupedByOffsetDelta = GroupFlags & ELF::RELOCATION_GROUPED_BY_OFFSET_DELTA_FLAG; 427 bool GroupedByAddend = GroupFlags & ELF::RELOCATION_GROUPED_BY_ADDEND_FLAG; 428 bool GroupHasAddend = GroupFlags & ELF::RELOCATION_GROUP_HAS_ADDEND_FLAG; 429 430 uint64_t GroupOffsetDelta; 431 if (GroupedByOffsetDelta) 432 GroupOffsetDelta = Data.getSLEB128(Cur); 433 434 uint64_t GroupRInfo; 435 if (GroupedByInfo) 436 GroupRInfo = Data.getSLEB128(Cur); 437 438 if (GroupedByAddend && GroupHasAddend) 439 Addend += Data.getSLEB128(Cur); 440 441 if (!GroupHasAddend) 442 Addend = 0; 443 444 for (uint64_t I = 0; Cur && I != NumRelocsInGroup; ++I) { 445 Elf_Rela R; 446 Offset += GroupedByOffsetDelta ? GroupOffsetDelta : Data.getSLEB128(Cur); 447 R.r_offset = Offset; 448 R.r_info = GroupedByInfo ? GroupRInfo : Data.getSLEB128(Cur); 449 if (GroupHasAddend && !GroupedByAddend) 450 Addend += Data.getSLEB128(Cur); 451 R.r_addend = Addend; 452 Relocs.push_back(R); 453 } 454 if (!Cur) 455 return std::move(Cur.takeError()); 456 } 457 458 return Relocs; 459 } 460 461 template <class ELFT> 462 std::string ELFFile<ELFT>::getDynamicTagAsString(unsigned Arch, 463 uint64_t Type) const { 464 #define DYNAMIC_STRINGIFY_ENUM(tag, value) \ 465 case value: \ 466 return #tag; 467 468 #define DYNAMIC_TAG(n, v) 469 switch (Arch) { 470 case ELF::EM_AARCH64: 471 switch (Type) { 472 #define AARCH64_DYNAMIC_TAG(name, value) DYNAMIC_STRINGIFY_ENUM(name, value) 473 #include "llvm/BinaryFormat/DynamicTags.def" 474 #undef AARCH64_DYNAMIC_TAG 475 } 476 break; 477 478 case ELF::EM_HEXAGON: 479 switch (Type) { 480 #define HEXAGON_DYNAMIC_TAG(name, value) DYNAMIC_STRINGIFY_ENUM(name, value) 481 #include "llvm/BinaryFormat/DynamicTags.def" 482 #undef HEXAGON_DYNAMIC_TAG 483 } 484 break; 485 486 case ELF::EM_MIPS: 487 switch (Type) { 488 #define MIPS_DYNAMIC_TAG(name, value) DYNAMIC_STRINGIFY_ENUM(name, value) 489 #include "llvm/BinaryFormat/DynamicTags.def" 490 #undef MIPS_DYNAMIC_TAG 491 } 492 break; 493 494 case ELF::EM_PPC: 495 switch (Type) { 496 #define PPC_DYNAMIC_TAG(name, value) DYNAMIC_STRINGIFY_ENUM(name, value) 497 #include "llvm/BinaryFormat/DynamicTags.def" 498 #undef PPC_DYNAMIC_TAG 499 } 500 break; 501 502 case ELF::EM_PPC64: 503 switch (Type) { 504 #define PPC64_DYNAMIC_TAG(name, value) DYNAMIC_STRINGIFY_ENUM(name, value) 505 #include "llvm/BinaryFormat/DynamicTags.def" 506 #undef PPC64_DYNAMIC_TAG 507 } 508 break; 509 510 case ELF::EM_RISCV: 511 switch (Type) { 512 #define RISCV_DYNAMIC_TAG(name, value) DYNAMIC_STRINGIFY_ENUM(name, value) 513 #include "llvm/BinaryFormat/DynamicTags.def" 514 #undef RISCV_DYNAMIC_TAG 515 } 516 break; 517 } 518 #undef DYNAMIC_TAG 519 switch (Type) { 520 // Now handle all dynamic tags except the architecture specific ones 521 #define AARCH64_DYNAMIC_TAG(name, value) 522 #define MIPS_DYNAMIC_TAG(name, value) 523 #define HEXAGON_DYNAMIC_TAG(name, value) 524 #define PPC_DYNAMIC_TAG(name, value) 525 #define PPC64_DYNAMIC_TAG(name, value) 526 #define RISCV_DYNAMIC_TAG(name, value) 527 // Also ignore marker tags such as DT_HIOS (maps to DT_VERNEEDNUM), etc. 528 #define DYNAMIC_TAG_MARKER(name, value) 529 #define DYNAMIC_TAG(name, value) case value: return #name; 530 #include "llvm/BinaryFormat/DynamicTags.def" 531 #undef DYNAMIC_TAG 532 #undef AARCH64_DYNAMIC_TAG 533 #undef MIPS_DYNAMIC_TAG 534 #undef HEXAGON_DYNAMIC_TAG 535 #undef PPC_DYNAMIC_TAG 536 #undef PPC64_DYNAMIC_TAG 537 #undef RISCV_DYNAMIC_TAG 538 #undef DYNAMIC_TAG_MARKER 539 #undef DYNAMIC_STRINGIFY_ENUM 540 default: 541 return "<unknown:>0x" + utohexstr(Type, true); 542 } 543 } 544 545 template <class ELFT> 546 std::string ELFFile<ELFT>::getDynamicTagAsString(uint64_t Type) const { 547 return getDynamicTagAsString(getHeader().e_machine, Type); 548 } 549 550 template <class ELFT> 551 Expected<typename ELFT::DynRange> ELFFile<ELFT>::dynamicEntries() const { 552 ArrayRef<Elf_Dyn> Dyn; 553 554 auto ProgramHeadersOrError = program_headers(); 555 if (!ProgramHeadersOrError) 556 return ProgramHeadersOrError.takeError(); 557 558 for (const Elf_Phdr &Phdr : *ProgramHeadersOrError) { 559 if (Phdr.p_type == ELF::PT_DYNAMIC) { 560 Dyn = ArrayRef(reinterpret_cast<const Elf_Dyn *>(base() + Phdr.p_offset), 561 Phdr.p_filesz / sizeof(Elf_Dyn)); 562 break; 563 } 564 } 565 566 // If we can't find the dynamic section in the program headers, we just fall 567 // back on the sections. 568 if (Dyn.empty()) { 569 auto SectionsOrError = sections(); 570 if (!SectionsOrError) 571 return SectionsOrError.takeError(); 572 573 for (const Elf_Shdr &Sec : *SectionsOrError) { 574 if (Sec.sh_type == ELF::SHT_DYNAMIC) { 575 Expected<ArrayRef<Elf_Dyn>> DynOrError = 576 getSectionContentsAsArray<Elf_Dyn>(Sec); 577 if (!DynOrError) 578 return DynOrError.takeError(); 579 Dyn = *DynOrError; 580 break; 581 } 582 } 583 584 if (!Dyn.data()) 585 return ArrayRef<Elf_Dyn>(); 586 } 587 588 if (Dyn.empty()) 589 return createError("invalid empty dynamic section"); 590 591 if (Dyn.back().d_tag != ELF::DT_NULL) 592 return createError("dynamic sections must be DT_NULL terminated"); 593 594 return Dyn; 595 } 596 597 template <class ELFT> 598 Expected<const uint8_t *> 599 ELFFile<ELFT>::toMappedAddr(uint64_t VAddr, WarningHandler WarnHandler) const { 600 auto ProgramHeadersOrError = program_headers(); 601 if (!ProgramHeadersOrError) 602 return ProgramHeadersOrError.takeError(); 603 604 llvm::SmallVector<Elf_Phdr *, 4> LoadSegments; 605 606 for (const Elf_Phdr &Phdr : *ProgramHeadersOrError) 607 if (Phdr.p_type == ELF::PT_LOAD) 608 LoadSegments.push_back(const_cast<Elf_Phdr *>(&Phdr)); 609 610 auto SortPred = [](const Elf_Phdr_Impl<ELFT> *A, 611 const Elf_Phdr_Impl<ELFT> *B) { 612 return A->p_vaddr < B->p_vaddr; 613 }; 614 if (!llvm::is_sorted(LoadSegments, SortPred)) { 615 if (Error E = 616 WarnHandler("loadable segments are unsorted by virtual address")) 617 return std::move(E); 618 llvm::stable_sort(LoadSegments, SortPred); 619 } 620 621 const Elf_Phdr *const *I = llvm::upper_bound( 622 LoadSegments, VAddr, [](uint64_t VAddr, const Elf_Phdr_Impl<ELFT> *Phdr) { 623 return VAddr < Phdr->p_vaddr; 624 }); 625 626 if (I == LoadSegments.begin()) 627 return createError("virtual address is not in any segment: 0x" + 628 Twine::utohexstr(VAddr)); 629 --I; 630 const Elf_Phdr &Phdr = **I; 631 uint64_t Delta = VAddr - Phdr.p_vaddr; 632 if (Delta >= Phdr.p_filesz) 633 return createError("virtual address is not in any segment: 0x" + 634 Twine::utohexstr(VAddr)); 635 636 uint64_t Offset = Phdr.p_offset + Delta; 637 if (Offset >= getBufSize()) 638 return createError("can't map virtual address 0x" + 639 Twine::utohexstr(VAddr) + " to the segment with index " + 640 Twine(&Phdr - (*ProgramHeadersOrError).data() + 1) + 641 ": the segment ends at 0x" + 642 Twine::utohexstr(Phdr.p_offset + Phdr.p_filesz) + 643 ", which is greater than the file size (0x" + 644 Twine::utohexstr(getBufSize()) + ")"); 645 646 return base() + Offset; 647 } 648 649 // Helper to extract and decode the next ULEB128 value as unsigned int. 650 // Returns zero and sets ULEBSizeErr if the ULEB128 value exceeds the unsigned 651 // int limit. 652 // Also returns zero if ULEBSizeErr is already in an error state. 653 // ULEBSizeErr is an out variable if an error occurs. 654 template <typename IntTy, std::enable_if_t<std::is_unsigned_v<IntTy>, int> = 0> 655 static IntTy readULEB128As(DataExtractor &Data, DataExtractor::Cursor &Cur, 656 Error &ULEBSizeErr) { 657 // Bail out and do not extract data if ULEBSizeErr is already set. 658 if (ULEBSizeErr) 659 return 0; 660 uint64_t Offset = Cur.tell(); 661 uint64_t Value = Data.getULEB128(Cur); 662 if (Value > std::numeric_limits<IntTy>::max()) { 663 ULEBSizeErr = createError("ULEB128 value at offset 0x" + 664 Twine::utohexstr(Offset) + " exceeds UINT" + 665 Twine(std::numeric_limits<IntTy>::digits) + 666 "_MAX (0x" + Twine::utohexstr(Value) + ")"); 667 return 0; 668 } 669 return static_cast<IntTy>(Value); 670 } 671 672 template <typename ELFT> 673 static Expected<std::vector<BBAddrMap>> 674 decodeBBAddrMapImpl(const ELFFile<ELFT> &EF, 675 const typename ELFFile<ELFT>::Elf_Shdr &Sec, 676 const typename ELFFile<ELFT>::Elf_Shdr *RelaSec, 677 std::vector<PGOAnalysisMap> *PGOAnalyses) { 678 bool IsRelocatable = EF.getHeader().e_type == ELF::ET_REL; 679 680 // This DenseMap maps the offset of each function (the location of the 681 // reference to the function in the SHT_LLVM_BB_ADDR_MAP section) to the 682 // addend (the location of the function in the text section). 683 llvm::DenseMap<uint64_t, uint64_t> FunctionOffsetTranslations; 684 if (IsRelocatable && RelaSec) { 685 assert(RelaSec && 686 "Can't read a SHT_LLVM_BB_ADDR_MAP section in a relocatable " 687 "object file without providing a relocation section."); 688 Expected<typename ELFFile<ELFT>::Elf_Rela_Range> Relas = EF.relas(*RelaSec); 689 if (!Relas) 690 return createError("unable to read relocations for section " + 691 describe(EF, Sec) + ": " + 692 toString(Relas.takeError())); 693 for (typename ELFFile<ELFT>::Elf_Rela Rela : *Relas) 694 FunctionOffsetTranslations[Rela.r_offset] = Rela.r_addend; 695 } 696 Expected<ArrayRef<uint8_t>> ContentsOrErr = EF.getSectionContents(Sec); 697 if (!ContentsOrErr) 698 return ContentsOrErr.takeError(); 699 ArrayRef<uint8_t> Content = *ContentsOrErr; 700 DataExtractor Data(Content, EF.isLE(), ELFT::Is64Bits ? 8 : 4); 701 std::vector<BBAddrMap> FunctionEntries; 702 703 DataExtractor::Cursor Cur(0); 704 Error ULEBSizeErr = Error::success(); 705 Error MetadataDecodeErr = Error::success(); 706 707 uint8_t Version = 0; 708 uint8_t Feature = 0; 709 PGOAnalysisMap::Features FeatEnable{}; 710 while (!ULEBSizeErr && !MetadataDecodeErr && Cur && 711 Cur.tell() < Content.size()) { 712 if (Sec.sh_type == ELF::SHT_LLVM_BB_ADDR_MAP) { 713 Version = Data.getU8(Cur); 714 if (!Cur) 715 break; 716 if (Version > 2) 717 return createError("unsupported SHT_LLVM_BB_ADDR_MAP version: " + 718 Twine(static_cast<int>(Version))); 719 Feature = Data.getU8(Cur); // Feature byte 720 if (!Cur) 721 break; 722 auto FeatEnableOrErr = PGOAnalysisMap::Features::decode(Feature); 723 if (!FeatEnableOrErr) 724 return FeatEnableOrErr.takeError(); 725 FeatEnable = 726 FeatEnableOrErr ? *FeatEnableOrErr : PGOAnalysisMap::Features{}; 727 if (Feature != 0 && Version < 2 && Cur) 728 return createError( 729 "version should be >= 2 for SHT_LLVM_BB_ADDR_MAP when " 730 "PGO features are enabled: version = " + 731 Twine(static_cast<int>(Version)) + 732 " feature = " + Twine(static_cast<int>(Feature))); 733 } 734 uint64_t SectionOffset = Cur.tell(); 735 auto Address = 736 static_cast<typename ELFFile<ELFT>::uintX_t>(Data.getAddress(Cur)); 737 if (!Cur) 738 return Cur.takeError(); 739 if (IsRelocatable) { 740 assert(Address == 0); 741 auto FOTIterator = FunctionOffsetTranslations.find(SectionOffset); 742 if (FOTIterator == FunctionOffsetTranslations.end()) { 743 return createError("failed to get relocation data for offset: " + 744 Twine::utohexstr(SectionOffset) + " in section " + 745 describe(EF, Sec)); 746 } 747 Address = FOTIterator->second; 748 } 749 uint32_t NumBlocks = readULEB128As<uint32_t>(Data, Cur, ULEBSizeErr); 750 751 std::vector<BBAddrMap::BBEntry> BBEntries; 752 uint32_t PrevBBEndOffset = 0; 753 for (uint32_t BlockIndex = 0; 754 !MetadataDecodeErr && !ULEBSizeErr && Cur && (BlockIndex < NumBlocks); 755 ++BlockIndex) { 756 uint32_t ID = Version >= 2 757 ? readULEB128As<uint32_t>(Data, Cur, ULEBSizeErr) 758 : BlockIndex; 759 uint32_t Offset = readULEB128As<uint32_t>(Data, Cur, ULEBSizeErr); 760 uint32_t Size = readULEB128As<uint32_t>(Data, Cur, ULEBSizeErr); 761 uint32_t MD = readULEB128As<uint32_t>(Data, Cur, ULEBSizeErr); 762 if (Version >= 1) { 763 // Offset is calculated relative to the end of the previous BB. 764 Offset += PrevBBEndOffset; 765 PrevBBEndOffset = Offset + Size; 766 } 767 Expected<BBAddrMap::BBEntry::Metadata> MetadataOrErr = 768 BBAddrMap::BBEntry::Metadata::decode(MD); 769 if (!MetadataOrErr) { 770 MetadataDecodeErr = MetadataOrErr.takeError(); 771 break; 772 } 773 BBEntries.push_back({ID, Offset, Size, *MetadataOrErr}); 774 } 775 FunctionEntries.emplace_back(Address, std::move(BBEntries)); 776 777 if (PGOAnalyses || FeatEnable.anyEnabled()) { 778 // Function entry count 779 uint64_t FuncEntryCount = 780 FeatEnable.FuncEntryCount 781 ? readULEB128As<uint64_t>(Data, Cur, ULEBSizeErr) 782 : 0; 783 784 std::vector<PGOAnalysisMap::PGOBBEntry> PGOBBEntries; 785 for (uint32_t BlockIndex = 0; 786 (FeatEnable.BBFreq || FeatEnable.BrProb) && !MetadataDecodeErr && 787 !ULEBSizeErr && Cur && (BlockIndex < NumBlocks); 788 ++BlockIndex) { 789 // Block frequency 790 uint64_t BBF = FeatEnable.BBFreq 791 ? readULEB128As<uint64_t>(Data, Cur, ULEBSizeErr) 792 : 0; 793 794 // Branch probability 795 llvm::SmallVector<PGOAnalysisMap::PGOBBEntry::SuccessorEntry, 2> 796 Successors; 797 if (FeatEnable.BrProb) { 798 auto SuccCount = readULEB128As<uint64_t>(Data, Cur, ULEBSizeErr); 799 for (uint64_t I = 0; I < SuccCount; ++I) { 800 uint32_t BBID = readULEB128As<uint32_t>(Data, Cur, ULEBSizeErr); 801 uint32_t BrProb = readULEB128As<uint32_t>(Data, Cur, ULEBSizeErr); 802 if (PGOAnalyses) 803 Successors.push_back({BBID, BranchProbability::getRaw(BrProb)}); 804 } 805 } 806 807 if (PGOAnalyses) 808 PGOBBEntries.push_back({BlockFrequency(BBF), std::move(Successors)}); 809 } 810 811 if (PGOAnalyses) 812 PGOAnalyses->push_back( 813 {FuncEntryCount, std::move(PGOBBEntries), FeatEnable}); 814 } 815 } 816 // Either Cur is in the error state, or we have an error in ULEBSizeErr or 817 // MetadataDecodeErr (but not both), but we join all errors here to be safe. 818 if (!Cur || ULEBSizeErr || MetadataDecodeErr) 819 return joinErrors(joinErrors(Cur.takeError(), std::move(ULEBSizeErr)), 820 std::move(MetadataDecodeErr)); 821 return FunctionEntries; 822 } 823 824 template <class ELFT> 825 Expected<std::vector<BBAddrMap>> 826 ELFFile<ELFT>::decodeBBAddrMap(const Elf_Shdr &Sec, const Elf_Shdr *RelaSec, 827 std::vector<PGOAnalysisMap> *PGOAnalyses) const { 828 size_t OriginalPGOSize = PGOAnalyses ? PGOAnalyses->size() : 0; 829 auto AddrMapsOrErr = decodeBBAddrMapImpl(*this, Sec, RelaSec, PGOAnalyses); 830 // remove new analyses when an error occurs 831 if (!AddrMapsOrErr && PGOAnalyses) 832 PGOAnalyses->resize(OriginalPGOSize); 833 return std::move(AddrMapsOrErr); 834 } 835 836 template <class ELFT> 837 Expected< 838 MapVector<const typename ELFT::Shdr *, const typename ELFT::Shdr *>> 839 ELFFile<ELFT>::getSectionAndRelocations( 840 std::function<Expected<bool>(const Elf_Shdr &)> IsMatch) const { 841 MapVector<const Elf_Shdr *, const Elf_Shdr *> SecToRelocMap; 842 Error Errors = Error::success(); 843 for (const Elf_Shdr &Sec : cantFail(this->sections())) { 844 Expected<bool> DoesSectionMatch = IsMatch(Sec); 845 if (!DoesSectionMatch) { 846 Errors = joinErrors(std::move(Errors), DoesSectionMatch.takeError()); 847 continue; 848 } 849 if (*DoesSectionMatch) { 850 if (SecToRelocMap.insert(std::make_pair(&Sec, (const Elf_Shdr *)nullptr)) 851 .second) 852 continue; 853 } 854 855 if (Sec.sh_type != ELF::SHT_RELA && Sec.sh_type != ELF::SHT_REL) 856 continue; 857 858 Expected<const Elf_Shdr *> RelSecOrErr = this->getSection(Sec.sh_info); 859 if (!RelSecOrErr) { 860 Errors = joinErrors(std::move(Errors), 861 createError(describe(*this, Sec) + 862 ": failed to get a relocated section: " + 863 toString(RelSecOrErr.takeError()))); 864 continue; 865 } 866 const Elf_Shdr *ContentsSec = *RelSecOrErr; 867 Expected<bool> DoesRelTargetMatch = IsMatch(*ContentsSec); 868 if (!DoesRelTargetMatch) { 869 Errors = joinErrors(std::move(Errors), DoesRelTargetMatch.takeError()); 870 continue; 871 } 872 if (*DoesRelTargetMatch) 873 SecToRelocMap[ContentsSec] = &Sec; 874 } 875 if(Errors) 876 return std::move(Errors); 877 return SecToRelocMap; 878 } 879 880 template class llvm::object::ELFFile<ELF32LE>; 881 template class llvm::object::ELFFile<ELF32BE>; 882 template class llvm::object::ELFFile<ELF64LE>; 883 template class llvm::object::ELFFile<ELF64BE>; 884