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