llvm/lib/Object/ELF.cpp

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