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