llvm/lib/Object/ELFObjectFile.cpp

   1 //===- ELFObjectFile.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 // Part of the ELFObjectFile class implementation.
  10 //
  11 //===----------------------------------------------------------------------===//
  12
  13 #include "llvm/Object/ELFObjectFile.h"
  14 #include "llvm/BinaryFormat/ELF.h"
  15 #include "llvm/MC/MCInstrAnalysis.h"
  16 #include "llvm/MC/TargetRegistry.h"
  17 #include "llvm/Object/ELF.h"
  18 #include "llvm/Object/ELFTypes.h"
  19 #include "llvm/Object/Error.h"
  20 #include "llvm/Support/ARMAttributeParser.h"
  21 #include "llvm/Support/ARMBuildAttributes.h"
  22 #include "llvm/Support/ErrorHandling.h"
  23 #include "llvm/Support/MathExtras.h"
  24 #include "llvm/Support/RISCVAttributeParser.h"
  25 #include "llvm/Support/RISCVAttributes.h"
  26 #include "llvm/Support/RISCVISAInfo.h"
  27 #include "llvm/TargetParser/SubtargetFeature.h"
  28 #include "llvm/TargetParser/Triple.h"
  29 #include <algorithm>
  30 #include <cstddef>
  31 #include <cstdint>
  32 #include <memory>
  33 #include <optional>
  34 #include <string>
  35 #include <utility>
  36
  37 using namespace llvm;
  38 using namespace object;
  39
  40 const EnumEntry<unsigned> llvm::object::ElfSymbolTypes[NumElfSymbolTypes] = {
  41     {"None", "NOTYPE", ELF::STT_NOTYPE},
  42     {"Object", "OBJECT", ELF::STT_OBJECT},
  43     {"Function", "FUNC", ELF::STT_FUNC},
  44     {"Section", "SECTION", ELF::STT_SECTION},
  45     {"File", "FILE", ELF::STT_FILE},
  46     {"Common", "COMMON", ELF::STT_COMMON},
  47     {"TLS", "TLS", ELF::STT_TLS},
  48     {"Unknown", "<unknown>: 7", 7},
  49     {"Unknown", "<unknown>: 8", 8},
  50     {"Unknown", "<unknown>: 9", 9},
  51     {"GNU_IFunc", "IFUNC", ELF::STT_GNU_IFUNC},
  52     {"OS Specific", "<OS specific>: 11", 11},
  53     {"OS Specific", "<OS specific>: 12", 12},
  54     {"Proc Specific", "<processor specific>: 13", 13},
  55     {"Proc Specific", "<processor specific>: 14", 14},
  56     {"Proc Specific", "<processor specific>: 15", 15}
  57 };
  58
  59 ELFObjectFileBase::ELFObjectFileBase(unsigned int Type, MemoryBufferRef Source)
  60     : ObjectFile(Type, Source) {}
  61
  62 template <class ELFT>
  63 static Expected<std::unique_ptr<ELFObjectFile<ELFT>>>
  64 createPtr(MemoryBufferRef Object, bool InitContent) {
  65   auto Ret = ELFObjectFile<ELFT>::create(Object, InitContent);
  66   if (Error E = Ret.takeError())
  67     return std::move(E);
  68   return std::make_unique<ELFObjectFile<ELFT>>(std::move(*Ret));
  69 }
  70
  71 Expected<std::unique_ptr<ObjectFile>>
  72 ObjectFile::createELFObjectFile(MemoryBufferRef Obj, bool InitContent) {
  73   std::pair<unsigned char, unsigned char> Ident =
  74       getElfArchType(Obj.getBuffer());
  75   std::size_t MaxAlignment =
  76       1ULL << llvm::countr_zero(
  77           reinterpret_cast<uintptr_t>(Obj.getBufferStart()));
  78
  79   if (MaxAlignment < 2)
  80     return createError("Insufficient alignment");
  81
  82   if (Ident.first == ELF::ELFCLASS32) {
  83     if (Ident.second == ELF::ELFDATA2LSB)
  84       return createPtr<ELF32LE>(Obj, InitContent);
  85     else if (Ident.second == ELF::ELFDATA2MSB)
  86       return createPtr<ELF32BE>(Obj, InitContent);
  87     else
  88       return createError("Invalid ELF data");
  89   } else if (Ident.first == ELF::ELFCLASS64) {
  90     if (Ident.second == ELF::ELFDATA2LSB)
  91       return createPtr<ELF64LE>(Obj, InitContent);
  92     else if (Ident.second == ELF::ELFDATA2MSB)
  93       return createPtr<ELF64BE>(Obj, InitContent);
  94     else
  95       return createError("Invalid ELF data");
  96   }
  97   return createError("Invalid ELF class");
  98 }
  99
 100 SubtargetFeatures ELFObjectFileBase::getMIPSFeatures() const {
 101   SubtargetFeatures Features;
 102   unsigned PlatformFlags = getPlatformFlags();
 103
 104   switch (PlatformFlags & ELF::EF_MIPS_ARCH) {
 105   case ELF::EF_MIPS_ARCH_1:
 106     break;
 107   case ELF::EF_MIPS_ARCH_2:
 108     Features.AddFeature("mips2");
 109     break;
 110   case ELF::EF_MIPS_ARCH_3:
 111     Features.AddFeature("mips3");
 112     break;
 113   case ELF::EF_MIPS_ARCH_4:
 114     Features.AddFeature("mips4");
 115     break;
 116   case ELF::EF_MIPS_ARCH_5:
 117     Features.AddFeature("mips5");
 118     break;
 119   case ELF::EF_MIPS_ARCH_32:
 120     Features.AddFeature("mips32");
 121     break;
 122   case ELF::EF_MIPS_ARCH_64:
 123     Features.AddFeature("mips64");
 124     break;
 125   case ELF::EF_MIPS_ARCH_32R2:
 126     Features.AddFeature("mips32r2");
 127     break;
 128   case ELF::EF_MIPS_ARCH_64R2:
 129     Features.AddFeature("mips64r2");
 130     break;
 131   case ELF::EF_MIPS_ARCH_32R6:
 132     Features.AddFeature("mips32r6");
 133     break;
 134   case ELF::EF_MIPS_ARCH_64R6:
 135     Features.AddFeature("mips64r6");
 136     break;
 137   default:
 138     llvm_unreachable("Unknown EF_MIPS_ARCH value");
 139   }
 140
 141   switch (PlatformFlags & ELF::EF_MIPS_MACH) {
 142   case ELF::EF_MIPS_MACH_NONE:
 143     // No feature associated with this value.
 144     break;
 145   case ELF::EF_MIPS_MACH_OCTEON:
 146     Features.AddFeature("cnmips");
 147     break;
 148   default:
 149     llvm_unreachable("Unknown EF_MIPS_ARCH value");
 150   }
 151
 152   if (PlatformFlags & ELF::EF_MIPS_ARCH_ASE_M16)
 153     Features.AddFeature("mips16");
 154   if (PlatformFlags & ELF::EF_MIPS_MICROMIPS)
 155     Features.AddFeature("micromips");
 156
 157   return Features;
 158 }
 159
 160 SubtargetFeatures ELFObjectFileBase::getARMFeatures() const {
 161   SubtargetFeatures Features;
 162   ARMAttributeParser Attributes;
 163   if (Error E = getBuildAttributes(Attributes)) {
 164     consumeError(std::move(E));
 165     return SubtargetFeatures();
 166   }
 167
 168   // both ARMv7-M and R have to support thumb hardware div
 169   bool isV7 = false;
 170   std::optional<unsigned> Attr =
 171       Attributes.getAttributeValue(ARMBuildAttrs::CPU_arch);
 172   if (Attr)
 173     isV7 = *Attr == ARMBuildAttrs::v7;
 174
 175   Attr = Attributes.getAttributeValue(ARMBuildAttrs::CPU_arch_profile);
 176   if (Attr) {
 177     switch (*Attr) {
 178     case ARMBuildAttrs::ApplicationProfile:
 179       Features.AddFeature("aclass");
 180       break;
 181     case ARMBuildAttrs::RealTimeProfile:
 182       Features.AddFeature("rclass");
 183       if (isV7)
 184         Features.AddFeature("hwdiv");
 185       break;
 186     case ARMBuildAttrs::MicroControllerProfile:
 187       Features.AddFeature("mclass");
 188       if (isV7)
 189         Features.AddFeature("hwdiv");
 190       break;
 191     }
 192   }
 193
 194   Attr = Attributes.getAttributeValue(ARMBuildAttrs::THUMB_ISA_use);
 195   if (Attr) {
 196     switch (*Attr) {
 197     default:
 198       break;
 199     case ARMBuildAttrs::Not_Allowed:
 200       Features.AddFeature("thumb", false);
 201       Features.AddFeature("thumb2", false);
 202       break;
 203     case ARMBuildAttrs::AllowThumb32:
 204       Features.AddFeature("thumb2");
 205       break;
 206     }
 207   }
 208
 209   Attr = Attributes.getAttributeValue(ARMBuildAttrs::FP_arch);
 210   if (Attr) {
 211     switch (*Attr) {
 212     default:
 213       break;
 214     case ARMBuildAttrs::Not_Allowed:
 215       Features.AddFeature("vfp2sp", false);
 216       Features.AddFeature("vfp3d16sp", false);
 217       Features.AddFeature("vfp4d16sp", false);
 218       break;
 219     case ARMBuildAttrs::AllowFPv2:
 220       Features.AddFeature("vfp2");
 221       break;
 222     case ARMBuildAttrs::AllowFPv3A:
 223     case ARMBuildAttrs::AllowFPv3B:
 224       Features.AddFeature("vfp3");
 225       break;
 226     case ARMBuildAttrs::AllowFPv4A:
 227     case ARMBuildAttrs::AllowFPv4B:
 228       Features.AddFeature("vfp4");
 229       break;
 230     }
 231   }
 232
 233   Attr = Attributes.getAttributeValue(ARMBuildAttrs::Advanced_SIMD_arch);
 234   if (Attr) {
 235     switch (*Attr) {
 236     default:
 237       break;
 238     case ARMBuildAttrs::Not_Allowed:
 239       Features.AddFeature("neon", false);
 240       Features.AddFeature("fp16", false);
 241       break;
 242     case ARMBuildAttrs::AllowNeon:
 243       Features.AddFeature("neon");
 244       break;
 245     case ARMBuildAttrs::AllowNeon2:
 246       Features.AddFeature("neon");
 247       Features.AddFeature("fp16");
 248       break;
 249     }
 250   }
 251
 252   Attr = Attributes.getAttributeValue(ARMBuildAttrs::MVE_arch);
 253   if (Attr) {
 254     switch (*Attr) {
 255     default:
 256       break;
 257     case ARMBuildAttrs::Not_Allowed:
 258       Features.AddFeature("mve", false);
 259       Features.AddFeature("mve.fp", false);
 260       break;
 261     case ARMBuildAttrs::AllowMVEInteger:
 262       Features.AddFeature("mve.fp", false);
 263       Features.AddFeature("mve");
 264       break;
 265     case ARMBuildAttrs::AllowMVEIntegerAndFloat:
 266       Features.AddFeature("mve.fp");
 267       break;
 268     }
 269   }
 270
 271   Attr = Attributes.getAttributeValue(ARMBuildAttrs::DIV_use);
 272   if (Attr) {
 273     switch (*Attr) {
 274     default:
 275       break;
 276     case ARMBuildAttrs::DisallowDIV:
 277       Features.AddFeature("hwdiv", false);
 278       Features.AddFeature("hwdiv-arm", false);
 279       break;
 280     case ARMBuildAttrs::AllowDIVExt:
 281       Features.AddFeature("hwdiv");
 282       Features.AddFeature("hwdiv-arm");
 283       break;
 284     }
 285   }
 286
 287   return Features;
 288 }
 289
 290 Expected<SubtargetFeatures> ELFObjectFileBase::getRISCVFeatures() const {
 291   SubtargetFeatures Features;
 292   unsigned PlatformFlags = getPlatformFlags();
 293
 294   if (PlatformFlags & ELF::EF_RISCV_RVC) {
 295     Features.AddFeature("c");
 296   }
 297
 298   RISCVAttributeParser Attributes;
 299   if (Error E = getBuildAttributes(Attributes)) {
 300     return std::move(E);
 301   }
 302
 303   std::optional<StringRef> Attr =
 304       Attributes.getAttributeString(RISCVAttrs::ARCH);
 305   if (Attr) {
 306     auto ParseResult = RISCVISAInfo::parseNormalizedArchString(*Attr);
 307     if (!ParseResult)
 308       return ParseResult.takeError();
 309     auto &ISAInfo = *ParseResult;
 310
 311     if (ISAInfo->getXLen() == 32)
 312       Features.AddFeature("64bit", false);
 313     else if (ISAInfo->getXLen() == 64)
 314       Features.AddFeature("64bit");
 315     else
 316       llvm_unreachable("XLEN should be 32 or 64.");
 317
 318     Features.addFeaturesVector(ISAInfo->toFeatureVector());
 319   }
 320
 321   return Features;
 322 }
 323
 324 SubtargetFeatures ELFObjectFileBase::getLoongArchFeatures() const {
 325   SubtargetFeatures Features;
 326
 327   switch (getPlatformFlags() & ELF::EF_LOONGARCH_ABI_MODIFIER_MASK) {
 328   case ELF::EF_LOONGARCH_ABI_SOFT_FLOAT:
 329     break;
 330   case ELF::EF_LOONGARCH_ABI_DOUBLE_FLOAT:
 331     Features.AddFeature("d");
 332     // D implies F according to LoongArch ISA spec.
 333     [[fallthrough]];
 334   case ELF::EF_LOONGARCH_ABI_SINGLE_FLOAT:
 335     Features.AddFeature("f");
 336     break;
 337   }
 338
 339   return Features;
 340 }
 341
 342 Expected<SubtargetFeatures> ELFObjectFileBase::getFeatures() const {
 343   switch (getEMachine()) {
 344   case ELF::EM_MIPS:
 345     return getMIPSFeatures();
 346   case ELF::EM_ARM:
 347     return getARMFeatures();
 348   case ELF::EM_RISCV:
 349     return getRISCVFeatures();
 350   case ELF::EM_LOONGARCH:
 351     return getLoongArchFeatures();
 352   default:
 353     return SubtargetFeatures();
 354   }
 355 }
 356
 357 std::optional<StringRef> ELFObjectFileBase::tryGetCPUName() const {
 358   switch (getEMachine()) {
 359   case ELF::EM_AMDGPU:
 360     return getAMDGPUCPUName();
 361   case ELF::EM_PPC:
 362   case ELF::EM_PPC64:
 363     return StringRef("future");
 364   default:
 365     return std::nullopt;
 366   }
 367 }
 368
 369 StringRef ELFObjectFileBase::getAMDGPUCPUName() const {
 370   assert(getEMachine() == ELF::EM_AMDGPU);
 371   unsigned CPU = getPlatformFlags() & ELF::EF_AMDGPU_MACH;
 372
 373   switch (CPU) {
 374   // Radeon HD 2000/3000 Series (R600).
 375   case ELF::EF_AMDGPU_MACH_R600_R600:
 376     return "r600";
 377   case ELF::EF_AMDGPU_MACH_R600_R630:
 378     return "r630";
 379   case ELF::EF_AMDGPU_MACH_R600_RS880:
 380     return "rs880";
 381   case ELF::EF_AMDGPU_MACH_R600_RV670:
 382     return "rv670";
 383
 384   // Radeon HD 4000 Series (R700).
 385   case ELF::EF_AMDGPU_MACH_R600_RV710:
 386     return "rv710";
 387   case ELF::EF_AMDGPU_MACH_R600_RV730:
 388     return "rv730";
 389   case ELF::EF_AMDGPU_MACH_R600_RV770:
 390     return "rv770";
 391
 392   // Radeon HD 5000 Series (Evergreen).
 393   case ELF::EF_AMDGPU_MACH_R600_CEDAR:
 394     return "cedar";
 395   case ELF::EF_AMDGPU_MACH_R600_CYPRESS:
 396     return "cypress";
 397   case ELF::EF_AMDGPU_MACH_R600_JUNIPER:
 398     return "juniper";
 399   case ELF::EF_AMDGPU_MACH_R600_REDWOOD:
 400     return "redwood";
 401   case ELF::EF_AMDGPU_MACH_R600_SUMO:
 402     return "sumo";
 403
 404   // Radeon HD 6000 Series (Northern Islands).
 405   case ELF::EF_AMDGPU_MACH_R600_BARTS:
 406     return "barts";
 407   case ELF::EF_AMDGPU_MACH_R600_CAICOS:
 408     return "caicos";
 409   case ELF::EF_AMDGPU_MACH_R600_CAYMAN:
 410     return "cayman";
 411   case ELF::EF_AMDGPU_MACH_R600_TURKS:
 412     return "turks";
 413
 414   // AMDGCN GFX6.
 415   case ELF::EF_AMDGPU_MACH_AMDGCN_GFX600:
 416     return "gfx600";
 417   case ELF::EF_AMDGPU_MACH_AMDGCN_GFX601:
 418     return "gfx601";
 419   case ELF::EF_AMDGPU_MACH_AMDGCN_GFX602:
 420     return "gfx602";
 421
 422   // AMDGCN GFX7.
 423   case ELF::EF_AMDGPU_MACH_AMDGCN_GFX700:
 424     return "gfx700";
 425   case ELF::EF_AMDGPU_MACH_AMDGCN_GFX701:
 426     return "gfx701";
 427   case ELF::EF_AMDGPU_MACH_AMDGCN_GFX702:
 428     return "gfx702";
 429   case ELF::EF_AMDGPU_MACH_AMDGCN_GFX703:
 430     return "gfx703";
 431   case ELF::EF_AMDGPU_MACH_AMDGCN_GFX704:
 432     return "gfx704";
 433   case ELF::EF_AMDGPU_MACH_AMDGCN_GFX705:
 434     return "gfx705";
 435
 436   // AMDGCN GFX8.
 437   case ELF::EF_AMDGPU_MACH_AMDGCN_GFX801:
 438     return "gfx801";
 439   case ELF::EF_AMDGPU_MACH_AMDGCN_GFX802:
 440     return "gfx802";
 441   case ELF::EF_AMDGPU_MACH_AMDGCN_GFX803:
 442     return "gfx803";
 443   case ELF::EF_AMDGPU_MACH_AMDGCN_GFX805:
 444     return "gfx805";
 445   case ELF::EF_AMDGPU_MACH_AMDGCN_GFX810:
 446     return "gfx810";
 447
 448   // AMDGCN GFX9.
 449   case ELF::EF_AMDGPU_MACH_AMDGCN_GFX900:
 450     return "gfx900";
 451   case ELF::EF_AMDGPU_MACH_AMDGCN_GFX902:
 452     return "gfx902";
 453   case ELF::EF_AMDGPU_MACH_AMDGCN_GFX904:
 454     return "gfx904";
 455   case ELF::EF_AMDGPU_MACH_AMDGCN_GFX906:
 456     return "gfx906";
 457   case ELF::EF_AMDGPU_MACH_AMDGCN_GFX908:
 458     return "gfx908";
 459   case ELF::EF_AMDGPU_MACH_AMDGCN_GFX909:
 460     return "gfx909";
 461   case ELF::EF_AMDGPU_MACH_AMDGCN_GFX90A:
 462     return "gfx90a";
 463   case ELF::EF_AMDGPU_MACH_AMDGCN_GFX90C:
 464     return "gfx90c";
 465   case ELF::EF_AMDGPU_MACH_AMDGCN_GFX940:
 466     return "gfx940";
 467   case ELF::EF_AMDGPU_MACH_AMDGCN_GFX941:
 468     return "gfx941";
 469   case ELF::EF_AMDGPU_MACH_AMDGCN_GFX942:
 470     return "gfx942";
 471
 472   // AMDGCN GFX10.
 473   case ELF::EF_AMDGPU_MACH_AMDGCN_GFX1010:
 474     return "gfx1010";
 475   case ELF::EF_AMDGPU_MACH_AMDGCN_GFX1011:
 476     return "gfx1011";
 477   case ELF::EF_AMDGPU_MACH_AMDGCN_GFX1012:
 478     return "gfx1012";
 479   case ELF::EF_AMDGPU_MACH_AMDGCN_GFX1013:
 480     return "gfx1013";
 481   case ELF::EF_AMDGPU_MACH_AMDGCN_GFX1030:
 482     return "gfx1030";
 483   case ELF::EF_AMDGPU_MACH_AMDGCN_GFX1031:
 484     return "gfx1031";
 485   case ELF::EF_AMDGPU_MACH_AMDGCN_GFX1032:
 486     return "gfx1032";
 487   case ELF::EF_AMDGPU_MACH_AMDGCN_GFX1033:
 488     return "gfx1033";
 489   case ELF::EF_AMDGPU_MACH_AMDGCN_GFX1034:
 490     return "gfx1034";
 491   case ELF::EF_AMDGPU_MACH_AMDGCN_GFX1035:
 492     return "gfx1035";
 493   case ELF::EF_AMDGPU_MACH_AMDGCN_GFX1036:
 494     return "gfx1036";
 495
 496   // AMDGCN GFX11.
 497   case ELF::EF_AMDGPU_MACH_AMDGCN_GFX1100:
 498     return "gfx1100";
 499   case ELF::EF_AMDGPU_MACH_AMDGCN_GFX1101:
 500     return "gfx1101";
 501   case ELF::EF_AMDGPU_MACH_AMDGCN_GFX1102:
 502     return "gfx1102";
 503   case ELF::EF_AMDGPU_MACH_AMDGCN_GFX1103:
 504     return "gfx1103";
 505   case ELF::EF_AMDGPU_MACH_AMDGCN_GFX1150:
 506     return "gfx1150";
 507   case ELF::EF_AMDGPU_MACH_AMDGCN_GFX1151:
 508     return "gfx1151";
 509   default:
 510     llvm_unreachable("Unknown EF_AMDGPU_MACH value");
 511   }
 512 }
 513
 514 // FIXME Encode from a tablegen description or target parser.
 515 void ELFObjectFileBase::setARMSubArch(Triple &TheTriple) const {
 516   if (TheTriple.getSubArch() != Triple::NoSubArch)
 517     return;
 518
 519   ARMAttributeParser Attributes;
 520   if (Error E = getBuildAttributes(Attributes)) {
 521     // TODO Propagate Error.
 522     consumeError(std::move(E));
 523     return;
 524   }
 525
 526   std::string Triple;
 527   // Default to ARM, but use the triple if it's been set.
 528   if (TheTriple.isThumb())
 529     Triple = "thumb";
 530   else
 531     Triple = "arm";
 532
 533   std::optional<unsigned> Attr =
 534       Attributes.getAttributeValue(ARMBuildAttrs::CPU_arch);
 535   if (Attr) {
 536     switch (*Attr) {
 537     case ARMBuildAttrs::v4:
 538       Triple += "v4";
 539       break;
 540     case ARMBuildAttrs::v4T:
 541       Triple += "v4t";
 542       break;
 543     case ARMBuildAttrs::v5T:
 544       Triple += "v5t";
 545       break;
 546     case ARMBuildAttrs::v5TE:
 547       Triple += "v5te";
 548       break;
 549     case ARMBuildAttrs::v5TEJ:
 550       Triple += "v5tej";
 551       break;
 552     case ARMBuildAttrs::v6:
 553       Triple += "v6";
 554       break;
 555     case ARMBuildAttrs::v6KZ:
 556       Triple += "v6kz";
 557       break;
 558     case ARMBuildAttrs::v6T2:
 559       Triple += "v6t2";
 560       break;
 561     case ARMBuildAttrs::v6K:
 562       Triple += "v6k";
 563       break;
 564     case ARMBuildAttrs::v7: {
 565       std::optional<unsigned> ArchProfileAttr =
 566           Attributes.getAttributeValue(ARMBuildAttrs::CPU_arch_profile);
 567       if (ArchProfileAttr &&
 568           *ArchProfileAttr == ARMBuildAttrs::MicroControllerProfile)
 569         Triple += "v7m";
 570       else
 571         Triple += "v7";
 572       break;
 573     }
 574     case ARMBuildAttrs::v6_M:
 575       Triple += "v6m";
 576       break;
 577     case ARMBuildAttrs::v6S_M:
 578       Triple += "v6sm";
 579       break;
 580     case ARMBuildAttrs::v7E_M:
 581       Triple += "v7em";
 582       break;
 583     case ARMBuildAttrs::v8_A:
 584       Triple += "v8a";
 585       break;
 586     case ARMBuildAttrs::v8_R:
 587       Triple += "v8r";
 588       break;
 589     case ARMBuildAttrs::v8_M_Base:
 590       Triple += "v8m.base";
 591       break;
 592     case ARMBuildAttrs::v8_M_Main:
 593       Triple += "v8m.main";
 594       break;
 595     case ARMBuildAttrs::v8_1_M_Main:
 596       Triple += "v8.1m.main";
 597       break;
 598     case ARMBuildAttrs::v9_A:
 599       Triple += "v9a";
 600       break;
 601     }
 602   }
 603   if (!isLittleEndian())
 604     Triple += "eb";
 605
 606   TheTriple.setArchName(Triple);
 607 }
 608
 609 std::vector<ELFPltEntry> ELFObjectFileBase::getPltEntries() const {
 610   std::string Err;
 611   const auto Triple = makeTriple();
 612   const auto *T = TargetRegistry::lookupTarget(Triple.str(), Err);
 613   if (!T)
 614     return {};
 615   uint32_t JumpSlotReloc = 0, GlobDatReloc = 0;
 616   switch (Triple.getArch()) {
 617     case Triple::x86:
 618       JumpSlotReloc = ELF::R_386_JUMP_SLOT;
 619       GlobDatReloc = ELF::R_386_GLOB_DAT;
 620       break;
 621     case Triple::x86_64:
 622       JumpSlotReloc = ELF::R_X86_64_JUMP_SLOT;
 623       GlobDatReloc = ELF::R_X86_64_GLOB_DAT;
 624       break;
 625     case Triple::aarch64:
 626     case Triple::aarch64_be:
 627       JumpSlotReloc = ELF::R_AARCH64_JUMP_SLOT;
 628       break;
 629     default:
 630       return {};
 631   }
 632   std::unique_ptr<const MCInstrInfo> MII(T->createMCInstrInfo());
 633   std::unique_ptr<const MCInstrAnalysis> MIA(
 634       T->createMCInstrAnalysis(MII.get()));
 635   if (!MIA)
 636     return {};
 637   std::vector<std::pair<uint64_t, uint64_t>> PltEntries;
 638   std::optional<SectionRef> RelaPlt, RelaDyn;
 639   uint64_t GotBaseVA = 0;
 640   for (const SectionRef &Section : sections()) {
 641     Expected<StringRef> NameOrErr = Section.getName();
 642     if (!NameOrErr) {
 643       consumeError(NameOrErr.takeError());
 644       continue;
 645     }
 646     StringRef Name = *NameOrErr;
 647
 648     if (Name == ".rela.plt" || Name == ".rel.plt") {
 649       RelaPlt = Section;
 650     } else if (Name == ".rela.dyn" || Name == ".rel.dyn") {
 651       RelaDyn = Section;
 652     } else if (Name == ".got.plt") {
 653       GotBaseVA = Section.getAddress();
 654     } else if (Name == ".plt" || Name == ".plt.got") {
 655       Expected<StringRef> PltContents = Section.getContents();
 656       if (!PltContents) {
 657         consumeError(PltContents.takeError());
 658         return {};
 659       }
 660       llvm::append_range(
 661           PltEntries,
 662           MIA->findPltEntries(Section.getAddress(),
 663                               arrayRefFromStringRef(*PltContents), Triple));
 664     }
 665   }
 666
 667   // Build a map from GOT entry virtual address to PLT entry virtual address.
 668   DenseMap<uint64_t, uint64_t> GotToPlt;
 669   for (auto [Plt, GotPlt] : PltEntries) {
 670     uint64_t GotPltEntry = GotPlt;
 671     // An x86-32 PIC PLT uses jmp DWORD PTR [ebx-offset]. Add
 672     // _GLOBAL_OFFSET_TABLE_ (EBX) to get the .got.plt (or .got) entry address.
 673     // See X86MCTargetDesc.cpp:findPltEntries for the 1 << 32 bit.
 674     if (GotPltEntry & (uint64_t(1) << 32) && getEMachine() == ELF::EM_386)
 675       GotPltEntry = static_cast<int32_t>(GotPltEntry) + GotBaseVA;
 676     GotToPlt.insert(std::make_pair(GotPltEntry, Plt));
 677   }
 678
 679   // Find the relocations in the dynamic relocation table that point to
 680   // locations in the GOT for which we know the corresponding PLT entry.
 681   std::vector<ELFPltEntry> Result;
 682   auto handleRels = [&](iterator_range<relocation_iterator> Rels,
 683                         uint32_t RelType, StringRef PltSec) {
 684     for (const auto &R : Rels) {
 685       if (R.getType() != RelType)
 686         continue;
 687       auto PltEntryIter = GotToPlt.find(R.getOffset());
 688       if (PltEntryIter != GotToPlt.end()) {
 689         symbol_iterator Sym = R.getSymbol();
 690         if (Sym == symbol_end())
 691           Result.push_back(
 692               ELFPltEntry{PltSec, std::nullopt, PltEntryIter->second});
 693         else
 694           Result.push_back(ELFPltEntry{PltSec, Sym->getRawDataRefImpl(),
 695                                        PltEntryIter->second});
 696       }
 697     }
 698   };
 699
 700   if (RelaPlt)
 701     handleRels(RelaPlt->relocations(), JumpSlotReloc, ".plt");
 702
 703   // If a symbol needing a PLT entry also needs a GLOB_DAT relocation, GNU ld's
 704   // x86 port places the PLT entry in the .plt.got section.
 705   if (RelaDyn)
 706     handleRels(RelaDyn->relocations(), GlobDatReloc, ".plt.got");
 707
 708   return Result;
 709 }
 710
 711 template <class ELFT>
 712 Expected<std::vector<BBAddrMap>> static readBBAddrMapImpl(
 713     const ELFFile<ELFT> &EF, std::optional<unsigned> TextSectionIndex) {
 714   using Elf_Shdr = typename ELFT::Shdr;
 715   bool IsRelocatable = EF.getHeader().e_type == ELF::ET_REL;
 716   std::vector<BBAddrMap> BBAddrMaps;
 717
 718   const auto &Sections = cantFail(EF.sections());
 719   auto IsMatch = [&](const Elf_Shdr &Sec) -> Expected<bool> {
 720     if (Sec.sh_type != ELF::SHT_LLVM_BB_ADDR_MAP &&
 721         Sec.sh_type != ELF::SHT_LLVM_BB_ADDR_MAP_V0)
 722       return false;
 723     if (!TextSectionIndex)
 724       return true;
 725     Expected<const Elf_Shdr *> TextSecOrErr = EF.getSection(Sec.sh_link);
 726     if (!TextSecOrErr)
 727       return createError("unable to get the linked-to section for " +
 728                          describe(EF, Sec) + ": " +
 729                          toString(TextSecOrErr.takeError()));
 730     if (*TextSectionIndex != std::distance(Sections.begin(), *TextSecOrErr))
 731       return false;
 732     return true;
 733   };
 734
 735   Expected<MapVector<const Elf_Shdr *, const Elf_Shdr *>> SectionRelocMapOrErr =
 736       EF.getSectionAndRelocations(IsMatch);
 737   if (!SectionRelocMapOrErr)
 738     return SectionRelocMapOrErr.takeError();
 739
 740   for (auto const &[Sec, RelocSec] : *SectionRelocMapOrErr) {
 741     if (IsRelocatable && !RelocSec)
 742       return createError("unable to get relocation section for " +
 743                          describe(EF, *Sec));
 744     Expected<std::vector<BBAddrMap>> BBAddrMapOrErr =
 745         EF.decodeBBAddrMap(*Sec, RelocSec);
 746     if (!BBAddrMapOrErr)
 747       return createError("unable to read " + describe(EF, *Sec) + ": " +
 748                          toString(BBAddrMapOrErr.takeError()));
 749     std::move(BBAddrMapOrErr->begin(), BBAddrMapOrErr->end(),
 750               std::back_inserter(BBAddrMaps));
 751   }
 752   return BBAddrMaps;
 753 }
 754
 755 template <class ELFT>
 756 static Expected<std::vector<VersionEntry>>
 757 readDynsymVersionsImpl(const ELFFile<ELFT> &EF,
 758                        ELFObjectFileBase::elf_symbol_iterator_range Symbols) {
 759   using Elf_Shdr = typename ELFT::Shdr;
 760   const Elf_Shdr *VerSec = nullptr;
 761   const Elf_Shdr *VerNeedSec = nullptr;
 762   const Elf_Shdr *VerDefSec = nullptr;
 763   // The user should ensure sections() can't fail here.
 764   for (const Elf_Shdr &Sec : cantFail(EF.sections())) {
 765     if (Sec.sh_type == ELF::SHT_GNU_versym)
 766       VerSec = &Sec;
 767     else if (Sec.sh_type == ELF::SHT_GNU_verdef)
 768       VerDefSec = &Sec;
 769     else if (Sec.sh_type == ELF::SHT_GNU_verneed)
 770       VerNeedSec = &Sec;
 771   }
 772   if (!VerSec)
 773     return std::vector<VersionEntry>();
 774
 775   Expected<SmallVector<std::optional<VersionEntry>, 0>> MapOrErr =
 776       EF.loadVersionMap(VerNeedSec, VerDefSec);
 777   if (!MapOrErr)
 778     return MapOrErr.takeError();
 779
 780   std::vector<VersionEntry> Ret;
 781   size_t I = 0;
 782   for (const ELFSymbolRef &Sym : Symbols) {
 783     ++I;
 784     Expected<const typename ELFT::Versym *> VerEntryOrErr =
 785         EF.template getEntry<typename ELFT::Versym>(*VerSec, I);
 786     if (!VerEntryOrErr)
 787       return createError("unable to read an entry with index " + Twine(I) +
 788                          " from " + describe(EF, *VerSec) + ": " +
 789                          toString(VerEntryOrErr.takeError()));
 790
 791     Expected<uint32_t> FlagsOrErr = Sym.getFlags();
 792     if (!FlagsOrErr)
 793       return createError("unable to read flags for symbol with index " +
 794                          Twine(I) + ": " + toString(FlagsOrErr.takeError()));
 795
 796     bool IsDefault;
 797     Expected<StringRef> VerOrErr = EF.getSymbolVersionByIndex(
 798         (*VerEntryOrErr)->vs_index, IsDefault, *MapOrErr,
 799         (*FlagsOrErr) & SymbolRef::SF_Undefined);
 800     if (!VerOrErr)
 801       return createError("unable to get a version for entry " + Twine(I) +
 802                          " of " + describe(EF, *VerSec) + ": " +
 803                          toString(VerOrErr.takeError()));
 804
 805     Ret.push_back({(*VerOrErr).str(), IsDefault});
 806   }
 807
 808   return Ret;
 809 }
 810
 811 Expected<std::vector<VersionEntry>>
 812 ELFObjectFileBase::readDynsymVersions() const {
 813   elf_symbol_iterator_range Symbols = getDynamicSymbolIterators();
 814   if (const auto *Obj = dyn_cast<ELF32LEObjectFile>(this))
 815     return readDynsymVersionsImpl(Obj->getELFFile(), Symbols);
 816   if (const auto *Obj = dyn_cast<ELF32BEObjectFile>(this))
 817     return readDynsymVersionsImpl(Obj->getELFFile(), Symbols);
 818   if (const auto *Obj = dyn_cast<ELF64LEObjectFile>(this))
 819     return readDynsymVersionsImpl(Obj->getELFFile(), Symbols);
 820   return readDynsymVersionsImpl(cast<ELF64BEObjectFile>(this)->getELFFile(),
 821                                 Symbols);
 822 }
 823
 824 Expected<std::vector<BBAddrMap>> ELFObjectFileBase::readBBAddrMap(
 825     std::optional<unsigned> TextSectionIndex) const {
 826   if (const auto *Obj = dyn_cast<ELF32LEObjectFile>(this))
 827     return readBBAddrMapImpl(Obj->getELFFile(), TextSectionIndex);
 828   if (const auto *Obj = dyn_cast<ELF64LEObjectFile>(this))
 829     return readBBAddrMapImpl(Obj->getELFFile(), TextSectionIndex);
 830   if (const auto *Obj = dyn_cast<ELF32BEObjectFile>(this))
 831     return readBBAddrMapImpl(Obj->getELFFile(), TextSectionIndex);
 832   return readBBAddrMapImpl(cast<ELF64BEObjectFile>(this)->getELFFile(),
 833                            TextSectionIndex);
 834 }