Movatterモバイル変換

Go to the documentation of this file.

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

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/HexagonAttributeParser.h"

24#include "llvm/Support/RISCVAttributeParser.h"

25#include "llvm/Support/RISCVAttributes.h"

26#include "llvm/TargetParser/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>

37using namespacellvm;

38using namespaceobject;

40constEnumEntry<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};

59ELFObjectFileBase::ELFObjectFileBase(unsignedintType,MemoryBufferRef Source)

60 :ObjectFile(Type, Source) {}

62template <class ELFT>

63staticExpected<std::unique_ptr<ELFObjectFile<ELFT>>>

64createPtr(MemoryBufferRef Object,bool InitContent) {

65auto Ret =ELFObjectFile<ELFT>::create(Object, InitContent);

66if (Error E = Ret.takeError())

67return std::move(E);

68return std::make_unique<ELFObjectFile<ELFT>>(std::move(*Ret));

69}

71Expected<std::unique_ptr<ObjectFile>>

72ObjectFile::createELFObjectFile(MemoryBufferRef Obj,bool InitContent) {

73 std::pair<unsigned char, unsigned char> Ident =

74getElfArchType(Obj.getBuffer());

75 std::size_t MaxAlignment =

76 1ULL <<llvm::countr_zero(

77reinterpret_cast<uintptr_t>(Obj.getBufferStart()));

79if (MaxAlignment < 2)

80returncreateError("Insufficient alignment");

82if (Ident.first ==ELF::ELFCLASS32) {

83if (Ident.second ==ELF::ELFDATA2LSB)

84return createPtr<ELF32LE>(Obj, InitContent);

85elseif (Ident.second ==ELF::ELFDATA2MSB)

86return createPtr<ELF32BE>(Obj, InitContent);

87else

88returncreateError("Invalid ELF data");

89 }elseif (Ident.first ==ELF::ELFCLASS64) {

90if (Ident.second ==ELF::ELFDATA2LSB)

91return createPtr<ELF64LE>(Obj, InitContent);

92elseif (Ident.second ==ELF::ELFDATA2MSB)

93return createPtr<ELF64BE>(Obj, InitContent);

94else

95returncreateError("Invalid ELF data");

96 }

97returncreateError("Invalid ELF class");

98}

100SubtargetFeatures ELFObjectFileBase::getMIPSFeatures() const{

101SubtargetFeatures Features;

102unsigned PlatformFlags =getPlatformFlags();

103

104switch (PlatformFlags &ELF::EF_MIPS_ARCH) {

105caseELF::EF_MIPS_ARCH_1:

106break;

107caseELF::EF_MIPS_ARCH_2:

108 Features.AddFeature("mips2");

109break;

110caseELF::EF_MIPS_ARCH_3:

111 Features.AddFeature("mips3");

112break;

113caseELF::EF_MIPS_ARCH_4:

114 Features.AddFeature("mips4");

115break;

116caseELF::EF_MIPS_ARCH_5:

117 Features.AddFeature("mips5");

118break;

119caseELF::EF_MIPS_ARCH_32:

120 Features.AddFeature("mips32");

121break;

122caseELF::EF_MIPS_ARCH_64:

123 Features.AddFeature("mips64");

124break;

125caseELF::EF_MIPS_ARCH_32R2:

126 Features.AddFeature("mips32r2");

127break;

128caseELF::EF_MIPS_ARCH_64R2:

129 Features.AddFeature("mips64r2");

130break;

131caseELF::EF_MIPS_ARCH_32R6:

132 Features.AddFeature("mips32r6");

133break;

134caseELF::EF_MIPS_ARCH_64R6:

135 Features.AddFeature("mips64r6");

136break;

137default:

138llvm_unreachable("Unknown EF_MIPS_ARCH value");

139 }

140

141switch (PlatformFlags &ELF::EF_MIPS_MACH) {

142caseELF::EF_MIPS_MACH_NONE:

143// No feature associated with this value.

144break;

145caseELF::EF_MIPS_MACH_OCTEON:

146 Features.AddFeature("cnmips");

147break;

148default:

149llvm_unreachable("Unknown EF_MIPS_ARCH value");

150 }

151

152if (PlatformFlags &ELF::EF_MIPS_ARCH_ASE_M16)

153 Features.AddFeature("mips16");

154if (PlatformFlags &ELF::EF_MIPS_MICROMIPS)

155 Features.AddFeature("micromips");

156

157return Features;

158}

159

160SubtargetFeatures ELFObjectFileBase::getARMFeatures() const{

161SubtargetFeatures Features;

162ARMAttributeParser Attributes;

163if (Error E =getBuildAttributes(Attributes)) {

164consumeError(std::move(E));

165returnSubtargetFeatures();

166 }

167

168// both ARMv7-M and R have to support thumb hardware div

169bool isV7 =false;

170 std::optional<unsigned> Attr =

171Attributes.getAttributeValue(ARMBuildAttrs::CPU_arch);

172if (Attr)

173 isV7 = *Attr ==ARMBuildAttrs::v7;

174

175 Attr =Attributes.getAttributeValue(ARMBuildAttrs::CPU_arch_profile);

176if (Attr) {

177switch (*Attr) {

178caseARMBuildAttrs::ApplicationProfile:

179 Features.AddFeature("aclass");

180break;

181caseARMBuildAttrs::RealTimeProfile:

182 Features.AddFeature("rclass");

183if (isV7)

184 Features.AddFeature("hwdiv");

185break;

186caseARMBuildAttrs::MicroControllerProfile:

187 Features.AddFeature("mclass");

188if (isV7)

189 Features.AddFeature("hwdiv");

190break;

191 }

192 }

193

194 Attr =Attributes.getAttributeValue(ARMBuildAttrs::THUMB_ISA_use);

195if (Attr) {

196switch (*Attr) {

197default:

198break;

199caseARMBuildAttrs::Not_Allowed:

200 Features.AddFeature("thumb",false);

201 Features.AddFeature("thumb2",false);

202break;

203caseARMBuildAttrs::AllowThumb32:

204 Features.AddFeature("thumb2");

205break;

206 }

207 }

208

209 Attr =Attributes.getAttributeValue(ARMBuildAttrs::FP_arch);

210if (Attr) {

211switch (*Attr) {

212default:

213break;

214caseARMBuildAttrs::Not_Allowed:

215 Features.AddFeature("vfp2sp",false);

216 Features.AddFeature("vfp3d16sp",false);

217 Features.AddFeature("vfp4d16sp",false);

218break;

219caseARMBuildAttrs::AllowFPv2:

220 Features.AddFeature("vfp2");

221break;

222caseARMBuildAttrs::AllowFPv3A:

223caseARMBuildAttrs::AllowFPv3B:

224 Features.AddFeature("vfp3");

225break;

226caseARMBuildAttrs::AllowFPv4A:

227caseARMBuildAttrs::AllowFPv4B:

228 Features.AddFeature("vfp4");

229break;

230 }

231 }

232

233 Attr =Attributes.getAttributeValue(ARMBuildAttrs::Advanced_SIMD_arch);

234if (Attr) {

235switch (*Attr) {

236default:

237break;

238caseARMBuildAttrs::Not_Allowed:

239 Features.AddFeature("neon",false);

240 Features.AddFeature("fp16",false);

241break;

242caseARMBuildAttrs::AllowNeon:

243 Features.AddFeature("neon");

244break;

245caseARMBuildAttrs::AllowNeon2:

246 Features.AddFeature("neon");

247 Features.AddFeature("fp16");

248break;

249 }

250 }

251

252 Attr =Attributes.getAttributeValue(ARMBuildAttrs::MVE_arch);

253if (Attr) {

254switch (*Attr) {

255default:

256break;

257caseARMBuildAttrs::Not_Allowed:

258 Features.AddFeature("mve",false);

259 Features.AddFeature("mve.fp",false);

260break;

261caseARMBuildAttrs::AllowMVEInteger:

262 Features.AddFeature("mve.fp",false);

263 Features.AddFeature("mve");

264break;

265caseARMBuildAttrs::AllowMVEIntegerAndFloat:

266 Features.AddFeature("mve.fp");

267break;

268 }

269 }

270

271 Attr =Attributes.getAttributeValue(ARMBuildAttrs::DIV_use);

272if (Attr) {

273switch (*Attr) {

274default:

275break;

276caseARMBuildAttrs::DisallowDIV:

277 Features.AddFeature("hwdiv",false);

278 Features.AddFeature("hwdiv-arm",false);

279break;

280caseARMBuildAttrs::AllowDIVExt:

281 Features.AddFeature("hwdiv");

282 Features.AddFeature("hwdiv-arm");

283break;

284 }

285 }

286

287return Features;

288}

289

290static std::optional<std::string>hexagonAttrToFeatureString(unsigned Attr) {

291switch (Attr) {

292case 5:

293return"v5";

294case 55:

295return"v55";

296case 60:

297return"v60";

298case 62:

299return"v62";

300case 65:

301return"v65";

302case 67:

303return"v67";

304case 68:

305return"v68";

306case 69:

307return"v69";

308case 71:

309return"v71";

310case 73:

311return"v73";

312case 75:

313return"v75";

314default:

315return {};

316 }

317}

318

319SubtargetFeatures ELFObjectFileBase::getHexagonFeatures() const{

320SubtargetFeatures Features;

321HexagonAttributeParser Parser;

322if (Error E =getBuildAttributes(Parser)) {

323// Return no attributes if none can be read.

324// This behavior is important for backwards compatibility.

325consumeError(std::move(E));

326return Features;

327 }

328 std::optional<unsigned> Attr;

329

330if ((Attr =Parser.getAttributeValue(HexagonAttrs::ARCH))) {

331if (std::optional<std::string> FeatureString =

332hexagonAttrToFeatureString(*Attr))

333 Features.AddFeature(*FeatureString);

334 }

335

336if ((Attr =Parser.getAttributeValue(HexagonAttrs::HVXARCH))) {

337 std::optional<std::string> FeatureString =

338hexagonAttrToFeatureString(*Attr);

339// There is no corresponding hvx arch for v5 and v55.

340if (FeatureString && *Attr >= 60)

341 Features.AddFeature("hvx" + *FeatureString);

342 }

343

344if ((Attr =Parser.getAttributeValue(HexagonAttrs::HVXIEEEFP)))

345if (*Attr)

346 Features.AddFeature("hvx-ieee-fp");

347

348if ((Attr =Parser.getAttributeValue(HexagonAttrs::HVXQFLOAT)))

349if (*Attr)

350 Features.AddFeature("hvx-qfloat");

351

352if ((Attr =Parser.getAttributeValue(HexagonAttrs::ZREG)))

353if (*Attr)

354 Features.AddFeature("zreg");

355

356if ((Attr =Parser.getAttributeValue(HexagonAttrs::AUDIO)))

357if (*Attr)

358 Features.AddFeature("audio");

359

360if ((Attr =Parser.getAttributeValue(HexagonAttrs::CABAC)))

361if (*Attr)

362 Features.AddFeature("cabac");

363

364return Features;

365}

366

367Expected<SubtargetFeatures> ELFObjectFileBase::getRISCVFeatures() const{

368SubtargetFeatures Features;

369unsigned PlatformFlags =getPlatformFlags();

370

371if (PlatformFlags &ELF::EF_RISCV_RVC) {

372 Features.AddFeature("zca");

373 }

374

375RISCVAttributeParser Attributes;

376if (Error E =getBuildAttributes(Attributes)) {

377return std::move(E);

378 }

379

380 std::optional<StringRef> Attr =

381Attributes.getAttributeString(RISCVAttrs::ARCH);

382if (Attr) {

383autoParseResult =RISCVISAInfo::parseNormalizedArchString(*Attr);

384if (!ParseResult)

385returnParseResult.takeError();

386auto &ISAInfo = *ParseResult;

387

388if (ISAInfo->getXLen() == 32)

389 Features.AddFeature("64bit",false);

390elseif (ISAInfo->getXLen() == 64)

391 Features.AddFeature("64bit");

392else

393llvm_unreachable("XLEN should be 32 or 64.");

394

395 Features.addFeaturesVector(ISAInfo->toFeatures());

396 }

397

398return Features;

399}

400

401SubtargetFeatures ELFObjectFileBase::getLoongArchFeatures() const{

402SubtargetFeatures Features;

403

404switch (getPlatformFlags() &ELF::EF_LOONGARCH_ABI_MODIFIER_MASK) {

405caseELF::EF_LOONGARCH_ABI_SOFT_FLOAT:

406break;

407caseELF::EF_LOONGARCH_ABI_DOUBLE_FLOAT:

408 Features.AddFeature("d");

409// D implies F according to LoongArch ISA spec.

410 [[fallthrough]];

411caseELF::EF_LOONGARCH_ABI_SINGLE_FLOAT:

412 Features.AddFeature("f");

413break;

414 }

415

416return Features;

417}

418

419Expected<SubtargetFeatures>ELFObjectFileBase::getFeatures() const{

420switch (getEMachine()) {

421caseELF::EM_MIPS:

422return getMIPSFeatures();

423caseELF::EM_ARM:

424return getARMFeatures();

425caseELF::EM_RISCV:

426return getRISCVFeatures();

427caseELF::EM_LOONGARCH:

428return getLoongArchFeatures();

429caseELF::EM_HEXAGON:

430return getHexagonFeatures();

431default:

432returnSubtargetFeatures();

433 }

434}

435

436std::optional<StringRef>ELFObjectFileBase::tryGetCPUName() const{

437switch (getEMachine()) {

438caseELF::EM_AMDGPU:

439return getAMDGPUCPUName();

440caseELF::EM_CUDA:

441return getNVPTXCPUName();

442caseELF::EM_PPC:

443caseELF::EM_PPC64:

444returnStringRef("future");

445caseELF::EM_BPF:

446returnStringRef("v4");

447default:

448return std::nullopt;

449 }

450}

451

452StringRef ELFObjectFileBase::getAMDGPUCPUName() const{

453assert(getEMachine() ==ELF::EM_AMDGPU);

454unsigned CPU =getPlatformFlags() &ELF::EF_AMDGPU_MACH;

455

456switch (CPU) {

457// Radeon HD 2000/3000 Series (R600).

458caseELF::EF_AMDGPU_MACH_R600_R600:

459return"r600";

460caseELF::EF_AMDGPU_MACH_R600_R630:

461return"r630";

462caseELF::EF_AMDGPU_MACH_R600_RS880:

463return"rs880";

464caseELF::EF_AMDGPU_MACH_R600_RV670:

465return"rv670";

466

467// Radeon HD 4000 Series (R700).

468caseELF::EF_AMDGPU_MACH_R600_RV710:

469return"rv710";

470caseELF::EF_AMDGPU_MACH_R600_RV730:

471return"rv730";

472caseELF::EF_AMDGPU_MACH_R600_RV770:

473return"rv770";

474

475// Radeon HD 5000 Series (Evergreen).

476caseELF::EF_AMDGPU_MACH_R600_CEDAR:

477return"cedar";

478caseELF::EF_AMDGPU_MACH_R600_CYPRESS:

479return"cypress";

480caseELF::EF_AMDGPU_MACH_R600_JUNIPER:

481return"juniper";

482caseELF::EF_AMDGPU_MACH_R600_REDWOOD:

483return"redwood";

484caseELF::EF_AMDGPU_MACH_R600_SUMO:

485return"sumo";

486

487// Radeon HD 6000 Series (Northern Islands).

488caseELF::EF_AMDGPU_MACH_R600_BARTS:

489return"barts";

490caseELF::EF_AMDGPU_MACH_R600_CAICOS:

491return"caicos";

492caseELF::EF_AMDGPU_MACH_R600_CAYMAN:

493return"cayman";

494caseELF::EF_AMDGPU_MACH_R600_TURKS:

495return"turks";

496

497// AMDGCN GFX6.

498caseELF::EF_AMDGPU_MACH_AMDGCN_GFX600:

499return"gfx600";

500caseELF::EF_AMDGPU_MACH_AMDGCN_GFX601:

501return"gfx601";

502caseELF::EF_AMDGPU_MACH_AMDGCN_GFX602:

503return"gfx602";

504

505// AMDGCN GFX7.

506caseELF::EF_AMDGPU_MACH_AMDGCN_GFX700:

507return"gfx700";

508caseELF::EF_AMDGPU_MACH_AMDGCN_GFX701:

509return"gfx701";

510caseELF::EF_AMDGPU_MACH_AMDGCN_GFX702:

511return"gfx702";

512caseELF::EF_AMDGPU_MACH_AMDGCN_GFX703:

513return"gfx703";

514caseELF::EF_AMDGPU_MACH_AMDGCN_GFX704:

515return"gfx704";

516caseELF::EF_AMDGPU_MACH_AMDGCN_GFX705:

517return"gfx705";

518

519// AMDGCN GFX8.

520caseELF::EF_AMDGPU_MACH_AMDGCN_GFX801:

521return"gfx801";

522caseELF::EF_AMDGPU_MACH_AMDGCN_GFX802:

523return"gfx802";

524caseELF::EF_AMDGPU_MACH_AMDGCN_GFX803:

525return"gfx803";

526caseELF::EF_AMDGPU_MACH_AMDGCN_GFX805:

527return"gfx805";

528caseELF::EF_AMDGPU_MACH_AMDGCN_GFX810:

529return"gfx810";

530

531// AMDGCN GFX9.

532caseELF::EF_AMDGPU_MACH_AMDGCN_GFX900:

533return"gfx900";

534caseELF::EF_AMDGPU_MACH_AMDGCN_GFX902:

535return"gfx902";

536caseELF::EF_AMDGPU_MACH_AMDGCN_GFX904:

537return"gfx904";

538caseELF::EF_AMDGPU_MACH_AMDGCN_GFX906:

539return"gfx906";

540caseELF::EF_AMDGPU_MACH_AMDGCN_GFX908:

541return"gfx908";

542caseELF::EF_AMDGPU_MACH_AMDGCN_GFX909:

543return"gfx909";

544caseELF::EF_AMDGPU_MACH_AMDGCN_GFX90A:

545return"gfx90a";

546caseELF::EF_AMDGPU_MACH_AMDGCN_GFX90C:

547return"gfx90c";

548caseELF::EF_AMDGPU_MACH_AMDGCN_GFX940:

549return"gfx940";

550caseELF::EF_AMDGPU_MACH_AMDGCN_GFX941:

551return"gfx941";

552caseELF::EF_AMDGPU_MACH_AMDGCN_GFX942:

553return"gfx942";

554caseELF::EF_AMDGPU_MACH_AMDGCN_GFX950:

555return"gfx950";

556

557// AMDGCN GFX10.

558caseELF::EF_AMDGPU_MACH_AMDGCN_GFX1010:

559return"gfx1010";

560caseELF::EF_AMDGPU_MACH_AMDGCN_GFX1011:

561return"gfx1011";

562caseELF::EF_AMDGPU_MACH_AMDGCN_GFX1012:

563return"gfx1012";

564caseELF::EF_AMDGPU_MACH_AMDGCN_GFX1013:

565return"gfx1013";

566caseELF::EF_AMDGPU_MACH_AMDGCN_GFX1030:

567return"gfx1030";

568caseELF::EF_AMDGPU_MACH_AMDGCN_GFX1031:

569return"gfx1031";

570caseELF::EF_AMDGPU_MACH_AMDGCN_GFX1032:

571return"gfx1032";

572caseELF::EF_AMDGPU_MACH_AMDGCN_GFX1033:

573return"gfx1033";

574caseELF::EF_AMDGPU_MACH_AMDGCN_GFX1034:

575return"gfx1034";

576caseELF::EF_AMDGPU_MACH_AMDGCN_GFX1035:

577return"gfx1035";

578caseELF::EF_AMDGPU_MACH_AMDGCN_GFX1036:

579return"gfx1036";

580

581// AMDGCN GFX11.

582caseELF::EF_AMDGPU_MACH_AMDGCN_GFX1100:

583return"gfx1100";

584caseELF::EF_AMDGPU_MACH_AMDGCN_GFX1101:

585return"gfx1101";

586caseELF::EF_AMDGPU_MACH_AMDGCN_GFX1102:

587return"gfx1102";

588caseELF::EF_AMDGPU_MACH_AMDGCN_GFX1103:

589return"gfx1103";

590caseELF::EF_AMDGPU_MACH_AMDGCN_GFX1150:

591return"gfx1150";

592caseELF::EF_AMDGPU_MACH_AMDGCN_GFX1151:

593return"gfx1151";

594caseELF::EF_AMDGPU_MACH_AMDGCN_GFX1152:

595return"gfx1152";

596caseELF::EF_AMDGPU_MACH_AMDGCN_GFX1153:

597return"gfx1153";

598

599// AMDGCN GFX12.

600caseELF::EF_AMDGPU_MACH_AMDGCN_GFX1200:

601return"gfx1200";

602caseELF::EF_AMDGPU_MACH_AMDGCN_GFX1201:

603return"gfx1201";

604

605// Generic AMDGCN targets

606caseELF::EF_AMDGPU_MACH_AMDGCN_GFX9_GENERIC:

607return"gfx9-generic";

608caseELF::EF_AMDGPU_MACH_AMDGCN_GFX9_4_GENERIC:

609return"gfx9-4-generic";

610caseELF::EF_AMDGPU_MACH_AMDGCN_GFX10_1_GENERIC:

611return"gfx10-1-generic";

612caseELF::EF_AMDGPU_MACH_AMDGCN_GFX10_3_GENERIC:

613return"gfx10-3-generic";

614caseELF::EF_AMDGPU_MACH_AMDGCN_GFX11_GENERIC:

615return"gfx11-generic";

616caseELF::EF_AMDGPU_MACH_AMDGCN_GFX12_GENERIC:

617return"gfx12-generic";

618default:

619llvm_unreachable("Unknown EF_AMDGPU_MACH value");

620 }

621}

622

623StringRef ELFObjectFileBase::getNVPTXCPUName() const{

624assert(getEMachine() ==ELF::EM_CUDA);

625unsigned SM =getPlatformFlags() &ELF::EF_CUDA_SM;

626

627switch (SM) {

628// Fermi architecture.

629caseELF::EF_CUDA_SM20:

630return"sm_20";

631caseELF::EF_CUDA_SM21:

632return"sm_21";

633

634// Kepler architecture.

635caseELF::EF_CUDA_SM30:

636return"sm_30";

637caseELF::EF_CUDA_SM32:

638return"sm_32";

639caseELF::EF_CUDA_SM35:

640return"sm_35";

641caseELF::EF_CUDA_SM37:

642return"sm_37";

643

644// Maxwell architecture.

645caseELF::EF_CUDA_SM50:

646return"sm_50";

647caseELF::EF_CUDA_SM52:

648return"sm_52";

649caseELF::EF_CUDA_SM53:

650return"sm_53";

651

652// Pascal architecture.

653caseELF::EF_CUDA_SM60:

654return"sm_60";

655caseELF::EF_CUDA_SM61:

656return"sm_61";

657caseELF::EF_CUDA_SM62:

658return"sm_62";

659

660// Volta architecture.

661caseELF::EF_CUDA_SM70:

662return"sm_70";

663caseELF::EF_CUDA_SM72:

664return"sm_72";

665

666// Turing architecture.

667caseELF::EF_CUDA_SM75:

668return"sm_75";

669

670// Ampere architecture.

671caseELF::EF_CUDA_SM80:

672return"sm_80";

673caseELF::EF_CUDA_SM86:

674return"sm_86";

675caseELF::EF_CUDA_SM87:

676return"sm_87";

677

678// Ada architecture.

679caseELF::EF_CUDA_SM89:

680return"sm_89";

681

682// Hopper architecture.

683caseELF::EF_CUDA_SM90:

684returngetPlatformFlags() &ELF::EF_CUDA_ACCELERATORS ?"sm_90a" :"sm_90";

685default:

686llvm_unreachable("Unknown EF_CUDA_SM value");

687 }

688}

689

690// FIXME Encode from a tablegen description or target parser.

691voidELFObjectFileBase::setARMSubArch(Triple &TheTriple) const{

692if (TheTriple.getSubArch() !=Triple::NoSubArch)

693return;

694

695ARMAttributeParser Attributes;

696if (Error E =getBuildAttributes(Attributes)) {

697// TODO Propagate Error.

698consumeError(std::move(E));

699return;

700 }

701

702 std::stringTriple;

703// Default to ARM, but use the triple if it's been set.

704if (TheTriple.isThumb())

705Triple ="thumb";

706else

707Triple ="arm";

708

709 std::optional<unsigned> Attr =

710Attributes.getAttributeValue(ARMBuildAttrs::CPU_arch);

711if (Attr) {

712switch (*Attr) {

713caseARMBuildAttrs::v4:

714Triple +="v4";

715break;

716caseARMBuildAttrs::v4T:

717Triple +="v4t";

718break;

719caseARMBuildAttrs::v5T:

720Triple +="v5t";

721break;

722caseARMBuildAttrs::v5TE:

723Triple +="v5te";

724break;

725caseARMBuildAttrs::v5TEJ:

726Triple +="v5tej";

727break;

728caseARMBuildAttrs::v6:

729Triple +="v6";

730break;

731caseARMBuildAttrs::v6KZ:

732Triple +="v6kz";

733break;

734caseARMBuildAttrs::v6T2:

735Triple +="v6t2";

736break;

737caseARMBuildAttrs::v6K:

738Triple +="v6k";

739break;

740caseARMBuildAttrs::v7: {

741 std::optional<unsigned> ArchProfileAttr =

742Attributes.getAttributeValue(ARMBuildAttrs::CPU_arch_profile);

743if (ArchProfileAttr &&

744 *ArchProfileAttr ==ARMBuildAttrs::MicroControllerProfile)

745Triple +="v7m";

746else

747Triple +="v7";

748break;

749 }

750caseARMBuildAttrs::v6_M:

751Triple +="v6m";

752break;

753caseARMBuildAttrs::v6S_M:

754Triple +="v6sm";

755break;

756caseARMBuildAttrs::v7E_M:

757Triple +="v7em";

758break;

759caseARMBuildAttrs::v8_A:

760Triple +="v8a";

761break;

762caseARMBuildAttrs::v8_R:

763Triple +="v8r";

764break;

765caseARMBuildAttrs::v8_M_Base:

766Triple +="v8m.base";

767break;

768caseARMBuildAttrs::v8_M_Main:

769Triple +="v8m.main";

770break;

771caseARMBuildAttrs::v8_1_M_Main:

772Triple +="v8.1m.main";

773break;

774caseARMBuildAttrs::v9_A:

775Triple +="v9a";

776break;

777 }

778 }

779if (!isLittleEndian())

780Triple +="eb";

781

782 TheTriple.setArchName(Triple);

783}

784

785std::vector<ELFPltEntry>ELFObjectFileBase::getPltEntries() const{

786 std::string Err;

787constautoTriple =makeTriple();

788constauto *T =TargetRegistry::lookupTarget(Triple.str(), Err);

789if (!T)

790return {};

791uint32_t JumpSlotReloc = 0, GlobDatReloc = 0;

792switch (Triple.getArch()) {

793caseTriple::x86:

794 JumpSlotReloc = ELF::R_386_JUMP_SLOT;

795 GlobDatReloc = ELF::R_386_GLOB_DAT;

796break;

797caseTriple::x86_64:

798 JumpSlotReloc = ELF::R_X86_64_JUMP_SLOT;

799 GlobDatReloc = ELF::R_X86_64_GLOB_DAT;

800break;

801caseTriple::aarch64:

802caseTriple::aarch64_be:

803 JumpSlotReloc = ELF::R_AARCH64_JUMP_SLOT;

804break;

805default:

806return {};

807 }

808 std::unique_ptr<const MCInstrInfo> MII(T->createMCInstrInfo());

809 std::unique_ptr<const MCInstrAnalysis> MIA(

810T->createMCInstrAnalysis(MII.get()));

811if (!MIA)

812return {};

813 std::vector<std::pair<uint64_t, uint64_t>> PltEntries;

814 std::optional<SectionRef> RelaPlt, RelaDyn;

815uint64_t GotBaseVA = 0;

816for (constSectionRef &Section :sections()) {

817Expected<StringRef> NameOrErr = Section.getName();

818if (!NameOrErr) {

819consumeError(NameOrErr.takeError());

820continue;

821 }

822StringRef Name = *NameOrErr;

823

824if (Name ==".rela.plt" ||Name ==".rel.plt") {

825 RelaPlt = Section;

826 }elseif (Name ==".rela.dyn" ||Name ==".rel.dyn") {

827 RelaDyn = Section;

828 }elseif (Name ==".got.plt") {

829 GotBaseVA = Section.getAddress();

830 }elseif (Name ==".plt" ||Name ==".plt.got") {

831Expected<StringRef> PltContents = Section.getContents();

832if (!PltContents) {

833consumeError(PltContents.takeError());

834return {};

835 }

836llvm::append_range(

837 PltEntries,

838 MIA->findPltEntries(Section.getAddress(),

839 arrayRefFromStringRef(*PltContents),Triple));

840 }

841 }

842

843// Build a map from GOT entry virtual address to PLT entry virtual address.

844DenseMap<uint64_t, uint64_t> GotToPlt;

845for (auto [Plt, GotPlt] : PltEntries) {

846uint64_t GotPltEntry = GotPlt;

847// An x86-32 PIC PLT uses jmp DWORD PTR [ebx-offset]. Add

848// _GLOBAL_OFFSET_TABLE_ (EBX) to get the .got.plt (or .got) entry address.

849// See X86MCTargetDesc.cpp:findPltEntries for the 1 << 32 bit.

850if (GotPltEntry & (uint64_t(1) << 32) &&getEMachine() ==ELF::EM_386)

851 GotPltEntry =static_cast<int32_t>(GotPltEntry) + GotBaseVA;

852 GotToPlt.insert(std::make_pair(GotPltEntry, Plt));

853 }

854

855// Find the relocations in the dynamic relocation table that point to

856// locations in the GOT for which we know the corresponding PLT entry.

857 std::vector<ELFPltEntry> Result;

858auto handleRels = [&](iterator_range<relocation_iterator> Rels,

859uint32_t RelType,StringRef PltSec) {

860for (constauto &R : Rels) {

861if (R.getType() != RelType)

862continue;

863auto PltEntryIter = GotToPlt.find(R.getOffset());

864if (PltEntryIter != GotToPlt.end()) {

865symbol_iterator Sym = R.getSymbol();

866if (Sym ==symbol_end())

867 Result.push_back(

868ELFPltEntry{PltSec, std::nullopt, PltEntryIter->second});

869else

870 Result.push_back(ELFPltEntry{PltSec,Sym->getRawDataRefImpl(),

871 PltEntryIter->second});

872 }

873 }

874 };

875

876if (RelaPlt)

877 handleRels(RelaPlt->relocations(), JumpSlotReloc,".plt");

878

879// If a symbol needing a PLT entry also needs a GLOB_DAT relocation, GNU ld's

880// x86 port places the PLT entry in the .plt.got section.

881if (RelaDyn)

882 handleRels(RelaDyn->relocations(), GlobDatReloc,".plt.got");

883

884return Result;

885}

886

887template <class ELFT>

888Expected<std::vector<BBAddrMap>>staticreadBBAddrMapImpl(

889constELFFile<ELFT> &EF, std::optional<unsigned> TextSectionIndex,

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

891usingElf_Shdr =typename ELFT::Shdr;

892bool IsRelocatable = EF.getHeader().e_type ==ELF::ET_REL;

893 std::vector<BBAddrMap> BBAddrMaps;

894if (PGOAnalyses)

895 PGOAnalyses->clear();

896

897constauto &Sections =cantFail(EF.sections());

898auto IsMatch = [&](const Elf_Shdr &Sec) ->Expected<bool> {

899if (Sec.sh_type !=ELF::SHT_LLVM_BB_ADDR_MAP &&

900 Sec.sh_type !=ELF::SHT_LLVM_BB_ADDR_MAP_V0)

901returnfalse;

902if (!TextSectionIndex)

903returntrue;

904Expected<const Elf_Shdr *> TextSecOrErr = EF.getSection(Sec.sh_link);

905if (!TextSecOrErr)

906returncreateError("unable to get the linked-to section for " +

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

908toString(TextSecOrErr.takeError()));

909assert(*TextSecOrErr >= Sections.begin() &&

910"Text section pointer outside of bounds");

911if (*TextSectionIndex !=

912 (unsigned)std::distance(Sections.begin(), *TextSecOrErr))

913returnfalse;

914returntrue;

915 };

916

917Expected<MapVector<const Elf_Shdr *, const Elf_Shdr *>> SectionRelocMapOrErr =

918 EF.getSectionAndRelocations(IsMatch);

919if (!SectionRelocMapOrErr)

920return SectionRelocMapOrErr.takeError();

921

922for (autoconst &[Sec, RelocSec] : *SectionRelocMapOrErr) {

923if (IsRelocatable && !RelocSec)

924returncreateError("unable to get relocation section for " +

925describe(EF, *Sec));

926Expected<std::vector<BBAddrMap>> BBAddrMapOrErr =

927 EF.decodeBBAddrMap(*Sec, RelocSec, PGOAnalyses);

928if (!BBAddrMapOrErr) {

929if (PGOAnalyses)

930 PGOAnalyses->clear();

931returncreateError("unable to read " +describe(EF, *Sec) +": " +

932toString(BBAddrMapOrErr.takeError()));

933 }

934 std::move(BBAddrMapOrErr->begin(), BBAddrMapOrErr->end(),

935 std::back_inserter(BBAddrMaps));

936 }

937if (PGOAnalyses)

938assert(PGOAnalyses->size() == BBAddrMaps.size() &&

939"The same number of BBAddrMaps and PGOAnalysisMaps should be "

940"returned when PGO information is requested");

941return BBAddrMaps;

942}

943

944template <class ELFT>

945staticExpected<std::vector<VersionEntry>>

946readDynsymVersionsImpl(constELFFile<ELFT> &EF,

947ELFObjectFileBase::elf_symbol_iterator_range Symbols) {

948usingElf_Shdr =typename ELFT::Shdr;

949const Elf_Shdr *VerSec =nullptr;

950const Elf_Shdr *VerNeedSec =nullptr;

951const Elf_Shdr *VerDefSec =nullptr;

952// The user should ensure sections() can't fail here.

953for (const Elf_Shdr &Sec :cantFail(EF.sections())) {

954if (Sec.sh_type ==ELF::SHT_GNU_versym)

955 VerSec = &Sec;

956elseif (Sec.sh_type ==ELF::SHT_GNU_verdef)

957 VerDefSec = &Sec;

958elseif (Sec.sh_type ==ELF::SHT_GNU_verneed)

959 VerNeedSec = &Sec;

960 }

961if (!VerSec)

962return std::vector<VersionEntry>();

963

964Expected<SmallVector<std::optional<VersionEntry>, 0>> MapOrErr =

965 EF.loadVersionMap(VerNeedSec, VerDefSec);

966if (!MapOrErr)

967return MapOrErr.takeError();

968

969 std::vector<VersionEntry> Ret;

970size_tI = 0;

971for (constELFSymbolRef &Sym : Symbols) {

972 ++I;

973Expected<const typename ELFT::Versym *> VerEntryOrErr =

974 EF.template getEntry<typename ELFT::Versym>(*VerSec,I);

975if (!VerEntryOrErr)

976returncreateError("unable to read an entry with index " +Twine(I) +

977" from " +describe(EF, *VerSec) +": " +

978toString(VerEntryOrErr.takeError()));

979

980Expected<uint32_t> FlagsOrErr =Sym.getFlags();

981if (!FlagsOrErr)

982returncreateError("unable to read flags for symbol with index " +

983Twine(I) +": " +toString(FlagsOrErr.takeError()));

984

985bool IsDefault;

986Expected<StringRef> VerOrErr = EF.getSymbolVersionByIndex(

987 (*VerEntryOrErr)->vs_index, IsDefault, *MapOrErr,

988 (*FlagsOrErr) &SymbolRef::SF_Undefined);

989if (!VerOrErr)

990returncreateError("unable to get a version for entry " +Twine(I) +

991" of " +describe(EF, *VerSec) +": " +

992toString(VerOrErr.takeError()));

993

994 Ret.push_back({(*VerOrErr).str(), IsDefault});

995 }

996

997return Ret;

998}

999

1000Expected<std::vector<VersionEntry>>

1001ELFObjectFileBase::readDynsymVersions() const{

1002elf_symbol_iterator_range Symbols =getDynamicSymbolIterators();

1003if (constauto *Obj = dyn_cast<ELF32LEObjectFile>(this))

1004returnreadDynsymVersionsImpl(Obj->getELFFile(), Symbols);

1005if (constauto *Obj = dyn_cast<ELF32BEObjectFile>(this))

1006returnreadDynsymVersionsImpl(Obj->getELFFile(), Symbols);

1007if (constauto *Obj = dyn_cast<ELF64LEObjectFile>(this))

1008returnreadDynsymVersionsImpl(Obj->getELFFile(), Symbols);

1009returnreadDynsymVersionsImpl(cast<ELF64BEObjectFile>(this)->getELFFile(),

1010 Symbols);

1011}

1012

1013Expected<std::vector<BBAddrMap>>ELFObjectFileBase::readBBAddrMap(

1014 std::optional<unsigned> TextSectionIndex,

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

1016if (constauto *Obj = dyn_cast<ELF32LEObjectFile>(this))

1017returnreadBBAddrMapImpl(Obj->getELFFile(), TextSectionIndex, PGOAnalyses);

1018if (constauto *Obj = dyn_cast<ELF64LEObjectFile>(this))

1019returnreadBBAddrMapImpl(Obj->getELFFile(), TextSectionIndex, PGOAnalyses);

1020if (constauto *Obj = dyn_cast<ELF32BEObjectFile>(this))

1021returnreadBBAddrMapImpl(Obj->getELFFile(), TextSectionIndex, PGOAnalyses);

1022returnreadBBAddrMapImpl(cast<ELF64BEObjectFile>(this)->getELFFile(),

1023 TextSectionIndex, PGOAnalyses);

1024}

1025

1026StringRef ELFObjectFileBase::getCrelDecodeProblem(SectionRef Sec) const{

1027autoData = Sec.getRawDataRefImpl();

1028if (constauto *Obj = dyn_cast<ELF32LEObjectFile>(this))

1029return Obj->getCrelDecodeProblem(Data);

1030if (constauto *Obj = dyn_cast<ELF32BEObjectFile>(this))

1031return Obj->getCrelDecodeProblem(Data);

1032if (constauto *Obj = dyn_cast<ELF64LEObjectFile>(this))

1033return Obj->getCrelDecodeProblem(Data);

1034return cast<ELF64BEObjectFile>(this)->getCrelDecodeProblem(Data);

1035}

Attributes

AMDGPU Kernel Attributes

Definition:AMDGPULowerKernelAttributes.cpp:370

std::string Name

Definition:ELFObjHandler.cpp:77

createPtr

static Expected< std::unique_ptr< ELFObjectFile< ELFT > > > createPtr(MemoryBufferRef Object, bool InitContent)

Definition:ELFObjectFile.cpp:64

readBBAddrMapImpl

static Expected< std::vector< BBAddrMap > > readBBAddrMapImpl(const ELFFile< ELFT > &EF, std::optional< unsigned > TextSectionIndex, std::vector< PGOAnalysisMap > *PGOAnalyses)

Definition:ELFObjectFile.cpp:888

hexagonAttrToFeatureString

static std::optional< std::string > hexagonAttrToFeatureString(unsigned Attr)

Definition:ELFObjectFile.cpp:290

readDynsymVersionsImpl

static Expected< std::vector< VersionEntry > > readDynsymVersionsImpl(const ELFFile< ELFT > &EF, ELFObjectFileBase::elf_symbol_iterator_range Symbols)

Definition:ELFObjectFile.cpp:946

ELFObjectFile.h

ELFTypes.h

Sym

Symbol * Sym

Definition:ELF_riscv.cpp:479

HexagonAttributeParser.h

MCInstrAnalysis.h

#define I(x, y, z)

Definition:MD5.cpp:58

ELF.h

RISCVAttributeParser.h

RISCVAttributes.h

RISCVISAInfo.h

assert

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

SubtargetFeature.h

TargetRegistry.h

Triple.h

llvm::ARMAttributeParser

Definition:ARMAttributeParser.h:21

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::DenseMapBase::insert

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

Definition:DenseMap.h:211

llvm::DenseMap

Definition:DenseMap.h:727

llvm::Error

Lightweight error class with error context and mandatory checking.

Definition:Error.h:160

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::HexagonAttributeParser

Definition:HexagonAttributeParser.h:16

llvm::MemoryBufferRef

Definition:MemoryBufferRef.h:22

llvm::MemoryBufferRef::getBufferStart

const char * getBufferStart() const

Definition:MemoryBufferRef.h:35

llvm::MemoryBufferRef::getBuffer

StringRef getBuffer() const

Definition:MemoryBufferRef.h:32

llvm::ParseResult

This class represents success/failure for parsing-like operations that find it important to chain tog...

Definition:LogicalResult.h:119

llvm::RISCVAttributeParser

Definition:RISCVAttributeParser.h:16

llvm::RISCVISAInfo::parseNormalizedArchString

static llvm::Expected< std::unique_ptr< RISCVISAInfo > > parseNormalizedArchString(StringRef Arch)

Parse RISC-V ISA info from an arch string that is already in normalized form (as defined in the psABI...

Definition:RISCVISAInfo.cpp:481

llvm::StringRef

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

Definition:StringRef.h:51

llvm::SubtargetFeatures

Manages the enabling and disabling of subtarget specific features.

Definition:SubtargetFeature.h:174

llvm::SubtargetFeatures::AddFeature

void AddFeature(StringRef String, bool Enable=true)

Adds Features.

Definition:SubtargetFeature.cpp:36

llvm::SubtargetFeatures::addFeaturesVector

void addFeaturesVector(const ArrayRef< std::string > OtherFeatures)

Definition:SubtargetFeature.cpp:44

llvm::Triple

Triple - Helper class for working with autoconf configuration names.

Definition:Triple.h:44

llvm::Triple::setArchName

void setArchName(StringRef Str)

Set the architecture (first) component of the triple by name.

Definition:Triple.cpp:1609

llvm::Triple::isThumb

bool isThumb() const

Tests whether the target is Thumb (little and big endian).

Definition:Triple.h:890

llvm::Triple::getSubArch

SubArchType getSubArch() const

get the parsed subarchitecture type for this triple.

Definition:Triple.h:398

llvm::Triple::x86

@ x86

Definition:Triple.h:85

llvm::Triple::x86_64

@ x86_64

Definition:Triple.h:86

llvm::Triple::aarch64_be

@ aarch64_be

Definition:Triple.h:52

llvm::Triple::aarch64

@ aarch64

Definition:Triple.h:51

llvm::Triple::getArch

ArchType getArch() const

Get the parsed architecture type of this triple.

Definition:Triple.h:395

llvm::Triple::str

const std::string & str() const

Definition:Triple.h:462

llvm::Triple::NoSubArch

@ NoSubArch

Definition:Triple.h:111

llvm::Twine

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

Definition:Twine.h:81

llvm::Type

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

Definition:Type.h:45

llvm::iterator_range

A range adaptor for a pair of iterators.

Definition:iterator_range.h:42

llvm::object::BasicSymbolRef::SF_Undefined

@ SF_Undefined

Definition:SymbolicFile.h:110

llvm::object::Binary::Data

MemoryBufferRef Data

Definition:Binary.h:37

llvm::object::Binary::isLittleEndian

bool isLittleEndian() const

Definition:Binary.h:155

llvm::object::ELFFile

Definition:ELF.h:255

llvm::object::ELFFile::getHeader

const Elf_Ehdr & getHeader() const

Definition:ELF.h:279

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::getSymbolVersionByIndex

Expected< StringRef > getSymbolVersionByIndex(uint32_t SymbolVersionIndex, bool &IsDefault, SmallVector< std::optional< VersionEntry >, 0 > &VersionMap, std::optional< bool > IsSymHidden) const

Definition:ELF.h:1005

llvm::object::ELFFile::sections

Expected< Elf_Shdr_Range > sections() const

Definition:ELF.h:925

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::loadVersionMap

Expected< SmallVector< std::optional< VersionEntry >, 0 > > loadVersionMap(const Elf_Shdr *VerNeedSec, const Elf_Shdr *VerDefSec) const

Definition:ELF.h:719

llvm::object::ELFFile::getSection

Expected< const Elf_Shdr * > getSection(const Elf_Sym &Sym, const Elf_Shdr *SymTab, DataRegion< Elf_Word > ShndxTable) const

Definition:ELF.h:577

llvm::object::ELFObjectFileBase::getBuildAttributes

virtual Error getBuildAttributes(ELFAttributeParser &Attributes) const =0

llvm::object::ELFObjectFileBase::readDynsymVersions

Expected< std::vector< VersionEntry > > readDynsymVersions() const

Returns a vector containing a symbol version for each dynamic symbol.

Definition:ELFObjectFile.cpp:1001

llvm::object::ELFObjectFileBase::getDynamicSymbolIterators

virtual elf_symbol_iterator_range getDynamicSymbolIterators() const =0

llvm::object::ELFObjectFileBase::getCrelDecodeProblem

StringRef getCrelDecodeProblem(SectionRef Sec) const

Definition:ELFObjectFile.cpp:1026

llvm::object::ELFObjectFileBase::getPltEntries

std::vector< ELFPltEntry > getPltEntries() const

Definition:ELFObjectFile.cpp:785

llvm::object::ELFObjectFileBase::getFeatures

Expected< SubtargetFeatures > getFeatures() const override

Definition:ELFObjectFile.cpp:419

llvm::object::ELFObjectFileBase::tryGetCPUName

std::optional< StringRef > tryGetCPUName() const override

Definition:ELFObjectFile.cpp:436

llvm::object::ELFObjectFileBase::getEMachine

virtual uint16_t getEMachine() const =0

llvm::object::ELFObjectFileBase::getPlatformFlags

virtual unsigned getPlatformFlags() const =0

Returns platform-specific object flags, if any.

llvm::object::ELFObjectFileBase::ELFObjectFileBase

ELFObjectFileBase(unsigned int Type, MemoryBufferRef Source)

Definition:ELFObjectFile.cpp:59

llvm::object::ELFObjectFileBase::setARMSubArch

void setARMSubArch(Triple &TheTriple) const override

Definition:ELFObjectFile.cpp:691

llvm::object::ELFObjectFileBase::readBBAddrMap

Expected< std::vector< BBAddrMap > > readBBAddrMap(std::optional< unsigned > TextSectionIndex=std::nullopt, std::vector< PGOAnalysisMap > *PGOAnalyses=nullptr) const

Returns a vector of all BB address maps in the object file.

Definition:ELFObjectFile.cpp:1013

llvm::object::ELFObjectFile::create

static Expected< ELFObjectFile< ELFT > > create(MemoryBufferRef Object, bool InitContent=true)

Definition:ELFObjectFile.h:1194

llvm::object::ELFSymbolRef

Definition:ELFObjectFile.h:168

llvm::object::ObjectFile

This class is the base class for all object file types.

Definition:ObjectFile.h:229

llvm::object::ObjectFile::createELFObjectFile

static Expected< std::unique_ptr< ObjectFile > > createELFObjectFile(MemoryBufferRef Object, bool InitContent=true)

Definition:ELFObjectFile.cpp:72

llvm::object::ObjectFile::makeTriple

Triple makeTriple() const

Create a triple from the data in this object file.

Definition:ObjectFile.cpp:109

llvm::object::ObjectFile::sections

section_iterator_range sections() const

Definition:ObjectFile.h:329

llvm::object::Parser

Definition:COFFModuleDefinition.cpp:139

llvm::object::SectionRef

This is a value type class that represents a single section in the list of sections in the object fil...

Definition:ObjectFile.h:81

llvm::object::SectionRef::getRawDataRefImpl

DataRefImpl getRawDataRefImpl() const

Definition:ObjectFile.h:598

llvm::object::SymbolicFile::symbol_end

virtual basic_symbol_iterator symbol_end() const =0

llvm::object::symbol_iterator

Definition:ObjectFile.h:208

#define llvm_unreachable(msg)

Marks that the current location is not supposed to be reachable.

Definition:ErrorHandling.h:143

llvm::ARMBuildAttrs::AllowFPv4B

@ AllowFPv4B

Definition:ARMBuildAttributes.h:139

llvm::ARMBuildAttrs::AllowMVEIntegerAndFloat

@ AllowMVEIntegerAndFloat

Definition:ARMBuildAttributes.h:156

llvm::ARMBuildAttrs::AllowFPv3B

@ AllowFPv3B

Definition:ARMBuildAttributes.h:137

llvm::ARMBuildAttrs::AllowNeon2

@ AllowNeon2

Definition:ARMBuildAttributes.h:150

llvm::ARMBuildAttrs::Not_Allowed

@ Not_Allowed

Definition:ARMBuildAttributes.h:125

llvm::ARMBuildAttrs::AllowDIVExt

@ AllowDIVExt

Definition:ARMBuildAttributes.h:238

llvm::ARMBuildAttrs::AllowMVEInteger

@ AllowMVEInteger

Definition:ARMBuildAttributes.h:155

llvm::ARMBuildAttrs::AllowThumb32

@ AllowThumb32

Definition:ARMBuildAttributes.h:131

llvm::ARMBuildAttrs::AllowFPv2

@ AllowFPv2

Definition:ARMBuildAttributes.h:135

llvm::ARMBuildAttrs::AllowFPv3A

@ AllowFPv3A

Definition:ARMBuildAttributes.h:136

llvm::ARMBuildAttrs::AllowNeon

@ AllowNeon

Definition:ARMBuildAttributes.h:149

llvm::ARMBuildAttrs::DisallowDIV

@ DisallowDIV

Definition:ARMBuildAttributes.h:237

llvm::ARMBuildAttrs::AllowFPv4A

@ AllowFPv4A

Definition:ARMBuildAttributes.h:138

llvm::ARMBuildAttrs::ApplicationProfile

@ ApplicationProfile

Definition:ARMBuildAttributes.h:117

llvm::ARMBuildAttrs::MicroControllerProfile

@ MicroControllerProfile

Definition:ARMBuildAttributes.h:119

llvm::ARMBuildAttrs::RealTimeProfile

@ RealTimeProfile

Definition:ARMBuildAttributes.h:118

llvm::ARMBuildAttrs::v6

@ v6

Definition:ARMBuildAttributes.h:99

llvm::ARMBuildAttrs::v9_A

@ v9_A

Definition:ARMBuildAttributes.h:112

llvm::ARMBuildAttrs::v8_M_Base

@ v8_M_Base

Definition:ARMBuildAttributes.h:109

llvm::ARMBuildAttrs::v4T

@ v4T

Definition:ARMBuildAttributes.h:95

llvm::ARMBuildAttrs::v8_1_M_Main

@ v8_1_M_Main

Definition:ARMBuildAttributes.h:111

llvm::ARMBuildAttrs::v7

@ v7

Definition:ARMBuildAttributes.h:103

llvm::ARMBuildAttrs::v7E_M

@ v7E_M

Definition:ARMBuildAttributes.h:106

llvm::ARMBuildAttrs::v6S_M

@ v6S_M

Definition:ARMBuildAttributes.h:105

llvm::ARMBuildAttrs::v8_M_Main

@ v8_M_Main

Definition:ARMBuildAttributes.h:110

llvm::ARMBuildAttrs::v5TE

@ v5TE

Definition:ARMBuildAttributes.h:97

llvm::ARMBuildAttrs::v6K

@ v6K

Definition:ARMBuildAttributes.h:102

llvm::ARMBuildAttrs::v8_R

@ v8_R

Definition:ARMBuildAttributes.h:108

llvm::ARMBuildAttrs::v4

@ v4

Definition:ARMBuildAttributes.h:94

llvm::ARMBuildAttrs::v5TEJ

@ v5TEJ

Definition:ARMBuildAttributes.h:98

llvm::ARMBuildAttrs::v6T2

@ v6T2

Definition:ARMBuildAttributes.h:101

llvm::ARMBuildAttrs::v5T

@ v5T

Definition:ARMBuildAttributes.h:96

llvm::ARMBuildAttrs::v6_M

@ v6_M

Definition:ARMBuildAttributes.h:104

llvm::ARMBuildAttrs::v8_A

@ v8_A

Definition:ARMBuildAttributes.h:107

llvm::ARMBuildAttrs::v6KZ

@ v6KZ

Definition:ARMBuildAttributes.h:100

llvm::ARMBuildAttrs::CPU_arch

@ CPU_arch

Definition:ARMBuildAttributes.h:39

llvm::ARMBuildAttrs::MVE_arch

@ MVE_arch

Definition:ARMBuildAttributes.h:72

llvm::ARMBuildAttrs::Advanced_SIMD_arch

@ Advanced_SIMD_arch

Definition:ARMBuildAttributes.h:45

llvm::ARMBuildAttrs::DIV_use

@ DIV_use

Definition:ARMBuildAttributes.h:70

llvm::ARMBuildAttrs::FP_arch

@ FP_arch

Definition:ARMBuildAttributes.h:43

llvm::ARMBuildAttrs::CPU_arch_profile

@ CPU_arch_profile

Definition:ARMBuildAttributes.h:40

llvm::ARMBuildAttrs::THUMB_ISA_use

@ THUMB_ISA_use

Definition:ARMBuildAttributes.h:42

llvm::ELF::ELFCLASS64

@ ELFCLASS64

Definition:ELF.h:332

llvm::ELF::ELFCLASS32

@ ELFCLASS32

Definition:ELF.h:331

llvm::ELF::EM_PPC64

@ EM_PPC64

Definition:ELF.h:152

llvm::ELF::EM_386

@ EM_386

Definition:ELF.h:139

llvm::ELF::EM_CUDA

@ EM_CUDA

Definition:ELF.h:289

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_HEXAGON

@ EM_HEXAGON

Definition:ELF.h:260

llvm::ELF::EM_MIPS

@ EM_MIPS

Definition:ELF.h:144

llvm::ELF::EM_RISCV

@ EM_RISCV

Definition:ELF.h:320

llvm::ELF::EM_ARM

@ EM_ARM

Definition:ELF.h:159

llvm::ELF::EM_AMDGPU

@ EM_AMDGPU

Definition:ELF.h:319

llvm::ELF::SHT_LLVM_BB_ADDR_MAP_V0

@ SHT_LLVM_BB_ADDR_MAP_V0

Definition:ELF.h:1134

llvm::ELF::SHT_GNU_verneed

@ SHT_GNU_verneed

Definition:ELF.h:1148

llvm::ELF::SHT_GNU_verdef

@ SHT_GNU_verdef

Definition:ELF.h:1147

llvm::ELF::SHT_LLVM_BB_ADDR_MAP

@ SHT_LLVM_BB_ADDR_MAP

Definition:ELF.h:1138

llvm::ELF::SHT_GNU_versym

@ SHT_GNU_versym

Definition:ELF.h:1149

llvm::ELF::EF_AMDGPU_MACH_AMDGCN_GFX703

@ EF_AMDGPU_MACH_AMDGCN_GFX703

Definition:ELF.h:780

llvm::ELF::EF_AMDGPU_MACH_AMDGCN_GFX1035

@ EF_AMDGPU_MACH_AMDGCN_GFX1035

Definition:ELF.h:804

llvm::ELF::EF_AMDGPU_MACH_AMDGCN_GFX1031

@ EF_AMDGPU_MACH_AMDGCN_GFX1031

Definition:ELF.h:798

llvm::ELF::EF_AMDGPU_MACH_R600_CAYMAN

@ EF_AMDGPU_MACH_R600_CAYMAN

Definition:ELF.h:762

llvm::ELF::EF_AMDGPU_MACH_AMDGCN_GFX704

@ EF_AMDGPU_MACH_AMDGCN_GFX704

Definition:ELF.h:781

llvm::ELF::EF_AMDGPU_MACH_AMDGCN_GFX902

@ EF_AMDGPU_MACH_AMDGCN_GFX902

Definition:ELF.h:788

llvm::ELF::EF_AMDGPU_MACH_AMDGCN_GFX810

@ EF_AMDGPU_MACH_AMDGCN_GFX810

Definition:ELF.h:786

llvm::ELF::EF_AMDGPU_MACH_AMDGCN_GFX950

@ EF_AMDGPU_MACH_AMDGCN_GFX950

Definition:ELF.h:822

llvm::ELF::EF_AMDGPU_MACH_AMDGCN_GFX1036

@ EF_AMDGPU_MACH_AMDGCN_GFX1036

Definition:ELF.h:812

llvm::ELF::EF_AMDGPU_MACH_AMDGCN_GFX1102

@ EF_AMDGPU_MACH_AMDGCN_GFX1102

Definition:ELF.h:814

llvm::ELF::EF_AMDGPU_MACH_R600_RV730

@ EF_AMDGPU_MACH_R600_RV730

Definition:ELF.h:751

llvm::ELF::EF_AMDGPU_MACH_R600_RV710

@ EF_AMDGPU_MACH_R600_RV710

Definition:ELF.h:750

llvm::ELF::EF_AMDGPU_MACH_AMDGCN_GFX908

@ EF_AMDGPU_MACH_AMDGCN_GFX908

Definition:ELF.h:791

llvm::ELF::EF_AMDGPU_MACH_AMDGCN_GFX1011

@ EF_AMDGPU_MACH_AMDGCN_GFX1011

Definition:ELF.h:795

llvm::ELF::EF_AMDGPU_MACH_R600_CYPRESS

@ EF_AMDGPU_MACH_R600_CYPRESS

Definition:ELF.h:755

llvm::ELF::EF_AMDGPU_MACH_AMDGCN_GFX1032

@ EF_AMDGPU_MACH_AMDGCN_GFX1032

Definition:ELF.h:799

llvm::ELF::EF_AMDGPU_MACH_R600_R600

@ EF_AMDGPU_MACH_R600_R600

Definition:ELF.h:745

llvm::ELF::EF_AMDGPU_MACH_AMDGCN_GFX940

@ EF_AMDGPU_MACH_AMDGCN_GFX940

Definition:ELF.h:807

llvm::ELF::EF_AMDGPU_MACH_AMDGCN_GFX941

@ EF_AMDGPU_MACH_AMDGCN_GFX941

Definition:ELF.h:818

llvm::ELF::EF_AMDGPU_MACH_R600_TURKS

@ EF_AMDGPU_MACH_R600_TURKS

Definition:ELF.h:763

llvm::ELF::EF_AMDGPU_MACH_R600_JUNIPER

@ EF_AMDGPU_MACH_R600_JUNIPER

Definition:ELF.h:756

llvm::ELF::EF_AMDGPU_MACH_AMDGCN_GFX601

@ EF_AMDGPU_MACH_AMDGCN_GFX601

Definition:ELF.h:776

llvm::ELF::EF_AMDGPU_MACH_AMDGCN_GFX942

@ EF_AMDGPU_MACH_AMDGCN_GFX942

Definition:ELF.h:819

llvm::ELF::EF_AMDGPU_MACH_AMDGCN_GFX1152

@ EF_AMDGPU_MACH_AMDGCN_GFX1152

Definition:ELF.h:828

llvm::ELF::EF_AMDGPU_MACH_R600_R630

@ EF_AMDGPU_MACH_R600_R630

Definition:ELF.h:746

llvm::ELF::EF_AMDGPU_MACH_R600_REDWOOD

@ EF_AMDGPU_MACH_R600_REDWOOD

Definition:ELF.h:757

llvm::ELF::EF_AMDGPU_MACH_R600_RV770

@ EF_AMDGPU_MACH_R600_RV770

Definition:ELF.h:752

llvm::ELF::EF_AMDGPU_MACH_AMDGCN_GFX600

@ EF_AMDGPU_MACH_AMDGCN_GFX600

Definition:ELF.h:775

llvm::ELF::EF_AMDGPU_MACH_AMDGCN_GFX602

@ EF_AMDGPU_MACH_AMDGCN_GFX602

Definition:ELF.h:801

llvm::ELF::EF_AMDGPU_MACH_AMDGCN_GFX1101

@ EF_AMDGPU_MACH_AMDGCN_GFX1101

Definition:ELF.h:813

llvm::ELF::EF_AMDGPU_MACH_AMDGCN_GFX1100

@ EF_AMDGPU_MACH_AMDGCN_GFX1100

Definition:ELF.h:808

llvm::ELF::EF_AMDGPU_MACH_AMDGCN_GFX1033

@ EF_AMDGPU_MACH_AMDGCN_GFX1033

Definition:ELF.h:800

llvm::ELF::EF_AMDGPU_MACH_AMDGCN_GFX801

@ EF_AMDGPU_MACH_AMDGCN_GFX801

Definition:ELF.h:783

llvm::ELF::EF_AMDGPU_MACH_AMDGCN_GFX705

@ EF_AMDGPU_MACH_AMDGCN_GFX705

Definition:ELF.h:802

llvm::ELF::EF_AMDGPU_MACH_AMDGCN_GFX9_4_GENERIC

@ EF_AMDGPU_MACH_AMDGCN_GFX9_4_GENERIC

Definition:ELF.h:833

llvm::ELF::EF_AMDGPU_MACH_AMDGCN_GFX1153

@ EF_AMDGPU_MACH_AMDGCN_GFX1153

Definition:ELF.h:831

llvm::ELF::EF_AMDGPU_MACH_AMDGCN_GFX1010

@ EF_AMDGPU_MACH_AMDGCN_GFX1010

Definition:ELF.h:794

llvm::ELF::EF_AMDGPU_MACH_R600_RV670

@ EF_AMDGPU_MACH_R600_RV670

Definition:ELF.h:748

llvm::ELF::EF_AMDGPU_MACH_AMDGCN_GFX701

@ EF_AMDGPU_MACH_AMDGCN_GFX701

Definition:ELF.h:778

llvm::ELF::EF_AMDGPU_MACH_AMDGCN_GFX10_3_GENERIC

@ EF_AMDGPU_MACH_AMDGCN_GFX10_3_GENERIC

Definition:ELF.h:826

llvm::ELF::EF_AMDGPU_MACH_AMDGCN_GFX1012

@ EF_AMDGPU_MACH_AMDGCN_GFX1012

Definition:ELF.h:796

llvm::ELF::EF_AMDGPU_MACH_AMDGCN_GFX1151

@ EF_AMDGPU_MACH_AMDGCN_GFX1151

Definition:ELF.h:817

llvm::ELF::EF_AMDGPU_MACH_AMDGCN_GFX1030

@ EF_AMDGPU_MACH_AMDGCN_GFX1030

Definition:ELF.h:797

llvm::ELF::EF_AMDGPU_MACH_R600_CEDAR

@ EF_AMDGPU_MACH_R600_CEDAR

Definition:ELF.h:754

llvm::ELF::EF_AMDGPU_MACH_AMDGCN_GFX1200

@ EF_AMDGPU_MACH_AMDGCN_GFX1200

Definition:ELF.h:815

llvm::ELF::EF_AMDGPU_MACH_AMDGCN_GFX700

@ EF_AMDGPU_MACH_AMDGCN_GFX700

Definition:ELF.h:777

llvm::ELF::EF_AMDGPU_MACH_AMDGCN_GFX11_GENERIC

@ EF_AMDGPU_MACH_AMDGCN_GFX11_GENERIC

Definition:ELF.h:827

llvm::ELF::EF_AMDGPU_MACH_AMDGCN_GFX803

@ EF_AMDGPU_MACH_AMDGCN_GFX803

Definition:ELF.h:785

llvm::ELF::EF_AMDGPU_MACH_AMDGCN_GFX802

@ EF_AMDGPU_MACH_AMDGCN_GFX802

Definition:ELF.h:784

llvm::ELF::EF_AMDGPU_MACH_AMDGCN_GFX90C

@ EF_AMDGPU_MACH_AMDGCN_GFX90C

Definition:ELF.h:793

llvm::ELF::EF_AMDGPU_MACH_AMDGCN_GFX900

@ EF_AMDGPU_MACH_AMDGCN_GFX900

Definition:ELF.h:787

llvm::ELF::EF_AMDGPU_MACH_AMDGCN_GFX909

@ EF_AMDGPU_MACH_AMDGCN_GFX909

Definition:ELF.h:792

llvm::ELF::EF_AMDGPU_MACH

@ EF_AMDGPU_MACH

Definition:ELF.h:737

llvm::ELF::EF_AMDGPU_MACH_AMDGCN_GFX906

@ EF_AMDGPU_MACH_AMDGCN_GFX906

Definition:ELF.h:790

llvm::ELF::EF_AMDGPU_MACH_AMDGCN_GFX9_GENERIC

@ EF_AMDGPU_MACH_AMDGCN_GFX9_GENERIC

Definition:ELF.h:824

llvm::ELF::EF_AMDGPU_MACH_AMDGCN_GFX1103

@ EF_AMDGPU_MACH_AMDGCN_GFX1103

Definition:ELF.h:811

llvm::ELF::EF_AMDGPU_MACH_R600_CAICOS

@ EF_AMDGPU_MACH_R600_CAICOS

Definition:ELF.h:761

llvm::ELF::EF_AMDGPU_MACH_AMDGCN_GFX90A

@ EF_AMDGPU_MACH_AMDGCN_GFX90A

Definition:ELF.h:806

llvm::ELF::EF_AMDGPU_MACH_AMDGCN_GFX1034

@ EF_AMDGPU_MACH_AMDGCN_GFX1034

Definition:ELF.h:805

llvm::ELF::EF_AMDGPU_MACH_AMDGCN_GFX1013

@ EF_AMDGPU_MACH_AMDGCN_GFX1013

Definition:ELF.h:809

llvm::ELF::EF_AMDGPU_MACH_AMDGCN_GFX12_GENERIC

@ EF_AMDGPU_MACH_AMDGCN_GFX12_GENERIC

Definition:ELF.h:832

llvm::ELF::EF_AMDGPU_MACH_AMDGCN_GFX10_1_GENERIC

@ EF_AMDGPU_MACH_AMDGCN_GFX10_1_GENERIC

Definition:ELF.h:825

llvm::ELF::EF_AMDGPU_MACH_AMDGCN_GFX904

@ EF_AMDGPU_MACH_AMDGCN_GFX904

Definition:ELF.h:789

llvm::ELF::EF_AMDGPU_MACH_R600_RS880

@ EF_AMDGPU_MACH_R600_RS880

Definition:ELF.h:747

llvm::ELF::EF_AMDGPU_MACH_AMDGCN_GFX805

@ EF_AMDGPU_MACH_AMDGCN_GFX805

Definition:ELF.h:803

llvm::ELF::EF_AMDGPU_MACH_AMDGCN_GFX1201

@ EF_AMDGPU_MACH_AMDGCN_GFX1201

Definition:ELF.h:821

llvm::ELF::EF_AMDGPU_MACH_AMDGCN_GFX1150

@ EF_AMDGPU_MACH_AMDGCN_GFX1150

Definition:ELF.h:810

llvm::ELF::EF_AMDGPU_MACH_R600_SUMO

@ EF_AMDGPU_MACH_R600_SUMO

Definition:ELF.h:758

llvm::ELF::EF_AMDGPU_MACH_R600_BARTS

@ EF_AMDGPU_MACH_R600_BARTS

Definition:ELF.h:760

llvm::ELF::EF_AMDGPU_MACH_AMDGCN_GFX702

@ EF_AMDGPU_MACH_AMDGCN_GFX702

Definition:ELF.h:779

llvm::ELF::EF_LOONGARCH_ABI_SINGLE_FLOAT

@ EF_LOONGARCH_ABI_SINGLE_FLOAT

Definition:ELF.h:1021

llvm::ELF::EF_LOONGARCH_ABI_DOUBLE_FLOAT

@ EF_LOONGARCH_ABI_DOUBLE_FLOAT

Definition:ELF.h:1022

llvm::ELF::EF_LOONGARCH_ABI_SOFT_FLOAT

@ EF_LOONGARCH_ABI_SOFT_FLOAT

Definition:ELF.h:1020

llvm::ELF::EF_LOONGARCH_ABI_MODIFIER_MASK

@ EF_LOONGARCH_ABI_MODIFIER_MASK

Definition:ELF.h:1023

llvm::ELF::EF_MIPS_ARCH

@ EF_MIPS_ARCH

Definition:ELF.h:571

llvm::ELF::EF_MIPS_MICROMIPS

@ EF_MIPS_MICROMIPS

Definition:ELF.h:554

llvm::ELF::EF_MIPS_ARCH_32R6

@ EF_MIPS_ARCH_32R6

Definition:ELF.h:569

llvm::ELF::EF_MIPS_MACH_NONE

@ EF_MIPS_MACH_NONE

Definition:ELF.h:532

llvm::ELF::EF_MIPS_ARCH_64

@ EF_MIPS_ARCH_64

Definition:ELF.h:566

llvm::ELF::EF_MIPS_ARCH_32

@ EF_MIPS_ARCH_32

Definition:ELF.h:565

llvm::ELF::EF_MIPS_MACH_OCTEON

@ EF_MIPS_MACH_OCTEON

Definition:ELF.h:540

llvm::ELF::EF_MIPS_ARCH_4

@ EF_MIPS_ARCH_4

Definition:ELF.h:563

llvm::ELF::EF_MIPS_ARCH_5

@ EF_MIPS_ARCH_5

Definition:ELF.h:564

llvm::ELF::EF_MIPS_ARCH_2

@ EF_MIPS_ARCH_2

Definition:ELF.h:561

llvm::ELF::EF_MIPS_ARCH_32R2

@ EF_MIPS_ARCH_32R2

Definition:ELF.h:567

llvm::ELF::EF_MIPS_ARCH_64R2

@ EF_MIPS_ARCH_64R2

Definition:ELF.h:568

llvm::ELF::EF_MIPS_ARCH_ASE_M16

@ EF_MIPS_ARCH_ASE_M16

Definition:ELF.h:555

llvm::ELF::EF_MIPS_MACH

@ EF_MIPS_MACH

Definition:ELF.h:551

llvm::ELF::EF_MIPS_ARCH_1

@ EF_MIPS_ARCH_1

Definition:ELF.h:560

llvm::ELF::EF_MIPS_ARCH_64R6

@ EF_MIPS_ARCH_64R6

Definition:ELF.h:570

llvm::ELF::EF_MIPS_ARCH_3

@ EF_MIPS_ARCH_3

Definition:ELF.h:562

llvm::ELF::EF_RISCV_RVC

@ EF_RISCV_RVC

Definition:ELF.h:679

llvm::ELF::ET_REL

@ ET_REL

Definition:ELF.h:117

llvm::ELF::STT_FUNC

@ STT_FUNC

Definition:ELF.h:1365

llvm::ELF::STT_NOTYPE

@ STT_NOTYPE

Definition:ELF.h:1363

llvm::ELF::STT_SECTION

@ STT_SECTION

Definition:ELF.h:1366

llvm::ELF::STT_FILE

@ STT_FILE

Definition:ELF.h:1367

llvm::ELF::STT_COMMON

@ STT_COMMON

Definition:ELF.h:1368

llvm::ELF::STT_GNU_IFUNC

@ STT_GNU_IFUNC

Definition:ELF.h:1370

llvm::ELF::STT_OBJECT

@ STT_OBJECT

Definition:ELF.h:1364

llvm::ELF::STT_TLS

@ STT_TLS

Definition:ELF.h:1369

llvm::ELF::ELFDATA2MSB

@ ELFDATA2MSB

Definition:ELF.h:339

llvm::ELF::ELFDATA2LSB

@ ELFDATA2LSB

Definition:ELF.h:338

llvm::ELF::EF_CUDA_SM21

@ EF_CUDA_SM21

Definition:ELF.h:907

llvm::ELF::EF_CUDA_SM90

@ EF_CUDA_SM90

Definition:ELF.h:926

llvm::ELF::EF_CUDA_SM86

@ EF_CUDA_SM86

Definition:ELF.h:922

llvm::ELF::EF_CUDA_SM60

@ EF_CUDA_SM60

Definition:ELF.h:915

llvm::ELF::EF_CUDA_SM

@ EF_CUDA_SM

Definition:ELF.h:903

llvm::ELF::EF_CUDA_SM89

@ EF_CUDA_SM89

Definition:ELF.h:924

llvm::ELF::EF_CUDA_SM37

@ EF_CUDA_SM37

Definition:ELF.h:911

llvm::ELF::EF_CUDA_SM32

@ EF_CUDA_SM32

Definition:ELF.h:909

llvm::ELF::EF_CUDA_SM72

@ EF_CUDA_SM72

Definition:ELF.h:919

llvm::ELF::EF_CUDA_SM50

@ EF_CUDA_SM50

Definition:ELF.h:912

llvm::ELF::EF_CUDA_ACCELERATORS

@ EF_CUDA_ACCELERATORS

Definition:ELF.h:935

llvm::ELF::EF_CUDA_SM61

@ EF_CUDA_SM61

Definition:ELF.h:916

llvm::ELF::EF_CUDA_SM52

@ EF_CUDA_SM52

Definition:ELF.h:913

llvm::ELF::EF_CUDA_SM35

@ EF_CUDA_SM35

Definition:ELF.h:910

llvm::ELF::EF_CUDA_SM62

@ EF_CUDA_SM62

Definition:ELF.h:917

llvm::ELF::EF_CUDA_SM30

@ EF_CUDA_SM30

Definition:ELF.h:908

llvm::ELF::EF_CUDA_SM75

@ EF_CUDA_SM75

Definition:ELF.h:920

llvm::ELF::EF_CUDA_SM87

@ EF_CUDA_SM87

Definition:ELF.h:923

llvm::ELF::EF_CUDA_SM20

@ EF_CUDA_SM20

Definition:ELF.h:906

llvm::ELF::EF_CUDA_SM80

@ EF_CUDA_SM80

Definition:ELF.h:921

llvm::ELF::EF_CUDA_SM53

@ EF_CUDA_SM53

Definition:ELF.h:914

llvm::ELF::EF_CUDA_SM70

@ EF_CUDA_SM70

Definition:ELF.h:918

llvm::HexagonAttrs::HVXIEEEFP

@ HVXIEEEFP

Definition:HexagonAttributes.h:22

llvm::HexagonAttrs::ZREG

@ ZREG

Definition:HexagonAttributes.h:24

llvm::HexagonAttrs::HVXQFLOAT

@ HVXQFLOAT

Definition:HexagonAttributes.h:23

llvm::HexagonAttrs::CABAC

@ CABAC

Definition:HexagonAttributes.h:26

llvm::HexagonAttrs::HVXARCH

@ HVXARCH

Definition:HexagonAttributes.h:21

llvm::HexagonAttrs::ARCH

@ ARCH

Definition:HexagonAttributes.h:20

llvm::HexagonAttrs::AUDIO

@ AUDIO

Definition:HexagonAttributes.h:25

llvm::RISCVAttrs::ARCH

@ ARCH

Definition:RISCVAttributes.h:30

llvm::object::createError

Error createError(const Twine &Err)

Definition:Error.h:84

llvm::object::NumElfSymbolTypes

constexpr int NumElfSymbolTypes

Definition:ELFObjectFile.h:46

llvm::object::describe

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

Definition:ELF.h:145

llvm::object::getElfArchType

std::pair< unsigned char, unsigned char > getElfArchType(StringRef Object)

Definition:ELF.h:80

llvm::object::ElfSymbolTypes

const llvm::EnumEntry< unsigned > ElfSymbolTypes[NumElfSymbolTypes]

Definition:ELFObjectFile.cpp:40

llvm

This is an optimization pass for GlobalISel generic memory operations.

Definition:AddressRanges.h:18

llvm::append_range

void append_range(Container &C, Range &&R)

Wrapper function to append range R to container C.

Definition:STLExtras.h:2115

llvm::countr_zero

int countr_zero(T Val)

Count number of 0's from the least significant bit to the most stopping at the first 1.

Definition:bit.h:215

llvm::cantFail

void cantFail(Error Err, const char *Msg=nullptr)

Report a fatal error if Err is a failure value.

Definition:Error.h:756

llvm::toString

const char * toString(DWARFSectionKind Kind)

Definition:DWARFUnitIndex.h:67

llvm::consumeError

void consumeError(Error Err)

Consume a Error without doing anything.

Definition:Error.h:1069

llvm::EnumEntry

Definition:ScopedPrinter.h:24

llvm::TargetRegistry::lookupTarget

static const Target * lookupTarget(StringRef Triple, std::string &Error)

lookupTarget - Lookup a target based on a target triple.

Definition:TargetRegistry.cpp:154

llvm::object::ELFPltEntry

Definition:ELFObjectFile.h:51