Dwarf.cpp Source File (original) (raw)

18using namespace llvm;

19using namespace dwarf;

22 switch (Tag) {

23 default:

25#define HANDLE_DW_TAG(ID, NAME, VERSION, VENDOR, KIND) \

26 case DW_TAG_##NAME: \

27 return "DW_TAG_" #NAME;

28#include "llvm/BinaryFormat/Dwarf.def"

29 }

30}

34#define HANDLE_DW_TAG(ID, NAME, VERSION, VENDOR, KIND) \

35 .Case("DW_TAG_" #NAME, DW_TAG_##NAME)

36#include "llvm/BinaryFormat/Dwarf.def"

38}

41 switch (Tag) {

42 default:

43 return 0;

44#define HANDLE_DW_TAG(ID, NAME, VERSION, VENDOR, KIND) \

45 case DW_TAG_##NAME: \

46 return VERSION;

47#include "llvm/BinaryFormat/Dwarf.def"

48 }

49}

52 switch (Tag) {

53 default:

54 return 0;

55#define HANDLE_DW_TAG(ID, NAME, VERSION, VENDOR, KIND) \

56 case DW_TAG_##NAME: \

57 return DWARF_VENDOR_##VENDOR;

58#include "llvm/BinaryFormat/Dwarf.def"

59 }

60}

63 switch (Children) {

65 return "DW_CHILDREN_no";

67 return "DW_CHILDREN_yes";

68 }

70}

74 default:

76#define HANDLE_DW_AT(ID, NAME, VERSION, VENDOR) \

77 case DW_AT_##NAME: \

78 return "DW_AT_" #NAME;

79#include "llvm/BinaryFormat/Dwarf.def"

80 }

81}

85 default:

86 return 0;

87#define HANDLE_DW_AT(ID, NAME, VERSION, VENDOR) \

88 case DW_AT_##NAME: \

89 return VERSION;

90#include "llvm/BinaryFormat/Dwarf.def"

91 }

92}

96 default:

97 return 0;

98#define HANDLE_DW_AT(ID, NAME, VERSION, VENDOR) \

99 case DW_AT_##NAME: \

100 return DWARF_VENDOR_##VENDOR;

101#include "llvm/BinaryFormat/Dwarf.def"

102 }

103}

104

106 switch (Encoding) {

107 default:

109#define HANDLE_DW_FORM(ID, NAME, VERSION, VENDOR) \

110 case DW_FORM_##NAME: \

111 return "DW_FORM_" #NAME;

112#include "llvm/BinaryFormat/Dwarf.def"

113 }

114}

115

117 switch (Form) {

118 default:

119 return 0;

120#define HANDLE_DW_FORM(ID, NAME, VERSION, VENDOR) \

121 case DW_FORM_##NAME: \

122 return VERSION;

123#include "llvm/BinaryFormat/Dwarf.def"

124 }

125}

126

128 switch (Form) {

129 default:

130 return 0;

131#define HANDLE_DW_FORM(ID, NAME, VERSION, VENDOR) \

132 case DW_FORM_##NAME: \

133 return DWARF_VENDOR_##VENDOR;

134#include "llvm/BinaryFormat/Dwarf.def"

135 }

136}

137

139 switch (Encoding) {

140 default:

142#define HANDLE_DW_OP(ID, NAME, OPERANDS, ARITY, VERSION, VENDOR) \

143 case DW_OP_##NAME: \

144 return "DW_OP_" #NAME;

145#include "llvm/BinaryFormat/Dwarf.def"

147 return "DW_OP_LLVM_convert";

149 return "DW_OP_LLVM_fragment";

151 return "DW_OP_LLVM_tag_offset";

153 return "DW_OP_LLVM_entry_value";

155 return "DW_OP_LLVM_implicit_pointer";

157 return "DW_OP_LLVM_arg";

159 return "DW_OP_LLVM_extract_bits_sext";

161 return "DW_OP_LLVM_extract_bits_zext";

162 }

163}

164

167#define HANDLE_DW_OP(ID, NAME, OPERANDS, ARITY, VERSION, VENDOR) \

168 .Case("DW_OP_" #NAME, DW_OP_##NAME)

169#include "llvm/BinaryFormat/Dwarf.def"

179}

180

182 switch (Encoding) {

183 default:

184 llvm_unreachable("unhandled DWARF operation with LLVM user op");

185#define HANDLE_DW_OP_LLVM_USEROP(ID, NAME) \

186 case DW_OP_LLVM_##NAME: \

187 return "DW_OP_LLVM_" #NAME;

188#include "llvm/BinaryFormat/Dwarf.def"

189 }

190}

191

192static unsigned

195#define HANDLE_DW_OP_LLVM_USEROP(ID, NAME) .Case(#NAME, DW_OP_LLVM_##NAME)

196#include "llvm/BinaryFormat/Dwarf.def"

198 assert(E && "unhandled DWARF operation string with LLVM user op");

199 return E;

200}

201

203 unsigned SubOpEncoding) {

204 assert(OpEncoding == DW_OP_LLVM_user);

206}

207

208unsigned

211 assert(OpEncoding == DW_OP_LLVM_user);

213}

214

216 switch (Op) {

217 default:

218 return 0;

219#define HANDLE_DW_OP(ID, NAME, OPERANDS, ARITY, VERSION, VENDOR) \

220 case DW_OP_##NAME: \

221 return VERSION;

222#include "llvm/BinaryFormat/Dwarf.def"

223 }

224}

225

227 switch (Op) {

228 default:

229 return std::nullopt;

230#define HANDLE_DW_OP(ID, NAME, OPERANDS, ARITY, VERSION, VENDOR) \

231 case DW_OP_##NAME: \

232 if (OPERANDS == -1) \

233 return std::nullopt; \

234 return OPERANDS;

235#include "llvm/BinaryFormat/Dwarf.def"

236 }

237}

238

240 switch (Op) {

241 default:

242 return std::nullopt;

243#define HANDLE_DW_OP(ID, NAME, OPERANDS, ARITY, VERSION, VENDOR) \

244 case DW_OP_##NAME: \

245 if (ARITY == -1) \

246 return std::nullopt; \

247 return ARITY;

248#include "llvm/BinaryFormat/Dwarf.def"

249 }

250}

251

253 switch (Op) {

254 default:

255 return 0;

256#define HANDLE_DW_OP(ID, NAME, OPERANDS, ARITY, VERSION, VENDOR) \

257 case DW_OP_##NAME: \

258 return DWARF_VENDOR_##VENDOR;

259#include "llvm/BinaryFormat/Dwarf.def"

260 }

261}

262

264 switch (Encoding) {

265 default:

267#define HANDLE_DW_ATE(ID, NAME, VERSION, VENDOR) \

268 case DW_ATE_##NAME: \

269 return "DW_ATE_" #NAME;

270#include "llvm/BinaryFormat/Dwarf.def"

271 }

272}

273

276#define HANDLE_DW_ATE(ID, NAME, VERSION, VENDOR) \

277 .Case("DW_ATE_" #NAME, DW_ATE_##NAME)

278#include "llvm/BinaryFormat/Dwarf.def"

280}

281

283 switch (ATE) {

284 default:

285 return 0;

286#define HANDLE_DW_ATE(ID, NAME, VERSION, VENDOR) \

287 case DW_ATE_##NAME: \

288 return VERSION;

289#include "llvm/BinaryFormat/Dwarf.def"

290 }

291}

292

294 switch (ATE) {

295 default:

296 return 0;

297#define HANDLE_DW_ATE(ID, NAME, VERSION, VENDOR) \

298 case DW_ATE_##NAME: \

299 return DWARF_VENDOR_##VENDOR;

300#include "llvm/BinaryFormat/Dwarf.def"

301 }

302}

303

305 switch (Sign) {

307 return "DW_DS_unsigned";

309 return "DW_DS_leading_overpunch";

311 return "DW_DS_trailing_overpunch";

313 return "DW_DS_leading_separate";

315 return "DW_DS_trailing_separate";

316 }

318}

319

322 case DW_END_default:

323 return "DW_END_default";

324 case DW_END_big:

325 return "DW_END_big";

326 case DW_END_little:

327 return "DW_END_little";

329 return "DW_END_lo_user";

331 return "DW_END_hi_user";

332 }

334}

335

338

340 return "DW_ACCESS_public";

342 return "DW_ACCESS_protected";

344 return "DW_ACCESS_private";

345 }

347}

348

350 switch (DefaultedEncodings) {

351

352 case DW_DEFAULTED_no:

353 return "DW_DEFAULTED_no";

354 case DW_DEFAULTED_in_class:

355 return "DW_DEFAULTED_in_class";

356 case DW_DEFAULTED_out_of_class:

357 return "DW_DEFAULTED_out_of_class";

358 }

360}

361

363 switch (Visibility) {

365 return "DW_VIS_local";

367 return "DW_VIS_exported";

369 return "DW_VIS_qualified";

370 }

372}

373

375 switch (Virtuality) {

376 default:

378#define HANDLE_DW_VIRTUALITY(ID, NAME) \

379 case DW_VIRTUALITY_##NAME: \

380 return "DW_VIRTUALITY_" #NAME;

381#include "llvm/BinaryFormat/Dwarf.def"

382 }

383}

384

387#define HANDLE_DW_VIRTUALITY(ID, NAME) \

388 .Case("DW_VIRTUALITY_" #NAME, DW_VIRTUALITY_##NAME)

389#include "llvm/BinaryFormat/Dwarf.def"

391}

392

394 switch (Language) {

395 default:

397#define HANDLE_DW_LANG(ID, NAME, LOWER_BOUND, VERSION, VENDOR) \

398 case DW_LANG_##NAME: \

399 return "DW_LANG_" #NAME;

400#include "llvm/BinaryFormat/Dwarf.def"

401 }

402}

403

406#define HANDLE_DW_LANG(ID, NAME, LOWER_BOUND, VERSION, VENDOR) \

407 .Case("DW_LANG_" #NAME, DW_LANG_##NAME)

408#include "llvm/BinaryFormat/Dwarf.def"

410}

411

413 switch (Lang) {

414 default:

415 return 0;

416#define HANDLE_DW_LANG(ID, NAME, LOWER_BOUND, VERSION, VENDOR) \

417 case DW_LANG_##NAME: \

418 return VERSION;

419#include "llvm/BinaryFormat/Dwarf.def"

420 }

421}

422

424 switch (Lang) {

425 default:

426 return 0;

427#define HANDLE_DW_LANG(ID, NAME, LOWER_BOUND, VERSION, VENDOR) \

428 case DW_LANG_##NAME: \

429 return DWARF_VENDOR_##VENDOR;

430#include "llvm/BinaryFormat/Dwarf.def"

431 }

432}

433

434std::optional

436 switch (Lang) {

437 default:

438 return std::nullopt;

439#define HANDLE_DW_LANG(ID, NAME, LOWER_BOUND, VERSION, VENDOR) \

440 case DW_LANG_##NAME: \

441 return LOWER_BOUND;

442#include "llvm/BinaryFormat/Dwarf.def"

443 }

444}

445

447 switch (lname) {

448#define HANDLE_DW_LNAME(ID, NAME, DESC, LOWER_BOUND) \

449 case DW_LNAME_##NAME: \

450 return DESC;

451#include "llvm/BinaryFormat/Dwarf.def"

452 }

453 return "Unknown";

454}

455

457 switch (Case) {

459 return "DW_ID_case_sensitive";

461 return "DW_ID_up_case";

463 return "DW_ID_down_case";

465 return "DW_ID_case_insensitive";

466 }

468}

469

471 switch (CC) {

472 default:

474#define HANDLE_DW_CC(ID, NAME) \

475 case DW_CC_##NAME: \

476 return "DW_CC_" #NAME;

477#include "llvm/BinaryFormat/Dwarf.def"

478 }

479}

480

483#define HANDLE_DW_CC(ID, NAME) .Case("DW_CC_" #NAME, DW_CC_##NAME)

484#include "llvm/BinaryFormat/Dwarf.def"

486}

487

489 switch (Code) {

491 return "DW_INL_not_inlined";

493 return "DW_INL_inlined";

495 return "DW_INL_declared_not_inlined";

497 return "DW_INL_declared_inlined";

498 }

500}

501

503 switch (Order) {

505 return "DW_ORD_row_major";

507 return "DW_ORD_col_major";

508 }

510}

511

513 switch (Standard) {

514 default:

516#define HANDLE_DW_LNS(ID, NAME) \

517 case DW_LNS_##NAME: \

518 return "DW_LNS_" #NAME;

519#include "llvm/BinaryFormat/Dwarf.def"

520 }

521}

522

524 switch (Encoding) {

525 default:

527#define HANDLE_DW_LNE(ID, NAME) \

528 case DW_LNE_##NAME: \

529 return "DW_LNE_" #NAME;

530#include "llvm/BinaryFormat/Dwarf.def"

531 }

532}

533

535 switch (Encoding) {

536

538 return "DW_MACINFO_define";

540 return "DW_MACINFO_undef";

542 return "DW_MACINFO_start_file";

544 return "DW_MACINFO_end_file";

546 return "DW_MACINFO_vendor_ext";

548 return "DW_MACINFO_invalid";

549 }

551}

552

561}

562

564 switch (Encoding) {

565 default:

567#define HANDLE_DW_MACRO(ID, NAME) \

568 case DW_MACRO_##NAME: \

569 return "DW_MACRO_" #NAME;

570#include "llvm/BinaryFormat/Dwarf.def"

571 }

572}

573

575 switch (Encoding) {

576 default:

578#define HANDLE_DW_MACRO_GNU(ID, NAME) \

579 case DW_MACRO_GNU_##NAME: \

580 return "DW_MACRO_GNU_" #NAME;

581#include "llvm/BinaryFormat/Dwarf.def"

582 }

583}

584

587#define HANDLE_DW_MACRO(ID, NAME) .Case("DW_MACRO_" #NAME, ID)

588#include "llvm/BinaryFormat/Dwarf.def"

590}

592 switch (Encoding) {

593 default:

595#define HANDLE_DW_RLE(ID, NAME) \

596 case DW_RLE_##NAME: \

597 return "DW_RLE_" #NAME;

598#include "llvm/BinaryFormat/Dwarf.def"

599 }

600}

601

603 switch (Encoding) {

604 default:

606#define HANDLE_DW_LLE(ID, NAME) \

607 case DW_LLE_##NAME: \

608 return "DW_LLE_" #NAME;

609#include "llvm/BinaryFormat/Dwarf.def"

610 }

611}

612

616#define SELECT_AARCH64 (Arch == llvm::Triple::aarch64_be || Arch == llvm::Triple::aarch64)

617#define SELECT_MIPS64 Arch == llvm::Triple::mips64

618#define SELECT_SPARC (Arch == llvm::Triple::sparc || Arch == llvm::Triple::sparcv9)

619#define SELECT_X86 (Arch == llvm::Triple::x86 || Arch == llvm::Triple::x86_64)

620#define HANDLE_DW_CFA(ID, NAME)

621#define HANDLE_DW_CFA_PRED(ID, NAME, PRED) \

622 if (ID == Encoding && PRED) \

623 return "DW_CFA_" #NAME;

624#include "llvm/BinaryFormat/Dwarf.def"

625

626 switch (Encoding) {

627 default:

629#define HANDLE_DW_CFA_PRED(ID, NAME, PRED)

630#define HANDLE_DW_CFA(ID, NAME) \

631 case DW_CFA_##NAME: \

632 return "DW_CFA_" #NAME;

633#include "llvm/BinaryFormat/Dwarf.def"

634

635#undef SELECT_X86

636#undef SELECT_SPARC

637#undef SELECT_MIPS64

638#undef SELECT_AARCH64

639 }

640}

641

643 switch (Prop) {

644 default:

646#define HANDLE_DW_APPLE_PROPERTY(ID, NAME) \

647 case DW_APPLE_PROPERTY_##NAME: \

648 return "DW_APPLE_PROPERTY_" #NAME;

649#include "llvm/BinaryFormat/Dwarf.def"

650 }

651}

652

654 switch (UT) {

655 default:

657#define HANDLE_DW_UT(ID, NAME) \

658 case DW_UT_##NAME: \

659 return "DW_UT_" #NAME;

660#include "llvm/BinaryFormat/Dwarf.def"

661 }

662}

663

665 switch (AT) {

667 return "DW_ATOM_null";

669 return "DW_ATOM_die_offset";

671 return "DW_ATOM_cu_offset";

673 return "DW_ATOM_die_tag";

676 return "DW_ATOM_type_flags";

678 return "DW_ATOM_qual_name_hash";

679 }

681}

682

684 switch (Kind) {

686 return "NONE";

688 return "TYPE";

690 return "VARIABLE";

692 return "FUNCTION";

694 return "OTHER";

696 return "UNUSED5";

698 return "UNUSED6";

700 return "UNUSED7";

701 }

703}

704

707 switch (Linkage) {

709 return "EXTERNAL";

711 return "STATIC";

712 }

714}

715

717 switch (Attr) {

718 case DW_AT_accessibility:

720 case DW_AT_virtuality:

722 case DW_AT_language:

724 case DW_AT_encoding:

726 case DW_AT_decimal_sign:

728 case DW_AT_endianity:

730 case DW_AT_visibility:

732 case DW_AT_identifier_case:

734 case DW_AT_calling_convention:

736 case DW_AT_inline:

738 case DW_AT_ordering:

740 case DW_AT_APPLE_runtime_class:

742 case DW_AT_defaulted:

744 }

745

747}

748

750 switch (Atom) {

752 return "NULL";

755 }

756

758}

759

761 switch (Idx) {

762 default:

764#define HANDLE_DW_IDX(ID, NAME) \

765 case DW_IDX_##NAME: \

766 return "DW_IDX_" #NAME;

767#include "llvm/BinaryFormat/Dwarf.def"

768 }

769}

770

773 switch (Form) {

774 case DW_FORM_addr:

775 if (Params)

777 return std::nullopt;

778

779 case DW_FORM_block:

780 case DW_FORM_block1:

781 case DW_FORM_block2:

782 case DW_FORM_block4:

783 case DW_FORM_string:

784 case DW_FORM_sdata:

785 case DW_FORM_udata:

786 case DW_FORM_ref_udata:

787 case DW_FORM_indirect:

788 case DW_FORM_exprloc:

789 case DW_FORM_strx:

790 case DW_FORM_addrx:

791 case DW_FORM_loclistx:

792 case DW_FORM_rnglistx:

793 case DW_FORM_GNU_addr_index:

794 case DW_FORM_GNU_str_index:

795 return std::nullopt;

796

797 case DW_FORM_ref_addr:

798 if (Params)

800 return std::nullopt;

801

802 case DW_FORM_flag:

803 case DW_FORM_data1:

804 case DW_FORM_ref1:

805 case DW_FORM_strx1:

806 case DW_FORM_addrx1:

807 return 1;

808

809 case DW_FORM_data2:

810 case DW_FORM_ref2:

811 case DW_FORM_strx2:

812 case DW_FORM_addrx2:

813 return 2;

814

815 case DW_FORM_strx3:

816 case DW_FORM_addrx3:

817 return 3;

818

819 case DW_FORM_data4:

820 case DW_FORM_ref4:

821 case DW_FORM_ref_sup4:

822 case DW_FORM_strx4:

823 case DW_FORM_addrx4:

824 return 4;

825

826 case DW_FORM_strp:

827 case DW_FORM_GNU_ref_alt:

828 case DW_FORM_GNU_strp_alt:

829 case DW_FORM_line_strp:

830 case DW_FORM_sec_offset:

831 case DW_FORM_strp_sup:

832 if (Params)

834 return std::nullopt;

835

836 case DW_FORM_data8:

837 case DW_FORM_ref8:

838 case DW_FORM_ref_sig8:

839 case DW_FORM_ref_sup8:

840 return 8;

841

842 case DW_FORM_flag_present:

843 return 0;

844

845 case DW_FORM_data16:

846 return 16;

847

848 case DW_FORM_implicit_const:

849

850

851 return 0;

852

853 default:

854 break;

855 }

856 return std::nullopt;

857}

858

860 bool ExtensionsOk) {

863 return FV > 0 && FV <= Version;

864 }

865 return ExtensionsOk;

866}

867

869 switch (Format) {

871 return "DWARF32";

873 return "DWARF64";

874 }

876}

877

880}

881

883 switch (RLE) {

884 default:

886#define HANDLE_DW_RLE(ID, NAME) \

887 case DW_RLE_##NAME: \

888 return "DW_RLE_" #NAME;

889#include "llvm/BinaryFormat/Dwarf.def"

890 }

891}

892

Returns the sub type a function will return at a given Idx Should correspond to the result type of an ExtractValue instruction executed with just that one unsigned Idx

static unsigned getLlvmUserOperationEncoding(StringRef LlvmUserOperationEncodingString)

static StringRef LlvmUserOperationEncodingString(unsigned Encoding)

This file contains constants used for implementing Dwarf debug support.

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

This file implements the StringSwitch template, which mimics a switch() statement whose cases are str...

This class represents an Operation in the Expression.

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

A switch()-like statement whose cases are string literals.

StringSwitch & Case(StringLiteral S, T Value)

StringRef LNExtendedString(unsigned Encoding)

StringRef RangeListEncodingString(unsigned Encoding)

StringRef CaseString(unsigned Case)

StringRef VisibilityString(unsigned Visibility)

StringRef GDBIndexEntryLinkageString(GDBIndexEntryLinkage Linkage)

StringRef AttributeString(unsigned Attribute)

StringRef CallFrameString(unsigned Encoding, Triple::ArchType Arch)

StringRef FormEncodingString(unsigned Encoding)

StringRef ArrayOrderString(unsigned Order)

StringRef MacroString(unsigned Encoding)

StringRef LocListEncodingString(unsigned Encoding)

StringRef IndexString(unsigned Idx)

StringRef RLEString(unsigned RLE)

StringRef SubOperationEncodingString(unsigned OpEncoding, unsigned SubOpEncoding)

StringRef LanguageString(unsigned Language)

StringRef DecimalSignString(unsigned Sign)

StringRef VirtualityString(unsigned Virtuality)

StringRef AttributeEncodingString(unsigned Encoding)

StringRef ChildrenString(unsigned Children)

StringRef ApplePropertyString(unsigned)

StringRef AtomTypeString(unsigned Atom)

StringRef FormatString(DwarfFormat Format)

StringRef GnuMacroString(unsigned Encoding)

StringRef EndianityString(unsigned Endian)

StringRef ConventionString(unsigned Convention)

StringRef MacinfoString(unsigned Encoding)

StringRef OperationEncodingString(unsigned Encoding)

StringRef UnitTypeString(unsigned)

StringRef InlineCodeString(unsigned Code)

StringRef GDBIndexEntryKindString(GDBIndexEntryKind Kind)

StringRef TagString(unsigned Tag)

StringRef LNStandardString(unsigned Standard)

StringRef AccessibilityString(unsigned Access)

StringRef DefaultedMemberString(unsigned DefaultedEncodings)

unsigned getSubOperationEncoding(unsigned OpEncoding, StringRef SubOperationEncodingString)

unsigned getOperationEncoding(StringRef OperationEncodingString)

unsigned getAttributeEncoding(StringRef EncodingString)

unsigned getTag(StringRef TagString)

unsigned getCallingConvention(StringRef LanguageString)

unsigned getLanguage(StringRef LanguageString)

unsigned getVirtuality(StringRef VirtualityString)

unsigned getMacro(StringRef MacroString)

unsigned getMacinfo(StringRef MacinfoString)

unsigned AttributeEncodingVendor(TypeKind E)

unsigned FormVendor(Form F)

unsigned AttributeVendor(Attribute A)

unsigned OperationVendor(LocationAtom O)

unsigned TagVendor(Tag T)

unsigned LanguageVendor(SourceLanguage L)

unsigned OperationVersion(LocationAtom O)

unsigned AttributeVersion(Attribute A)

unsigned LanguageVersion(SourceLanguage L)

unsigned AttributeEncodingVersion(TypeKind E)

unsigned TagVersion(Tag T)

unsigned FormVersion(Form F)

#define llvm_unreachable(msg)

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

@ DW_INL_declared_not_inlined

@ DW_INL_declared_inlined

std::optional< unsigned > LanguageLowerBound(SourceLanguage L)

StringRef AtomValueString(uint16_t Atom, unsigned Val)

Returns the symbolic string representing Val when used as a value for atom Atom.

std::optional< unsigned > OperationArity(LocationAtom O)

The arity of the given LocationAtom.

@ DW_OP_LLVM_entry_value

Only used in LLVM metadata.

@ DW_OP_LLVM_implicit_pointer

Only used in LLVM metadata.

@ DW_OP_LLVM_extract_bits_zext

Only used in LLVM metadata.

@ DW_OP_LLVM_tag_offset

Only used in LLVM metadata.

@ DW_OP_LLVM_fragment

Only used in LLVM metadata.

@ DW_OP_LLVM_arg

Only used in LLVM metadata.

@ DW_OP_LLVM_convert

Only used in LLVM metadata.

@ DW_OP_LLVM_extract_bits_sext

Only used in LLVM metadata.

DwarfFormat

Constants that define the DWARF format as 32 or 64 bit.

bool isValidFormForVersion(Form F, unsigned Version, bool ExtensionsOk=true)

Tells whether the specified form is defined in the specified version, or is an extension if extension...

std::optional< uint8_t > getFixedFormByteSize(dwarf::Form Form, FormParams Params)

Get the fixed byte size for a given form.

StringRef AttributeValueString(uint16_t Attr, unsigned Val)

Returns the symbolic string representing Val when used as a value for attribute Attr.

std::optional< unsigned > OperationOperands(LocationAtom O)

The number of operands for the given LocationAtom.

@ DW_DS_trailing_separate

@ DW_DS_trailing_overpunch

@ DW_DS_leading_overpunch

llvm::StringRef LanguageDescription(SourceLanguageName name)

@ DW_ATOM_die_offset

Marker as the end of a list of atoms.

@ DW_ATOM_type_type_flags

@ DW_TAG_invalid

LLVM mock tags (see also llvm/BinaryFormat/Dwarf.def).

@ DW_MACINFO_invalid

Macinfo type for invalid results.

@ DW_VIRTUALITY_invalid

Virtuality for invalid results.

@ DWARF_VENDOR_DWARF

Identifiers we use to distinguish vendor extensions.

This is an optimization pass for GlobalISel generic memory operations.

A helper struct providing information about the byte size of DW_FORM values that vary in size dependi...

uint8_t getDwarfOffsetByteSize() const

The size of a reference is determined by the DWARF 32/64-bit format.

uint8_t getRefAddrByteSize() const

The definition of the size of form DW_FORM_ref_addr depends on the version.