Movatterモバイル変換

Go to the documentation of this file.

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//===----------------------------------------------------------------------===//

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"

15using namespacellvm;

16using namespaceobject;

18#define STRINGIFY_ENUM_CASE(ns, name) \

19 case ns::name: \

20 return #name;

22#define ELF_RELOC(name, value) STRINGIFY_ENUM_CASE(ELF, name)

24StringRef llvm::object::getELFRelocationTypeName(uint32_t Machine,

25uint32_t Type) {

26switch (Machine) {

27caseELF::EM_68K:

28switch (Type) {

29#include "llvm/BinaryFormat/ELFRelocs/M68k.def"

30default:

31break;

32 }

33break;

34caseELF::EM_X86_64:

35switch (Type) {

36#include "llvm/BinaryFormat/ELFRelocs/x86_64.def"

37default:

38break;

39 }

40break;

41caseELF::EM_386:

42caseELF::EM_IAMCU:

43switch (Type) {

44#include "llvm/BinaryFormat/ELFRelocs/i386.def"

45default:

46break;

47 }

48break;

49caseELF::EM_MIPS:

50switch (Type) {

51#include "llvm/BinaryFormat/ELFRelocs/Mips.def"

52default:

53break;

54 }

55break;

56caseELF::EM_AARCH64:

57switch (Type) {

58#include "llvm/BinaryFormat/ELFRelocs/AArch64.def"

59default:

60break;

61 }

62break;

63caseELF::EM_ARM:

64switch (Type) {

65#include "llvm/BinaryFormat/ELFRelocs/ARM.def"

66default:

67break;

68 }

69break;

70caseELF::EM_ARC_COMPACT:

71caseELF::EM_ARC_COMPACT2:

72switch (Type) {

73#include "llvm/BinaryFormat/ELFRelocs/ARC.def"

74default:

75break;

76 }

77break;

78caseELF::EM_AVR:

79switch (Type) {

80#include "llvm/BinaryFormat/ELFRelocs/AVR.def"

81default:

82break;

83 }

84break;

85caseELF::EM_HEXAGON:

86switch (Type) {

87#include "llvm/BinaryFormat/ELFRelocs/Hexagon.def"

88default:

89break;

90 }

91break;

92caseELF::EM_LANAI:

93switch (Type) {

94#include "llvm/BinaryFormat/ELFRelocs/Lanai.def"

95default:

96break;

97 }

98break;

99caseELF::EM_PPC:

100switch (Type) {

101#include "llvm/BinaryFormat/ELFRelocs/PowerPC.def"

102default:

103break;

104 }

105break;

106caseELF::EM_PPC64:

107switch (Type) {

108#include "llvm/BinaryFormat/ELFRelocs/PowerPC64.def"

109default:

110break;

111 }

112break;

113caseELF::EM_RISCV:

114switch (Type) {

115#include "llvm/BinaryFormat/ELFRelocs/RISCV.def"

116default:

117break;

118 }

119break;

120caseELF::EM_S390:

121switch (Type) {

122#include "llvm/BinaryFormat/ELFRelocs/SystemZ.def"

123default:

124break;

125 }

126break;

127caseELF::EM_SPARC:

128caseELF::EM_SPARC32PLUS:

129caseELF::EM_SPARCV9:

130switch (Type) {

131#include "llvm/BinaryFormat/ELFRelocs/Sparc.def"

132default:

133break;

134 }

135break;

136caseELF::EM_AMDGPU:

137switch (Type) {

138#include "llvm/BinaryFormat/ELFRelocs/AMDGPU.def"

139default:

140break;

141 }

142break;

143caseELF::EM_BPF:

144switch (Type) {

145#include "llvm/BinaryFormat/ELFRelocs/BPF.def"

146default:

147break;

148 }

149break;

150caseELF::EM_MSP430:

151switch (Type) {

152#include "llvm/BinaryFormat/ELFRelocs/MSP430.def"

153default:

154break;

155 }

156break;

157caseELF::EM_VE:

158switch (Type) {

159#include "llvm/BinaryFormat/ELFRelocs/VE.def"

160default:

161break;

162 }

163break;

164caseELF::EM_CSKY:

165switch (Type) {

166#include "llvm/BinaryFormat/ELFRelocs/CSKY.def"

167default:

168break;

169 }

170break;

171caseELF::EM_LOONGARCH:

172switch (Type) {

173#include "llvm/BinaryFormat/ELFRelocs/LoongArch.def"

174default:

175break;

176 }

177break;

178caseELF::EM_XTENSA:

179switch (Type) {

180#include "llvm/BinaryFormat/ELFRelocs/Xtensa.def"

181default:

182break;

183 }

184break;

185default:

186break;

187 }

188return"Unknown";

189}

190

191#undef ELF_RELOC

192

193uint32_t llvm::object::getELFRelativeRelocationType(uint32_t Machine) {

194switch (Machine) {

195caseELF::EM_X86_64:

196return ELF::R_X86_64_RELATIVE;

197caseELF::EM_386:

198caseELF::EM_IAMCU:

199return ELF::R_386_RELATIVE;

200caseELF::EM_MIPS:

201break;

202caseELF::EM_AARCH64:

203return ELF::R_AARCH64_RELATIVE;

204caseELF::EM_ARM:

205return ELF::R_ARM_RELATIVE;

206caseELF::EM_ARC_COMPACT:

207caseELF::EM_ARC_COMPACT2:

208return ELF::R_ARC_RELATIVE;

209caseELF::EM_AVR:

210break;

211caseELF::EM_HEXAGON:

212return ELF::R_HEX_RELATIVE;

213caseELF::EM_LANAI:

214break;

215caseELF::EM_PPC:

216break;

217caseELF::EM_PPC64:

218return ELF::R_PPC64_RELATIVE;

219caseELF::EM_RISCV:

220return ELF::R_RISCV_RELATIVE;

221caseELF::EM_S390:

222return ELF::R_390_RELATIVE;

223caseELF::EM_SPARC:

224caseELF::EM_SPARC32PLUS:

225caseELF::EM_SPARCV9:

226return ELF::R_SPARC_RELATIVE;

227caseELF::EM_CSKY:

228return ELF::R_CKCORE_RELATIVE;

229caseELF::EM_VE:

230return ELF::R_VE_RELATIVE;

231caseELF::EM_AMDGPU:

232break;

233caseELF::EM_BPF:

234break;

235caseELF::EM_LOONGARCH:

236return ELF::R_LARCH_RELATIVE;

237default:

238break;

239 }

240return 0;

241}

242

243StringRef llvm::object::getELFSectionTypeName(uint32_t Machine,unsignedType) {

244switch (Machine) {

245caseELF::EM_ARM:

246switch (Type) {

247STRINGIFY_ENUM_CASE(ELF, SHT_ARM_EXIDX);

248STRINGIFY_ENUM_CASE(ELF, SHT_ARM_PREEMPTMAP);

249STRINGIFY_ENUM_CASE(ELF, SHT_ARM_ATTRIBUTES);

250STRINGIFY_ENUM_CASE(ELF, SHT_ARM_DEBUGOVERLAY);

251STRINGIFY_ENUM_CASE(ELF, SHT_ARM_OVERLAYSECTION);

252 }

253break;

254caseELF::EM_HEXAGON:

255switch (Type) {

256STRINGIFY_ENUM_CASE(ELF, SHT_HEX_ORDERED);

257STRINGIFY_ENUM_CASE(ELF, SHT_HEXAGON_ATTRIBUTES);

258 }

259break;

260caseELF::EM_X86_64:

261switch (Type) {STRINGIFY_ENUM_CASE(ELF, SHT_X86_64_UNWIND); }

262break;

263caseELF::EM_MIPS:

264caseELF::EM_MIPS_RS3_LE:

265switch (Type) {

266STRINGIFY_ENUM_CASE(ELF, SHT_MIPS_REGINFO);

267STRINGIFY_ENUM_CASE(ELF, SHT_MIPS_OPTIONS);

268STRINGIFY_ENUM_CASE(ELF, SHT_MIPS_DWARF);

269STRINGIFY_ENUM_CASE(ELF, SHT_MIPS_ABIFLAGS);

270 }

271break;

272caseELF::EM_MSP430:

273switch (Type) {STRINGIFY_ENUM_CASE(ELF, SHT_MSP430_ATTRIBUTES); }

274break;

275caseELF::EM_RISCV:

276switch (Type) {STRINGIFY_ENUM_CASE(ELF, SHT_RISCV_ATTRIBUTES); }

277break;

278caseELF::EM_AARCH64:

279switch (Type) {

280STRINGIFY_ENUM_CASE(ELF, SHT_AARCH64_AUTH_RELR);

281STRINGIFY_ENUM_CASE(ELF, SHT_AARCH64_MEMTAG_GLOBALS_DYNAMIC);

282STRINGIFY_ENUM_CASE(ELF, SHT_AARCH64_MEMTAG_GLOBALS_STATIC);

283 }

284default:

285break;

286 }

287

288switch (Type) {

289STRINGIFY_ENUM_CASE(ELF, SHT_NULL);

290STRINGIFY_ENUM_CASE(ELF, SHT_PROGBITS);

291STRINGIFY_ENUM_CASE(ELF, SHT_SYMTAB);

292STRINGIFY_ENUM_CASE(ELF, SHT_STRTAB);

293STRINGIFY_ENUM_CASE(ELF, SHT_RELA);

294STRINGIFY_ENUM_CASE(ELF, SHT_HASH);

295STRINGIFY_ENUM_CASE(ELF, SHT_DYNAMIC);

296STRINGIFY_ENUM_CASE(ELF, SHT_NOTE);

297STRINGIFY_ENUM_CASE(ELF, SHT_NOBITS);

298STRINGIFY_ENUM_CASE(ELF, SHT_REL);

299STRINGIFY_ENUM_CASE(ELF, SHT_SHLIB);

300STRINGIFY_ENUM_CASE(ELF, SHT_DYNSYM);

301STRINGIFY_ENUM_CASE(ELF, SHT_INIT_ARRAY);

302STRINGIFY_ENUM_CASE(ELF, SHT_FINI_ARRAY);

303STRINGIFY_ENUM_CASE(ELF, SHT_PREINIT_ARRAY);

304STRINGIFY_ENUM_CASE(ELF, SHT_GROUP);

305STRINGIFY_ENUM_CASE(ELF, SHT_SYMTAB_SHNDX);

306STRINGIFY_ENUM_CASE(ELF, SHT_RELR);

307STRINGIFY_ENUM_CASE(ELF, SHT_CREL);

308STRINGIFY_ENUM_CASE(ELF, SHT_ANDROID_REL);

309STRINGIFY_ENUM_CASE(ELF, SHT_ANDROID_RELA);

310STRINGIFY_ENUM_CASE(ELF, SHT_ANDROID_RELR);

311STRINGIFY_ENUM_CASE(ELF, SHT_LLVM_ODRTAB);

312STRINGIFY_ENUM_CASE(ELF, SHT_LLVM_LINKER_OPTIONS);

313STRINGIFY_ENUM_CASE(ELF, SHT_LLVM_CALL_GRAPH_PROFILE);

314STRINGIFY_ENUM_CASE(ELF, SHT_LLVM_ADDRSIG);

315STRINGIFY_ENUM_CASE(ELF, SHT_LLVM_DEPENDENT_LIBRARIES);

316STRINGIFY_ENUM_CASE(ELF, SHT_LLVM_SYMPART);

317STRINGIFY_ENUM_CASE(ELF, SHT_LLVM_PART_EHDR);

318STRINGIFY_ENUM_CASE(ELF, SHT_LLVM_PART_PHDR);

319STRINGIFY_ENUM_CASE(ELF, SHT_LLVM_BB_ADDR_MAP_V0);

320STRINGIFY_ENUM_CASE(ELF, SHT_LLVM_BB_ADDR_MAP);

321STRINGIFY_ENUM_CASE(ELF, SHT_LLVM_OFFLOADING);

322STRINGIFY_ENUM_CASE(ELF, SHT_LLVM_LTO);

323STRINGIFY_ENUM_CASE(ELF, SHT_LLVM_JT_SIZES)

324STRINGIFY_ENUM_CASE(ELF, SHT_GNU_ATTRIBUTES);

325STRINGIFY_ENUM_CASE(ELF, SHT_GNU_HASH);

326STRINGIFY_ENUM_CASE(ELF, SHT_GNU_verdef);

327STRINGIFY_ENUM_CASE(ELF, SHT_GNU_verneed);

328STRINGIFY_ENUM_CASE(ELF, SHT_GNU_versym);

329default:

330return"Unknown";

331 }

332}

333

334template <class ELFT>

335std::vector<typename ELFT::Rel>

336ELFFile<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.

373usingAddr =typename ELFT::uint;

374

375Addr Base = 0;

376for (Elf_Relr R : relrs) {

377typename ELFT::uint Entry = R;

378if ((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.

383Base = Entry +sizeof(Addr);

384 }else {

385// Odd entry: encodes bitmap for relocations starting at base.

386for (Addr Offset =Base; (Entry >>= 1) != 0;Offset +=sizeof(Addr))

387if ((Entry & 1) != 0) {

388 Rel.r_offset =Offset;

389 Relocs.push_back(Rel);

390 }

391Base += (CHAR_BIT *sizeof(Entry) - 1) *sizeof(Addr);

392 }

393 }

394

395return Relocs;

396}

397

398template <class ELFT>

399Expected<uint64_t>

400ELFFile<ELFT>::getCrelHeader(ArrayRef<uint8_t>Content) const{

401DataExtractor Data(Content, isLE(),sizeof(typename ELFT::Addr));

402Error Err =Error::success();

403uint64_t Hdr = 0;

404 Hdr = Data.getULEB128(&Hdr, &Err);

405if (Err)

406return Err;

407return Hdr;

408}

409

410template <class ELFT>

411Expected<typename ELFFile<ELFT>::RelsOrRelas>

412ELFFile<ELFT>::decodeCrel(ArrayRef<uint8_t>Content) const{

413 std::vector<Elf_Rel> Rels;

414 std::vector<Elf_Rela> Relas;

415size_tI = 0;

416bool HasAddend;

417Error Err = object::decodeCrel<ELFT::Is64Bits>(

418Content,

419 [&](uint64_t Count,bool HasA) {

420 HasAddend = HasA;

421if (HasAddend)

422 Relas.resize(Count);

423else

424 Rels.resize(Count);

425 },

426 [&](Elf_Crel Crel) {

427if (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 });

436if (Err)

437return std::move(Err);

438return std::make_pair(std::move(Rels), std::move(Relas));

439}

440

441template <class ELFT>

442Expected<typename ELFFile<ELFT>::RelsOrRelas>

443ELFFile<ELFT>::crels(const Elf_Shdr &Sec) const{

444Expected<ArrayRef<uint8_t>> ContentsOrErr = getSectionContents(Sec);

445if (!ContentsOrErr)

446return ContentsOrErr.takeError();

447returndecodeCrel(*ContentsOrErr);

448}

449

450template <class ELFT>

451Expected<std::vector<typename ELFT::Rela>>

452ELFFile<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.

455Expected<ArrayRef<uint8_t>> ContentsOrErr = getSectionContents(Sec);

456if (!ContentsOrErr)

457return ContentsOrErr.takeError();

458ArrayRef<uint8_t>Content = *ContentsOrErr;

459if (Content.size() < 4 ||Content[0] !='A' ||Content[1] !='P' ||

460Content[2] !='S' ||Content[3] !='2')

461returncreateError("invalid packed relocation header");

462DataExtractor Data(Content, isLE(), ELFT::Is64Bits ? 8 : 4);

463DataExtractor::Cursor Cur(/*Offset=*/4);

464

465uint64_t NumRelocs = Data.getSLEB128(Cur);

466uint64_t Offset = Data.getSLEB128(Cur);

467uint64_t Addend = 0;

468

469if (!Cur)

470return std::move(Cur.takeError());

471

472 std::vector<Elf_Rela> Relocs;

473 Relocs.reserve(NumRelocs);

474while (NumRelocs) {

475uint64_t NumRelocsInGroup = Data.getSLEB128(Cur);

476if (!Cur)

477return std::move(Cur.takeError());

478if (NumRelocsInGroup > NumRelocs)

479returncreateError("relocation group unexpectedly large");

480 NumRelocs -= NumRelocsInGroup;

481

482uint64_t GroupFlags = Data.getSLEB128(Cur);

483bool GroupedByInfo = GroupFlags &ELF::RELOCATION_GROUPED_BY_INFO_FLAG;

484bool GroupedByOffsetDelta = GroupFlags &ELF::RELOCATION_GROUPED_BY_OFFSET_DELTA_FLAG;

485bool GroupedByAddend = GroupFlags &ELF::RELOCATION_GROUPED_BY_ADDEND_FLAG;

486bool GroupHasAddend = GroupFlags &ELF::RELOCATION_GROUP_HAS_ADDEND_FLAG;

487

488uint64_t GroupOffsetDelta;

489if (GroupedByOffsetDelta)

490 GroupOffsetDelta = Data.getSLEB128(Cur);

491

492uint64_t GroupRInfo;

493if (GroupedByInfo)

494 GroupRInfo = Data.getSLEB128(Cur);

495

496if (GroupedByAddend && GroupHasAddend)

497 Addend += Data.getSLEB128(Cur);

498

499if (!GroupHasAddend)

500 Addend = 0;

501

502for (uint64_t I = 0; Cur &&I != NumRelocsInGroup; ++I) {

503 Elf_Rela R;

504Offset += GroupedByOffsetDelta ? GroupOffsetDelta : Data.getSLEB128(Cur);

505 R.r_offset =Offset;

506 R.r_info = GroupedByInfo ? GroupRInfo : Data.getSLEB128(Cur);

507if (GroupHasAddend && !GroupedByAddend)

508 Addend += Data.getSLEB128(Cur);

509 R.r_addend = Addend;

510 Relocs.push_back(R);

511 }

512if (!Cur)

513return std::move(Cur.takeError());

514 }

515

516return Relocs;

517}

518

519template <class ELFT>

520std::stringELFFile<ELFT>::getDynamicTagAsString(unsigned Arch,

521uint64_t Type) const{

522#define DYNAMIC_STRINGIFY_ENUM(tag, value) \

523 case value: \

524 return #tag;

525

526#define DYNAMIC_TAG(n, v)

527switch (Arch) {

528caseELF::EM_AARCH64:

529switch (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 }

534break;

535

536caseELF::EM_HEXAGON:

537switch (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 }

542break;

543

544caseELF::EM_MIPS:

545switch (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 }

550break;

551

552caseELF::EM_PPC:

553switch (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 }

558break;

559

560caseELF::EM_PPC64:

561switch (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 }

566break;

567

568caseELF::EM_RISCV:

569switch (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 }

574break;

575 }

576#undef DYNAMIC_TAG

577switch (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

598default:

599return"<unknown:>0x" + utohexstr(Type,true);

600 }

601}

602

603template <class ELFT>

604std::stringELFFile<ELFT>::getDynamicTagAsString(uint64_t Type) const{

605return getDynamicTagAsString(getHeader().e_machine,Type);

606}

607

608template <class ELFT>

609Expected<typename ELFT::DynRange>ELFFile<ELFT>::dynamicEntries() const{

610ArrayRef<Elf_Dyn> Dyn;

611

612auto ProgramHeadersOrError = program_headers();

613if (!ProgramHeadersOrError)

614return ProgramHeadersOrError.takeError();

615

616for (const Elf_Phdr &Phdr : *ProgramHeadersOrError) {

617if (Phdr.p_type ==ELF::PT_DYNAMIC) {

618constuint8_t *DynOffset = base() + Phdr.p_offset;

619if (DynOffset > end())

620returncreateError(

621"dynamic section offset past file size: corrupted ELF");

622 Dyn =ArrayRef(reinterpret_cast<constElf_Dyn *>(DynOffset),

623 Phdr.p_filesz /sizeof(Elf_Dyn));

624break;

625 }

626 }

627

628// If we can't find the dynamic section in the program headers, we just fall

629// back on the sections.

630if (Dyn.empty()) {

631auto SectionsOrError =sections();

632if (!SectionsOrError)

633return SectionsOrError.takeError();

634

635for (const Elf_Shdr &Sec : *SectionsOrError) {

636if (Sec.sh_type ==ELF::SHT_DYNAMIC) {

637Expected<ArrayRef<Elf_Dyn>> DynOrError =

638 getSectionContentsAsArray<Elf_Dyn>(Sec);

639if (!DynOrError)

640return DynOrError.takeError();

641 Dyn = *DynOrError;

642break;

643 }

644 }

645

646if (!Dyn.data())

647returnArrayRef<Elf_Dyn>();

648 }

649

650if (Dyn.empty())

651returncreateError("invalid empty dynamic section");

652

653if (Dyn.back().d_tag != ELF::DT_NULL)

654returncreateError("dynamic sections must be DT_NULL terminated");

655

656return Dyn;

657}

658

659template <class ELFT>

660Expected<const uint8_t *>

661ELFFile<ELFT>::toMappedAddr(uint64_t VAddr,WarningHandler WarnHandler) const{

662auto ProgramHeadersOrError = program_headers();

663if (!ProgramHeadersOrError)

664return ProgramHeadersOrError.takeError();

665

666llvm::SmallVector<Elf_Phdr *, 4> LoadSegments;

667

668for (const Elf_Phdr &Phdr : *ProgramHeadersOrError)

669if (Phdr.p_type ==ELF::PT_LOAD)

670 LoadSegments.push_back(const_cast<Elf_Phdr *>(&Phdr));

671

672auto SortPred = [](constElf_Phdr_Impl<ELFT> *A,

673constElf_Phdr_Impl<ELFT> *B) {

674returnA->p_vaddr <B->p_vaddr;

675 };

676if (!llvm::is_sorted(LoadSegments, SortPred)) {

677if (Error E =

678 WarnHandler("loadable segments are unsorted by virtual address"))

679return std::move(E);

680llvm::stable_sort(LoadSegments, SortPred);

681 }

682

683const Elf_Phdr *const *I =llvm::upper_bound(

684 LoadSegments, VAddr, [](uint64_t VAddr,constElf_Phdr_Impl<ELFT> *Phdr) {

685return VAddr < Phdr->p_vaddr;

686 });

687

688if (I == LoadSegments.begin())

689returncreateError("virtual address is not in any segment: 0x" +

690Twine::utohexstr(VAddr));

691 --I;

692const Elf_Phdr &Phdr = **I;

693uint64_t Delta = VAddr - Phdr.p_vaddr;

694if (Delta >= Phdr.p_filesz)

695returncreateError("virtual address is not in any segment: 0x" +

696Twine::utohexstr(VAddr));

697

698uint64_t Offset = Phdr.p_offset + Delta;

699if (Offset >= getBufSize())

700returncreateError("can't map virtual address 0x" +

701Twine::utohexstr(VAddr) +" to the segment with index " +

702Twine(&Phdr - (*ProgramHeadersOrError).data() + 1) +

703": the segment ends at 0x" +

704Twine::utohexstr(Phdr.p_offset + Phdr.p_filesz) +

705", which is greater than the file size (0x" +

706Twine::utohexstr(getBufSize()) +")");

707

708return 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.

716template <typename IntTy, std::enable_if_t<std::is_unsigned_v<IntTy>,int> = 0>

717static IntTyreadULEB128As(DataExtractor &Data,DataExtractor::Cursor &Cur,

718Error &ULEBSizeErr) {

719// Bail out and do not extract data if ULEBSizeErr is already set.

720if (ULEBSizeErr)

721return 0;

722uint64_t Offset = Cur.tell();

723uint64_t Value = Data.getULEB128(Cur);

724if (Value > std::numeric_limits<IntTy>::max()) {

725 ULEBSizeErr =createError("ULEB128 value at offset 0x" +

726Twine::utohexstr(Offset) +" exceeds UINT" +

727Twine(std::numeric_limits<IntTy>::digits) +

728"_MAX (0x" +Twine::utohexstr(Value) +")");

729return 0;

730 }

731returnstatic_cast<IntTy>(Value);

732}

733

734template <typename ELFT>

735staticExpected<std::vector<BBAddrMap>>

736decodeBBAddrMapImpl(constELFFile<ELFT> &EF,

737consttypenameELFFile<ELFT>::Elf_Shdr &Sec,

738consttypenameELFFile<ELFT>::Elf_Shdr *RelaSec,

739 std::vector<PGOAnalysisMap> *PGOAnalyses) {

740bool 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).

745llvm::DenseMap<uint64_t, uint64_t> FunctionOffsetTranslations;

746if (IsRelocatable && RelaSec) {

747assert(RelaSec &&

748"Can't read a SHT_LLVM_BB_ADDR_MAP section in a relocatable "

749"object file without providing a relocation section.");

750Expected<typename ELFFile<ELFT>::Elf_Rela_Range> Relas = EF.relas(*RelaSec);

751if (!Relas)

752returncreateError("unable to read relocations for section " +

753describe(EF, Sec) +": " +

754toString(Relas.takeError()));

755for (typenameELFFile<ELFT>::Elf_Rela Rela : *Relas)

756 FunctionOffsetTranslations[Rela.r_offset] = Rela.r_addend;

757 }

758auto GetAddressForRelocation =

759 [&](unsigned RelocationOffsetInSection) ->Expected<unsigned> {

760auto FOTIterator =

761 FunctionOffsetTranslations.find(RelocationOffsetInSection);

762if (FOTIterator == FunctionOffsetTranslations.end()) {

763returncreateError("failed to get relocation data for offset: " +

764Twine::utohexstr(RelocationOffsetInSection) +

765" in section " +describe(EF, Sec));

766 }

767return FOTIterator->second;

768 };

769Expected<ArrayRef<uint8_t>> ContentsOrErr = EF.getSectionContents(Sec);

770if (!ContentsOrErr)

771return ContentsOrErr.takeError();

772ArrayRef<uint8_t>Content = *ContentsOrErr;

773DataExtractor Data(Content, EF.isLE(), ELFT::Is64Bits ? 8 : 4);

774 std::vector<BBAddrMap> FunctionEntries;

775

776DataExtractor::Cursor Cur(0);

777Error ULEBSizeErr =Error::success();

778Error MetadataDecodeErr =Error::success();

779

780// Helper lampda to extract the (possiblly relocatable) address stored at Cur.

781auto ExtractAddress = [&]() ->Expected<typenameELFFile<ELFT>::uintX_t> {

782uint64_t RelocationOffsetInSection = Cur.tell();

783autoAddress =

784static_cast<typenameELFFile<ELFT>::uintX_t>(Data.getAddress(Cur));

785if (!Cur)

786return Cur.takeError();

787if (!IsRelocatable)

788returnAddress;

789assert(Address == 0);

790Expected<unsigned> AddressOrErr =

791 GetAddressForRelocation(RelocationOffsetInSection);

792if (!AddressOrErr)

793return AddressOrErr.takeError();

794return *AddressOrErr;

795 };

796

797uint8_t Version = 0;

798uint8_t Feature = 0;

799BBAddrMap::Features FeatEnable{};

800while (!ULEBSizeErr && !MetadataDecodeErr && Cur &&

801 Cur.tell() <Content.size()) {

802if (Sec.sh_type ==ELF::SHT_LLVM_BB_ADDR_MAP) {

803 Version = Data.getU8(Cur);

804if (!Cur)

805break;

806if (Version > 2)

807returncreateError("unsupported SHT_LLVM_BB_ADDR_MAP version: " +

808Twine(static_cast<int>(Version)));

809 Feature = Data.getU8(Cur);// Feature byte

810if (!Cur)

811break;

812auto FeatEnableOrErr =BBAddrMap::Features::decode(Feature);

813if (!FeatEnableOrErr)

814return FeatEnableOrErr.takeError();

815 FeatEnable = *FeatEnableOrErr;

816if (Feature != 0 && Version < 2 && Cur)

817returncreateError(

818"version should be >= 2 for SHT_LLVM_BB_ADDR_MAP when "

819"PGO features are enabled: version = " +

820Twine(static_cast<int>(Version)) +

821" feature = " +Twine(static_cast<int>(Feature)));

822 }

823uint32_t NumBlocksInBBRange = 0;

824uint32_t NumBBRanges = 1;

825typenameELFFile<ELFT>::uintX_t RangeBaseAddress = 0;

826if (FeatEnable.MultiBBRange) {

827 NumBBRanges = readULEB128As<uint32_t>(Data, Cur, ULEBSizeErr);

828if (!Cur || ULEBSizeErr)

829break;

830if (!NumBBRanges)

831returncreateError("invalid zero number of BB ranges at offset " +

832Twine::utohexstr(Cur.tell()) +" in " +

833describe(EF, Sec));

834 }else {

835auto AddressOrErr = ExtractAddress();

836if (!AddressOrErr)

837return AddressOrErr.takeError();

838 RangeBaseAddress = *AddressOrErr;

839 NumBlocksInBBRange = readULEB128As<uint32_t>(Data, Cur, ULEBSizeErr);

840 }

841 std::vector<BBAddrMap::BBRangeEntry> BBRangeEntries;

842uint32_t TotalNumBlocks = 0;

843for (uint32_t BBRangeIndex = 0; BBRangeIndex < NumBBRanges;

844 ++BBRangeIndex) {

845uint32_t PrevBBEndOffset = 0;

846if (FeatEnable.MultiBBRange) {

847auto AddressOrErr = ExtractAddress();

848if (!AddressOrErr)

849return AddressOrErr.takeError();

850 RangeBaseAddress = *AddressOrErr;

851 NumBlocksInBBRange = readULEB128As<uint32_t>(Data, Cur, ULEBSizeErr);

852 }

853 std::vector<BBAddrMap::BBEntry> BBEntries;

854if (!FeatEnable.OmitBBEntries) {

855for (uint32_t BlockIndex = 0; !MetadataDecodeErr && !ULEBSizeErr &&

856 Cur && (BlockIndex < NumBlocksInBBRange);

857 ++BlockIndex) {

858uint32_t ID = Version >= 2

859 ? readULEB128As<uint32_t>(Data, Cur, ULEBSizeErr)

860 : BlockIndex;

861uint32_t Offset = readULEB128As<uint32_t>(Data, Cur, ULEBSizeErr);

862uint32_t Size = readULEB128As<uint32_t>(Data, Cur, ULEBSizeErr);

863uint32_t MD = readULEB128As<uint32_t>(Data, Cur, ULEBSizeErr);

864if (Version >= 1) {

865// Offset is calculated relative to the end of the previous BB.

866Offset += PrevBBEndOffset;

867 PrevBBEndOffset =Offset +Size;

868 }

869Expected<BBAddrMap::BBEntry::Metadata> MetadataOrErr =

870BBAddrMap::BBEntry::Metadata::decode(MD);

871if (!MetadataOrErr) {

872 MetadataDecodeErr = MetadataOrErr.takeError();

873break;

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

883if (PGOAnalyses || FeatEnable.hasPGOAnalysis()) {

884// Function entry count

885uint64_t FuncEntryCount =

886 FeatEnable.FuncEntryCount

887 ? readULEB128As<uint64_t>(Data, Cur, ULEBSizeErr)

888 : 0;

889

890 std::vector<PGOAnalysisMap::PGOBBEntry> PGOBBEntries;

891for (uint32_t BlockIndex = 0;

892 FeatEnable.hasPGOAnalysisBBData() && !MetadataDecodeErr &&

893 !ULEBSizeErr && Cur && (BlockIndex < TotalNumBlocks);

894 ++BlockIndex) {

895// Block frequency

896uint64_t BBF = FeatEnable.BBFreq

897 ? readULEB128As<uint64_t>(Data, Cur, ULEBSizeErr)

898 : 0;

899

900// Branch probability

901llvm::SmallVector<PGOAnalysisMap::PGOBBEntry::SuccessorEntry, 2>

902 Successors;

903if (FeatEnable.BrProb) {

904auto SuccCount = readULEB128As<uint64_t>(Data, Cur, ULEBSizeErr);

905for (uint64_t I = 0;I < SuccCount; ++I) {

906uint32_t BBID = readULEB128As<uint32_t>(Data, Cur, ULEBSizeErr);

907uint32_t BrProb = readULEB128As<uint32_t>(Data, Cur, ULEBSizeErr);

908if (PGOAnalyses)

909 Successors.push_back({BBID,BranchProbability::getRaw(BrProb)});

910 }

911 }

912

913if (PGOAnalyses)

914 PGOBBEntries.push_back({BlockFrequency(BBF), std::move(Successors)});

915 }

916

917if (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.

924if (!Cur || ULEBSizeErr || MetadataDecodeErr)

925returnjoinErrors(joinErrors(Cur.takeError(), std::move(ULEBSizeErr)),

926 std::move(MetadataDecodeErr));

927return FunctionEntries;

928}

929

930template <class ELFT>

931Expected<std::vector<BBAddrMap>>

932ELFFile<ELFT>::decodeBBAddrMap(const Elf_Shdr &Sec,const Elf_Shdr *RelaSec,

933 std::vector<PGOAnalysisMap> *PGOAnalyses) const{

934size_t OriginalPGOSize = PGOAnalyses ? PGOAnalyses->size() : 0;

935auto AddrMapsOrErr =decodeBBAddrMapImpl(*this, Sec, RelaSec, PGOAnalyses);

936// remove new analyses when an error occurs

937if (!AddrMapsOrErr && PGOAnalyses)

938 PGOAnalyses->resize(OriginalPGOSize);

939return std::move(AddrMapsOrErr);

940}

941

942template <class ELFT>

943Expected<

944MapVector<const typename ELFT::Shdr *, const typename ELFT::Shdr *>>

945ELFFile<ELFT>::getSectionAndRelocations(

946 std::function<Expected<bool>(const Elf_Shdr &)> IsMatch) const{

947MapVector<const Elf_Shdr *, const Elf_Shdr *> SecToRelocMap;

948Error Errors =Error::success();

949for (const Elf_Shdr &Sec :cantFail(this->sections())) {

950Expected<bool> DoesSectionMatch = IsMatch(Sec);

951if (!DoesSectionMatch) {

952 Errors =joinErrors(std::move(Errors), DoesSectionMatch.takeError());

953continue;

954 }

955if (*DoesSectionMatch) {

956if (SecToRelocMap.insert(std::make_pair(&Sec, (const Elf_Shdr *)nullptr))

957 .second)

958continue;

959 }

960

961if (Sec.sh_type !=ELF::SHT_RELA && Sec.sh_type !=ELF::SHT_REL)

962continue;

963

964Expected<const Elf_Shdr *> RelSecOrErr = this->getSection(Sec.sh_info);

965if (!RelSecOrErr) {

966 Errors =joinErrors(std::move(Errors),

967createError(describe(*this, Sec) +

968": failed to get a relocated section: " +

969toString(RelSecOrErr.takeError())));

970continue;

971 }

972const Elf_Shdr *ContentsSec = *RelSecOrErr;

973Expected<bool> DoesRelTargetMatch = IsMatch(*ContentsSec);

974if (!DoesRelTargetMatch) {

975 Errors =joinErrors(std::move(Errors), DoesRelTargetMatch.takeError());

976continue;

977 }

978if (*DoesRelTargetMatch)

979 SecToRelocMap[ContentsSec] = &Sec;

980 }

981if(Errors)

982return std::move(Errors);

983return SecToRelocMap;

984}

985

986templateclassLLVM_EXPORT_TEMPLATEllvm::object::ELFFile<ELF32LE>;

987templateclassLLVM_EXPORT_TEMPLATEllvm::object::ELFFile<ELF32BE>;

988templateclassLLVM_EXPORT_TEMPLATEllvm::object::ELFFile<ELF64LE>;

989templateclassLLVM_EXPORT_TEMPLATEllvm::object::ELFFile<ELF64BE>;

PGOMapFeaturesEnum::FuncEntryCount

@ FuncEntryCount

PGOMapFeaturesEnum::BrProb

@ BrProb

sections

bbsections Prepares for basic block sections

Definition:BasicBlockSections.cpp:139

ELF.h

static GCRegistry::Add< OcamlGC > B("ocaml", "ocaml 3.10-compatible GC")

static GCRegistry::Add< ErlangGC > A("erlang", "erlang-compatible garbage collector")

Machine

COFF::MachineTypes Machine

Definition:COFFYAML.cpp:390

Compiler.h

DataExtractor.h

Content

T Content

Definition:ELFObjHandler.cpp:89

Addr

uint64_t Addr

Definition:ELFObjHandler.cpp:79

Size

uint64_t Size

Definition:ELFObjHandler.cpp:81

#define I(x, y, z)

Definition:MD5.cpp:58

readULEB128As

static IntTy readULEB128As(DataExtractor &Data, DataExtractor::Cursor &Cur, Error &ULEBSizeErr)

Definition:ELF.cpp:717

STRINGIFY_ENUM_CASE

#define STRINGIFY_ENUM_CASE(ns, name)

Definition:ELF.cpp:18

decodeBBAddrMapImpl

static Expected< std::vector< BBAddrMap > > decodeBBAddrMapImpl(const ELFFile< ELFT > &EF, const typename ELFFile< ELFT >::Elf_Shdr &Sec, const typename ELFFile< ELFT >::Elf_Shdr *RelaSec, std::vector< PGOAnalysisMap > *PGOAnalyses)

Definition:ELF.cpp:736

ELF.h

assert

assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())

Address

@ Address

Definition:SPIRVEmitNonSemanticDI.cpp:68

StringExtras.h

This file contains some functions that are useful when dealing with strings.

llvm::ArrayRef

ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...

Definition:ArrayRef.h:41

llvm::ArrayRef::back

const T & back() const

back - Get the last element.

Definition:ArrayRef.h:177

llvm::ArrayRef::empty

bool empty() const

empty - Check if the array is empty.

Definition:ArrayRef.h:163

llvm::ArrayRef::data

const T * data() const

Definition:ArrayRef.h:165

llvm::BlockFrequency

Definition:BlockFrequency.h:26

llvm::BranchProbability::getRaw

static BranchProbability getRaw(uint32_t N)

Definition:BranchProbability.h:54

llvm::DataExtractor::Cursor

A class representing a position in a DataExtractor, as well as any error encountered during extractio...

Definition:DataExtractor.h:54

llvm::DataExtractor::Cursor::tell

uint64_t tell() const

Return the current position of this Cursor.

Definition:DataExtractor.h:71

llvm::DataExtractor::Cursor::takeError

Error takeError()

Return error contained inside this Cursor, if any.

Definition:DataExtractor.h:78

llvm::DataExtractor

Definition:DataExtractor.h:41

llvm::DenseMapBase::find

iterator find(const_arg_type_t< KeyT > Val)

Definition:DenseMap.h:156

llvm::DenseMapBase::end

iterator end()

Definition:DenseMap.h:84

llvm::DenseMap

Definition:DenseMap.h:727

llvm::Error

Lightweight error class with error context and mandatory checking.

Definition:Error.h:160

llvm::Error::success

static ErrorSuccess success()

Create a success value.

Definition:Error.h:337

llvm::Expected

Tagged union holding either a T or a Error.

Definition:Error.h:481

llvm::Expected::takeError

Error takeError()

Take ownership of the stored error.

Definition:Error.h:608

llvm::MapVector

This class implements a map that also provides access to all stored values in a deterministic order.

Definition:MapVector.h:36

llvm::MapVector::insert

std::pair< iterator, bool > insert(const std::pair< KeyT, ValueT > &KV)

Definition:MapVector.h:141

llvm::SmallVectorTemplateBase::push_back

void push_back(const T &Elt)

Definition:SmallVector.h:413

llvm::SmallVectorTemplateCommon::begin

iterator begin()

Definition:SmallVector.h:267

llvm::SmallVector

This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.

Definition:SmallVector.h:1196

llvm::StringRef

StringRef - Represent a constant reference to a string, i.e.

Definition:StringRef.h:51

llvm::Twine

Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...

Definition:Twine.h:81

llvm::Twine::utohexstr

static Twine utohexstr(const uint64_t &Val)

Definition:Twine.h:416

llvm::Type

The instances of the Type class are immutable: once they are created, they are never changed.

Definition:Type.h:45

llvm::Value

LLVM Value Representation.

Definition:Value.h:74

llvm::function_ref

An efficient, type-erasing, non-owning reference to a callable.

Definition:STLFunctionalExtras.h:37

llvm::object::ELFFile

Definition:ELF.h:255

llvm::object::ELFFile::getHeader

const Elf_Ehdr & getHeader() const

Definition:ELF.h:279

llvm::object::ELFFile::android_relas

Expected< std::vector< Elf_Rela > > android_relas(const Elf_Shdr &Sec) const

Definition:ELF.cpp:452

llvm::object::ELFFile::getDynamicTagAsString

std::string getDynamicTagAsString(unsigned Arch, uint64_t Type) const

Definition:ELF.cpp:520

llvm::object::ELFFile::decodeBBAddrMap

Expected< std::vector< BBAddrMap > > decodeBBAddrMap(const Elf_Shdr &Sec, const Elf_Shdr *RelaSec=nullptr, std::vector< PGOAnalysisMap > *PGOAnalyses=nullptr) const

Returns a vector of BBAddrMap structs corresponding to each function within the text section that the...

Definition:ELF.cpp:932

llvm::object::ELFFile::getSectionContents

Expected< ArrayRef< uint8_t > > getSectionContents(const Elf_Shdr &Sec) const

Definition:ELF.h:672

llvm::object::ELFFile::relas

Expected< Elf_Rela_Range > relas(const Elf_Shdr &Sec) const

Definition:ELF.h:354

llvm::object::ELFFile::decodeCrel

Expected< RelsOrRelas > decodeCrel(ArrayRef< uint8_t > Content) const

Definition:ELF.cpp:412

llvm::object::ELFFile::getCrelHeader

Expected< uint64_t > getCrelHeader(ArrayRef< uint8_t > Content) const

Definition:ELF.cpp:400

llvm::object::ELFFile::dynamicEntries

Expected< Elf_Dyn_Range > dynamicEntries() const

Definition:ELF.cpp:609

llvm::object::ELFFile::toMappedAddr

Expected< const uint8_t * > toMappedAddr(uint64_t VAddr, WarningHandler WarnHandler=&defaultWarningHandler) const

Definition:ELF.cpp:661

llvm::object::ELFFile::getSectionAndRelocations

Expected< MapVector< const Elf_Shdr *, const Elf_Shdr * > > getSectionAndRelocations(std::function< Expected< bool >(const Elf_Shdr &)> IsMatch) const

Returns a map from every section matching IsMatch to its relocation section, or nullptr if it has no ...

Definition:ELF.cpp:945

llvm::object::ELFFile::isLE

bool isLE() const

Definition:ELF.h:329

llvm::object::ELFFile::crels

Expected< RelsOrRelas > crels(const Elf_Shdr &Sec) const

Definition:ELF.cpp:443

llvm::object::ELFFile::decode_relrs

std::vector< Elf_Rel > decode_relrs(Elf_Relr_Range relrs) const

Definition:ELF.cpp:336

llvm::CallingConv::ID

unsigned ID

LLVM IR allows to use arbitrary numbers as calling convention identifiers.

Definition:CallingConv.h:24

llvm::ELF::RELOCATION_GROUPED_BY_OFFSET_DELTA_FLAG

@ RELOCATION_GROUPED_BY_OFFSET_DELTA_FLAG

Definition:ELF.h:1948

llvm::ELF::RELOCATION_GROUPED_BY_INFO_FLAG

@ RELOCATION_GROUPED_BY_INFO_FLAG

Definition:ELF.h:1947

llvm::ELF::RELOCATION_GROUPED_BY_ADDEND_FLAG

@ RELOCATION_GROUPED_BY_ADDEND_FLAG

Definition:ELF.h:1949

llvm::ELF::RELOCATION_GROUP_HAS_ADDEND_FLAG

@ RELOCATION_GROUP_HAS_ADDEND_FLAG

Definition:ELF.h:1950

llvm::ELF::EM_MSP430

@ EM_MSP430

Definition:ELF.h:225

llvm::ELF::EM_S390

@ EM_S390

Definition:ELF.h:153

llvm::ELF::EM_PPC64

@ EM_PPC64

Definition:ELF.h:152

llvm::ELF::EM_SPARC

@ EM_SPARC

Definition:ELF.h:138

llvm::ELF::EM_CSKY

@ EM_CSKY

Definition:ELF.h:324

llvm::ELF::EM_SPARC32PLUS

@ EM_SPARC32PLUS

Definition:ELF.h:149

llvm::ELF::EM_MIPS_RS3_LE

@ EM_MIPS_RS3_LE

Definition:ELF.h:146

llvm::ELF::EM_68K

@ EM_68K

Definition:ELF.h:140

llvm::ELF::EM_386

@ EM_386

Definition:ELF.h:139

llvm::ELF::EM_LOONGARCH

@ EM_LOONGARCH

Definition:ELF.h:325

llvm::ELF::EM_BPF

@ EM_BPF

Definition:ELF.h:322

llvm::ELF::EM_PPC

@ EM_PPC

Definition:ELF.h:151

llvm::ELF::EM_X86_64

@ EM_X86_64

Definition:ELF.h:181

llvm::ELF::EM_HEXAGON

@ EM_HEXAGON

Definition:ELF.h:260

llvm::ELF::EM_LANAI

@ EM_LANAI

Definition:ELF.h:321

llvm::ELF::EM_MIPS

@ EM_MIPS

Definition:ELF.h:144

llvm::ELF::EM_SPARCV9

@ EM_SPARCV9

Definition:ELF.h:162

llvm::ELF::EM_AARCH64

@ EM_AARCH64

Definition:ELF.h:283

llvm::ELF::EM_XTENSA

@ EM_XTENSA

Definition:ELF.h:214

llvm::ELF::EM_ARC_COMPACT2

@ EM_ARC_COMPACT2

Definition:ELF.h:294

llvm::ELF::EM_RISCV

@ EM_RISCV

Definition:ELF.h:320

llvm::ELF::EM_ARC_COMPACT

@ EM_ARC_COMPACT

Definition:ELF.h:212

llvm::ELF::EM_ARM

@ EM_ARM

Definition:ELF.h:159

llvm::ELF::EM_VE

@ EM_VE

Definition:ELF.h:323

llvm::ELF::EM_IAMCU

@ EM_IAMCU

Definition:ELF.h:142

llvm::ELF::EM_AMDGPU

@ EM_AMDGPU

Definition:ELF.h:319

llvm::ELF::EM_AVR

@ EM_AVR

Definition:ELF.h:202

llvm::ELF::SHT_REL

@ SHT_REL

Definition:ELF.h:1106

llvm::ELF::SHT_DYNAMIC

@ SHT_DYNAMIC

Definition:ELF.h:1103

llvm::ELF::SHT_LLVM_BB_ADDR_MAP

@ SHT_LLVM_BB_ADDR_MAP

Definition:ELF.h:1138

llvm::ELF::SHT_RELA

@ SHT_RELA

Definition:ELF.h:1101

llvm::ELF::PT_LOAD

@ PT_LOAD

Definition:ELF.h:1505

llvm::ELF::PT_DYNAMIC

@ PT_DYNAMIC

Definition:ELF.h:1506

llvm::ELF::ET_REL

@ ET_REL

Definition:ELF.h:117

llvm::object::getSection

Expected< const typename ELFT::Shdr * > getSection(typename ELFT::ShdrRange Sections, uint32_t Index)

Definition:ELF.h:534

llvm::object::createError

Error createError(const Twine &Err)

Definition:Error.h:84

llvm::object::getELFRelocationTypeName

StringRef getELFRelocationTypeName(uint32_t Machine, uint32_t Type)

Definition:ELF.cpp:24

llvm::object::getELFRelativeRelocationType

uint32_t getELFRelativeRelocationType(uint32_t Machine)

Definition:ELF.cpp:193

llvm::object::describe

static std::string describe(const ELFFile< ELFT > &Obj, const typename ELFT::Shdr &Sec)

Definition:ELF.h:145

llvm::object::getELFSectionTypeName

StringRef getELFSectionTypeName(uint32_t Machine, uint32_t Type)

llvm::object::decodeCrel

static Error decodeCrel(ArrayRef< uint8_t > Content, function_ref< void(uint64_t, bool)> HdrHandler, function_ref< void(Elf_Crel_Impl< Is64 >)> EntryHandler)

Definition:ELF.h:216

llvm::sampleprof::Base

@ Base

Definition:Discriminator.h:58

llvm

This is an optimization pass for GlobalISel generic memory operations.

Definition:AddressRanges.h:18

llvm::Offset

@ Offset

Definition:DWP.cpp:480

llvm::stable_sort

void stable_sort(R &&Range)