Movatterモバイル変換

Go to the documentation of this file.

1//===- ELFYAML.cpp - ELF YAMLIO 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// This file defines classes for handling the YAML representation of ELF.

10//

11//===----------------------------------------------------------------------===//

13#include "llvm/ObjectYAML/ELFYAML.h"

14#include "llvm/ADT/APInt.h"

15#include "llvm/ADT/MapVector.h"

16#include "llvm/ADT/StringRef.h"

17#include "llvm/BinaryFormat/ELF.h"

18#include "llvm/Support/ARMEHABI.h"

19#include "llvm/Support/Casting.h"

20#include "llvm/Support/ErrorHandling.h"

21#include "llvm/Support/MipsABIFlags.h"

22#include "llvm/Support/YAMLTraits.h"

23#include "llvm/Support/WithColor.h"

24#include <cassert>

25#include <cstdint>

26#include <optional>

28namespacellvm {

30ELFYAML::Chunk::~Chunk() =default;

32namespaceELFYAML {

33ELF_ELFOSABIObject::getOSAbi() const{returnHeader.OSABI; }

35unsignedObject::getMachine() const{

36if (Header.Machine)

37return *Header.Machine;

38returnllvm::ELF::EM_NONE;

39}

41constexprStringRef SectionHeaderTable::TypeStr;

42}// namespace ELFYAML

44namespaceyaml {

46void ScalarEnumerationTraits<ELFYAML::ELF_ET>::enumeration(

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

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

49ECase(ET_NONE);

50ECase(ET_REL);

51ECase(ET_EXEC);

52ECase(ET_DYN);

53ECase(ET_CORE);

54#undef ECase

55 IO.enumFallback<Hex16>(Value);

56}

58void ScalarEnumerationTraits<ELFYAML::ELF_PT>::enumeration(

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

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

61ECase(PT_NULL);

62ECase(PT_LOAD);

63ECase(PT_DYNAMIC);

64ECase(PT_INTERP);

65ECase(PT_NOTE);

66ECase(PT_SHLIB);

67ECase(PT_PHDR);

68ECase(PT_TLS);

69ECase(PT_GNU_EH_FRAME);

70ECase(PT_GNU_STACK);

71ECase(PT_GNU_RELRO);

72ECase(PT_GNU_PROPERTY);

73#undef ECase

74 IO.enumFallback<Hex32>(Value);

75}

77void ScalarEnumerationTraits<ELFYAML::ELF_NT>::enumeration(

78 IO &IO, ELFYAML::ELF_NT &Value) {

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

80// Generic note types.

81ECase(NT_VERSION);

82ECase(NT_ARCH);

83ECase(NT_GNU_BUILD_ATTRIBUTE_OPEN);

84ECase(NT_GNU_BUILD_ATTRIBUTE_FUNC);

85// Core note types.

86ECase(NT_PRSTATUS);

87ECase(NT_FPREGSET);

88ECase(NT_PRPSINFO);

89ECase(NT_TASKSTRUCT);

90ECase(NT_AUXV);

91ECase(NT_PSTATUS);

92ECase(NT_FPREGS);

93ECase(NT_PSINFO);

94ECase(NT_LWPSTATUS);

95ECase(NT_LWPSINFO);

96ECase(NT_WIN32PSTATUS);

97ECase(NT_PPC_VMX);

98ECase(NT_PPC_VSX);

99ECase(NT_PPC_TAR);

100ECase(NT_PPC_PPR);

101ECase(NT_PPC_DSCR);

102ECase(NT_PPC_EBB);

103ECase(NT_PPC_PMU);

104ECase(NT_PPC_TM_CGPR);

105ECase(NT_PPC_TM_CFPR);

106ECase(NT_PPC_TM_CVMX);

107ECase(NT_PPC_TM_CVSX);

108ECase(NT_PPC_TM_SPR);

109ECase(NT_PPC_TM_CTAR);

110ECase(NT_PPC_TM_CPPR);

111ECase(NT_PPC_TM_CDSCR);

112ECase(NT_386_TLS);

113ECase(NT_386_IOPERM);

114ECase(NT_X86_XSTATE);

115ECase(NT_S390_HIGH_GPRS);

116ECase(NT_S390_TIMER);

117ECase(NT_S390_TODCMP);

118ECase(NT_S390_TODPREG);

119ECase(NT_S390_CTRS);

120ECase(NT_S390_PREFIX);

121ECase(NT_S390_LAST_BREAK);

122ECase(NT_S390_SYSTEM_CALL);

123ECase(NT_S390_TDB);

124ECase(NT_S390_VXRS_LOW);

125ECase(NT_S390_VXRS_HIGH);

126ECase(NT_S390_GS_CB);

127ECase(NT_S390_GS_BC);

128ECase(NT_ARM_VFP);

129ECase(NT_ARM_TLS);

130ECase(NT_ARM_HW_BREAK);

131ECase(NT_ARM_HW_WATCH);

132ECase(NT_ARM_SVE);

133ECase(NT_ARM_PAC_MASK);

134ECase(NT_ARM_TAGGED_ADDR_CTRL);

135ECase(NT_ARM_SSVE);

136ECase(NT_ARM_ZA);

137ECase(NT_ARM_ZT);

138ECase(NT_ARM_FPMR);

139ECase(NT_ARM_GCS);

140ECase(NT_FILE);

141ECase(NT_PRXFPREG);

142ECase(NT_SIGINFO);

143// LLVM-specific notes.

144ECase(NT_LLVM_HWASAN_GLOBALS);

145// GNU note types

146ECase(NT_GNU_ABI_TAG);

147ECase(NT_GNU_HWCAP);

148ECase(NT_GNU_BUILD_ID);

149ECase(NT_GNU_GOLD_VERSION);

150ECase(NT_GNU_PROPERTY_TYPE_0);

151// FreeBSD note types.

152ECase(NT_FREEBSD_ABI_TAG);

153ECase(NT_FREEBSD_NOINIT_TAG);

154ECase(NT_FREEBSD_ARCH_TAG);

155ECase(NT_FREEBSD_FEATURE_CTL);

156// FreeBSD core note types.

157ECase(NT_FREEBSD_THRMISC);

158ECase(NT_FREEBSD_PROCSTAT_PROC);

159ECase(NT_FREEBSD_PROCSTAT_FILES);

160ECase(NT_FREEBSD_PROCSTAT_VMMAP);

161ECase(NT_FREEBSD_PROCSTAT_GROUPS);

162ECase(NT_FREEBSD_PROCSTAT_UMASK);

163ECase(NT_FREEBSD_PROCSTAT_RLIMIT);

164ECase(NT_FREEBSD_PROCSTAT_OSREL);

165ECase(NT_FREEBSD_PROCSTAT_PSSTRINGS);

166ECase(NT_FREEBSD_PROCSTAT_AUXV);

167// NetBSD core note types.

168ECase(NT_NETBSDCORE_PROCINFO);

169ECase(NT_NETBSDCORE_AUXV);

170ECase(NT_NETBSDCORE_LWPSTATUS);

171// OpenBSD core note types.

172ECase(NT_OPENBSD_PROCINFO);

173ECase(NT_OPENBSD_AUXV);

174ECase(NT_OPENBSD_REGS);

175ECase(NT_OPENBSD_FPREGS);

176ECase(NT_OPENBSD_XFPREGS);

177ECase(NT_OPENBSD_WCOOKIE);

178// AMD specific notes. (Code Object V2)

179ECase(NT_AMD_HSA_CODE_OBJECT_VERSION);

180ECase(NT_AMD_HSA_HSAIL);

181ECase(NT_AMD_HSA_ISA_VERSION);

182ECase(NT_AMD_HSA_METADATA);

183ECase(NT_AMD_HSA_ISA_NAME);

184ECase(NT_AMD_PAL_METADATA);

185// AMDGPU specific notes. (Code Object V3)

186ECase(NT_AMDGPU_METADATA);

187// Android specific notes.

188ECase(NT_ANDROID_TYPE_IDENT);

189ECase(NT_ANDROID_TYPE_KUSER);

190ECase(NT_ANDROID_TYPE_MEMTAG);

191#undef ECase

192 IO.enumFallback<Hex32>(Value);

193}

194

195void ScalarEnumerationTraits<ELFYAML::ELF_EM>::enumeration(

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

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

198ECase(EM_NONE);

199ECase(EM_M32);

200ECase(EM_SPARC);

201ECase(EM_386);

202ECase(EM_68K);

203ECase(EM_88K);

204ECase(EM_IAMCU);

205ECase(EM_860);

206ECase(EM_MIPS);

207ECase(EM_S370);

208ECase(EM_MIPS_RS3_LE);

209ECase(EM_PARISC);

210ECase(EM_VPP500);

211ECase(EM_SPARC32PLUS);

212ECase(EM_960);

213ECase(EM_PPC);

214ECase(EM_PPC64);

215ECase(EM_S390);

216ECase(EM_SPU);

217ECase(EM_V800);

218ECase(EM_FR20);

219ECase(EM_RH32);

220ECase(EM_RCE);

221ECase(EM_ARM);

222ECase(EM_ALPHA);

223ECase(EM_SH);

224ECase(EM_SPARCV9);

225ECase(EM_TRICORE);

226ECase(EM_ARC);

227ECase(EM_H8_300);

228ECase(EM_H8_300H);

229ECase(EM_H8S);

230ECase(EM_H8_500);

231ECase(EM_IA_64);

232ECase(EM_MIPS_X);

233ECase(EM_COLDFIRE);

234ECase(EM_68HC12);

235ECase(EM_MMA);

236ECase(EM_PCP);

237ECase(EM_NCPU);

238ECase(EM_NDR1);

239ECase(EM_STARCORE);

240ECase(EM_ME16);

241ECase(EM_ST100);

242ECase(EM_TINYJ);

243ECase(EM_X86_64);

244ECase(EM_PDSP);

245ECase(EM_PDP10);

246ECase(EM_PDP11);

247ECase(EM_FX66);

248ECase(EM_ST9PLUS);

249ECase(EM_ST7);

250ECase(EM_68HC16);

251ECase(EM_68HC11);

252ECase(EM_68HC08);

253ECase(EM_68HC05);

254ECase(EM_SVX);

255ECase(EM_ST19);

256ECase(EM_VAX);

257ECase(EM_CRIS);

258ECase(EM_JAVELIN);

259ECase(EM_FIREPATH);

260ECase(EM_ZSP);

261ECase(EM_MMIX);

262ECase(EM_HUANY);

263ECase(EM_PRISM);

264ECase(EM_AVR);

265ECase(EM_FR30);

266ECase(EM_D10V);

267ECase(EM_D30V);

268ECase(EM_V850);

269ECase(EM_M32R);

270ECase(EM_MN10300);

271ECase(EM_MN10200);

272ECase(EM_PJ);

273ECase(EM_OPENRISC);

274ECase(EM_ARC_COMPACT);

275ECase(EM_XTENSA);

276ECase(EM_VIDEOCORE);

277ECase(EM_TMM_GPP);

278ECase(EM_NS32K);

279ECase(EM_TPC);

280ECase(EM_SNP1K);

281ECase(EM_ST200);

282ECase(EM_IP2K);

283ECase(EM_MAX);

284ECase(EM_CR);

285ECase(EM_F2MC16);

286ECase(EM_MSP430);

287ECase(EM_BLACKFIN);

288ECase(EM_SE_C33);

289ECase(EM_SEP);

290ECase(EM_ARCA);

291ECase(EM_UNICORE);

292ECase(EM_EXCESS);

293ECase(EM_DXP);

294ECase(EM_ALTERA_NIOS2);

295ECase(EM_CRX);

296ECase(EM_XGATE);

297ECase(EM_C166);

298ECase(EM_M16C);

299ECase(EM_DSPIC30F);

300ECase(EM_CE);

301ECase(EM_M32C);

302ECase(EM_TSK3000);

303ECase(EM_RS08);

304ECase(EM_SHARC);

305ECase(EM_ECOG2);

306ECase(EM_SCORE7);

307ECase(EM_DSP24);

308ECase(EM_VIDEOCORE3);

309ECase(EM_LATTICEMICO32);

310ECase(EM_SE_C17);

311ECase(EM_TI_C6000);

312ECase(EM_TI_C2000);

313ECase(EM_TI_C5500);

314ECase(EM_MMDSP_PLUS);

315ECase(EM_CYPRESS_M8C);

316ECase(EM_R32C);

317ECase(EM_TRIMEDIA);

318ECase(EM_HEXAGON);

319ECase(EM_8051);

320ECase(EM_STXP7X);

321ECase(EM_NDS32);

322ECase(EM_ECOG1);

323ECase(EM_ECOG1X);

324ECase(EM_MAXQ30);

325ECase(EM_XIMO16);

326ECase(EM_MANIK);

327ECase(EM_CRAYNV2);

328ECase(EM_RX);

329ECase(EM_METAG);

330ECase(EM_MCST_ELBRUS);

331ECase(EM_ECOG16);

332ECase(EM_CR16);

333ECase(EM_ETPU);

334ECase(EM_SLE9X);

335ECase(EM_L10M);

336ECase(EM_K10M);

337ECase(EM_AARCH64);

338ECase(EM_AVR32);

339ECase(EM_STM8);

340ECase(EM_TILE64);

341ECase(EM_TILEPRO);

342ECase(EM_MICROBLAZE);

343ECase(EM_CUDA);

344ECase(EM_TILEGX);

345ECase(EM_CLOUDSHIELD);

346ECase(EM_COREA_1ST);

347ECase(EM_COREA_2ND);

348ECase(EM_ARC_COMPACT2);

349ECase(EM_OPEN8);

350ECase(EM_RL78);

351ECase(EM_VIDEOCORE5);

352ECase(EM_78KOR);

353ECase(EM_56800EX);

354ECase(EM_AMDGPU);

355ECase(EM_RISCV);

356ECase(EM_LANAI);

357ECase(EM_BPF);

358ECase(EM_VE);

359ECase(EM_CSKY);

360ECase(EM_LOONGARCH);

361#undef ECase

362 IO.enumFallback<Hex16>(Value);

363}

364

365void ScalarEnumerationTraits<ELFYAML::ELF_ELFCLASS>::enumeration(

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

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

368// Since the semantics of ELFCLASSNONE is "invalid", just don't accept it

369// here.

370ECase(ELFCLASS32);

371ECase(ELFCLASS64);

372#undef ECase

373}

374

375void ScalarEnumerationTraits<ELFYAML::ELF_ELFDATA>::enumeration(

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

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

378// ELFDATANONE is an invalid data encoding, but we accept it because

379// we want to be able to produce invalid binaries for the tests.

380ECase(ELFDATANONE);

381ECase(ELFDATA2LSB);

382ECase(ELFDATA2MSB);

383#undef ECase

384}

385

386void ScalarEnumerationTraits<ELFYAML::ELF_ELFOSABI>::enumeration(

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

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

389ECase(ELFOSABI_NONE);

390ECase(ELFOSABI_HPUX);

391ECase(ELFOSABI_NETBSD);

392ECase(ELFOSABI_GNU);

393ECase(ELFOSABI_LINUX);

394ECase(ELFOSABI_HURD);

395ECase(ELFOSABI_SOLARIS);

396ECase(ELFOSABI_AIX);

397ECase(ELFOSABI_IRIX);

398ECase(ELFOSABI_FREEBSD);

399ECase(ELFOSABI_TRU64);

400ECase(ELFOSABI_MODESTO);

401ECase(ELFOSABI_OPENBSD);

402ECase(ELFOSABI_OPENVMS);

403ECase(ELFOSABI_NSK);

404ECase(ELFOSABI_AROS);

405ECase(ELFOSABI_FENIXOS);

406ECase(ELFOSABI_CLOUDABI);

407ECase(ELFOSABI_AMDGPU_HSA);

408ECase(ELFOSABI_AMDGPU_PAL);

409ECase(ELFOSABI_AMDGPU_MESA3D);

410ECase(ELFOSABI_ARM);

411ECase(ELFOSABI_ARM_FDPIC);

412ECase(ELFOSABI_C6000_ELFABI);

413ECase(ELFOSABI_C6000_LINUX);

414ECase(ELFOSABI_STANDALONE);

415#undef ECase

416 IO.enumFallback<Hex8>(Value);

417}

418

419void ScalarBitSetTraits<ELFYAML::ELF_EF>::bitset(IO &IO,

420 ELFYAML::ELF_EF &Value) {

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

422assert(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)

425switch (Object->getMachine()) {

426caseELF::EM_ARM:

427BCase(EF_ARM_SOFT_FLOAT);

428BCase(EF_ARM_VFP_FLOAT);

429BCaseMask(EF_ARM_EABI_UNKNOWN, EF_ARM_EABIMASK);

430BCaseMask(EF_ARM_EABI_VER1, EF_ARM_EABIMASK);

431BCaseMask(EF_ARM_EABI_VER2, EF_ARM_EABIMASK);

432BCaseMask(EF_ARM_EABI_VER3, EF_ARM_EABIMASK);

433BCaseMask(EF_ARM_EABI_VER4, EF_ARM_EABIMASK);

434BCaseMask(EF_ARM_EABI_VER5, EF_ARM_EABIMASK);

435BCaseMask(EF_ARM_BE8, EF_ARM_BE8);

436break;

437caseELF::EM_MIPS:

438BCase(EF_MIPS_NOREORDER);

439BCase(EF_MIPS_PIC);

440BCase(EF_MIPS_CPIC);

441BCase(EF_MIPS_ABI2);

442BCase(EF_MIPS_32BITMODE);

443BCase(EF_MIPS_FP64);

444BCase(EF_MIPS_NAN2008);

445BCase(EF_MIPS_MICROMIPS);

446BCase(EF_MIPS_ARCH_ASE_M16);

447BCase(EF_MIPS_ARCH_ASE_MDMX);

448BCaseMask(EF_MIPS_ABI_O32, EF_MIPS_ABI);

449BCaseMask(EF_MIPS_ABI_O64, EF_MIPS_ABI);

450BCaseMask(EF_MIPS_ABI_EABI32, EF_MIPS_ABI);

451BCaseMask(EF_MIPS_ABI_EABI64, EF_MIPS_ABI);

452BCaseMask(EF_MIPS_MACH_3900, EF_MIPS_MACH);

453BCaseMask(EF_MIPS_MACH_4010, EF_MIPS_MACH);

454BCaseMask(EF_MIPS_MACH_4100, EF_MIPS_MACH);

455BCaseMask(EF_MIPS_MACH_4650, EF_MIPS_MACH);

456BCaseMask(EF_MIPS_MACH_4120, EF_MIPS_MACH);

457BCaseMask(EF_MIPS_MACH_4111, EF_MIPS_MACH);

458BCaseMask(EF_MIPS_MACH_SB1, EF_MIPS_MACH);

459BCaseMask(EF_MIPS_MACH_OCTEON, EF_MIPS_MACH);

460BCaseMask(EF_MIPS_MACH_XLR, EF_MIPS_MACH);

461BCaseMask(EF_MIPS_MACH_OCTEON2, EF_MIPS_MACH);

462BCaseMask(EF_MIPS_MACH_OCTEON3, EF_MIPS_MACH);

463BCaseMask(EF_MIPS_MACH_5400, EF_MIPS_MACH);

464BCaseMask(EF_MIPS_MACH_5900, EF_MIPS_MACH);

465BCaseMask(EF_MIPS_MACH_5500, EF_MIPS_MACH);

466BCaseMask(EF_MIPS_MACH_9000, EF_MIPS_MACH);

467BCaseMask(EF_MIPS_MACH_LS2E, EF_MIPS_MACH);

468BCaseMask(EF_MIPS_MACH_LS2F, EF_MIPS_MACH);

469BCaseMask(EF_MIPS_MACH_LS3A, EF_MIPS_MACH);

470BCaseMask(EF_MIPS_ARCH_1, EF_MIPS_ARCH);

471BCaseMask(EF_MIPS_ARCH_2, EF_MIPS_ARCH);

472BCaseMask(EF_MIPS_ARCH_3, EF_MIPS_ARCH);

473BCaseMask(EF_MIPS_ARCH_4, EF_MIPS_ARCH);

474BCaseMask(EF_MIPS_ARCH_5, EF_MIPS_ARCH);

475BCaseMask(EF_MIPS_ARCH_32, EF_MIPS_ARCH);

476BCaseMask(EF_MIPS_ARCH_64, EF_MIPS_ARCH);

477BCaseMask(EF_MIPS_ARCH_32R2, EF_MIPS_ARCH);

478BCaseMask(EF_MIPS_ARCH_64R2, EF_MIPS_ARCH);

479BCaseMask(EF_MIPS_ARCH_32R6, EF_MIPS_ARCH);

480BCaseMask(EF_MIPS_ARCH_64R6, EF_MIPS_ARCH);

481break;

482caseELF::EM_HEXAGON:

483BCaseMask(EF_HEXAGON_MACH_V2, EF_HEXAGON_MACH);

484BCaseMask(EF_HEXAGON_MACH_V3, EF_HEXAGON_MACH);

485BCaseMask(EF_HEXAGON_MACH_V4, EF_HEXAGON_MACH);

486BCaseMask(EF_HEXAGON_MACH_V5, EF_HEXAGON_MACH);

487BCaseMask(EF_HEXAGON_MACH_V55, EF_HEXAGON_MACH);

488BCaseMask(EF_HEXAGON_MACH_V60, EF_HEXAGON_MACH);

489BCaseMask(EF_HEXAGON_MACH_V62, EF_HEXAGON_MACH);

490BCaseMask(EF_HEXAGON_MACH_V65, EF_HEXAGON_MACH);

491BCaseMask(EF_HEXAGON_MACH_V66, EF_HEXAGON_MACH);

492BCaseMask(EF_HEXAGON_MACH_V67, EF_HEXAGON_MACH);

493BCaseMask(EF_HEXAGON_MACH_V67T, EF_HEXAGON_MACH);

494BCaseMask(EF_HEXAGON_MACH_V68, EF_HEXAGON_MACH);

495BCaseMask(EF_HEXAGON_MACH_V69, EF_HEXAGON_MACH);

496BCaseMask(EF_HEXAGON_MACH_V71, EF_HEXAGON_MACH);

497BCaseMask(EF_HEXAGON_MACH_V71T, EF_HEXAGON_MACH);

498BCaseMask(EF_HEXAGON_MACH_V73, EF_HEXAGON_MACH);

499BCaseMask(EF_HEXAGON_MACH_V75, EF_HEXAGON_MACH);

500BCaseMask(EF_HEXAGON_ISA_V2, EF_HEXAGON_ISA);

501BCaseMask(EF_HEXAGON_ISA_V3, EF_HEXAGON_ISA);

502BCaseMask(EF_HEXAGON_ISA_V4, EF_HEXAGON_ISA);

503BCaseMask(EF_HEXAGON_ISA_V5, EF_HEXAGON_ISA);

504BCaseMask(EF_HEXAGON_ISA_V55, EF_HEXAGON_ISA);

505BCaseMask(EF_HEXAGON_ISA_V60, EF_HEXAGON_ISA);

506BCaseMask(EF_HEXAGON_ISA_V62, EF_HEXAGON_ISA);

507BCaseMask(EF_HEXAGON_ISA_V65, EF_HEXAGON_ISA);

508BCaseMask(EF_HEXAGON_ISA_V66, EF_HEXAGON_ISA);

509BCaseMask(EF_HEXAGON_ISA_V67, EF_HEXAGON_ISA);

510BCaseMask(EF_HEXAGON_ISA_V68, EF_HEXAGON_ISA);

511BCaseMask(EF_HEXAGON_ISA_V69, EF_HEXAGON_ISA);

512BCaseMask(EF_HEXAGON_ISA_V71, EF_HEXAGON_ISA);

513BCaseMask(EF_HEXAGON_ISA_V73, EF_HEXAGON_ISA);

514BCaseMask(EF_HEXAGON_ISA_V75, EF_HEXAGON_ISA);

515break;

516caseELF::EM_AVR:

517BCaseMask(EF_AVR_ARCH_AVR1, EF_AVR_ARCH_MASK);

518BCaseMask(EF_AVR_ARCH_AVR2, EF_AVR_ARCH_MASK);

519BCaseMask(EF_AVR_ARCH_AVR25, EF_AVR_ARCH_MASK);

520BCaseMask(EF_AVR_ARCH_AVR3, EF_AVR_ARCH_MASK);

521BCaseMask(EF_AVR_ARCH_AVR31, EF_AVR_ARCH_MASK);

522BCaseMask(EF_AVR_ARCH_AVR35, EF_AVR_ARCH_MASK);

523BCaseMask(EF_AVR_ARCH_AVR4, EF_AVR_ARCH_MASK);

524BCaseMask(EF_AVR_ARCH_AVR5, EF_AVR_ARCH_MASK);

525BCaseMask(EF_AVR_ARCH_AVR51, EF_AVR_ARCH_MASK);

526BCaseMask(EF_AVR_ARCH_AVR6, EF_AVR_ARCH_MASK);

527BCaseMask(EF_AVR_ARCH_AVRTINY, EF_AVR_ARCH_MASK);

528BCaseMask(EF_AVR_ARCH_XMEGA1, EF_AVR_ARCH_MASK);

529BCaseMask(EF_AVR_ARCH_XMEGA2, EF_AVR_ARCH_MASK);

530BCaseMask(EF_AVR_ARCH_XMEGA3, EF_AVR_ARCH_MASK);

531BCaseMask(EF_AVR_ARCH_XMEGA4, EF_AVR_ARCH_MASK);

532BCaseMask(EF_AVR_ARCH_XMEGA5, EF_AVR_ARCH_MASK);

533BCaseMask(EF_AVR_ARCH_XMEGA6, EF_AVR_ARCH_MASK);

534BCaseMask(EF_AVR_ARCH_XMEGA7, EF_AVR_ARCH_MASK);

535BCase(EF_AVR_LINKRELAX_PREPARED);

536break;

537caseELF::EM_LOONGARCH:

538BCaseMask(EF_LOONGARCH_ABI_SOFT_FLOAT, EF_LOONGARCH_ABI_MODIFIER_MASK);

539BCaseMask(EF_LOONGARCH_ABI_SINGLE_FLOAT, EF_LOONGARCH_ABI_MODIFIER_MASK);

540BCaseMask(EF_LOONGARCH_ABI_DOUBLE_FLOAT, EF_LOONGARCH_ABI_MODIFIER_MASK);

541BCaseMask(EF_LOONGARCH_OBJABI_V0, EF_LOONGARCH_OBJABI_MASK);

542BCaseMask(EF_LOONGARCH_OBJABI_V1, EF_LOONGARCH_OBJABI_MASK);

543break;

544caseELF::EM_RISCV:

545BCase(EF_RISCV_RVC);

546BCaseMask(EF_RISCV_FLOAT_ABI_SOFT, EF_RISCV_FLOAT_ABI);

547BCaseMask(EF_RISCV_FLOAT_ABI_SINGLE, EF_RISCV_FLOAT_ABI);

548BCaseMask(EF_RISCV_FLOAT_ABI_DOUBLE, EF_RISCV_FLOAT_ABI);

549BCaseMask(EF_RISCV_FLOAT_ABI_QUAD, EF_RISCV_FLOAT_ABI);

550BCase(EF_RISCV_RVE);

551BCase(EF_RISCV_TSO);

552break;

553caseELF::EM_SPARC32PLUS:

554BCase(EF_SPARC_32PLUS);

555BCase(EF_SPARC_SUN_US1);

556BCase(EF_SPARC_SUN_US3);

557BCase(EF_SPARC_HAL_R1);

558break;

559caseELF::EM_SPARCV9:

560BCase(EF_SPARC_SUN_US1);

561BCase(EF_SPARC_SUN_US3);

562BCase(EF_SPARC_HAL_R1);

563BCaseMask(EF_SPARCV9_RMO, EF_SPARCV9_MM);

564BCaseMask(EF_SPARCV9_PSO, EF_SPARCV9_MM);

565BCaseMask(EF_SPARCV9_TSO, EF_SPARCV9_MM);

566break;

567caseELF::EM_XTENSA:

568BCase(EF_XTENSA_XT_INSN);

569BCaseMask(EF_XTENSA_MACH_NONE, EF_XTENSA_MACH);

570BCase(EF_XTENSA_XT_LIT);

571break;

572caseELF::EM_AMDGPU:

573BCaseMask(EF_AMDGPU_MACH_NONE, EF_AMDGPU_MACH);

574BCaseMask(EF_AMDGPU_MACH_R600_R600, EF_AMDGPU_MACH);

575BCaseMask(EF_AMDGPU_MACH_R600_R630, EF_AMDGPU_MACH);

576BCaseMask(EF_AMDGPU_MACH_R600_RS880, EF_AMDGPU_MACH);

577BCaseMask(EF_AMDGPU_MACH_R600_RV670, EF_AMDGPU_MACH);

578BCaseMask(EF_AMDGPU_MACH_R600_RV710, EF_AMDGPU_MACH);

579BCaseMask(EF_AMDGPU_MACH_R600_RV730, EF_AMDGPU_MACH);

580BCaseMask(EF_AMDGPU_MACH_R600_RV770, EF_AMDGPU_MACH);

581BCaseMask(EF_AMDGPU_MACH_R600_CEDAR, EF_AMDGPU_MACH);

582BCaseMask(EF_AMDGPU_MACH_R600_CYPRESS, EF_AMDGPU_MACH);

583BCaseMask(EF_AMDGPU_MACH_R600_JUNIPER, EF_AMDGPU_MACH);

584BCaseMask(EF_AMDGPU_MACH_R600_REDWOOD, EF_AMDGPU_MACH);

585BCaseMask(EF_AMDGPU_MACH_R600_SUMO, EF_AMDGPU_MACH);

586BCaseMask(EF_AMDGPU_MACH_R600_BARTS, EF_AMDGPU_MACH);

587BCaseMask(EF_AMDGPU_MACH_R600_CAICOS, EF_AMDGPU_MACH);

588BCaseMask(EF_AMDGPU_MACH_R600_CAYMAN, EF_AMDGPU_MACH);

589BCaseMask(EF_AMDGPU_MACH_R600_TURKS, EF_AMDGPU_MACH);

590BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX600, EF_AMDGPU_MACH);

591BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX601, EF_AMDGPU_MACH);

592BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX602, EF_AMDGPU_MACH);

593BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX700, EF_AMDGPU_MACH);

594BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX701, EF_AMDGPU_MACH);

595BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX702, EF_AMDGPU_MACH);

596BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX703, EF_AMDGPU_MACH);

597BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX704, EF_AMDGPU_MACH);

598BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX705, EF_AMDGPU_MACH);

599BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX801, EF_AMDGPU_MACH);

600BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX802, EF_AMDGPU_MACH);

601BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX803, EF_AMDGPU_MACH);

602BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX805, EF_AMDGPU_MACH);

603BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX810, EF_AMDGPU_MACH);

604BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX900, EF_AMDGPU_MACH);

605BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX902, EF_AMDGPU_MACH);

606BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX904, EF_AMDGPU_MACH);

607BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX906, EF_AMDGPU_MACH);

608BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX908, EF_AMDGPU_MACH);

609BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX909, EF_AMDGPU_MACH);

610BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX90A, EF_AMDGPU_MACH);

611BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX90C, EF_AMDGPU_MACH);

612BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX940, EF_AMDGPU_MACH);

613BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX941, EF_AMDGPU_MACH);

614BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX942, EF_AMDGPU_MACH);

615BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX950, EF_AMDGPU_MACH);

616BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX1010, EF_AMDGPU_MACH);

617BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX1011, EF_AMDGPU_MACH);

618BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX1012, EF_AMDGPU_MACH);

619BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX1013, EF_AMDGPU_MACH);

620BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX1030, EF_AMDGPU_MACH);

621BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX1031, EF_AMDGPU_MACH);

622BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX1032, EF_AMDGPU_MACH);

623BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX1033, EF_AMDGPU_MACH);

624BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX1034, EF_AMDGPU_MACH);

625BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX1035, EF_AMDGPU_MACH);

626BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX1036, EF_AMDGPU_MACH);

627BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX1100, EF_AMDGPU_MACH);

628BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX1101, EF_AMDGPU_MACH);

629BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX1102, EF_AMDGPU_MACH);

630BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX1103, EF_AMDGPU_MACH);

631BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX1150, EF_AMDGPU_MACH);

632BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX1151, EF_AMDGPU_MACH);

633BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX1152, EF_AMDGPU_MACH);

634BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX1153, EF_AMDGPU_MACH);

635BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX1200, EF_AMDGPU_MACH);

636BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX1201, EF_AMDGPU_MACH);

637BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX9_GENERIC, EF_AMDGPU_MACH);

638BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX9_4_GENERIC, EF_AMDGPU_MACH);

639BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX10_1_GENERIC, EF_AMDGPU_MACH);

640BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX10_3_GENERIC, EF_AMDGPU_MACH);

641BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX11_GENERIC, EF_AMDGPU_MACH);

642BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX12_GENERIC, EF_AMDGPU_MACH);

643switch (Object->Header.ABIVersion) {

644default:

645// ELFOSABI_AMDGPU_PAL, ELFOSABI_AMDGPU_MESA3D support *_V3 flags.

646 [[fallthrough]];

647caseELF::ELFABIVERSION_AMDGPU_HSA_V3:

648BCase(EF_AMDGPU_FEATURE_XNACK_V3);

649BCase(EF_AMDGPU_FEATURE_SRAMECC_V3);

650break;

651caseELF::ELFABIVERSION_AMDGPU_HSA_V6:

652for (unsigned K =ELF::EF_AMDGPU_GENERIC_VERSION_MIN;

653K <=ELF::EF_AMDGPU_GENERIC_VERSION_MAX; ++K) {

654 std::stringKey ="EF_AMDGPU_GENERIC_VERSION_V" + std::to_string(K);

655 IO.maskedBitSetCase(Value,Key.c_str(),

656 K <<ELF::EF_AMDGPU_GENERIC_VERSION_OFFSET,

657ELF::EF_AMDGPU_GENERIC_VERSION);

658 }

659 [[fallthrough]];

660caseELF::ELFABIVERSION_AMDGPU_HSA_V4:

661caseELF::ELFABIVERSION_AMDGPU_HSA_V5:

662BCaseMask(EF_AMDGPU_FEATURE_XNACK_UNSUPPORTED_V4,

663 EF_AMDGPU_FEATURE_XNACK_V4);

664BCaseMask(EF_AMDGPU_FEATURE_XNACK_ANY_V4,

665 EF_AMDGPU_FEATURE_XNACK_V4);

666BCaseMask(EF_AMDGPU_FEATURE_XNACK_OFF_V4,

667 EF_AMDGPU_FEATURE_XNACK_V4);

668BCaseMask(EF_AMDGPU_FEATURE_XNACK_ON_V4,

669 EF_AMDGPU_FEATURE_XNACK_V4);

670BCaseMask(EF_AMDGPU_FEATURE_SRAMECC_UNSUPPORTED_V4,

671 EF_AMDGPU_FEATURE_SRAMECC_V4);

672BCaseMask(EF_AMDGPU_FEATURE_SRAMECC_ANY_V4,

673 EF_AMDGPU_FEATURE_SRAMECC_V4);

674BCaseMask(EF_AMDGPU_FEATURE_SRAMECC_OFF_V4,

675 EF_AMDGPU_FEATURE_SRAMECC_V4);

676BCaseMask(EF_AMDGPU_FEATURE_SRAMECC_ON_V4,

677 EF_AMDGPU_FEATURE_SRAMECC_V4);

678break;

679 }

680break;

681default:

682break;

683 }

684#undef BCase

685#undef BCaseMask

686}

687

688void ScalarEnumerationTraits<ELFYAML::ELF_SHT>::enumeration(

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

690constauto *Object =static_cast<ELFYAML::Object *>(IO.getContext());

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

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

693ECase(SHT_NULL);

694ECase(SHT_PROGBITS);

695ECase(SHT_SYMTAB);

696// FIXME: Issue a diagnostic with this information.

697ECase(SHT_STRTAB);

698ECase(SHT_RELA);

699ECase(SHT_HASH);

700ECase(SHT_DYNAMIC);

701ECase(SHT_NOTE);

702ECase(SHT_NOBITS);

703ECase(SHT_REL);

704ECase(SHT_SHLIB);

705ECase(SHT_DYNSYM);

706ECase(SHT_INIT_ARRAY);

707ECase(SHT_FINI_ARRAY);

708ECase(SHT_PREINIT_ARRAY);

709ECase(SHT_GROUP);

710ECase(SHT_SYMTAB_SHNDX);

711ECase(SHT_RELR);

712ECase(SHT_CREL);

713ECase(SHT_ANDROID_REL);

714ECase(SHT_ANDROID_RELA);

715ECase(SHT_ANDROID_RELR);

716ECase(SHT_LLVM_ODRTAB);

717ECase(SHT_LLVM_LINKER_OPTIONS);

718ECase(SHT_LLVM_CALL_GRAPH_PROFILE);

719ECase(SHT_LLVM_ADDRSIG);

720ECase(SHT_LLVM_DEPENDENT_LIBRARIES);

721ECase(SHT_LLVM_SYMPART);

722ECase(SHT_LLVM_PART_EHDR);

723ECase(SHT_LLVM_PART_PHDR);

724ECase(SHT_LLVM_BB_ADDR_MAP_V0);

725ECase(SHT_LLVM_BB_ADDR_MAP);

726ECase(SHT_LLVM_OFFLOADING);

727ECase(SHT_LLVM_LTO);

728ECase(SHT_GNU_ATTRIBUTES);

729ECase(SHT_GNU_HASH);

730ECase(SHT_GNU_verdef);

731ECase(SHT_GNU_verneed);

732ECase(SHT_GNU_versym);

733switch (Object->getMachine()) {

734caseELF::EM_ARM:

735ECase(SHT_ARM_EXIDX);

736ECase(SHT_ARM_PREEMPTMAP);

737ECase(SHT_ARM_ATTRIBUTES);

738ECase(SHT_ARM_DEBUGOVERLAY);

739ECase(SHT_ARM_OVERLAYSECTION);

740break;

741caseELF::EM_HEXAGON:

742ECase(SHT_HEX_ORDERED);

743ECase(SHT_HEXAGON_ATTRIBUTES);

744break;

745caseELF::EM_X86_64:

746ECase(SHT_X86_64_UNWIND);

747break;

748caseELF::EM_MIPS:

749ECase(SHT_MIPS_REGINFO);

750ECase(SHT_MIPS_OPTIONS);

751ECase(SHT_MIPS_DWARF);

752ECase(SHT_MIPS_ABIFLAGS);

753break;

754caseELF::EM_RISCV:

755ECase(SHT_RISCV_ATTRIBUTES);

756break;

757caseELF::EM_MSP430:

758ECase(SHT_MSP430_ATTRIBUTES);

759break;

760caseELF::EM_AARCH64:

761ECase(SHT_AARCH64_AUTH_RELR);

762ECase(SHT_AARCH64_MEMTAG_GLOBALS_STATIC);

763ECase(SHT_AARCH64_MEMTAG_GLOBALS_DYNAMIC);

764break;

765default:

766// Nothing to do.

767break;

768 }

769#undef ECase

770 IO.enumFallback<Hex32>(Value);

771}

772

773void ScalarBitSetTraits<ELFYAML::ELF_PF>::bitset(IO &IO,

774 ELFYAML::ELF_PF &Value) {

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

776BCase(PF_X);

777BCase(PF_W);

778BCase(PF_R);

779}

780

781void ScalarBitSetTraits<ELFYAML::ELF_SHF>::bitset(IO &IO,

782 ELFYAML::ELF_SHF &Value) {

783constauto *Object =static_cast<ELFYAML::Object *>(IO.getContext());

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

785BCase(SHF_WRITE);

786BCase(SHF_ALLOC);

787BCase(SHF_EXCLUDE);

788BCase(SHF_EXECINSTR);

789BCase(SHF_MERGE);

790BCase(SHF_STRINGS);

791BCase(SHF_INFO_LINK);

792BCase(SHF_LINK_ORDER);

793BCase(SHF_OS_NONCONFORMING);

794BCase(SHF_GROUP);

795BCase(SHF_TLS);

796BCase(SHF_COMPRESSED);

797switch (Object->getOSAbi()) {

798caseELF::ELFOSABI_SOLARIS:

799BCase(SHF_SUNW_NODISCARD);

800break;

801default:

802BCase(SHF_GNU_RETAIN);

803break;

804 }

805switch (Object->getMachine()) {

806caseELF::EM_ARM:

807BCase(SHF_ARM_PURECODE);

808break;

809caseELF::EM_HEXAGON:

810BCase(SHF_HEX_GPREL);

811break;

812caseELF::EM_MIPS:

813BCase(SHF_MIPS_NODUPES);

814BCase(SHF_MIPS_NAMES);

815BCase(SHF_MIPS_LOCAL);

816BCase(SHF_MIPS_NOSTRIP);

817BCase(SHF_MIPS_GPREL);

818BCase(SHF_MIPS_MERGE);

819BCase(SHF_MIPS_ADDR);

820BCase(SHF_MIPS_STRING);

821break;

822caseELF::EM_X86_64:

823BCase(SHF_X86_64_LARGE);

824break;

825default:

826// Nothing to do.

827break;

828 }

829#undef BCase

830}

831

832void ScalarEnumerationTraits<ELFYAML::ELF_SHN>::enumeration(

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

834constauto *Object =static_cast<ELFYAML::Object *>(IO.getContext());

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

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

837ECase(SHN_UNDEF);

838ECase(SHN_LORESERVE);

839ECase(SHN_LOPROC);

840ECase(SHN_HIPROC);

841ECase(SHN_LOOS);

842ECase(SHN_HIOS);

843ECase(SHN_ABS);

844ECase(SHN_COMMON);

845ECase(SHN_XINDEX);

846ECase(SHN_HIRESERVE);

847ECase(SHN_AMDGPU_LDS);

848

849if (!IO.outputting() ||Object->getMachine() ==ELF::EM_MIPS) {

850ECase(SHN_MIPS_ACOMMON);

851ECase(SHN_MIPS_TEXT);

852ECase(SHN_MIPS_DATA);

853ECase(SHN_MIPS_SCOMMON);

854ECase(SHN_MIPS_SUNDEFINED);

855 }

856

857ECase(SHN_HEXAGON_SCOMMON);

858ECase(SHN_HEXAGON_SCOMMON_1);

859ECase(SHN_HEXAGON_SCOMMON_2);

860ECase(SHN_HEXAGON_SCOMMON_4);

861ECase(SHN_HEXAGON_SCOMMON_8);

862#undef ECase

863 IO.enumFallback<Hex16>(Value);

864}

865

866void ScalarEnumerationTraits<ELFYAML::ELF_STB>::enumeration(

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

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

869ECase(STB_LOCAL);

870ECase(STB_GLOBAL);

871ECase(STB_WEAK);

872ECase(STB_GNU_UNIQUE);

873#undef ECase

874 IO.enumFallback<Hex8>(Value);

875}

876

877void ScalarEnumerationTraits<ELFYAML::ELF_STT>::enumeration(

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

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

880ECase(STT_NOTYPE);

881ECase(STT_OBJECT);

882ECase(STT_FUNC);

883ECase(STT_SECTION);

884ECase(STT_FILE);

885ECase(STT_COMMON);

886ECase(STT_TLS);

887ECase(STT_GNU_IFUNC);

888#undef ECase

889 IO.enumFallback<Hex8>(Value);

890}

891

892

893void ScalarEnumerationTraits<ELFYAML::ELF_RSS>::enumeration(

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

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

896ECase(RSS_UNDEF);

897ECase(RSS_GP);

898ECase(RSS_GP0);

899ECase(RSS_LOC);

900#undef ECase

901}

902

903void ScalarEnumerationTraits<ELFYAML::ELF_REL>::enumeration(

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

905constauto *Object =static_cast<ELFYAML::Object *>(IO.getContext());

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

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

908switch (Object->getMachine()) {

909caseELF::EM_X86_64:

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

911break;

912caseELF::EM_MIPS:

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

914break;

915caseELF::EM_HEXAGON:

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

917break;

918caseELF::EM_386:

919caseELF::EM_IAMCU:

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

921break;

922caseELF::EM_AARCH64:

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

924break;

925caseELF::EM_ARM:

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

927break;

928caseELF::EM_ARC:

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

930break;

931caseELF::EM_RISCV:

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

933break;

934caseELF::EM_LANAI:

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

936break;

937caseELF::EM_AMDGPU:

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

939break;

940caseELF::EM_BPF:

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

942break;

943caseELF::EM_VE:

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

945break;

946caseELF::EM_CSKY:

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

948break;

949caseELF::EM_PPC:

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

951break;

952caseELF::EM_PPC64:

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

954break;

955caseELF::EM_68K:

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

957break;

958caseELF::EM_LOONGARCH:

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

960break;

961caseELF::EM_XTENSA:

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

963break;

964default:

965// Nothing to do.

966break;

967 }

968#undef ELF_RELOC

969 IO.enumFallback<Hex32>(Value);

970}

971

972void ScalarEnumerationTraits<ELFYAML::ELF_DYNTAG>::enumeration(

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

974constauto *Object =static_cast<ELFYAML::Object *>(IO.getContext());

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

976

977// Disable architecture specific tags by default. We might enable them below.

978#define AARCH64_DYNAMIC_TAG(name, value)

979#define MIPS_DYNAMIC_TAG(name, value)

980#define HEXAGON_DYNAMIC_TAG(name, value)

981#define PPC_DYNAMIC_TAG(name, value)

982#define PPC64_DYNAMIC_TAG(name, value)

983// Ignore marker tags such as DT_HIOS (maps to DT_VERNEEDNUM), etc.

984#define DYNAMIC_TAG_MARKER(name, value)

985

986#define STRINGIFY(X) (#X)

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

988switch (Object->getMachine()) {

989caseELF::EM_AARCH64:

990#undef AARCH64_DYNAMIC_TAG

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

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

993#undef AARCH64_DYNAMIC_TAG

994#define AARCH64_DYNAMIC_TAG(name, value)

995break;

996caseELF::EM_MIPS:

997#undef MIPS_DYNAMIC_TAG

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

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

1000#undef MIPS_DYNAMIC_TAG

1001#define MIPS_DYNAMIC_TAG(name, value)

1002break;

1003caseELF::EM_HEXAGON:

1004#undef HEXAGON_DYNAMIC_TAG

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

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

1007#undef HEXAGON_DYNAMIC_TAG

1008#define HEXAGON_DYNAMIC_TAG(name, value)

1009break;

1010caseELF::EM_PPC:

1011#undef PPC_DYNAMIC_TAG

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

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

1014#undef PPC_DYNAMIC_TAG

1015#define PPC_DYNAMIC_TAG(name, value)

1016break;

1017caseELF::EM_PPC64:

1018#undef PPC64_DYNAMIC_TAG

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

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

1021#undef PPC64_DYNAMIC_TAG

1022#define PPC64_DYNAMIC_TAG(name, value)

1023break;

1024caseELF::EM_RISCV:

1025#undef RISCV_DYNAMIC_TAG

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

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

1028#undef RISCV_DYNAMIC_TAG

1029#define RISCV_DYNAMIC_TAG(name, value)

1030break;

1031default:

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

1033break;

1034 }

1035#undef AARCH64_DYNAMIC_TAG

1036#undef MIPS_DYNAMIC_TAG

1037#undef HEXAGON_DYNAMIC_TAG

1038#undef PPC_DYNAMIC_TAG

1039#undef PPC64_DYNAMIC_TAG

1040#undef DYNAMIC_TAG_MARKER

1041#undef STRINGIFY

1042#undef DYNAMIC_TAG

1043

1044 IO.enumFallback<Hex64>(Value);

1045}

1046

1047void ScalarEnumerationTraits<ELFYAML::MIPS_AFL_REG>::enumeration(

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

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

1050ECase(REG_NONE);

1051ECase(REG_32);

1052ECase(REG_64);

1053ECase(REG_128);

1054#undef ECase

1055}

1056

1057void ScalarEnumerationTraits<ELFYAML::MIPS_ABI_FP>::enumeration(

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

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

1060ECase(FP_ANY);

1061ECase(FP_DOUBLE);

1062ECase(FP_SINGLE);

1063ECase(FP_SOFT);

1064ECase(FP_OLD_64);

1065ECase(FP_XX);

1066ECase(FP_64);

1067ECase(FP_64A);

1068#undef ECase

1069}

1070

1071void ScalarEnumerationTraits<ELFYAML::MIPS_AFL_EXT>::enumeration(

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

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

1074ECase(EXT_NONE);

1075ECase(EXT_XLR);

1076ECase(EXT_OCTEON2);

1077ECase(EXT_OCTEONP);

1078ECase(EXT_LOONGSON_3A);

1079ECase(EXT_OCTEON);

1080ECase(EXT_5900);

1081ECase(EXT_4650);

1082ECase(EXT_4010);

1083ECase(EXT_4100);

1084ECase(EXT_3900);

1085ECase(EXT_10000);

1086ECase(EXT_SB1);

1087ECase(EXT_4111);

1088ECase(EXT_4120);

1089ECase(EXT_5400);

1090ECase(EXT_5500);

1091ECase(EXT_LOONGSON_2E);

1092ECase(EXT_LOONGSON_2F);

1093ECase(EXT_OCTEON3);

1094#undef ECase

1095}

1096

1097void ScalarEnumerationTraits<ELFYAML::MIPS_ISA>::enumeration(

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

1099 IO.enumCase(Value,"MIPS1", 1);

1100 IO.enumCase(Value,"MIPS2", 2);

1101 IO.enumCase(Value,"MIPS3", 3);

1102 IO.enumCase(Value,"MIPS4", 4);

1103 IO.enumCase(Value,"MIPS5", 5);

1104 IO.enumCase(Value,"MIPS32", 32);

1105 IO.enumCase(Value,"MIPS64", 64);

1106 IO.enumFallback<Hex32>(Value);

1107}

1108

1109void ScalarBitSetTraits<ELFYAML::MIPS_AFL_ASE>::bitset(

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

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

1112BCase(DSP);

1113BCase(DSPR2);

1114BCase(EVA);

1115BCase(MCU);

1116BCase(MDMX);

1117BCase(MIPS3D);

1118BCase(MT);

1119BCase(SMARTMIPS);

1120BCase(VIRT);

1121BCase(MSA);

1122BCase(MIPS16);

1123BCase(MICROMIPS);

1124BCase(XPA);

1125BCase(CRC);

1126BCase(GINV);

1127#undef BCase

1128}

1129

1130void ScalarBitSetTraits<ELFYAML::MIPS_AFL_FLAGS1>::bitset(

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

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

1133BCase(ODDSPREG);

1134#undef BCase

1135}

1136

1137void MappingTraits<ELFYAML::SectionHeader>::mapping(

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

1139 IO.mapRequired("Name", SHdr.Name);

1140}

1141

1142void MappingTraits<ELFYAML::FileHeader>::mapping(IO &IO,

1143 ELFYAML::FileHeader &FileHdr) {

1144 IO.mapRequired("Class", FileHdr.Class);

1145 IO.mapRequired("Data", FileHdr.Data);

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

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

1148 IO.mapRequired("Type", FileHdr.Type);

1149 IO.mapOptional("Machine", FileHdr.Machine);

1150 IO.mapOptional("Flags", FileHdr.Flags, ELFYAML::ELF_EF(0));

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

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

1153

1154// obj2yaml does not dump these fields.

1155assert(!IO.outputting() ||

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

1157 IO.mapOptional("EPhOff", FileHdr.EPhOff);

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

1159 IO.mapOptional("EPhNum", FileHdr.EPhNum);

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

1161 IO.mapOptional("EShOff", FileHdr.EShOff);

1162 IO.mapOptional("EShNum", FileHdr.EShNum);

1163 IO.mapOptional("EShStrNdx", FileHdr.EShStrNdx);

1164}

1165

1166void MappingTraits<ELFYAML::ProgramHeader>::mapping(

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

1168 IO.mapRequired("Type", Phdr.Type);

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

1170 IO.mapOptional("FirstSec", Phdr.FirstSec);

1171 IO.mapOptional("LastSec", Phdr.LastSec);

1172 IO.mapOptional("VAddr", Phdr.VAddr, Hex64(0));

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

1174 IO.mapOptional("Align", Phdr.Align);

1175 IO.mapOptional("FileSize", Phdr.FileSize);

1176 IO.mapOptional("MemSize", Phdr.MemSize);

1177 IO.mapOptional("Offset", Phdr.Offset);

1178}

1179

1180std::string MappingTraits<ELFYAML::ProgramHeader>::validate(

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

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

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

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

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

1186return"";

1187}

1188

1189LLVM_YAML_STRONG_TYPEDEF(StringRef, StOtherPiece)

1190

1191template <> struct ScalarTraits<StOtherPiece> {

1192staticvoidoutput(const StOtherPiece &Val,void *,raw_ostream &Out) {

1193 Out << Val;

1194 }

1195staticStringRef input(StringRef Scalar,void *, StOtherPiece &Val) {

1196 Val = Scalar;

1197return {};

1198 }

1199static QuotingTypemustQuote(StringRef) {return QuotingType::None; }

1200};

1201template <>structSequenceElementTraits<StOtherPiece> {

1202staticconstbool flow =true;

1203};

1204

1205template <>structScalarTraits<ELFYAML::YAMLFlowString> {

1206staticvoidoutput(const ELFYAML::YAMLFlowString &Val,void *,

1207raw_ostream &Out) {

1208 Out << Val;

1209 }

1210staticStringRef input(StringRef Scalar,void *,

1211 ELFYAML::YAMLFlowString &Val) {

1212 Val = Scalar;

1213return {};

1214 }

1215static QuotingTypemustQuote(StringRef S) {

1216return ScalarTraits<StringRef>::mustQuote(S);

1217 }

1218};

1219template <>structSequenceElementTraits<ELFYAML::YAMLFlowString> {

1220staticconstbool flow =true;

1221};

1222

1223namespace{

1224

1225structNormalizedOther {

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

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

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

1229"assumes a non-empty Original");

1230 std::vector<StOtherPiece> Ret;

1231constauto *Object =static_cast<ELFYAML::Object *>(YamlIO.getContext());

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

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

1234uint8_t FlagValue =P.second;

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

1236continue;

1237 *Original &= ~FlagValue;

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

1239 }

1240

1241if (*Original != 0) {

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

1243 Ret.push_back({UnknownFlagsHolder});

1244 }

1245

1246if (!Ret.empty())

1247Other = std::move(Ret);

1248 }

1249

1250uint8_t toValue(StringRef Name) {

1251constauto *Object =static_cast<ELFYAML::Object *>(YamlIO.getContext());

1252MapVector<StringRef, uint8_t> Flags =getFlags(Object->getMachine());

1253

1254auto It = Flags.find(Name);

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

1256return It->second;

1257

1258uint8_t Val;

1259if (to_integer(Name, Val))

1260return Val;

1261

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

1263Name);

1264return 0;

1265 }

1266

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

1268if (!Other)

1269return std::nullopt;

1270uint8_t Ret = 0;

1271for (StOtherPiece &Val : *Other)

1272 Ret |= toValue(Val);

1273return Ret;

1274 }

1275

1276// st_other field is used to encode symbol visibility and platform-dependent

1277// flags and values. This method returns a name to value map that is used for

1278// parsing and encoding this field.

1279MapVector<StringRef, uint8_t>getFlags(unsigned EMachine) {

1280MapVector<StringRef, uint8_t> Map;

1281// STV_* values are just enumeration values. We add them in a reversed order

1282// because when we convert the st_other to named constants when printing

1283// YAML we want to use a maximum number of bits on each step:

1284// when we have st_other == 3, we want to print it as STV_PROTECTED (3), but

1285// not as STV_HIDDEN (2) + STV_INTERNAL (1).

1286 Map["STV_PROTECTED"] =ELF::STV_PROTECTED;

1287 Map["STV_HIDDEN"] =ELF::STV_HIDDEN;

1288 Map["STV_INTERNAL"] =ELF::STV_INTERNAL;

1289// STV_DEFAULT is used to represent the default visibility and has a value

1290// 0. We want to be able to read it from YAML documents, but there is no

1291// reason to print it.

1292if (!YamlIO.outputting())

1293 Map["STV_DEFAULT"] =ELF::STV_DEFAULT;

1294

1295// MIPS is not consistent. All of the STO_MIPS_* values are bit flags,

1296// except STO_MIPS_MIPS16 which overlaps them. It should be checked and

1297// consumed first when we print the output, because we do not want to print

1298// any other flags that have the same bits instead.

1299if (EMachine ==ELF::EM_MIPS) {

1300 Map["STO_MIPS_MIPS16"] =ELF::STO_MIPS_MIPS16;

1301 Map["STO_MIPS_MICROMIPS"] =ELF::STO_MIPS_MICROMIPS;

1302 Map["STO_MIPS_PIC"] =ELF::STO_MIPS_PIC;

1303 Map["STO_MIPS_PLT"] =ELF::STO_MIPS_PLT;

1304 Map["STO_MIPS_OPTIONAL"] =ELF::STO_MIPS_OPTIONAL;

1305 }

1306

1307if (EMachine ==ELF::EM_AARCH64)

1308 Map["STO_AARCH64_VARIANT_PCS"] =ELF::STO_AARCH64_VARIANT_PCS;

1309if (EMachine ==ELF::EM_RISCV)

1310 Map["STO_RISCV_VARIANT_CC"] =ELF::STO_RISCV_VARIANT_CC;

1311return Map;

1312 }

1313

1314 IO &YamlIO;

1315 std::optional<std::vector<StOtherPiece>>Other;

1316 std::stringUnknownFlagsHolder;

1317};

1318

1319}// end anonymous namespace

1320

1321void ScalarTraits<ELFYAML::YAMLIntUInt>::output(const ELFYAML::YAMLIntUInt &Val,

1322void *Ctx, raw_ostream &Out) {

1323 Out << Val;

1324}

1325

1326StringRef ScalarTraits<ELFYAML::YAMLIntUInt>::input(StringRef Scalar,void *Ctx,

1327 ELFYAML::YAMLIntUInt &Val) {

1328constbool Is64 =static_cast<ELFYAML::Object *>(Ctx)->Header.Class ==

1329 ELFYAML::ELF_ELFCLASS(ELF::ELFCLASS64);

1330 StringRef ErrMsg ="invalid number";

1331// We do not accept negative hex numbers because their meaning is ambiguous.

1332// For example, would -0xfffffffff mean 1 or INT32_MIN?

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

1334return ErrMsg;

1335

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

1337const int64_t MinVal = Is64 ?INT64_MIN : INT32_MIN;

1338longlongInt;

1339if (getAsSignedInteger(Scalar,/*Radix=*/0,Int) || (Int < MinVal))

1340return ErrMsg;

1341 Val =Int;

1342return"";

1343 }

1344

1345constuint64_t MaxVal = Is64 ?UINT64_MAX : UINT32_MAX;

1346unsignedlonglongUInt;

1347if (getAsUnsignedInteger(Scalar,/*Radix=*/0, UInt) || (UInt > MaxVal))

1348return ErrMsg;

1349 Val =UInt;

1350return"";

1351}

1352

1353void MappingTraits<ELFYAML::Symbol>::mapping(IO &IO, ELFYAML::Symbol &Symbol) {

1354 IO.mapOptional("Name",Symbol.Name, StringRef());

1355 IO.mapOptional("StName",Symbol.StName);

1356 IO.mapOptional("Type",Symbol.Type, ELFYAML::ELF_STT(0));

1357 IO.mapOptional("Section",Symbol.Section);

1358 IO.mapOptional("Index",Symbol.Index);

1359 IO.mapOptional("Binding",Symbol.Binding, ELFYAML::ELF_STB(0));

1360 IO.mapOptional("Value",Symbol.Value);

1361 IO.mapOptional("Size",Symbol.Size);

1362

1363// Symbol's Other field is a bit special. It is usually a field that

1364// represents st_other and holds the symbol visibility. However, on some

1365// platforms, it can contain bit fields and regular values, or even sometimes

1366// a crazy mix of them (see comments for NormalizedOther). Because of this, we

1367// need special handling.

1368 MappingNormalization<NormalizedOther, std::optional<uint8_t>> Keys(

1369 IO,Symbol.Other);

1370 IO.mapOptional("Other", Keys->Other);

1371}

1372

1373std::string MappingTraits<ELFYAML::Symbol>::validate(IO &IO,

1374 ELFYAML::Symbol &Symbol) {

1375if (Symbol.Index &&Symbol.Section)

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

1377return"";

1378}

1379

1380staticvoidcommonSectionMapping(IO &IO,ELFYAML::Section &Section) {

1381 IO.mapOptional("Name", Section.Name,StringRef());

1382 IO.mapRequired("Type", Section.Type);

1383 IO.mapOptional("Flags", Section.Flags);

1384 IO.mapOptional("Address", Section.Address);

1385 IO.mapOptional("Link", Section.Link);

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

1387 IO.mapOptional("EntSize", Section.EntSize);

1388 IO.mapOptional("Offset", Section.Offset);

1389

1390 IO.mapOptional("Content", Section.Content);

1391 IO.mapOptional("Size", Section.Size);

1392

1393// obj2yaml does not dump these fields. They are expected to be empty when we

1394// are producing YAML, because yaml2obj sets appropriate values for them

1395// automatically when they are not explicitly defined.

1396assert(!IO.outputting() ||

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

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

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

1400 IO.mapOptional("ShName", Section.ShName);

1401 IO.mapOptional("ShOffset", Section.ShOffset);

1402 IO.mapOptional("ShSize", Section.ShSize);

1403 IO.mapOptional("ShFlags", Section.ShFlags);

1404 IO.mapOptional("ShType", Section.ShType);

1405}

1406

1407staticvoidsectionMapping(IO &IO,ELFYAML::DynamicSection &Section) {

1408commonSectionMapping(IO, Section);

1409 IO.mapOptional("Entries", Section.Entries);

1410}

1411

1412staticvoidsectionMapping(IO &IO,ELFYAML::RawContentSection &Section) {

1413commonSectionMapping(IO, Section);

1414

1415// We also support reading a content as array of bytes using the ContentArray

1416// key. obj2yaml never prints this field.

1417assert(!IO.outputting() || !Section.ContentBuf);

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

1419if (Section.ContentBuf) {

1420if (Section.Content)

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

1422 Section.Content =yaml::BinaryRef(*Section.ContentBuf);

1423 }

1424

1425 IO.mapOptional("Info", Section.Info);

1426}

1427

1428staticvoidsectionMapping(IO &IO,ELFYAML::BBAddrMapSection &Section) {

1429commonSectionMapping(IO, Section);

1430 IO.mapOptional("Content", Section.Content);

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

1432 IO.mapOptional("PGOAnalyses", Section.PGOAnalyses);

1433}

1434

1435staticvoidsectionMapping(IO &IO,ELFYAML::StackSizesSection &Section) {

1436commonSectionMapping(IO, Section);

1437 IO.mapOptional("Entries", Section.Entries);

1438}

1439

1440staticvoidsectionMapping(IO &IO,ELFYAML::HashSection &Section) {

1441commonSectionMapping(IO, Section);

1442 IO.mapOptional("Bucket", Section.Bucket);

1443 IO.mapOptional("Chain", Section.Chain);

1444

1445// obj2yaml does not dump these fields. They can be used to override nchain

1446// and nbucket values for creating broken sections.

1447assert(!IO.outputting() || (!Section.NBucket && !Section.NChain));

1448 IO.mapOptional("NChain", Section.NChain);

1449 IO.mapOptional("NBucket", Section.NBucket);

1450}

1451

1452staticvoidsectionMapping(IO &IO,ELFYAML::NoteSection &Section) {

1453commonSectionMapping(IO, Section);

1454 IO.mapOptional("Notes", Section.Notes);

1455}

1456

1457

1458staticvoidsectionMapping(IO &IO,ELFYAML::GnuHashSection &Section) {

1459commonSectionMapping(IO, Section);

1460 IO.mapOptional("Header", Section.Header);

1461 IO.mapOptional("BloomFilter", Section.BloomFilter);

1462 IO.mapOptional("HashBuckets", Section.HashBuckets);

1463 IO.mapOptional("HashValues", Section.HashValues);

1464}

1465staticvoidsectionMapping(IO &IO,ELFYAML::NoBitsSection &Section) {

1466commonSectionMapping(IO, Section);

1467}

1468

1469staticvoidsectionMapping(IO &IO,ELFYAML::VerdefSection &Section) {

1470commonSectionMapping(IO, Section);

1471 IO.mapOptional("Info", Section.Info);

1472 IO.mapOptional("Entries", Section.Entries);

1473}

1474

1475staticvoidsectionMapping(IO &IO,ELFYAML::SymverSection &Section) {

1476commonSectionMapping(IO, Section);

1477 IO.mapOptional("Entries", Section.Entries);

1478}

1479

1480staticvoidsectionMapping(IO &IO,ELFYAML::VerneedSection &Section) {

1481commonSectionMapping(IO, Section);

1482 IO.mapOptional("Info", Section.Info);

1483 IO.mapOptional("Dependencies", Section.VerneedV);

1484}

1485

1486staticvoidsectionMapping(IO &IO,ELFYAML::RelocationSection &Section) {

1487commonSectionMapping(IO, Section);

1488 IO.mapOptional("Info", Section.RelocatableSec,StringRef());

1489 IO.mapOptional("Relocations", Section.Relocations);

1490}

1491

1492staticvoidsectionMapping(IO &IO,ELFYAML::RelrSection &Section) {

1493commonSectionMapping(IO, Section);

1494 IO.mapOptional("Entries", Section.Entries);

1495}

1496

1497staticvoidgroupSectionMapping(IO &IO,ELFYAML::GroupSection &Group) {

1498commonSectionMapping(IO, Group);

1499 IO.mapOptional("Info", Group.Signature);

1500 IO.mapOptional("Members", Group.Members);

1501}

1502

1503staticvoidsectionMapping(IO &IO,ELFYAML::SymtabShndxSection &Section) {

1504commonSectionMapping(IO, Section);

1505 IO.mapOptional("Entries", Section.Entries);

1506}

1507

1508staticvoidsectionMapping(IO &IO,ELFYAML::AddrsigSection &Section) {

1509commonSectionMapping(IO, Section);

1510 IO.mapOptional("Symbols", Section.Symbols);

1511}

1512

1513staticvoidfillMapping(IO &IO,ELFYAML::Fill &Fill) {

1514 IO.mapOptional("Name", Fill.Name,StringRef());

1515 IO.mapOptional("Pattern", Fill.Pattern);

1516 IO.mapOptional("Offset", Fill.Offset);

1517 IO.mapRequired("Size", Fill.Size);

1518}

1519

1520staticvoidsectionHeaderTableMapping(IO &IO,

1521ELFYAML::SectionHeaderTable &SHT) {

1522 IO.mapOptional("Offset", SHT.Offset);

1523 IO.mapOptional("Sections", SHT.Sections);

1524 IO.mapOptional("Excluded", SHT.Excluded);

1525 IO.mapOptional("NoHeaders", SHT.NoHeaders);

1526}

1527

1528staticvoidsectionMapping(IO &IO,ELFYAML::LinkerOptionsSection &Section) {

1529commonSectionMapping(IO, Section);

1530 IO.mapOptional("Options", Section.Options);

1531}

1532

1533staticvoidsectionMapping(IO &IO,

1534ELFYAML::DependentLibrariesSection &Section) {

1535commonSectionMapping(IO, Section);

1536 IO.mapOptional("Libraries", Section.Libs);

1537}

1538

1539staticvoidsectionMapping(IO &IO,ELFYAML::CallGraphProfileSection &Section) {

1540commonSectionMapping(IO, Section);

1541 IO.mapOptional("Entries", Section.Entries);

1542}

1543

1544void MappingTraits<ELFYAML::SectionOrType>::mapping(

1545 IO &IO,ELFYAML::SectionOrType &sectionOrType) {

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

1547}

1548

1549staticvoidsectionMapping(IO &IO,ELFYAML::ARMIndexTableSection &Section) {

1550commonSectionMapping(IO, Section);

1551 IO.mapOptional("Entries", Section.Entries);

1552}

1553

1554staticvoidsectionMapping(IO &IO,ELFYAML::MipsABIFlags &Section) {

1555commonSectionMapping(IO, Section);

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

1557 IO.mapRequired("ISA", Section.ISALevel);

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

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

1560 ELFYAML::MIPS_AFL_EXT(Mips::AFL_EXT_NONE));

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

1562 IO.mapOptional("FpABI", Section.FpABI,

1563 ELFYAML::MIPS_ABI_FP(Mips::Val_GNU_MIPS_ABI_FP_ANY));

1564 IO.mapOptional("GPRSize", Section.GPRSize,

1565 ELFYAML::MIPS_AFL_REG(Mips::AFL_REG_NONE));

1566 IO.mapOptional("CPR1Size", Section.CPR1Size,

1567 ELFYAML::MIPS_AFL_REG(Mips::AFL_REG_NONE));

1568 IO.mapOptional("CPR2Size", Section.CPR2Size,

1569 ELFYAML::MIPS_AFL_REG(Mips::AFL_REG_NONE));

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

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

1572}

1573

1574staticStringRef getStringValue(IO &IO,constchar *Key) {

1575StringRef Val;

1576 IO.mapRequired(Key, Val);

1577return Val;

1578}

1579

1580staticvoidsetStringValue(IO &IO,constchar *Key,StringRef Val) {

1581 IO.mapRequired(Key, Val);

1582}

1583

1584staticboolisInteger(StringRef Val) {

1585APInt Tmp;

1586return !Val.getAsInteger(0, Tmp);

1587}

1588

1589void MappingTraits<std::unique_ptr<ELFYAML::Chunk>>::mapping(

1590 IO &IO, std::unique_ptr<ELFYAML::Chunk> &Section) {

1591 ELFYAML::ELF_SHTType =ELF::SHT_NULL;

1592StringRef TypeStr;

1593if (IO.outputting()) {

1594if (auto *S = dyn_cast<ELFYAML::Section>(Section.get()))

1595Type = S->Type;

1596elseif (auto *SHT = dyn_cast<ELFYAML::SectionHeaderTable>(Section.get()))

1597 TypeStr = SHT->TypeStr;

1598 }else {

1599// When the Type string does not have a "SHT_" prefix, we know it is not a

1600// description of a regular ELF output section.

1601 TypeStr =getStringValue(IO,"Type");

1602if (TypeStr.starts_with("SHT_") ||isInteger(TypeStr))

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

1604 }

1605

1606if (TypeStr =="Fill") {

1607assert(!IO.outputting());// We don't dump fills currently.

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

1609fillMapping(IO, *cast<ELFYAML::Fill>(Section.get()));

1610return;

1611 }

1612

1613if (TypeStr ==ELFYAML::SectionHeaderTable::TypeStr) {

1614if (IO.outputting())

1615setStringValue(IO,"Type", TypeStr);

1616else

1617Section.reset(new ELFYAML::SectionHeaderTable(/*IsImplicit=*/false));

1618

1619sectionHeaderTableMapping(

1620 IO, *cast<ELFYAML::SectionHeaderTable>(Section.get()));

1621return;

1622 }

1623

1624constauto &Obj = *static_cast<ELFYAML::Object *>(IO.getContext());

1625if (Obj.getMachine() ==ELF::EM_MIPS &&Type ==ELF::SHT_MIPS_ABIFLAGS) {

1626if (!IO.outputting())

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

1628sectionMapping(IO, *cast<ELFYAML::MipsABIFlags>(Section.get()));

1629return;

1630 }

1631

1632if (Obj.getMachine() ==ELF::EM_ARM && Type ==ELF::SHT_ARM_EXIDX) {

1633if (!IO.outputting())

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

1635sectionMapping(IO, *cast<ELFYAML::ARMIndexTableSection>(Section.get()));

1636return;

1637 }

1638

1639switch (Type) {

1640caseELF::SHT_DYNAMIC:

1641if (!IO.outputting())

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

1643sectionMapping(IO, *cast<ELFYAML::DynamicSection>(Section.get()));

1644break;

1645caseELF::SHT_REL:

1646caseELF::SHT_RELA:

1647caseELF::SHT_CREL:

1648if (!IO.outputting())

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

1650sectionMapping(IO, *cast<ELFYAML::RelocationSection>(Section.get()));

1651break;

1652caseELF::SHT_RELR:

1653if (!IO.outputting())

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

1655sectionMapping(IO, *cast<ELFYAML::RelrSection>(Section.get()));

1656break;

1657caseELF::SHT_GROUP:

1658if (!IO.outputting())

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

1660groupSectionMapping(IO, *cast<ELFYAML::GroupSection>(Section.get()));

1661break;

1662caseELF::SHT_NOBITS:

1663if (!IO.outputting())

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

1665sectionMapping(IO, *cast<ELFYAML::NoBitsSection>(Section.get()));

1666break;

1667caseELF::SHT_HASH:

1668if (!IO.outputting())

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

1670sectionMapping(IO, *cast<ELFYAML::HashSection>(Section.get()));

1671break;

1672caseELF::SHT_NOTE:

1673if (!IO.outputting())

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

1675sectionMapping(IO, *cast<ELFYAML::NoteSection>(Section.get()));

1676break;

1677caseELF::SHT_GNU_HASH:

1678if (!IO.outputting())

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

1680sectionMapping(IO, *cast<ELFYAML::GnuHashSection>(Section.get()));

1681break;

1682caseELF::SHT_GNU_verdef:

1683if (!IO.outputting())

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

1685sectionMapping(IO, *cast<ELFYAML::VerdefSection>(Section.get()));

1686break;

1687caseELF::SHT_GNU_versym:

1688if (!IO.outputting())

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

1690sectionMapping(IO, *cast<ELFYAML::SymverSection>(Section.get()));

1691break;

1692caseELF::SHT_GNU_verneed:

1693if (!IO.outputting())

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

1695sectionMapping(IO, *cast<ELFYAML::VerneedSection>(Section.get()));

1696break;

1697caseELF::SHT_SYMTAB_SHNDX:

1698if (!IO.outputting())

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

1700sectionMapping(IO, *cast<ELFYAML::SymtabShndxSection>(Section.get()));

1701break;

1702caseELF::SHT_LLVM_ADDRSIG:

1703if (!IO.outputting())

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

1705sectionMapping(IO, *cast<ELFYAML::AddrsigSection>(Section.get()));

1706break;

1707caseELF::SHT_LLVM_LINKER_OPTIONS:

1708if (!IO.outputting())

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

1710sectionMapping(IO, *cast<ELFYAML::LinkerOptionsSection>(Section.get()));

1711break;

1712caseELF::SHT_LLVM_DEPENDENT_LIBRARIES:

1713if (!IO.outputting())

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

1715sectionMapping(IO,

1716 *cast<ELFYAML::DependentLibrariesSection>(Section.get()));

1717break;

1718caseELF::SHT_LLVM_CALL_GRAPH_PROFILE:

1719if (!IO.outputting())

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

1721sectionMapping(IO, *cast<ELFYAML::CallGraphProfileSection>(Section.get()));

1722break;

1723caseELF::SHT_LLVM_BB_ADDR_MAP:

1724if (!IO.outputting())

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

1726sectionMapping(IO, *cast<ELFYAML::BBAddrMapSection>(Section.get()));

1727break;

1728default:

1729if (!IO.outputting()) {

1730 StringRefName;

1731 IO.mapOptional("Name",Name, StringRef());

1732Name =ELFYAML::dropUniqueSuffix(Name);

1733

1734if (ELFYAML::StackSizesSection::nameMatches(Name))

1735Section = std::make_unique<ELFYAML::StackSizesSection>();

1736else

1737Section = std::make_unique<ELFYAML::RawContentSection>();

1738 }

1739

1740if (auto S = dyn_cast<ELFYAML::RawContentSection>(Section.get()))

1741sectionMapping(IO, *S);

1742else

1743sectionMapping(IO, *cast<ELFYAML::StackSizesSection>(Section.get()));

1744 }

1745}

1746

1747std::string MappingTraits<std::unique_ptr<ELFYAML::Chunk>>::validate(

1748 IO &io, std::unique_ptr<ELFYAML::Chunk> &C) {

1749if (constauto *F = dyn_cast<ELFYAML::Fill>(C.get())) {

1750// Can't check the `Size`, as it's required and may be left uninitialized by

1751// previous error.

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

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

1754return"";

1755 }

1756

1757if (constauto *SHT = dyn_cast<ELFYAML::SectionHeaderTable>(C.get())) {

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

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

1760return"";

1761 }

1762

1763const ELFYAML::Section &Sec = *cast<ELFYAML::Section>(C.get());

1764if (Sec.Size && Sec.Content &&

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

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

1767

1768auto BuildErrPrefix = [](ArrayRef<std::pair<StringRef, bool>> EntV) {

1769 std::string Msg;

1770for (size_tI = 0,E = EntV.size();I !=E; ++I) {

1771 StringRefName = EntV[I].first;

1772if (I == 0) {

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

1774continue;

1775 }

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

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

1778else

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

1780 }

1781return Msg;

1782 };

1783

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

1785constsize_t NumUsedEntries =llvm::count_if(

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

1787

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

1789return BuildErrPrefix(Entries) +

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

1791

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

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

1794

1795if (constauto *RawSection = dyn_cast<ELFYAML::RawContentSection>(C.get())) {

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

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

1798return"";

1799 }

1800

1801if (constauto *NB = dyn_cast<ELFYAML::NoBitsSection>(C.get())) {

1802if (NB->Content)

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

1804return"";

1805 }

1806

1807if (constauto *MF = dyn_cast<ELFYAML::MipsABIFlags>(C.get())) {

1808if (MF->Content)

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

1810"sections";

1811if (MF->Size)

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

1813return"";

1814 }

1815

1816return"";

1817}

1818

1819namespace{

1820

1821structNormalizedMips64RelType {

1822 NormalizedMips64RelType(IO &)

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

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

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

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

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

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

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

1830

1831 ELFYAML::ELF_REL denormalize(IO &) {

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

1833return Res;

1834 }

1835

1836 ELFYAML::ELF_REL Type;

1837 ELFYAML::ELF_RELType2;

1838 ELFYAML::ELF_RELType3;

1839 ELFYAML::ELF_RSSSpecSym;

1840};

1841

1842}// end anonymous namespace

1843

1844void MappingTraits<ELFYAML::StackSizeEntry>::mapping(

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

1846assert(IO.getContext() &&"The IO context is not initialized");

1847 IO.mapOptional("Address",E.Address, Hex64(0));

1848 IO.mapRequired("Size",E.Size);

1849}

1850

1851void MappingTraits<ELFYAML::BBAddrMapEntry>::mapping(

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

1853assert(IO.getContext() &&"The IO context is not initialized");

1854 IO.mapRequired("Version",E.Version);

1855 IO.mapOptional("Feature",E.Feature, Hex8(0));

1856 IO.mapOptional("NumBBRanges",E.NumBBRanges);

1857 IO.mapOptional("BBRanges",E.BBRanges);

1858}

1859

1860void MappingTraits<ELFYAML::BBAddrMapEntry::BBRangeEntry>::mapping(

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

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

1863 IO.mapOptional("NumBlocks",E.NumBlocks);

1864 IO.mapOptional("BBEntries",E.BBEntries);

1865}

1866

1867void MappingTraits<ELFYAML::BBAddrMapEntry::BBEntry>::mapping(

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

1869assert(IO.getContext() &&"The IO context is not initialized");

1870 IO.mapOptional("ID",E.ID);

1871 IO.mapRequired("AddressOffset",E.AddressOffset);

1872 IO.mapRequired("Size",E.Size);

1873 IO.mapRequired("Metadata",E.Metadata);

1874}

1875

1876void MappingTraits<ELFYAML::PGOAnalysisMapEntry>::mapping(

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

1878assert(IO.getContext() &&"The IO context is not initialized");

1879 IO.mapOptional("FuncEntryCount",E.FuncEntryCount);

1880 IO.mapOptional("PGOBBEntries",E.PGOBBEntries);

1881}

1882

1883void MappingTraits<ELFYAML::PGOAnalysisMapEntry::PGOBBEntry>::mapping(

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

1885assert(IO.getContext() &&"The IO context is not initialized");

1886 IO.mapOptional("BBFreq",E.BBFreq);

1887 IO.mapOptional("Successors",E.Successors);

1888}

1889

1890void MappingTraits<ELFYAML::PGOAnalysisMapEntry::PGOBBEntry::SuccessorEntry>::

1891 mapping(IO &IO,

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

1893assert(IO.getContext() &&"The IO context is not initialized");

1894 IO.mapRequired("ID",E.ID);

1895 IO.mapRequired("BrProb",E.BrProb);

1896}

1897

1898void MappingTraits<ELFYAML::GnuHashHeader>::mapping(IO &IO,

1899 ELFYAML::GnuHashHeader &E) {

1900assert(IO.getContext() &&"The IO context is not initialized");

1901 IO.mapOptional("NBuckets",E.NBuckets);

1902 IO.mapRequired("SymNdx",E.SymNdx);

1903 IO.mapOptional("MaskWords",E.MaskWords);

1904 IO.mapRequired("Shift2",E.Shift2);

1905}

1906

1907void MappingTraits<ELFYAML::DynamicEntry>::mapping(IO &IO,

1908 ELFYAML::DynamicEntry &Rel) {

1909assert(IO.getContext() &&"The IO context is not initialized");

1910

1911 IO.mapRequired("Tag", Rel.Tag);

1912 IO.mapRequired("Value", Rel.Val);

1913}

1914

1915void MappingTraits<ELFYAML::NoteEntry>::mapping(IO &IO, ELFYAML::NoteEntry &N) {

1916assert(IO.getContext() &&"The IO context is not initialized");

1917

1918 IO.mapOptional("Name",N.Name);

1919 IO.mapOptional("Desc",N.Desc);

1920 IO.mapRequired("Type",N.Type);

1921}

1922

1923void MappingTraits<ELFYAML::VerdefEntry>::mapping(IO &IO,

1924 ELFYAML::VerdefEntry &E) {

1925assert(IO.getContext() &&"The IO context is not initialized");

1926

1927 IO.mapOptional("Version",E.Version);

1928 IO.mapOptional("Flags",E.Flags);

1929 IO.mapOptional("VersionNdx",E.VersionNdx);

1930 IO.mapOptional("Hash",E.Hash);

1931 IO.mapOptional("VDAux",E.VDAux);

1932 IO.mapRequired("Names",E.VerNames);

1933}

1934

1935void MappingTraits<ELFYAML::VerneedEntry>::mapping(IO &IO,

1936 ELFYAML::VerneedEntry &E) {

1937assert(IO.getContext() &&"The IO context is not initialized");

1938

1939 IO.mapRequired("Version",E.Version);

1940 IO.mapRequired("File",E.File);

1941 IO.mapRequired("Entries",E.AuxV);

1942}

1943

1944void MappingTraits<ELFYAML::VernauxEntry>::mapping(IO &IO,

1945 ELFYAML::VernauxEntry &E) {

1946assert(IO.getContext() &&"The IO context is not initialized");

1947

1948 IO.mapRequired("Name",E.Name);

1949 IO.mapRequired("Hash",E.Hash);

1950 IO.mapRequired("Flags",E.Flags);

1951 IO.mapRequired("Other",E.Other);

1952}

1953

1954void MappingTraits<ELFYAML::Relocation>::mapping(IO &IO,

1955 ELFYAML::Relocation &Rel) {

1956constauto *Object =static_cast<ELFYAML::Object *>(IO.getContext());

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

1958

1959 IO.mapOptional("Offset", Rel.Offset, (Hex64)0);

1960 IO.mapOptional("Symbol", Rel.Symbol);

1961

1962if (Object->getMachine() == ELFYAML::ELF_EM(ELF::EM_MIPS) &&

1963Object->Header.Class == ELFYAML::ELF_ELFCLASS(ELF::ELFCLASS64)) {

1964 MappingNormalization<NormalizedMips64RelType, ELFYAML::ELF_REL>Key(

1965 IO, Rel.Type);

1966 IO.mapRequired("Type",Key->Type);

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

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

1969 IO.mapOptional("SpecSym",Key->SpecSym, ELFYAML::ELF_RSS(ELF::RSS_UNDEF));

1970 }else

1971 IO.mapRequired("Type", Rel.Type);

1972

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

1974}

1975

1976void MappingTraits<ELFYAML::ARMIndexTableEntry>::mapping(

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

1978assert(IO.getContext() &&"The IO context is not initialized");

1979 IO.mapRequired("Offset",E.Offset);

1980

1981 StringRef CantUnwind ="EXIDX_CANTUNWIND";

1982if (IO.outputting() && (uint32_t)E.Value ==ARM::EHABI::EXIDX_CANTUNWIND)

1983 IO.mapRequired("Value", CantUnwind);

1984elseif (!IO.outputting() &&getStringValue(IO,"Value") == CantUnwind)

1985E.Value =ARM::EHABI::EXIDX_CANTUNWIND;

1986else

1987 IO.mapRequired("Value",E.Value);

1988}

1989

1990void MappingTraits<ELFYAML::Object>::mapping(IO &IO, ELFYAML::Object &Object) {

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

1992 IO.setContext(&Object);

1993 IO.mapTag("!ELF",true);

1994 IO.mapRequired("FileHeader",Object.Header);

1995 IO.mapOptional("ProgramHeaders",Object.ProgramHeaders);

1996 IO.mapOptional("Sections",Object.Chunks);

1997 IO.mapOptional("Symbols",Object.Symbols);

1998 IO.mapOptional("DynamicSymbols",Object.DynamicSymbols);

1999 IO.mapOptional("DWARF",Object.DWARF);

2000if (Object.DWARF) {

2001Object.DWARF->IsLittleEndian =

2002Object.Header.Data == ELFYAML::ELF_ELFDATA(ELF::ELFDATA2LSB);

2003Object.DWARF->Is64BitAddrSize =

2004Object.Header.Class == ELFYAML::ELF_ELFCLASS(ELF::ELFCLASS64);

2005 }

2006 IO.setContext(nullptr);

2007}

2008

2009void MappingTraits<ELFYAML::LinkerOption>::mapping(IO &IO,

2010 ELFYAML::LinkerOption &Opt) {

2011assert(IO.getContext() &&"The IO context is not initialized");

2012 IO.mapRequired("Name", Opt.Key);

2013 IO.mapRequired("Value", Opt.Value);

2014}

2015

2016void MappingTraits<ELFYAML::CallGraphEntryWeight>::mapping(

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

2018assert(IO.getContext() &&"The IO context is not initialized");

2019 IO.mapRequired("Weight",E.Weight);

2020}

2021

2022LLVM_YAML_STRONG_TYPEDEF(uint8_t, MIPS_AFL_REG)

2023LLVM_YAML_STRONG_TYPEDEF(uint8_t, MIPS_ABI_FP)

2024LLVM_YAML_STRONG_TYPEDEF(uint32_t, MIPS_AFL_EXT)

2025LLVM_YAML_STRONG_TYPEDEF(uint32_t, MIPS_AFL_ASE)

2026LLVM_YAML_STRONG_TYPEDEF(uint32_t, MIPS_AFL_FLAGS1)

2027

2028}// end namespace yaml

2029

2030}// end namespace llvm

APInt.h

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

ARMEHABI.h

ELF.h

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

BCase

#define BCase(X)

Definition:COFFYAML.cpp:267

Casting.h

Name

std::string Name

Definition:ELFObjHandler.cpp:77

UnknownFlagsHolder

std::string UnknownFlagsHolder

Definition:ELFYAML.cpp:1316

SpecSym

ELFYAML::ELF_RSS SpecSym

Definition:ELFYAML.cpp:1839

Type3

ELFYAML::ELF_REL Type3

Definition:ELFYAML.cpp:1838

BCaseMask

#define BCaseMask(X, M)

YamlIO

IO & YamlIO

Definition:ELFYAML.cpp:1314

Type2

ELFYAML::ELF_REL Type2

Definition:ELFYAML.cpp:1837

Other

std::optional< std::vector< StOtherPiece > > Other

Definition:ELFYAML.cpp:1315

ELFYAML.h

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

#define F(x, y, z)

Definition:MD5.cpp:55

#define I(x, y, z)

Definition:MD5.cpp:58

MapVector.h

This file implements a map that provides insertion order iteration.

MipsABIFlags.h

#define P(N)

assert

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

StringRef.h

getFlags

static uint32_t getFlags(const Symbol *Sym)

Definition:TapiFile.cpp:26

Int

@ Int

Definition:TargetLibraryInfo.cpp:65

ECase

#define ECase(X)

WithColor.h

YAMLTraits.h

LLVM_YAML_STRONG_TYPEDEF

#define LLVM_YAML_STRONG_TYPEDEF(_base, _type)

llvm::APInt

Class for arbitrary precision integers.

Definition:APInt.h:78

llvm::MapVector

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

Definition:MapVector.h:36

llvm::StringRef

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

Definition:StringRef.h:51

llvm::StringRef::getAsInteger

bool getAsInteger(unsigned Radix, T &Result) const

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

Definition:StringRef.h:470

llvm::StringRef::starts_with

bool starts_with(StringRef Prefix) const

Check if this string starts with the given Prefix.

Definition:StringRef.h:265

llvm::Type

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

Definition:Type.h:45

llvm::Type::Type

Type(LLVMContext &C, TypeID tid)

Definition:Type.h:93

llvm::Value

LLVM Value Representation.

Definition:Value.h:74

llvm::raw_ostream

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

Definition:raw_ostream.h:52

llvm::yaml::BinaryRef

Specialized YAMLIO scalar type for representing a binary blob.

Definition:YAML.h:63

#define UINT64_MAX

Definition:DataTypes.h:77

INT64_MIN

#define INT64_MIN

Definition:DataTypes.h:74

ErrorHandling.h

llvm::AMDGPU::PALMD::Key

Key

PAL metadata keys.

Definition:AMDGPUMetadata.h:487

llvm::ARMBuildAttrs::Section

@ Section

Legacy Tags.

Definition:ARMBuildAttributes.h:82

llvm::ARMBuildAttrs::Symbol

@ Symbol

Definition:ARMBuildAttributes.h:83

llvm::ARM::EHABI::EXIDX_CANTUNWIND

@ EXIDX_CANTUNWIND

Special entry for the function never unwind.

Definition:ARMEHABI.h:35

llvm::CallingConv::C

@ C

The default llvm calling convention, compatible with C.

Definition:CallingConv.h:34

llvm::ELFYAML::dropUniqueSuffix

StringRef dropUniqueSuffix(StringRef S)

Definition:ELFEmitter.cpp:695

llvm::ELF::STO_AARCH64_VARIANT_PCS

@ STO_AARCH64_VARIANT_PCS

Definition:ELF.h:435

llvm::ELF::ELFOSABI_SOLARIS

@ ELFOSABI_SOLARIS

Definition:ELF.h:350

llvm::ELF::STO_MIPS_PIC

@ STO_MIPS_PIC

Definition:ELF.h:592

llvm::ELF::STO_MIPS_OPTIONAL

@ STO_MIPS_OPTIONAL

Definition:ELF.h:590

llvm::ELF::STO_MIPS_MICROMIPS

@ STO_MIPS_MICROMIPS

Definition:ELF.h:593

llvm::ELF::STO_MIPS_MIPS16

@ STO_MIPS_MIPS16

Definition:ELF.h:594

llvm::ELF::STO_MIPS_PLT

@ STO_MIPS_PLT

Definition:ELF.h:591

llvm::ELF::ELFCLASS64

@ ELFCLASS64

Definition:ELF.h:332

llvm::ELF::EM_MSP430

@ EM_MSP430

Definition:ELF.h:225

llvm::ELF::EM_PPC64

@ EM_PPC64

Definition:ELF.h:152

llvm::ELF::EM_CSKY

@ EM_CSKY

Definition:ELF.h:324

llvm::ELF::EM_SPARC32PLUS

@ EM_SPARC32PLUS

Definition:ELF.h:149

llvm::ELF::EM_NONE

@ EM_NONE

Definition:ELF.h:136

llvm::ELF::EM_68K

@ EM_68K

Definition:ELF.h:140

llvm::ELF::EM_386

@ EM_386

Definition:ELF.h:139

llvm::ELF::EM_LOONGARCH

@ EM_LOONGARCH

Definition:ELF.h:325

llvm::ELF::EM_BPF

@ EM_BPF

Definition:ELF.h:322

llvm::ELF::EM_PPC

@ EM_PPC

Definition:ELF.h:151

llvm::ELF::EM_X86_64

@ EM_X86_64

Definition:ELF.h:181

llvm::ELF::EM_HEXAGON

@ EM_HEXAGON

Definition:ELF.h:260

llvm::ELF::EM_LANAI

@ EM_LANAI

Definition:ELF.h:321

llvm::ELF::EM_MIPS

@ EM_MIPS

Definition:ELF.h:144

llvm::ELF::EM_ARC

@ EM_ARC

Definition:ELF.h:164

llvm::ELF::EM_SPARCV9

@ EM_SPARCV9

Definition:ELF.h:162

llvm::ELF::EM_AARCH64

@ EM_AARCH64

Definition:ELF.h:283

llvm::ELF::EM_XTENSA

@ EM_XTENSA

Definition:ELF.h:214

llvm::ELF::EM_RISCV

@ EM_RISCV

Definition:ELF.h:320

llvm::ELF::EM_ARM

@ EM_ARM

Definition:ELF.h:159

llvm::ELF::EM_VE

@ EM_VE

Definition:ELF.h:323

llvm::ELF::EM_IAMCU

@ EM_IAMCU

Definition:ELF.h:142

llvm::ELF::EM_AMDGPU

@ EM_AMDGPU

Definition:ELF.h:319

llvm::ELF::EM_AVR

@ EM_AVR

Definition:ELF.h:202

llvm::ELF::SHT_LLVM_DEPENDENT_LIBRARIES

@ SHT_LLVM_DEPENDENT_LIBRARIES

Definition:ELF.h:1129

llvm::ELF::SHT_GROUP

@ SHT_GROUP

Definition:ELF.h:1112

llvm::ELF::SHT_LLVM_LINKER_OPTIONS

@ SHT_LLVM_LINKER_OPTIONS

Definition:ELF.h:1126

llvm::ELF::SHT_REL

@ SHT_REL

Definition:ELF.h:1106

llvm::ELF::SHT_NULL

@ SHT_NULL

Definition:ELF.h:1097

llvm::ELF::SHT_LLVM_CALL_GRAPH_PROFILE

@ SHT_LLVM_CALL_GRAPH_PROFILE

Definition:ELF.h:1137

llvm::ELF::SHT_NOBITS

@ SHT_NOBITS

Definition:ELF.h:1105

llvm::ELF::SHT_GNU_verneed

@ SHT_GNU_verneed

Definition:ELF.h:1148

llvm::ELF::SHT_RELR

@ SHT_RELR

Definition:ELF.h:1116

llvm::ELF::SHT_GNU_verdef

@ SHT_GNU_verdef

Definition:ELF.h:1147

llvm::ELF::SHT_CREL

@ SHT_CREL

Definition:ELF.h:1119

llvm::ELF::SHT_DYNAMIC

@ SHT_DYNAMIC

Definition:ELF.h:1103

llvm::ELF::SHT_SYMTAB_SHNDX

@ SHT_SYMTAB_SHNDX

Definition:ELF.h:1113

llvm::ELF::SHT_LLVM_ADDRSIG

@ SHT_LLVM_ADDRSIG

Definition:ELF.h:1127

llvm::ELF::SHT_ARM_EXIDX

@ SHT_ARM_EXIDX

Definition:ELF.h:1154

llvm::ELF::SHT_LLVM_BB_ADDR_MAP

@ SHT_LLVM_BB_ADDR_MAP

Definition:ELF.h:1138

llvm::ELF::SHT_GNU_HASH

@ SHT_GNU_HASH

Definition:ELF.h:1146

llvm::ELF::SHT_RELA

@ SHT_RELA

Definition:ELF.h:1101

llvm::ELF::SHT_NOTE

@ SHT_NOTE

Definition:ELF.h:1104

llvm::ELF::SHT_MIPS_ABIFLAGS

@ SHT_MIPS_ABIFLAGS

Definition:ELF.h:1177

llvm::ELF::SHT_GNU_versym

@ SHT_GNU_versym

Definition:ELF.h:1149

llvm::ELF::SHT_HASH

@ SHT_HASH

Definition:ELF.h:1102

llvm::ELF::EF_AMDGPU_GENERIC_VERSION_MAX

@ EF_AMDGPU_GENERIC_VERSION_MAX

Definition:ELF.h:892

llvm::ELF::EF_AMDGPU_GENERIC_VERSION_OFFSET

@ EF_AMDGPU_GENERIC_VERSION_OFFSET

Definition:ELF.h:890

llvm::ELF::EF_AMDGPU_GENERIC_VERSION_MIN

@ EF_AMDGPU_GENERIC_VERSION_MIN

Definition:ELF.h:891

llvm::ELF::EF_AMDGPU_GENERIC_VERSION

@ EF_AMDGPU_GENERIC_VERSION

Definition:ELF.h:889

llvm::ELF::ELFABIVERSION_AMDGPU_HSA_V4

@ ELFABIVERSION_AMDGPU_HSA_V4

Definition:ELF.h:381

llvm::ELF::ELFABIVERSION_AMDGPU_HSA_V5

@ ELFABIVERSION_AMDGPU_HSA_V5

Definition:ELF.h:382

llvm::ELF::ELFABIVERSION_AMDGPU_HSA_V3

@ ELFABIVERSION_AMDGPU_HSA_V3

Definition:ELF.h:380

llvm::ELF::ELFABIVERSION_AMDGPU_HSA_V6

@ ELFABIVERSION_AMDGPU_HSA_V6

Definition:ELF.h:383

llvm::ELF::STO_RISCV_VARIANT_CC

@ STO_RISCV_VARIANT_CC

Definition:ELF.h:700

llvm::ELF::ELFDATA2LSB

@ ELFDATA2LSB

Definition:ELF.h:338

llvm::ELF::RSS_UNDEF

@ RSS_UNDEF

Definition:ELF.h:1392

llvm::ELF::STV_INTERNAL

@ STV_INTERNAL

Definition:ELF.h:1382

llvm::ELF::STV_HIDDEN

@ STV_HIDDEN

Definition:ELF.h:1383

llvm::ELF::STV_PROTECTED

@ STV_PROTECTED

Definition:ELF.h:1384

llvm::ELF::STV_DEFAULT

@ STV_DEFAULT

Definition:ELF.h:1381

llvm::M68k::MemAddrModeKind::K

@ K

llvm::Mips::AFL_REG_NONE

@ AFL_REG_NONE

Definition:MipsABIFlags.h:24

llvm::Mips::AFL_EXT_NONE

@ AFL_EXT_NONE

Definition:MipsABIFlags.h:51

llvm::Mips::Val_GNU_MIPS_ABI_FP_ANY

@ Val_GNU_MIPS_ABI_FP_ANY

Definition:MipsABIFlags.h:85

llvm::NVPTX::PTXLdStInstCode::Scalar

@ Scalar

Definition:NVPTX.h:162

llvm::TargetStackID::Value

Value

Definition:TargetFrameLowering.h:29

llvm::ifs::IFSSymbolType::Object

@ Object

llvm::logicalview::LVBinaryType::ELF

@ ELF

llvm::msgpack::Type

Type

MessagePack types as defined in the standard, with the exception of Integer being divided into a sign...

Definition:MsgPackReader.h:53

llvm::msgpack::Type::UInt

@ UInt

llvm::yaml::sectionMapping

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

Definition:ELFYAML.cpp:1407

llvm::yaml::groupSectionMapping

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

Definition:ELFYAML.cpp:1497

llvm::yaml::getStringValue

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

Definition:ELFYAML.cpp:1574

llvm::yaml::sectionHeaderTableMapping

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

Definition:ELFYAML.cpp:1520

llvm::yaml::commonSectionMapping

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

Definition:ELFYAML.cpp:1380

llvm::yaml::isInteger

static bool isInteger(StringRef Val)

Definition:ELFYAML.cpp:1584

llvm::yaml::fillMapping

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

Definition:ELFYAML.cpp:1513

llvm::yaml::setStringValue

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

Definition:ELFYAML.cpp:1580

llvm

This is an optimization pass for GlobalISel generic memory operations.

Definition:AddressRanges.h:18

llvm::getAsSignedInteger

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

Definition:StringRef.cpp:498

llvm::count_if

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

Definition:STLExtras.h:1945

llvm::getAsUnsignedInteger

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

Helper functions for StringRef::getAsInteger.

Definition:StringRef.cpp:488

#define N

llvm::ELFYAML::ARMIndexTableSection

Definition:ELFYAML.h:672

llvm::ELFYAML::AddrsigSection

Definition:ELFYAML.h:503

llvm::ELFYAML::BBAddrMapSection

Definition:ELFYAML.h:343

llvm::ELFYAML::CallGraphProfileSection

Definition:ELFYAML.h:554

llvm::ELFYAML::Chunk::Name

StringRef Name

Definition:ELFYAML.h:240

llvm::ELFYAML::Chunk::Offset

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

Definition:ELFYAML.h:241

llvm::ELFYAML::Chunk::~Chunk

virtual ~Chunk()

llvm::ELFYAML::DependentLibrariesSection

Definition:ELFYAML.h:534

llvm::ELFYAML::DynamicSection

Definition:ELFYAML.h:376

llvm::ELFYAML::FileHeader::OSABI

ELF_ELFOSABI OSABI

Definition:ELFYAML.h:116

llvm::ELFYAML::FileHeader::Machine

std::optional< ELF_EM > Machine

Definition:ELFYAML.h:119

llvm::ELFYAML::Fill

Definition:ELFYAML.h:309

llvm::ELFYAML::Fill::Size

llvm::yaml::Hex64 Size

Definition:ELFYAML.h:311

llvm::ELFYAML::Fill::Pattern

std::optional< yaml::BinaryRef > Pattern

Definition:ELFYAML.h:310

llvm::ELFYAML::GnuHashSection

Definition:ELFYAML.h:457

llvm::ELFYAML::GroupSection

Definition:ELFYAML.h:602

llvm::ELFYAML::GroupSection::Members

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

Definition:ELFYAML.h:605

llvm::ELFYAML::GroupSection::Signature

std::optional< StringRef > Signature

Definition:ELFYAML.h:606

llvm::ELFYAML::HashSection

Definition:ELFYAML.h:419

llvm::ELFYAML::LinkerOptionsSection

Definition:ELFYAML.h:520

llvm::ELFYAML::MipsABIFlags

Definition:ELFYAML.h:687

llvm::ELFYAML::NoBitsSection

Definition:ELFYAML.h:401

llvm::ELFYAML::NoteSection

Definition:ELFYAML.h:407

llvm::ELFYAML::Object

Definition:ELFYAML.h:723

llvm::ELFYAML::Object::getMachine

unsigned getMachine() const

Definition:ELFYAML.cpp:35

llvm::ELFYAML::Object::Header

FileHeader Header

Definition:ELFYAML.h:724

llvm::ELFYAML::Object::getOSAbi

ELF_ELFOSABI getOSAbi() const

Definition:ELFYAML.cpp:33

llvm::ELFYAML::RawContentSection

Definition:ELFYAML.h:388

llvm::ELFYAML::RelocationSection

Definition:ELFYAML.h:624

llvm::ELFYAML::RelrSection

Definition:ELFYAML.h:639

llvm::ELFYAML::SectionHeaderTable

Definition:ELFYAML.h:318

llvm::ELFYAML::SectionHeaderTable::Excluded

std::optional< std::vector< SectionHeader > > Excluded

Definition:ELFYAML.h:327

llvm::ELFYAML::SectionHeaderTable::TypeStr

static constexpr StringRef TypeStr

Definition:ELFYAML.h:340

llvm::ELFYAML::SectionHeaderTable::NoHeaders

std::optional< bool > NoHeaders

Definition:ELFYAML.h:328

llvm::ELFYAML::SectionHeaderTable::Sections

std::optional< std::vector< SectionHeader > > Sections

Definition:ELFYAML.h:326

llvm::ELFYAML::SectionOrType

Definition:ELFYAML.h:150

llvm::ELFYAML::SectionOrType::sectionNameOrType

StringRef sectionNameOrType

Definition:ELFYAML.h:151

llvm::ELFYAML::Section

Definition:ELFYAML.h:251

llvm::ELFYAML::StackSizesSection

Definition:ELFYAML.h:358

llvm::ELFYAML::StackSizesSection::nameMatches

static bool nameMatches(StringRef Name)

Definition:ELFYAML.h:371

llvm::ELFYAML::SymtabShndxSection

Definition:ELFYAML.h:653

llvm::ELFYAML::SymverSection

Definition:ELFYAML.h:568

llvm::ELFYAML::VerdefSection

Definition:ELFYAML.h:589

llvm::ELFYAML::VerneedSection

Definition:ELFYAML.h:488

llvm::yaml::ScalarTraits< ELFYAML::YAMLFlowString >::input

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

Definition:ELFYAML.cpp:1210

llvm::yaml::ScalarTraits< ELFYAML::YAMLFlowString >::output

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

Definition:ELFYAML.cpp:1206

llvm::yaml::ScalarTraits< ELFYAML::YAMLFlowString >::mustQuote

static QuotingType mustQuote(StringRef S)

Definition:ELFYAML.cpp:1215

llvm::yaml::ScalarTraits< StOtherPiece >::input

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

Definition:ELFYAML.cpp:1195

llvm::yaml::ScalarTraits< StOtherPiece >::mustQuote

static QuotingType mustQuote(StringRef)

Definition:ELFYAML.cpp:1199

llvm::yaml::ScalarTraits< StOtherPiece >::output

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

Definition:ELFYAML.cpp:1192