ELFYAML.cpp Source File (original) (raw)

24#include

25#include

26#include

28namespace llvm {

37 return *Header.Machine;

39}

40}

42namespace yaml {

44void ScalarEnumerationTraitsELFYAML::ELF\_ET::enumeration(

45 IO &IO, ELFYAML::ELF_ET &Value) {

46#define ECase(X) IO.enumCase(Value, #X, ELF::X)

52#undef ECase

53 IO.enumFallback(Value);

54}

56void ScalarEnumerationTraitsELFYAML::ELF\_PT::enumeration(

57 IO &IO, ELFYAML::ELF_PT &Value) {

58#define ECase(X) IO.enumCase(Value, #X, ELF::X)

61 ECase(PT_DYNAMIC);

67 ECase(PT_GNU_EH_FRAME);

68 ECase(PT_GNU_STACK);

69 ECase(PT_GNU_RELRO);

70 ECase(PT_GNU_PROPERTY);

71 ECase(PT_GNU_SFRAME);

72#undef ECase

73 IO.enumFallback(Value);

74}

78#define ECase(X) IO.enumCase(Value, #X, ELF::X)

80 ECase(NT_VERSION);

82 ECase(NT_GNU_BUILD_ATTRIBUTE_OPEN);

83 ECase(NT_GNU_BUILD_ATTRIBUTE_FUNC);

85 ECase(NT_PRSTATUS);

86 ECase(NT_FPREGSET);

87 ECase(NT_PRPSINFO);

88 ECase(NT_TASKSTRUCT);

90 ECase(NT_PSTATUS);

93 ECase(NT_LWPSTATUS);

94 ECase(NT_LWPSINFO);

95 ECase(NT_WIN32PSTATUS);

96 ECase(NT_PPC_VMX);

97 ECase(NT_PPC_VSX);

98 ECase(NT_PPC_TAR);

99 ECase(NT_PPC_PPR);

100 ECase(NT_PPC_DSCR);

101 ECase(NT_PPC_EBB);

102 ECase(NT_PPC_PMU);

103 ECase(NT_PPC_TM_CGPR);

104 ECase(NT_PPC_TM_CFPR);

105 ECase(NT_PPC_TM_CVMX);

106 ECase(NT_PPC_TM_CVSX);

107 ECase(NT_PPC_TM_SPR);

108 ECase(NT_PPC_TM_CTAR);

109 ECase(NT_PPC_TM_CPPR);

110 ECase(NT_PPC_TM_CDSCR);

111 ECase(NT_386_TLS);

112 ECase(NT_386_IOPERM);

113 ECase(NT_X86_XSTATE);

114 ECase(NT_S390_HIGH_GPRS);

115 ECase(NT_S390_TIMER);

116 ECase(NT_S390_TODCMP);

117 ECase(NT_S390_TODPREG);

118 ECase(NT_S390_CTRS);

119 ECase(NT_S390_PREFIX);

120 ECase(NT_S390_LAST_BREAK);

121 ECase(NT_S390_SYSTEM_CALL);

122 ECase(NT_S390_TDB);

123 ECase(NT_S390_VXRS_LOW);

124 ECase(NT_S390_VXRS_HIGH);

125 ECase(NT_S390_GS_CB);

126 ECase(NT_S390_GS_BC);

127 ECase(NT_ARM_VFP);

128 ECase(NT_ARM_TLS);

129 ECase(NT_ARM_HW_BREAK);

130 ECase(NT_ARM_HW_WATCH);

131 ECase(NT_ARM_SVE);

132 ECase(NT_ARM_PAC_MASK);

133 ECase(NT_ARM_TAGGED_ADDR_CTRL);

134 ECase(NT_ARM_SSVE);

135 ECase(NT_ARM_ZA);

136 ECase(NT_ARM_ZT);

137 ECase(NT_ARM_FPMR);

138 ECase(NT_ARM_GCS);

140 ECase(NT_PRXFPREG);

141 ECase(NT_SIGINFO);

142

143 ECase(NT_LLVM_HWASAN_GLOBALS);

144

145 ECase(NT_GNU_ABI_TAG);

146 ECase(NT_GNU_HWCAP);

147 ECase(NT_GNU_BUILD_ID);

148 ECase(NT_GNU_GOLD_VERSION);

149 ECase(NT_GNU_PROPERTY_TYPE_0);

150

151 ECase(NT_FREEBSD_ABI_TAG);

152 ECase(NT_FREEBSD_NOINIT_TAG);

153 ECase(NT_FREEBSD_ARCH_TAG);

154 ECase(NT_FREEBSD_FEATURE_CTL);

155

156 ECase(NT_FREEBSD_THRMISC);

157 ECase(NT_FREEBSD_PROCSTAT_PROC);

158 ECase(NT_FREEBSD_PROCSTAT_FILES);

159 ECase(NT_FREEBSD_PROCSTAT_VMMAP);

160 ECase(NT_FREEBSD_PROCSTAT_GROUPS);

161 ECase(NT_FREEBSD_PROCSTAT_UMASK);

162 ECase(NT_FREEBSD_PROCSTAT_RLIMIT);

163 ECase(NT_FREEBSD_PROCSTAT_OSREL);

164 ECase(NT_FREEBSD_PROCSTAT_PSSTRINGS);

165 ECase(NT_FREEBSD_PROCSTAT_AUXV);

166

167 ECase(NT_NETBSDCORE_PROCINFO);

168 ECase(NT_NETBSDCORE_AUXV);

169 ECase(NT_NETBSDCORE_LWPSTATUS);

170

171 ECase(NT_OPENBSD_PROCINFO);

172 ECase(NT_OPENBSD_AUXV);

173 ECase(NT_OPENBSD_REGS);

174 ECase(NT_OPENBSD_FPREGS);

175 ECase(NT_OPENBSD_XFPREGS);

176 ECase(NT_OPENBSD_WCOOKIE);

177

178 ECase(NT_AMD_HSA_CODE_OBJECT_VERSION);

179 ECase(NT_AMD_HSA_HSAIL);

180 ECase(NT_AMD_HSA_ISA_VERSION);

181 ECase(NT_AMD_HSA_METADATA);

182 ECase(NT_AMD_HSA_ISA_NAME);

183 ECase(NT_AMD_PAL_METADATA);

184

185 ECase(NT_AMDGPU_METADATA);

186

187 ECase(NT_ANDROID_TYPE_IDENT);

188 ECase(NT_ANDROID_TYPE_KUSER);

189 ECase(NT_ANDROID_TYPE_MEMTAG);

190#undef ECase

192}

193

195 IO &IO, ELFYAML::ELF_EM &Value) {

196#define ECase(X) IO.enumCase(Value, #X, ELF::X)

207 ECase(EM_MIPS_RS3_LE);

208 ECase(EM_PARISC);

209 ECase(EM_VPP500);

210 ECase(EM_SPARC32PLUS);

223 ECase(EM_SPARCV9);

224 ECase(EM_TRICORE);

226 ECase(EM_H8_300);

227 ECase(EM_H8_300H);

229 ECase(EM_H8_500);

231 ECase(EM_MIPS_X);

232 ECase(EM_COLDFIRE);

233 ECase(EM_68HC12);

238 ECase(EM_STARCORE);

242 ECase(EM_X86_64);

247 ECase(EM_ST9PLUS);

249 ECase(EM_68HC16);

250 ECase(EM_68HC11);

251 ECase(EM_68HC08);

252 ECase(EM_68HC05);

257 ECase(EM_JAVELIN);

258 ECase(EM_FIREPATH);

269 ECase(EM_MN10300);

270 ECase(EM_MN10200);

272 ECase(EM_OPENRISC);

273 ECase(EM_ARC_COMPACT);

274 ECase(EM_XTENSA);

275 ECase(EM_VIDEOCORE);

276 ECase(EM_TMM_GPP);

284 ECase(EM_F2MC16);

285 ECase(EM_MSP430);

286 ECase(EM_BLACKFIN);

287 ECase(EM_SE_C33);

290 ECase(EM_UNICORE);

291 ECase(EM_EXCESS);

293 ECase(EM_ALTERA_NIOS2);

298 ECase(EM_DSPIC30F);

301 ECase(EM_TSK3000);

305 ECase(EM_SCORE7);

307 ECase(EM_VIDEOCORE3);

308 ECase(EM_LATTICEMICO32);

309 ECase(EM_SE_C17);

310 ECase(EM_TI_C6000);

311 ECase(EM_TI_C2000);

312 ECase(EM_TI_C5500);

313 ECase(EM_MMDSP_PLUS);

314 ECase(EM_CYPRESS_M8C);

316 ECase(EM_TRIMEDIA);

317 ECase(EM_HEXAGON);

319 ECase(EM_STXP7X);

322 ECase(EM_ECOG1X);

323 ECase(EM_MAXQ30);

324 ECase(EM_XIMO16);

326 ECase(EM_CRAYNV2);

329 ECase(EM_MCST_ELBRUS);

330 ECase(EM_ECOG16);

336 ECase(EM_AARCH64);

339 ECase(EM_TILE64);

340 ECase(EM_TILEPRO);

341 ECase(EM_MICROBLAZE);

343 ECase(EM_TILEGX);

344 ECase(EM_CLOUDSHIELD);

345 ECase(EM_COREA_1ST);

346 ECase(EM_COREA_2ND);

347 ECase(EM_ARC_COMPACT2);

350 ECase(EM_VIDEOCORE5);

352 ECase(EM_56800EX);

353 ECase(EM_AMDGPU);

359 ECase(EM_LOONGARCH);

360 ECase(EM_INTELGT);

361#undef ECase

363}

364

366 IO &IO, ELFYAML::ELF_ELFCLASS &Value) {

367#define ECase(X) IO.enumCase(Value, #X, ELF::X)

368

369

370 ECase(ELFCLASS32);

371 ECase(ELFCLASS64);

372#undef ECase

373}

374

376 IO &IO, ELFYAML::ELF_ELFDATA &Value) {

377#define ECase(X) IO.enumCase(Value, #X, ELF::X)

378

379

380 ECase(ELFDATANONE);

381 ECase(ELFDATA2LSB);

382 ECase(ELFDATA2MSB);

383#undef ECase

384}

385

387 IO &IO, ELFYAML::ELF_ELFOSABI &Value) {

388#define ECase(X) IO.enumCase(Value, #X, ELF::X)

389 ECase(ELFOSABI_NONE);

390 ECase(ELFOSABI_HPUX);

391 ECase(ELFOSABI_NETBSD);

392 ECase(ELFOSABI_GNU);

393 ECase(ELFOSABI_LINUX);

394 ECase(ELFOSABI_HURD);

395 ECase(ELFOSABI_SOLARIS);

396 ECase(ELFOSABI_AIX);

397 ECase(ELFOSABI_IRIX);

398 ECase(ELFOSABI_FREEBSD);

399 ECase(ELFOSABI_TRU64);

400 ECase(ELFOSABI_MODESTO);

401 ECase(ELFOSABI_OPENBSD);

402 ECase(ELFOSABI_OPENVMS);

403 ECase(ELFOSABI_NSK);

404 ECase(ELFOSABI_AROS);

405 ECase(ELFOSABI_FENIXOS);

406 ECase(ELFOSABI_CLOUDABI);

407 ECase(ELFOSABI_AMDGPU_HSA);

408 ECase(ELFOSABI_AMDGPU_PAL);

409 ECase(ELFOSABI_AMDGPU_MESA3D);

410 ECase(ELFOSABI_ARM);

411 ECase(ELFOSABI_ARM_FDPIC);

412 ECase(ELFOSABI_C6000_ELFABI);

413 ECase(ELFOSABI_C6000_LINUX);

414 ECase(ELFOSABI_STANDALONE);

415#undef ECase

417}

418

420 ELFYAML::ELF_EF &Value) {

421 const auto *Object = static_cast<ELFYAML::Object *>(IO.getContext());

422 assert(Object && "The IO context is not initialized");

423#define BCase(X) IO.bitSetCase(Value, #X, ELF::X)

424#define BCaseMask(X, M) IO.maskedBitSetCase(Value, #X, ELF::X, ELF::M)

425 switch (Object->getMachine()) {

427 BCase(EF_ARM_SOFT_FLOAT);

428 BCase(EF_ARM_VFP_FLOAT);

429 BCaseMask(EF_ARM_EABI_UNKNOWN, EF_ARM_EABIMASK);

430 BCaseMask(EF_ARM_EABI_VER1, EF_ARM_EABIMASK);

431 BCaseMask(EF_ARM_EABI_VER2, EF_ARM_EABIMASK);

432 BCaseMask(EF_ARM_EABI_VER3, EF_ARM_EABIMASK);

433 BCaseMask(EF_ARM_EABI_VER4, EF_ARM_EABIMASK);

434 BCaseMask(EF_ARM_EABI_VER5, EF_ARM_EABIMASK);

435 BCaseMask(EF_ARM_BE8, EF_ARM_BE8);

436 break;

438 BCase(EF_MIPS_NOREORDER);

439 BCase(EF_MIPS_PIC);

440 BCase(EF_MIPS_CPIC);

441 BCase(EF_MIPS_ABI2);

442 BCase(EF_MIPS_32BITMODE);

443 BCase(EF_MIPS_FP64);

444 BCase(EF_MIPS_NAN2008);

445 BCase(EF_MIPS_MICROMIPS);

446 BCase(EF_MIPS_ARCH_ASE_M16);

447 BCase(EF_MIPS_ARCH_ASE_MDMX);

448 BCaseMask(EF_MIPS_ABI_O32, EF_MIPS_ABI);

449 BCaseMask(EF_MIPS_ABI_O64, EF_MIPS_ABI);

450 BCaseMask(EF_MIPS_ABI_EABI32, EF_MIPS_ABI);

451 BCaseMask(EF_MIPS_ABI_EABI64, EF_MIPS_ABI);

452 BCaseMask(EF_MIPS_MACH_3900, EF_MIPS_MACH);

453 BCaseMask(EF_MIPS_MACH_4010, EF_MIPS_MACH);

454 BCaseMask(EF_MIPS_MACH_4100, EF_MIPS_MACH);

455 BCaseMask(EF_MIPS_MACH_4650, EF_MIPS_MACH);

456 BCaseMask(EF_MIPS_MACH_4120, EF_MIPS_MACH);

457 BCaseMask(EF_MIPS_MACH_4111, EF_MIPS_MACH);

458 BCaseMask(EF_MIPS_MACH_SB1, EF_MIPS_MACH);

459 BCaseMask(EF_MIPS_MACH_OCTEON, EF_MIPS_MACH);

460 BCaseMask(EF_MIPS_MACH_XLR, EF_MIPS_MACH);

461 BCaseMask(EF_MIPS_MACH_OCTEON2, EF_MIPS_MACH);

462 BCaseMask(EF_MIPS_MACH_OCTEON3, EF_MIPS_MACH);

463 BCaseMask(EF_MIPS_MACH_5400, EF_MIPS_MACH);

464 BCaseMask(EF_MIPS_MACH_5900, EF_MIPS_MACH);

465 BCaseMask(EF_MIPS_MACH_5500, EF_MIPS_MACH);

466 BCaseMask(EF_MIPS_MACH_9000, EF_MIPS_MACH);

467 BCaseMask(EF_MIPS_MACH_LS2E, EF_MIPS_MACH);

468 BCaseMask(EF_MIPS_MACH_LS2F, EF_MIPS_MACH);

469 BCaseMask(EF_MIPS_MACH_LS3A, EF_MIPS_MACH);

470 BCaseMask(EF_MIPS_ARCH_1, EF_MIPS_ARCH);

471 BCaseMask(EF_MIPS_ARCH_2, EF_MIPS_ARCH);

472 BCaseMask(EF_MIPS_ARCH_3, EF_MIPS_ARCH);

473 BCaseMask(EF_MIPS_ARCH_4, EF_MIPS_ARCH);

474 BCaseMask(EF_MIPS_ARCH_5, EF_MIPS_ARCH);

475 BCaseMask(EF_MIPS_ARCH_32, EF_MIPS_ARCH);

476 BCaseMask(EF_MIPS_ARCH_64, EF_MIPS_ARCH);

477 BCaseMask(EF_MIPS_ARCH_32R2, EF_MIPS_ARCH);

478 BCaseMask(EF_MIPS_ARCH_64R2, EF_MIPS_ARCH);

479 BCaseMask(EF_MIPS_ARCH_32R6, EF_MIPS_ARCH);

480 BCaseMask(EF_MIPS_ARCH_64R6, EF_MIPS_ARCH);

481 break;

483 BCaseMask(EF_HEXAGON_MACH_V2, EF_HEXAGON_MACH);

484 BCaseMask(EF_HEXAGON_MACH_V3, EF_HEXAGON_MACH);

485 BCaseMask(EF_HEXAGON_MACH_V4, EF_HEXAGON_MACH);

486 BCaseMask(EF_HEXAGON_MACH_V5, EF_HEXAGON_MACH);

487 BCaseMask(EF_HEXAGON_MACH_V55, EF_HEXAGON_MACH);

488 BCaseMask(EF_HEXAGON_MACH_V60, EF_HEXAGON_MACH);

489 BCaseMask(EF_HEXAGON_MACH_V61, EF_HEXAGON_MACH);

490 BCaseMask(EF_HEXAGON_MACH_V62, EF_HEXAGON_MACH);

491 BCaseMask(EF_HEXAGON_MACH_V65, EF_HEXAGON_MACH);

492 BCaseMask(EF_HEXAGON_MACH_V66, EF_HEXAGON_MACH);

493 BCaseMask(EF_HEXAGON_MACH_V67, EF_HEXAGON_MACH);

494 BCaseMask(EF_HEXAGON_MACH_V67T, EF_HEXAGON_MACH);

495 BCaseMask(EF_HEXAGON_MACH_V68, EF_HEXAGON_MACH);

496 BCaseMask(EF_HEXAGON_MACH_V69, EF_HEXAGON_MACH);

497 BCaseMask(EF_HEXAGON_MACH_V71, EF_HEXAGON_MACH);

498 BCaseMask(EF_HEXAGON_MACH_V71T, EF_HEXAGON_MACH);

499 BCaseMask(EF_HEXAGON_MACH_V73, EF_HEXAGON_MACH);

500 BCaseMask(EF_HEXAGON_MACH_V75, EF_HEXAGON_MACH);

501 BCaseMask(EF_HEXAGON_MACH_V77, EF_HEXAGON_MACH);

502 BCaseMask(EF_HEXAGON_MACH_V79, EF_HEXAGON_MACH);

503 BCaseMask(EF_HEXAGON_MACH_V81, EF_HEXAGON_MACH);

504 BCaseMask(EF_HEXAGON_MACH_V83, EF_HEXAGON_MACH);

505 BCaseMask(EF_HEXAGON_MACH_V85, EF_HEXAGON_MACH);

506 BCaseMask(EF_HEXAGON_MACH_V87, EF_HEXAGON_MACH);

507 BCaseMask(EF_HEXAGON_MACH_V89, EF_HEXAGON_MACH);

508 BCaseMask(EF_HEXAGON_MACH_V91, EF_HEXAGON_MACH);

509 BCaseMask(EF_HEXAGON_ISA_V2, EF_HEXAGON_ISA);

510 BCaseMask(EF_HEXAGON_ISA_V3, EF_HEXAGON_ISA);

511 BCaseMask(EF_HEXAGON_ISA_V4, EF_HEXAGON_ISA);

512 BCaseMask(EF_HEXAGON_ISA_V5, EF_HEXAGON_ISA);

513 BCaseMask(EF_HEXAGON_ISA_V55, EF_HEXAGON_ISA);

514 BCaseMask(EF_HEXAGON_ISA_V60, EF_HEXAGON_ISA);

515 BCaseMask(EF_HEXAGON_ISA_V61, EF_HEXAGON_ISA);

516 BCaseMask(EF_HEXAGON_ISA_V62, EF_HEXAGON_ISA);

517 BCaseMask(EF_HEXAGON_ISA_V65, EF_HEXAGON_ISA);

518 BCaseMask(EF_HEXAGON_ISA_V66, EF_HEXAGON_ISA);

519 BCaseMask(EF_HEXAGON_ISA_V67, EF_HEXAGON_ISA);

520 BCaseMask(EF_HEXAGON_ISA_V68, EF_HEXAGON_ISA);

521 BCaseMask(EF_HEXAGON_ISA_V69, EF_HEXAGON_ISA);

522 BCaseMask(EF_HEXAGON_ISA_V71, EF_HEXAGON_ISA);

523 BCaseMask(EF_HEXAGON_ISA_V73, EF_HEXAGON_ISA);

524 BCaseMask(EF_HEXAGON_ISA_V75, EF_HEXAGON_ISA);

525 BCaseMask(EF_HEXAGON_ISA_V77, EF_HEXAGON_ISA);

526 BCaseMask(EF_HEXAGON_ISA_V79, EF_HEXAGON_ISA);

527 BCaseMask(EF_HEXAGON_ISA_V81, EF_HEXAGON_ISA);

528 BCaseMask(EF_HEXAGON_ISA_V83, EF_HEXAGON_ISA);

529 BCaseMask(EF_HEXAGON_ISA_V85, EF_HEXAGON_ISA);

530 BCaseMask(EF_HEXAGON_ISA_V87, EF_HEXAGON_ISA);

531 BCaseMask(EF_HEXAGON_ISA_V89, EF_HEXAGON_ISA);

532 BCaseMask(EF_HEXAGON_ISA_V91, EF_HEXAGON_ISA);

533 break;

535 BCaseMask(EF_AVR_ARCH_AVR1, EF_AVR_ARCH_MASK);

536 BCaseMask(EF_AVR_ARCH_AVR2, EF_AVR_ARCH_MASK);

537 BCaseMask(EF_AVR_ARCH_AVR25, EF_AVR_ARCH_MASK);

538 BCaseMask(EF_AVR_ARCH_AVR3, EF_AVR_ARCH_MASK);

539 BCaseMask(EF_AVR_ARCH_AVR31, EF_AVR_ARCH_MASK);

540 BCaseMask(EF_AVR_ARCH_AVR35, EF_AVR_ARCH_MASK);

541 BCaseMask(EF_AVR_ARCH_AVR4, EF_AVR_ARCH_MASK);

542 BCaseMask(EF_AVR_ARCH_AVR5, EF_AVR_ARCH_MASK);

543 BCaseMask(EF_AVR_ARCH_AVR51, EF_AVR_ARCH_MASK);

544 BCaseMask(EF_AVR_ARCH_AVR6, EF_AVR_ARCH_MASK);

545 BCaseMask(EF_AVR_ARCH_AVRTINY, EF_AVR_ARCH_MASK);

546 BCaseMask(EF_AVR_ARCH_XMEGA1, EF_AVR_ARCH_MASK);

547 BCaseMask(EF_AVR_ARCH_XMEGA2, EF_AVR_ARCH_MASK);

548 BCaseMask(EF_AVR_ARCH_XMEGA3, EF_AVR_ARCH_MASK);

549 BCaseMask(EF_AVR_ARCH_XMEGA4, EF_AVR_ARCH_MASK);

550 BCaseMask(EF_AVR_ARCH_XMEGA5, EF_AVR_ARCH_MASK);

551 BCaseMask(EF_AVR_ARCH_XMEGA6, EF_AVR_ARCH_MASK);

552 BCaseMask(EF_AVR_ARCH_XMEGA7, EF_AVR_ARCH_MASK);

553 BCase(EF_AVR_LINKRELAX_PREPARED);

554 break;

556 BCaseMask(EF_LOONGARCH_ABI_SOFT_FLOAT, EF_LOONGARCH_ABI_MODIFIER_MASK);

557 BCaseMask(EF_LOONGARCH_ABI_SINGLE_FLOAT, EF_LOONGARCH_ABI_MODIFIER_MASK);

558 BCaseMask(EF_LOONGARCH_ABI_DOUBLE_FLOAT, EF_LOONGARCH_ABI_MODIFIER_MASK);

559 BCaseMask(EF_LOONGARCH_OBJABI_V0, EF_LOONGARCH_OBJABI_MASK);

560 BCaseMask(EF_LOONGARCH_OBJABI_V1, EF_LOONGARCH_OBJABI_MASK);

561 break;

563 BCase(EF_RISCV_RVC);

564 BCaseMask(EF_RISCV_FLOAT_ABI_SOFT, EF_RISCV_FLOAT_ABI);

565 BCaseMask(EF_RISCV_FLOAT_ABI_SINGLE, EF_RISCV_FLOAT_ABI);

566 BCaseMask(EF_RISCV_FLOAT_ABI_DOUBLE, EF_RISCV_FLOAT_ABI);

567 BCaseMask(EF_RISCV_FLOAT_ABI_QUAD, EF_RISCV_FLOAT_ABI);

568 BCase(EF_RISCV_RVE);

569 BCase(EF_RISCV_TSO);

570 break;

572 BCase(EF_SPARC_32PLUS);

573 BCase(EF_SPARC_SUN_US1);

574 BCase(EF_SPARC_SUN_US3);

575 BCase(EF_SPARC_HAL_R1);

576 break;

578 BCase(EF_SPARC_SUN_US1);

579 BCase(EF_SPARC_SUN_US3);

580 BCase(EF_SPARC_HAL_R1);

581 BCaseMask(EF_SPARCV9_RMO, EF_SPARCV9_MM);

582 BCaseMask(EF_SPARCV9_PSO, EF_SPARCV9_MM);

583 BCaseMask(EF_SPARCV9_TSO, EF_SPARCV9_MM);

584 break;

586 BCase(EF_XTENSA_XT_INSN);

587 BCaseMask(EF_XTENSA_MACH_NONE, EF_XTENSA_MACH);

588 BCase(EF_XTENSA_XT_LIT);

589 break;

591 BCaseMask(EF_AMDGPU_MACH_NONE, EF_AMDGPU_MACH);

592 BCaseMask(EF_AMDGPU_MACH_R600_R600, EF_AMDGPU_MACH);

593 BCaseMask(EF_AMDGPU_MACH_R600_R630, EF_AMDGPU_MACH);

594 BCaseMask(EF_AMDGPU_MACH_R600_RS880, EF_AMDGPU_MACH);

595 BCaseMask(EF_AMDGPU_MACH_R600_RV670, EF_AMDGPU_MACH);

596 BCaseMask(EF_AMDGPU_MACH_R600_RV710, EF_AMDGPU_MACH);

597 BCaseMask(EF_AMDGPU_MACH_R600_RV730, EF_AMDGPU_MACH);

598 BCaseMask(EF_AMDGPU_MACH_R600_RV770, EF_AMDGPU_MACH);

599 BCaseMask(EF_AMDGPU_MACH_R600_CEDAR, EF_AMDGPU_MACH);

600 BCaseMask(EF_AMDGPU_MACH_R600_CYPRESS, EF_AMDGPU_MACH);

601 BCaseMask(EF_AMDGPU_MACH_R600_JUNIPER, EF_AMDGPU_MACH);

602 BCaseMask(EF_AMDGPU_MACH_R600_REDWOOD, EF_AMDGPU_MACH);

603 BCaseMask(EF_AMDGPU_MACH_R600_SUMO, EF_AMDGPU_MACH);

604 BCaseMask(EF_AMDGPU_MACH_R600_BARTS, EF_AMDGPU_MACH);

605 BCaseMask(EF_AMDGPU_MACH_R600_CAICOS, EF_AMDGPU_MACH);

606 BCaseMask(EF_AMDGPU_MACH_R600_CAYMAN, EF_AMDGPU_MACH);

607 BCaseMask(EF_AMDGPU_MACH_R600_TURKS, EF_AMDGPU_MACH);

608 BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX600, EF_AMDGPU_MACH);

609 BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX601, EF_AMDGPU_MACH);

610 BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX602, EF_AMDGPU_MACH);

611 BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX700, EF_AMDGPU_MACH);

612 BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX701, EF_AMDGPU_MACH);

613 BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX702, EF_AMDGPU_MACH);

614 BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX703, EF_AMDGPU_MACH);

615 BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX704, EF_AMDGPU_MACH);

616 BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX705, EF_AMDGPU_MACH);

617 BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX801, EF_AMDGPU_MACH);

618 BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX802, EF_AMDGPU_MACH);

619 BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX803, EF_AMDGPU_MACH);

620 BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX805, EF_AMDGPU_MACH);

621 BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX810, EF_AMDGPU_MACH);

622 BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX900, EF_AMDGPU_MACH);

623 BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX902, EF_AMDGPU_MACH);

624 BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX904, EF_AMDGPU_MACH);

625 BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX906, EF_AMDGPU_MACH);

626 BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX908, EF_AMDGPU_MACH);

627 BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX909, EF_AMDGPU_MACH);

628 BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX90A, EF_AMDGPU_MACH);

629 BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX90C, EF_AMDGPU_MACH);

630 BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX942, EF_AMDGPU_MACH);

631 BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX950, EF_AMDGPU_MACH);

632 BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX1010, EF_AMDGPU_MACH);

633 BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX1011, EF_AMDGPU_MACH);

634 BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX1012, EF_AMDGPU_MACH);

635 BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX1013, EF_AMDGPU_MACH);

636 BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX1030, EF_AMDGPU_MACH);

637 BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX1031, EF_AMDGPU_MACH);

638 BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX1032, EF_AMDGPU_MACH);

639 BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX1033, EF_AMDGPU_MACH);

640 BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX1034, EF_AMDGPU_MACH);

641 BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX1035, EF_AMDGPU_MACH);

642 BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX1036, EF_AMDGPU_MACH);

643 BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX1100, EF_AMDGPU_MACH);

644 BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX1101, EF_AMDGPU_MACH);

645 BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX1102, EF_AMDGPU_MACH);

646 BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX1103, EF_AMDGPU_MACH);

647 BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX1150, EF_AMDGPU_MACH);

648 BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX1151, EF_AMDGPU_MACH);

649 BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX1152, EF_AMDGPU_MACH);

650 BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX1153, EF_AMDGPU_MACH);

651 BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX1200, EF_AMDGPU_MACH);

652 BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX1201, EF_AMDGPU_MACH);

653 BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX1250, EF_AMDGPU_MACH);

654 BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX1251, EF_AMDGPU_MACH);

655 BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX9_GENERIC, EF_AMDGPU_MACH);

656 BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX9_4_GENERIC, EF_AMDGPU_MACH);

657 BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX10_1_GENERIC, EF_AMDGPU_MACH);

658 BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX10_3_GENERIC, EF_AMDGPU_MACH);

659 BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX11_GENERIC, EF_AMDGPU_MACH);

660 BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX12_GENERIC, EF_AMDGPU_MACH);

661 switch (Object->Header.ABIVersion) {

662 default:

663

664 [[fallthrough]];

666 BCase(EF_AMDGPU_FEATURE_XNACK_V3);

667 BCase(EF_AMDGPU_FEATURE_SRAMECC_V3);

668 break;

672 std::string Key = "EF_AMDGPU_GENERIC_VERSION_V" + std::to_string(K);

676 }

677 [[fallthrough]];

680 BCaseMask(EF_AMDGPU_FEATURE_XNACK_UNSUPPORTED_V4,

681 EF_AMDGPU_FEATURE_XNACK_V4);

682 BCaseMask(EF_AMDGPU_FEATURE_XNACK_ANY_V4,

683 EF_AMDGPU_FEATURE_XNACK_V4);

684 BCaseMask(EF_AMDGPU_FEATURE_XNACK_OFF_V4,

685 EF_AMDGPU_FEATURE_XNACK_V4);

686 BCaseMask(EF_AMDGPU_FEATURE_XNACK_ON_V4,

687 EF_AMDGPU_FEATURE_XNACK_V4);

688 BCaseMask(EF_AMDGPU_FEATURE_SRAMECC_UNSUPPORTED_V4,

689 EF_AMDGPU_FEATURE_SRAMECC_V4);

690 BCaseMask(EF_AMDGPU_FEATURE_SRAMECC_ANY_V4,

691 EF_AMDGPU_FEATURE_SRAMECC_V4);

692 BCaseMask(EF_AMDGPU_FEATURE_SRAMECC_OFF_V4,

693 EF_AMDGPU_FEATURE_SRAMECC_V4);

694 BCaseMask(EF_AMDGPU_FEATURE_SRAMECC_ON_V4,

695 EF_AMDGPU_FEATURE_SRAMECC_V4);

696 break;

697 }

698 break;

699 default:

700 break;

701 }

702#undef BCase

703#undef BCaseMask

704}

705

707 IO &IO, ELFYAML::ELF_SHT &Value) {

708 const auto *Object = static_cast<ELFYAML::Object *>(IO.getContext());

709 assert(Object && "The IO context is not initialized");

710#define ECase(X) IO.enumCase(Value, #X, ELF::X)

712 ECase(SHT_PROGBITS);

713 ECase(SHT_SYMTAB);

714

715 ECase(SHT_STRTAB);

718 ECase(SHT_DYNAMIC);

720 ECase(SHT_NOBITS);

722 ECase(SHT_SHLIB);

723 ECase(SHT_DYNSYM);

724 ECase(SHT_INIT_ARRAY);

725 ECase(SHT_FINI_ARRAY);

726 ECase(SHT_PREINIT_ARRAY);

727 ECase(SHT_GROUP);

728 ECase(SHT_SYMTAB_SHNDX);

731 ECase(SHT_ANDROID_REL);

732 ECase(SHT_ANDROID_RELA);

733 ECase(SHT_ANDROID_RELR);

734 ECase(SHT_LLVM_ODRTAB);

735 ECase(SHT_LLVM_LINKER_OPTIONS);

736 ECase(SHT_LLVM_CALL_GRAPH_PROFILE);

737 ECase(SHT_LLVM_ADDRSIG);

738 ECase(SHT_LLVM_DEPENDENT_LIBRARIES);

739 ECase(SHT_LLVM_SYMPART);

740 ECase(SHT_LLVM_PART_EHDR);

741 ECase(SHT_LLVM_PART_PHDR);

742 ECase(SHT_LLVM_BB_ADDR_MAP);

743 ECase(SHT_LLVM_OFFLOADING);

744 ECase(SHT_LLVM_LTO);

745 ECase(SHT_LLVM_CALL_GRAPH);

746 ECase(SHT_GNU_SFRAME);

747 ECase(SHT_GNU_ATTRIBUTES);

748 ECase(SHT_GNU_HASH);

749 ECase(SHT_GNU_verdef);

750 ECase(SHT_GNU_verneed);

751 ECase(SHT_GNU_versym);

752 switch (Object->getMachine()) {

754 ECase(SHT_ARM_EXIDX);

755 ECase(SHT_ARM_PREEMPTMAP);

756 ECase(SHT_ARM_ATTRIBUTES);

757 ECase(SHT_ARM_DEBUGOVERLAY);

758 ECase(SHT_ARM_OVERLAYSECTION);

759 break;

761 ECase(SHT_HEX_ORDERED);

762 ECase(SHT_HEXAGON_ATTRIBUTES);

763 break;

765 ECase(SHT_X86_64_UNWIND);

766 break;

768 ECase(SHT_MIPS_REGINFO);

769 ECase(SHT_MIPS_OPTIONS);

770 ECase(SHT_MIPS_DWARF);

771 ECase(SHT_MIPS_ABIFLAGS);

772 break;

774 ECase(SHT_RISCV_ATTRIBUTES);

775 break;

777 ECase(SHT_MSP430_ATTRIBUTES);

778 break;

780 ECase(SHT_AARCH64_AUTH_RELR);

781 ECase(SHT_AARCH64_MEMTAG_GLOBALS_STATIC);

782 ECase(SHT_AARCH64_MEMTAG_GLOBALS_DYNAMIC);

783 break;

784 default:

785

786 break;

787 }

788#undef ECase

790}

791

793 ELFYAML::ELF_PF &Value) {

794#define BCase(X) IO.bitSetCase(Value, #X, ELF::X)

798}

799

801 ELFYAML::ELF_SHF &Value) {

802 const auto *Object = static_cast<ELFYAML::Object *>(IO.getContext());

803#define BCase(X) IO.bitSetCase(Value, #X, ELF::X)

804 BCase(SHF_WRITE);

805 BCase(SHF_ALLOC);

806 BCase(SHF_EXCLUDE);

807 BCase(SHF_EXECINSTR);

808 BCase(SHF_MERGE);

809 BCase(SHF_STRINGS);

810 BCase(SHF_INFO_LINK);

811 BCase(SHF_LINK_ORDER);

812 BCase(SHF_OS_NONCONFORMING);

813 BCase(SHF_GROUP);

815 BCase(SHF_COMPRESSED);

816 switch (Object->getOSAbi()) {

818 BCase(SHF_SUNW_NODISCARD);

819 break;

820 default:

821 BCase(SHF_GNU_RETAIN);

822 break;

823 }

824 switch (Object->getMachine()) {

826 BCase(SHF_AARCH64_PURECODE);

827 break;

829 BCase(SHF_ARM_PURECODE);

830 break;

832 BCase(SHF_HEX_GPREL);

833 break;

835 BCase(SHF_MIPS_NODUPES);

836 BCase(SHF_MIPS_NAMES);

837 BCase(SHF_MIPS_LOCAL);

838 BCase(SHF_MIPS_NOSTRIP);

839 BCase(SHF_MIPS_GPREL);

840 BCase(SHF_MIPS_MERGE);

841 BCase(SHF_MIPS_ADDR);

842 BCase(SHF_MIPS_STRING);

843 break;

845 BCase(SHF_X86_64_LARGE);

846 break;

847 default:

848

849 break;

850 }

851#undef BCase

852}

853

855 IO &IO, ELFYAML::ELF_SHN &Value) {

856 const auto *Object = static_cast<ELFYAML::Object *>(IO.getContext());

857 assert(Object && "The IO context is not initialized");

858#define ECase(X) IO.enumCase(Value, #X, ELF::X)

859 ECase(SHN_UNDEF);

860 ECase(SHN_LORESERVE);

861 ECase(SHN_LOPROC);

862 ECase(SHN_HIPROC);

866 ECase(SHN_COMMON);

867 ECase(SHN_XINDEX);

868 ECase(SHN_HIRESERVE);

869 ECase(SHN_AMDGPU_LDS);

870

872 ECase(SHN_MIPS_ACOMMON);

873 ECase(SHN_MIPS_TEXT);

874 ECase(SHN_MIPS_DATA);

875 ECase(SHN_MIPS_SCOMMON);

876 ECase(SHN_MIPS_SUNDEFINED);

877 }

878

879 ECase(SHN_HEXAGON_SCOMMON);

880 ECase(SHN_HEXAGON_SCOMMON_1);

881 ECase(SHN_HEXAGON_SCOMMON_2);

882 ECase(SHN_HEXAGON_SCOMMON_4);

883 ECase(SHN_HEXAGON_SCOMMON_8);

884#undef ECase

886}

887

889 IO &IO, ELFYAML::ELF_STB &Value) {

890#define ECase(X) IO.enumCase(Value, #X, ELF::X)

891 ECase(STB_LOCAL);

892 ECase(STB_GLOBAL);

894 ECase(STB_GNU_UNIQUE);

895#undef ECase

897}

898

900 IO &IO, ELFYAML::ELF_STT &Value) {

901#define ECase(X) IO.enumCase(Value, #X, ELF::X)

902 ECase(STT_NOTYPE);

903 ECase(STT_OBJECT);

905 ECase(STT_SECTION);

907 ECase(STT_COMMON);

909 ECase(STT_GNU_IFUNC);

910#undef ECase

912}

913

914

916 IO &IO, ELFYAML::ELF_RSS &Value) {

917#define ECase(X) IO.enumCase(Value, #X, ELF::X)

918 ECase(RSS_UNDEF);

922#undef ECase

923}

924

926 IO &IO, ELFYAML::ELF_REL &Value) {

927 const auto *Object = static_cast<ELFYAML::Object *>(IO.getContext());

928 assert(Object && "The IO context is not initialized");

929#define ELF_RELOC(X, Y) IO.enumCase(Value, #X, ELF::X);

930 switch (Object->getMachine()) {

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

933 break;

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

936 break;

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

939 break;

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

943 break;

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

946 break;

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

949 break;

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

952 break;

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

955 break;

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

958 break;

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

961 break;

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

964 break;

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

967 break;

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

970 break;

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

973 break;

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

976 break;

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

979 break;

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

982 break;

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

985 break;

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

988 break;

989 default:

990

991 break;

992 }

993#undef ELF_RELOC

995}

996

998 IO &IO, ELFYAML::ELF_DYNTAG &Value) {

999 const auto *Object = static_cast<ELFYAML::Object *>(IO.getContext());

1000 assert(Object && "The IO context is not initialized");

1001

1002

1003#define AARCH64_DYNAMIC_TAG(name, value)

1004#define MIPS_DYNAMIC_TAG(name, value)

1005#define HEXAGON_DYNAMIC_TAG(name, value)

1006#define PPC_DYNAMIC_TAG(name, value)

1007#define PPC64_DYNAMIC_TAG(name, value)

1008

1009#define DYNAMIC_TAG_MARKER(name, value)

1010

1011#define STRINGIFY(X) (#X)

1012#define DYNAMIC_TAG(X, Y) IO.enumCase(Value, STRINGIFY(DT_##X), ELF::DT_##X);

1013 switch (Object->getMachine()) {

1015#undef AARCH64_DYNAMIC_TAG

1016#define AARCH64_DYNAMIC_TAG(name, value) DYNAMIC_TAG(name, value)

1017#include "llvm/BinaryFormat/DynamicTags.def"

1018#undef AARCH64_DYNAMIC_TAG

1019#define AARCH64_DYNAMIC_TAG(name, value)

1020 break;

1022#undef MIPS_DYNAMIC_TAG

1023#define MIPS_DYNAMIC_TAG(name, value) DYNAMIC_TAG(name, value)

1024#include "llvm/BinaryFormat/DynamicTags.def"

1025#undef MIPS_DYNAMIC_TAG

1026#define MIPS_DYNAMIC_TAG(name, value)

1027 break;

1029#undef HEXAGON_DYNAMIC_TAG

1030#define HEXAGON_DYNAMIC_TAG(name, value) DYNAMIC_TAG(name, value)

1031#include "llvm/BinaryFormat/DynamicTags.def"

1032#undef HEXAGON_DYNAMIC_TAG

1033#define HEXAGON_DYNAMIC_TAG(name, value)

1034 break;

1036#undef PPC_DYNAMIC_TAG

1037#define PPC_DYNAMIC_TAG(name, value) DYNAMIC_TAG(name, value)

1038#include "llvm/BinaryFormat/DynamicTags.def"

1039#undef PPC_DYNAMIC_TAG

1040#define PPC_DYNAMIC_TAG(name, value)

1041 break;

1043#undef PPC64_DYNAMIC_TAG

1044#define PPC64_DYNAMIC_TAG(name, value) DYNAMIC_TAG(name, value)

1045#include "llvm/BinaryFormat/DynamicTags.def"

1046#undef PPC64_DYNAMIC_TAG

1047#define PPC64_DYNAMIC_TAG(name, value)

1048 break;

1050#undef RISCV_DYNAMIC_TAG

1051#define RISCV_DYNAMIC_TAG(name, value) DYNAMIC_TAG(name, value)

1052#include "llvm/BinaryFormat/DynamicTags.def"

1053#undef RISCV_DYNAMIC_TAG

1054#define RISCV_DYNAMIC_TAG(name, value)

1055 break;

1057#undef SPARC_DYNAMIC_TAG

1058#define SPARC_DYNAMIC_TAG(name, value) DYNAMIC_TAG(name, value)

1059#include "llvm/BinaryFormat/DynamicTags.def"

1060#undef SPARC_DYNAMIC_TAG

1061#define SPARC_DYNAMIC_TAG(name, value)

1062 break;

1063 default:

1064#include "llvm/BinaryFormat/DynamicTags.def"

1065 break;

1066 }

1067#undef AARCH64_DYNAMIC_TAG

1068#undef MIPS_DYNAMIC_TAG

1069#undef HEXAGON_DYNAMIC_TAG

1070#undef PPC_DYNAMIC_TAG

1071#undef PPC64_DYNAMIC_TAG

1072#undef DYNAMIC_TAG_MARKER

1073#undef STRINGIFY

1074#undef DYNAMIC_TAG

1075

1077}

1078

1080 IO &IO, ELFYAML::MIPS_AFL_REG &Value) {

1081#define ECase(X) IO.enumCase(Value, #X, Mips::AFL_##X)

1082 ECase(REG_NONE);

1086#undef ECase

1087}

1088

1090 IO &IO, ELFYAML::MIPS_ABI_FP &Value) {

1091#define ECase(X) IO.enumCase(Value, #X, Mips::Val_GNU_MIPS_ABI_##X)

1093 ECase(FP_DOUBLE);

1094 ECase(FP_SINGLE);

1096 ECase(FP_OLD_64);

1100#undef ECase

1101}

1102

1104 IO &IO, ELFYAML::MIPS_AFL_EXT &Value) {

1105#define ECase(X) IO.enumCase(Value, #X, Mips::AFL_##X)

1106 ECase(EXT_NONE);

1108 ECase(EXT_OCTEON2);

1109 ECase(EXT_OCTEONP);

1110 ECase(EXT_LOONGSON_3A);

1111 ECase(EXT_OCTEON);

1112 ECase(EXT_5900);

1113 ECase(EXT_4650);

1114 ECase(EXT_4010);

1115 ECase(EXT_4100);

1116 ECase(EXT_3900);

1117 ECase(EXT_10000);

1119 ECase(EXT_4111);

1120 ECase(EXT_4120);

1121 ECase(EXT_5400);

1122 ECase(EXT_5500);

1123 ECase(EXT_LOONGSON_2E);

1124 ECase(EXT_LOONGSON_2F);

1125 ECase(EXT_OCTEON3);

1126#undef ECase

1127}

1128

1130 IO &IO, ELFYAML::MIPS_ISA &Value) {

1139}

1140

1142 IO &IO, ELFYAML::MIPS_AFL_ASE &Value) {

1143#define BCase(X) IO.bitSetCase(Value, #X, Mips::AFL_ASE_##X)

1151 BCase(SMARTMIPS);

1155 BCase(MICROMIPS);

1159#undef BCase

1160}

1161

1163 IO &IO, ELFYAML::MIPS_AFL_FLAGS1 &Value) {

1164#define BCase(X) IO.bitSetCase(Value, #X, Mips::AFL_FLAGS1_##X)

1165 BCase(ODDSPREG);

1166#undef BCase

1167}

1168

1170 IO &IO, ELFYAML::SectionHeader &SHdr) {

1172}

1173

1175 ELFYAML::FileHeader &FileHdr) {

1178 IO.mapOptional("OSABI", FileHdr.OSABI, ELFYAML::ELF_ELFOSABI(0));

1179 IO.mapOptional("ABIVersion", FileHdr.ABIVersion, Hex8(0));

1183 IO.mapOptional("Entry", FileHdr.Entry, Hex64(0));

1184 IO.mapOptional("SectionHeaderStringTable", FileHdr.SectionHeaderStringTable);

1185

1186

1188 (!FileHdr.EPhOff && !FileHdr.EPhEntSize && !FileHdr.EPhNum));

1190 IO.mapOptional("EPhEntSize", FileHdr.EPhEntSize);

1192 IO.mapOptional("EShEntSize", FileHdr.EShEntSize);

1196}

1197

1199 IO &IO, ELFYAML::ProgramHeader &Phdr) {

1201 IO.mapOptional("Flags", Phdr.Flags, ELFYAML::ELF_PF(0));

1205 IO.mapOptional("PAddr", Phdr.PAddr, Phdr.VAddr);

1210}

1211

1213 IO &IO, ELFYAML::ProgramHeader &FileHdr) {

1214 if (!FileHdr.FirstSec && FileHdr.LastSec)

1215 return "the \"LastSec\" key can't be used without the \"FirstSec\" key";

1216 if (FileHdr.FirstSec && !FileHdr.LastSec)

1217 return "the \"FirstSec\" key can't be used without the \"LastSec\" key";

1218 return "";

1219}

1220

1222

1234 static const bool flow = true;

1235};

1236

1238 static void output(const ELFYAML::YAMLFlowString &Val, void *,

1240 Out << Val;

1241 }

1243 ELFYAML::YAMLFlowString &Val) {

1245 return {};

1246 }

1250};

1252 static const bool flow = true;

1253};

1254

1255namespace {

1256

1257struct NormalizedOther {

1258 NormalizedOther(IO &IO) : YamlIO(IO) {}

1259 NormalizedOther(IO &IO, std::optional<uint8_t> Original) : YamlIO(IO) {

1260 assert(Original && "This constructor is only used for outputting YAML and "

1261 "assumes a non-empty Original");

1262 std::vector Ret;

1263 const auto *Object = static_cast<ELFYAML::Object *>(YamlIO.getContext());

1264 for (std::pair<StringRef, uint8_t> &P :

1265 getFlags(Object->getMachine()).takeVector()) {

1266 uint8_t FlagValue = P.second;

1267 if ((*Original & FlagValue) != FlagValue)

1268 continue;

1269 *Original &= ~FlagValue;

1270 Ret.push_back({P.first});

1271 }

1272

1273 if (*Original != 0) {

1274 UnknownFlagsHolder = std::to_string(*Original);

1275 Ret.push_back({UnknownFlagsHolder});

1276 }

1277

1278 if (!Ret.empty())

1279 Other = std::move(Ret);

1280 }

1281

1283 const auto *Object = static_cast<ELFYAML::Object *>(YamlIO.getContext());

1285

1286 auto It = Flags.find(Name);

1287 if (It != Flags.end())

1288 return It->second;

1289

1292 return Val;

1293

1294 YamlIO.setError("an unknown value is used for symbol's 'Other' field: " +

1295 Name);

1296 return 0;

1297 }

1298

1299 std::optional<uint8_t> denormalize(IO &) {

1301 return std::nullopt;

1303 for (StOtherPiece &Val : *Other)

1304 Ret |= toValue(Val);

1305 return Ret;

1306 }

1307

1308

1309

1310

1313

1314

1315

1316

1317

1321

1322

1323

1324 if (!YamlIO.outputting())

1326

1327

1328

1329

1330

1337 }

1338

1343 return Map;

1344 }

1345

1346 IO &YamlIO;

1347 std::optional<std::vector> Other;

1348 std::string UnknownFlagsHolder;

1349};

1350

1351}

1352

1353void ScalarTraitsELFYAML::YAMLIntUInt::output(const ELFYAML::YAMLIntUInt &Val,

1354 void *Ctx, raw_ostream &Out) {

1355 Out << Val;

1356}

1357

1359 ELFYAML::YAMLIntUInt &Val) {

1360 const bool Is64 = static_cast<ELFYAML::Object *>(Ctx)->Header.Class ==

1362 StringRef ErrMsg = "invalid number";

1363

1364

1365 if (Scalar.empty() || Scalar.starts_with("-0x"))

1366 return ErrMsg;

1367

1368 if (Scalar.starts_with("-")) {

1369 const int64_t MinVal = Is64 ? INT64_MIN : INT32_MIN;

1370 long long Int;

1372 return ErrMsg;

1373 Val = Int;

1374 return "";

1375 }

1376

1377 const uint64_t MaxVal = Is64 ? UINT64_MAX : UINT32_MAX;

1378 unsigned long long UInt;

1380 return ErrMsg;

1382 return "";

1383}

1384

1394

1395

1396

1397

1398

1399

1403}

1404

1406 ELFYAML::Symbol &Symbol) {

1408 return "Index and Section cannot both be specified for Symbol";

1409 return "";

1410}

1411

1418 IO.mapOptional("AddressAlign", Section.AddressAlign, Hex64(0));

1421

1424

1425

1426

1427

1429 (!Section.ShOffset && !Section.ShSize && !Section.ShName &&

1430 !Section.ShFlags && !Section.ShType && !Section.ShAddrAlign));

1431 IO.mapOptional("ShAddrAlign", Section.ShAddrAlign);

1437}

1438

1443

1446

1447

1448

1450 IO.mapOptional("ContentArray", Section.ContentBuf);

1451 if (Section.ContentBuf) {

1452 if (Section.Content)

1453 IO.setError("Content and ContentArray can't be used together");

1455 }

1456

1458}

1459

1466

1471

1483

1488

1489

1500

1506

1511

1517

1523

1528

1534

1539

1544

1551

1559

1564

1570

1575

1576void MappingTraitsELFYAML::SectionOrType::mapping(

1578 IO.mapRequired("SectionOrType", sectionOrType.sectionNameOrType);

1579}

1580

1585

1588 IO.mapOptional("Version", Section.Version, Hex16(0));

1590 IO.mapOptional("ISARevision", Section.ISARevision, Hex8(0));

1591 IO.mapOptional("ISAExtension", Section.ISAExtension,

1593 IO.mapOptional("ASEs", Section.ASEs, ELFYAML::MIPS_AFL_ASE(0));

1602 IO.mapOptional("Flags1", Section.Flags1, ELFYAML::MIPS_AFL_FLAGS1(0));

1603 IO.mapOptional("Flags2", Section.Flags2, Hex32(0));

1604}

1605

1611

1615

1620

1621void MappingTraits<std::unique_ptrELFYAML::Chunk>::mapping(

1622 IO &IO, std::unique_ptrELFYAML::Chunk &Section) {

1625 if (IO.outputting()) {

1629 TypeStr = SHT->TypeStr;

1630 } else {

1631

1632

1635 IO.mapRequired("Type", Type);

1636 }

1637

1638 if (TypeStr == "Fill") {

1640 Section.reset(new ELFYAML::Fill());

1642 return;

1643 }

1644

1648 else

1649 Section.reset(new ELFYAML::SectionHeaderTable(false));

1650

1653 return;

1654 }

1655

1656 const auto &Obj = *static_cast<ELFYAML::Object *>(IO.getContext());

1659 Section.reset(new ELFYAML::MipsABIFlags());

1661 return;

1662 }

1663

1666 Section.reset(new ELFYAML::ARMIndexTableSection());

1668 return;

1669 }

1670

1671 switch (Type) {

1674 Section.reset(new ELFYAML::DynamicSection());

1676 break;

1681 Section.reset(new ELFYAML::RelocationSection());

1683 break;

1686 Section.reset(new ELFYAML::RelrSection());

1688 break;

1691 Section.reset(new ELFYAML::GroupSection());

1693 break;

1696 Section.reset(new ELFYAML::NoBitsSection());

1698 break;

1701 Section.reset(new ELFYAML::HashSection());

1703 break;

1706 Section.reset(new ELFYAML::NoteSection());

1708 break;

1711 Section.reset(new ELFYAML::GnuHashSection());

1713 break;

1716 Section.reset(new ELFYAML::VerdefSection());

1718 break;

1721 Section.reset(new ELFYAML::SymverSection());

1723 break;

1726 Section.reset(new ELFYAML::VerneedSection());

1728 break;

1731 Section.reset(new ELFYAML::SymtabShndxSection());

1733 break;

1736 Section.reset(new ELFYAML::AddrsigSection());

1738 break;

1741 Section.reset(new ELFYAML::LinkerOptionsSection());

1743 break;

1746 Section.reset(new ELFYAML::DependentLibrariesSection());

1749 break;

1752 Section.reset(new ELFYAML::CallGraphProfileSection());

1754 break;

1757 Section.reset(new ELFYAML::BBAddrMapSection());

1759 break;

1760 default:

1762 StringRef Name;

1765

1767 Section = std::make_uniqueELFYAML::StackSizesSection();

1768 else

1769 Section = std::make_uniqueELFYAML::RawContentSection();

1770 }

1771

1774 else

1776 }

1777}

1778

1780 IO &io, std::unique_ptrELFYAML::Chunk &C) {

1782

1783

1784 if (!io.error() && F->Pattern && F->Pattern->binary_size() != 0 && ->Size)

1785 return "\"Size\" can't be 0 when \"Pattern\" is not empty";

1786 return "";

1787 }

1788

1790 if (SHT->NoHeaders && (SHT->Sections || SHT->Excluded || SHT->Offset))

1791 return "NoHeaders can't be used together with Offset/Sections/Excluded";

1792 return "";

1793 }

1794

1796 if (Sec.Size && Sec.Content &&

1797 (uint64_t)(*Sec.Size) < Sec.Content->binary_size())

1798 return "Section size must be greater than or equal to the content size";

1799

1801 std::string Msg;

1802 for (size_t I = 0, E = EntV.size(); I != E; ++I) {

1803 StringRef Name = EntV[I].first;

1804 if (I == 0) {

1805 Msg = "\"" + Name.str() + "\"";

1806 continue;

1807 }

1808 if (I != EntV.size() - 1)

1809 Msg += ", \"" + Name.str() + "\"";

1810 else

1811 Msg += " and \"" + Name.str() + "\"";

1812 }

1813 return Msg;

1814 };

1815

1816 std::vector<std::pair<StringRef, bool>> Entries = Sec.getEntries();

1818 Entries, [](const std::pair<StringRef, bool> &P) { return P.second; });

1819

1820 if ((Sec.Size || Sec.Content) && NumUsedEntries > 0)

1821 return BuildErrPrefix(Entries) +

1822 " cannot be used with \"Content\" or \"Size\"";

1823

1824 if (NumUsedEntries > 0 && Entries.size() != NumUsedEntries)

1825 return BuildErrPrefix(Entries) + " must be used together";

1826

1828 if (RawSection->Flags && RawSection->ShFlags)

1829 return "ShFlags and Flags cannot be used together";

1830 return "";

1831 }

1832

1834 if (NB->Content)

1835 return "SHT_NOBITS section cannot have \"Content\"";

1836 return "";

1837 }

1838

1840 if (MF->Content)

1841 return "\"Content\" key is not implemented for SHT_MIPS_ABIFLAGS "

1842 "sections";

1843 if (MF->Size)

1844 return "\"Size\" key is not implemented for SHT_MIPS_ABIFLAGS sections";

1845 return "";

1846 }

1847

1848 return "";

1849}

1850

1851namespace {

1852

1853struct NormalizedMips64RelType {

1854 NormalizedMips64RelType(IO &)

1855 : Type(ELFYAML::ELF_REL(ELF::R_MIPS_NONE)),

1856 Type2(ELFYAML::ELF_REL(ELF::R_MIPS_NONE)),

1857 Type3(ELFYAML::ELF_REL(ELF::R_MIPS_NONE)),

1858 SpecSym(ELFYAML::ELF_REL(ELF::RSS_UNDEF)) {}

1859 NormalizedMips64RelType(IO &, ELFYAML::ELF_REL Original)

1860 : Type(Original & 0xFF), Type2(Original >> 8 & 0xFF),

1861 Type3(Original >> 16 & 0xFF), SpecSym(Original >> 24 & 0xFF) {}

1862

1863 ELFYAML::ELF_REL denormalize(IO &) {

1864 ELFYAML::ELF_REL Res = Type | Type2 << 8 | Type3 << 16 | SpecSym << 24;

1865 return Res;

1866 }

1867

1868 ELFYAML::ELF_REL Type;

1869 ELFYAML::ELF_REL Type2;

1870 ELFYAML::ELF_REL Type3;

1871 ELFYAML::ELF_RSS SpecSym;

1872};

1873

1874}

1875

1877 IO &IO, ELFYAML::StackSizeEntry &E) {

1881}

1882

1884 IO &IO, ELFYAML::BBAddrMapEntry &E) {

1890}

1891

1893 IO &IO, ELFYAML::BBAddrMapEntry::BBRangeEntry &E) {

1894 IO.mapOptional("BaseAddress", E.BaseAddress, Hex64(0));

1897}

1898

1900 IO &IO, ELFYAML::BBAddrMapEntry::BBEntry &E) {

1906 IO.mapOptional("CallsiteEndOffsets", E.CallsiteEndOffsets);

1908}

1909

1911 IO &IO, ELFYAML::PGOAnalysisMapEntry &E) {

1915}

1916

1918 IO &IO, ELFYAML::PGOAnalysisMapEntry::PGOBBEntry &E) {

1923}

1924

1927 ELFYAML::PGOAnalysisMapEntry::PGOBBEntry::SuccessorEntry &E) {

1932}

1933

1935 ELFYAML::GnuHashHeader &E) {

1941}

1942

1944 ELFYAML::DynamicEntry &Rel) {

1946

1949}

1950

1953

1957}

1958

1960 ELFYAML::VerdefEntry &E) {

1962

1969}

1970

1972 ELFYAML::VerneedEntry &E) {

1974

1978}

1979

1981 ELFYAML::VernauxEntry &E) {

1983

1988}

1989

1991 ELFYAML::Relocation &Rel) {

1992 const auto *Object = static_cast<ELFYAML::Object *>(IO.getContext());

1993 assert(Object && "The IO context is not initialized");

1994

1997

2001 IO, Rel.Type);

2003 IO.mapOptional("Type2", Key->Type2, ELFYAML::ELF_REL(ELF::R_MIPS_NONE));

2004 IO.mapOptional("Type3", Key->Type3, ELFYAML::ELF_REL(ELF::R_MIPS_NONE));

2006 } else

2008

2009 IO.mapOptional("Addend", Rel.Addend, (ELFYAML::YAMLIntUInt)0);

2010}

2011

2013 IO &IO, ELFYAML::ARMIndexTableEntry &E) {

2016

2017 StringRef CantUnwind = "EXIDX_CANTUNWIND";

2022 else

2024}

2025

2027 assert(.getContext() && "The IO context is initialized already");

2037 Object.DWARF->IsLittleEndian =

2039 Object.DWARF->Is64BitAddrSize =

2041 }

2043}

2044

2046 ELFYAML::LinkerOption &Opt) {

2050}

2051

2053 IO &IO, ELFYAML::CallGraphEntryWeight &E) {

2056}

2057

2063

2064}

2065

2066}

assert(UImm &&(UImm !=~static_cast< T >(0)) &&"Invalid immediate!")

This file implements a class to represent arbitrary precision integral constant values and operations...

static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")

This file declares classes for handling the YAML representation of ELF.

This file implements a map that provides insertion order iteration.

static uint32_t getFlags(const Symbol *Sym)

#define LLVM_YAML_STRONG_TYPEDEF(_base, _type)

YAML I/O does conversion based on types. But often native data types are just a typedef of built in i...

Class for arbitrary precision integers.

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

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

bool getAsInteger(unsigned Radix, T &Result) const

Parse the current string as an integer of the specified radix.

bool starts_with(StringRef Prefix) const

Check if this string starts with the given Prefix.

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

Type(LLVMContext &C, TypeID tid)

LLVM Value Representation.

This class implements an extremely fast bulk output stream that can only output to a stream.

Specialized YAMLIO scalar type for representing a binary blob.

virtual bool outputting() const =0

virtual bool mapTag(StringRef Tag, bool Default=false)=0

void enumCase(T &Val, StringRef Str, const T ConstVal)

void mapOptional(StringRef Key, T &Val)

virtual void setError(const Twine &)=0

void * getContext() const

void enumFallback(T &Val)

void mapRequired(StringRef Key, T &Val)

void maskedBitSetCase(T &Val, StringRef Str, T ConstVal, T Mask)

@ EXIDX_CANTUNWIND

Special entry for the function never unwind.

@ C

The default llvm calling convention, compatible with C.

StringRef dropUniqueSuffix(StringRef S)

@ SHT_LLVM_DEPENDENT_LIBRARIES

@ SHT_LLVM_LINKER_OPTIONS

@ SHT_LLVM_CALL_GRAPH_PROFILE

@ ELFABIVERSION_AMDGPU_HSA_V4

@ ELFABIVERSION_AMDGPU_HSA_V5

@ ELFABIVERSION_AMDGPU_HSA_V3

@ ELFABIVERSION_AMDGPU_HSA_V6

@ EF_AMDGPU_GENERIC_VERSION_MAX

@ EF_AMDGPU_GENERIC_VERSION_OFFSET

@ EF_AMDGPU_GENERIC_VERSION_MIN

@ EF_AMDGPU_GENERIC_VERSION

@ STO_AARCH64_VARIANT_PCS

@ Val_GNU_MIPS_ABI_FP_ANY

static void sectionMapping(IO &IO, ELFYAML::DynamicSection &Section)

Definition ELFYAML.cpp:1439

QuotingType

Describe which type of quotes should be used when quoting is necessary.

static void groupSectionMapping(IO &IO, ELFYAML::GroupSection &Group)

Definition ELFYAML.cpp:1529

static StringRef getStringValue(IO &IO, const char *Key)

Definition ELFYAML.cpp:1606

static void sectionHeaderTableMapping(IO &IO, ELFYAML::SectionHeaderTable &SHT)

Definition ELFYAML.cpp:1552

static void commonSectionMapping(IO &IO, ELFYAML::Section &Section)

Definition ELFYAML.cpp:1412

static bool isInteger(StringRef Val)

Definition ELFYAML.cpp:1616

static void fillMapping(IO &IO, ELFYAML::Fill &Fill)

Definition ELFYAML.cpp:1545

static void setStringValue(IO &IO, const char *Key, StringRef Val)

Definition ELFYAML.cpp:1612

This is an optimization pass for GlobalISel generic memory operations.

FunctionAddr VTableAddr Value

LLVM_ABI bool getAsSignedInteger(StringRef Str, unsigned Radix, long long &Result)

decltype(auto) dyn_cast(const From &Val)

dyn_cast - Return the argument parameter cast to the specified type.

LLVM_ATTRIBUTE_VISIBILITY_DEFAULT AnalysisKey InnerAnalysisManagerProxy< AnalysisManagerT, IRUnitT, ExtraArgTs... >::Key

ArrayRef(const T &OneElt) -> ArrayRef< T >

auto count_if(R &&Range, UnaryPredicate P)

Wrapper function around std::count_if to count the number of times an element satisfying a given pred...

decltype(auto) cast(const From &Val)

cast - Return the argument parameter cast to the specified type.

LLVM_ABI bool getAsUnsignedInteger(StringRef Str, unsigned Radix, unsigned long long &Result)

Helper functions for StringRef::getAsInteger.

bool to_integer(StringRef S, N &Num, unsigned Base=0)

Convert the string S to an integer of the specified type using the radix Base. If Base is 0,...

std::optional< llvm::yaml::Hex64 > Offset

std::optional< yaml::BinaryRef > Pattern

std::optional< std::vector< SectionOrType > > Members

std::optional< StringRef > Signature

unsigned getMachine() const

Definition ELFYAML.cpp:35

ELF_ELFOSABI getOSAbi() const

Definition ELFYAML.cpp:33

StringRef sectionNameOrType

static bool nameMatches(StringRef Name)

This class should be specialized by any type that needs to be converted to/from a YAML mapping.

This class should be specialized by any integer type that is a union of bit values and the YAML repre...

This class should be specialized by any integral type that converts to/from a YAML scalar where there...

static StringRef input(StringRef Scalar, void *, ELFYAML::YAMLFlowString &Val)

Definition ELFYAML.cpp:1242

static void output(const ELFYAML::YAMLFlowString &Val, void *, raw_ostream &Out)

Definition ELFYAML.cpp:1238

static QuotingType mustQuote(StringRef S)

Definition ELFYAML.cpp:1247

static StringRef input(StringRef Scalar, void *, StOtherPiece &Val)

Definition ELFYAML.cpp:1227

static QuotingType mustQuote(StringRef)

Definition ELFYAML.cpp:1231

static void output(const StOtherPiece &Val, void *, raw_ostream &Out)

Definition ELFYAML.cpp:1224

This class should be specialized by type that requires custom conversion to/from a yaml scalar.

static const bool flow

Definition ELFYAML.cpp:1252

static const bool flow

Definition ELFYAML.cpp:1234

This class should be specialized by any type for which vectors of that type need to be converted to/f...