DIE.cpp Source File (original) (raw)

17#include "llvm/Config/llvm-config.h"

26using namespace llvm;

28#define DEBUG_TYPE "dwarfdebug"

40 ID.AddInteger(unsigned(Form));

41 if (Form == dwarf::DW_FORM_implicit_const)

43}

52 ID.AddInteger(unsigned(Tag));

53 ID.AddInteger(unsigned(Children));

57 D.Profile(ID);

58}

76#ifndef NDEBUG

83 << "\n");

85 }

86#endif

91 if (AttrData.getForm() == dwarf::DW_FORM_implicit_const)

93 }

98}

102 O << "Abbreviation @"

103 << format("0x%lx", (long)(intptr_t)this)

104 << " "

106 << " "

108 << '\n';

109

113

114 if (D.getForm() == dwarf::DW_FORM_implicit_const)

115 O << " " << D.getValue();

116

117 O << '\n';

118 }

119}

120

121#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)

124}

125#endif

126

127

128

129

130

132 for (DIEAbbrev *Abbrev : Abbreviations)

133 Abbrev->~DIEAbbrev();

134}

135

137

141

142 void *InsertPos;

144 AbbreviationsSet.FindNodeOrInsertPos(ID, InsertPos)) {

146 return *Existing;

147 }

148

149

151 Abbreviations.push_back(New);

152 New->setNumber(Abbreviations.size());

154

155

156 AbbreviationsSet.InsertNode(New, InsertPos);

157 return *New;

158}

159

161 if (!Abbreviations.empty()) {

162

165 }

166}

167

168

169

170

171

173

177 if (V.getForm() == dwarf::DW_FORM_implicit_const)

179 V.getDIEInteger().getValue());

180 else

181 Abbrev.AddAttribute(V.getAttribute(), V.getForm());

182 return Abbrev;

183}

184

187 assert(Unit && "DIE must be owned by a DIEUnit to get its absolute offset");

188 return Unit->getDebugSectionOffset() + getOffset();

189}

190

192 const DIE *p = this;

193 while (p) {

194 if (p->getTag() == dwarf::DW_TAG_compile_unit ||

195 p->getTag() == dwarf::DW_TAG_skeleton_unit ||

196 p->getTag() == dwarf::DW_TAG_type_unit)

197 return p;

198 p = p->getParent();

199 }

200 return nullptr;

201}

202

205 if (UnitDie)

206 return dyn_cast_if_present<DIEUnit *>(UnitDie->Owner);

207 return nullptr;

208}

209

211

212

213 for (const auto &V : values())

214 if (V.getAttribute() == Attribute)

215 return V;

217}

218

222 O << Type << ": Size: " << Size << "\n";

223

224 unsigned I = 0;

225 const std::string Indent(IndentCount, ' ');

226 for (const auto &V : Values.values()) {

227 O << Indent;

228 O << "Blk[" << I++ << "]";

230 V.print(O);

231 O << "\n";

232 }

233}

234

237 const std::string Indent(IndentCount, ' ');

238 O << Indent << "Die: " << format("0x%lx", (long)(intptr_t) this)

239 << ", Offset: " << Offset << ", Size: " << Size << "\n";

240

243

244 IndentCount += 2;

245 for (const auto &V : values()) {

246 O << Indent;

249 V.print(O);

250 O << "\n";

251 }

252 IndentCount -= 2;

253

254 for (const auto &Child : children())

255 Child.print(O, IndentCount + 4);

256

257 O << "\n";

258}

259

260#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)

263}

264#endif

265

268 unsigned CUOffset) {

269

270

272

273

275

276

278

279

280 for (const auto &V : values())

281 CUOffset += V.sizeOf(FormParams);

282

283

285 (void)Abbrev;

287

288 for (auto &Child : children())

289 CUOffset =

290 Child.computeOffsetsAndAbbrevs(FormParams, AbbrevSet, CUOffset);

291

292

293 CUOffset += sizeof(int8_t);

294 }

295

296

297

298

300 return CUOffset;

301}

302

303

304

305

307 Die.Owner = this;

308 assert((UnitTag == dwarf::DW_TAG_compile_unit ||

309 UnitTag == dwarf::DW_TAG_skeleton_unit ||

310 UnitTag == dwarf::DW_TAG_type_unit ||

311 UnitTag == dwarf::DW_TAG_partial_unit) &&

312 "expected a unit TAG");

313}

314

316 switch (Ty) {

319#define HANDLE_DIEVALUE(T) \

320 case is##T: \

321 getDIE##T().emitValue(AP, Form); \

322 break;

323#include "llvm/CodeGen/DIEValue.def"

324 }

325}

326

328 switch (Ty) {

331#define HANDLE_DIEVALUE(T) \

332 case is##T: \

333 return getDIE##T().sizeOf(FormParams, Form);

334#include "llvm/CodeGen/DIEValue.def"

335 }

337}

338

341 switch (Ty) {

344#define HANDLE_DIEVALUE(T) \

345 case is##T: \

346 getDIE##T().print(O); \

347 break;

348#include "llvm/CodeGen/DIEValue.def"

349 }

350}

351

352#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)

355}

356#endif

357

358

359

360

361

362

363

365 switch (Form) {

366 case dwarf::DW_FORM_implicit_const:

367 case dwarf::DW_FORM_flag_present:

368

369

370 Asm->OutStreamer->addBlankLine();

371 return;

372 case dwarf::DW_FORM_flag:

373 case dwarf::DW_FORM_ref1:

374 case dwarf::DW_FORM_data1:

375 case dwarf::DW_FORM_strx1:

376 case dwarf::DW_FORM_addrx1:

377 case dwarf::DW_FORM_ref2:

378 case dwarf::DW_FORM_data2:

379 case dwarf::DW_FORM_strx2:

380 case dwarf::DW_FORM_addrx2:

381 case dwarf::DW_FORM_strx3:

382 case dwarf::DW_FORM_addrx3:

383 case dwarf::DW_FORM_strp:

384 case dwarf::DW_FORM_ref4:

385 case dwarf::DW_FORM_data4:

386 case dwarf::DW_FORM_ref_sup4:

387 case dwarf::DW_FORM_strx4:

388 case dwarf::DW_FORM_addrx4:

389 case dwarf::DW_FORM_ref8:

390 case dwarf::DW_FORM_ref_sig8:

391 case dwarf::DW_FORM_data8:

392 case dwarf::DW_FORM_ref_sup8:

393 case dwarf::DW_FORM_GNU_ref_alt:

394 case dwarf::DW_FORM_GNU_strp_alt:

395 case dwarf::DW_FORM_line_strp:

396 case dwarf::DW_FORM_sec_offset:

397 case dwarf::DW_FORM_strp_sup:

398 case dwarf::DW_FORM_addr:

399 case dwarf::DW_FORM_ref_addr:

400 Asm->OutStreamer->emitIntValue(Integer,

401 sizeOf(Asm->getDwarfFormParams(), Form));

402 return;

403 case dwarf::DW_FORM_GNU_str_index:

404 case dwarf::DW_FORM_GNU_addr_index:

405 case dwarf::DW_FORM_ref_udata:

406 case dwarf::DW_FORM_strx:

407 case dwarf::DW_FORM_addrx:

408 case dwarf::DW_FORM_rnglistx:

409 case dwarf::DW_FORM_udata:

410 Asm->emitULEB128(Integer);

411 return;

412 case dwarf::DW_FORM_sdata:

413 Asm->emitSLEB128(Integer);

414 return;

415 default: llvm_unreachable("DIE Value form not supported yet");

416 }

417}

418

419

420

423 if (std::optional<uint8_t> FixedSize =

425 return *FixedSize;

426

427 switch (Form) {

428 case dwarf::DW_FORM_GNU_str_index:

429 case dwarf::DW_FORM_GNU_addr_index:

430 case dwarf::DW_FORM_ref_udata:

431 case dwarf::DW_FORM_strx:

432 case dwarf::DW_FORM_addrx:

433 case dwarf::DW_FORM_rnglistx:

434 case dwarf::DW_FORM_udata:

436 case dwarf::DW_FORM_sdata:

438 default: llvm_unreachable("DIE Value form not supported yet");

439 }

440}

441

444 O << "Int: " << (int64_t)Integer << " 0x";

445 O.write_hex(Integer);

446}

447

448

449

450

451

452

453

456}

457

458

459

462 switch (Form) {

463 case dwarf::DW_FORM_data4:

464 return 4;

465 case dwarf::DW_FORM_data8:

466 return 8;

467 case dwarf::DW_FORM_sec_offset:

469 default:

471 }

472}

473

476

477

478

479

480

481

482

484 bool IsSectionRelative = Form != dwarf::DW_FORM_addr;

486 IsSectionRelative);

487}

488

489

490

493 switch (Form) {

494 case dwarf::DW_FORM_data4:

495 return 4;

496 case dwarf::DW_FORM_data8:

497 return 8;

498 case dwarf::DW_FORM_sec_offset:

499 case dwarf::DW_FORM_strp:

501 case dwarf::DW_FORM_addr:

503 default:

505 }

506}

507

510

511

512

513

514

516 uint64_t Offset = CU->ExprRefedBaseTypes[Index].Die->getOffset();

517 assert(Offset < (1ULL << (ULEB128PadSize * 7)) && "Offset wont fit");

519}

520

522 return ULEB128PadSize;

523}

524

527

528

529

530

531

532

533

537}

538

539

540

543 switch (Form) {

544 case dwarf::DW_FORM_data4:

545 return 4;

546 case dwarf::DW_FORM_data8:

547 return 8;

548 case dwarf::DW_FORM_sec_offset:

550 default:

552 }

553}

554

557 O << "Del: " << LabelHi->getName() << "-" << LabelLo->getName();

558}

559

560

561

562

563

564

565

567

568 switch (Form) {

569 case dwarf::DW_FORM_GNU_str_index:

570 case dwarf::DW_FORM_strx:

571 case dwarf::DW_FORM_strx1:

572 case dwarf::DW_FORM_strx2:

573 case dwarf::DW_FORM_strx3:

574 case dwarf::DW_FORM_strx4:

576 return;

577 case dwarf::DW_FORM_strp:

580 else

582 return;

583 default:

585 }

586}

587

588

589

592

593 switch (Form) {

594 case dwarf::DW_FORM_GNU_str_index:

595 case dwarf::DW_FORM_strx:

596 case dwarf::DW_FORM_strx1:

597 case dwarf::DW_FORM_strx2:

598 case dwarf::DW_FORM_strx3:

599 case dwarf::DW_FORM_strx4:

601 case dwarf::DW_FORM_strp:

605 default:

607 }

608}

609

612 O << "String: " << S.getString();

613}

614

615

616

617

619 if (Form == dwarf::DW_FORM_string) {

622 return;

623 }

625}

626

628

629 return S.size() + 1;

630}

631

634 O << "InlineString: " << S;

635}

636

637

638

639

640

641

642

644

645 switch (Form) {

646 case dwarf::DW_FORM_ref1:

647 case dwarf::DW_FORM_ref2:

648 case dwarf::DW_FORM_ref4:

649 case dwarf::DW_FORM_ref8:

652 return;

653

654 case dwarf::DW_FORM_ref_udata:

656 return;

657

658 case dwarf::DW_FORM_ref_addr: {

659

661 if (const MCSymbol *SectionSym =

665 return;

666 }

667

669 return;

670 }

671 default:

673 }

674}

675

678 switch (Form) {

679 case dwarf::DW_FORM_ref1:

680 return 1;

681 case dwarf::DW_FORM_ref2:

682 return 2;

683 case dwarf::DW_FORM_ref4:

684 return 4;

685 case dwarf::DW_FORM_ref8:

686 return 8;

687 case dwarf::DW_FORM_ref_udata:

689 case dwarf::DW_FORM_ref_addr:

691

692 default:

694 }

695}

696

699 O << format("Die: 0x%lx", (long)(intptr_t)&Entry);

700}

701

702

703

704

705

707 if (!Size) {

708 for (const auto &V : values())

709 Size += V.sizeOf(FormParams);

710 }

711

712 return Size;

713}

714

715

716

718 switch (Form) {

720 case dwarf::DW_FORM_block1: Asm->emitInt8(Size); break;

721 case dwarf::DW_FORM_block2: Asm->emitInt16(Size); break;

722 case dwarf::DW_FORM_block4: Asm->emitInt32(Size); break;

723 case dwarf::DW_FORM_block:

724 case dwarf::DW_FORM_exprloc:

725 Asm->emitULEB128(Size);

726 break;

727 }

728

729 for (const auto &V : values())

730 V.emitValue(Asm);

731}

732

733

734

736 switch (Form) {

737 case dwarf::DW_FORM_block1: return Size + sizeof(int8_t);

738 case dwarf::DW_FORM_block2: return Size + sizeof(int16_t);

739 case dwarf::DW_FORM_block4: return Size + sizeof(int32_t);

740 case dwarf::DW_FORM_block:

741 case dwarf::DW_FORM_exprloc:

744 }

745}

746

749 printValues(O, *this, "ExprLoc", Size, 5);

750}

751

752

753

754

755

757 if (!Size) {

758 for (const auto &V : values())

759 Size += V.sizeOf(FormParams);

760 }

761

762 return Size;

763}

764

765

766

768 switch (Form) {

770 case dwarf::DW_FORM_block1: Asm->emitInt8(Size); break;

771 case dwarf::DW_FORM_block2: Asm->emitInt16(Size); break;

772 case dwarf::DW_FORM_block4: Asm->emitInt32(Size); break;

773 case dwarf::DW_FORM_exprloc:

774 case dwarf::DW_FORM_block:

775 Asm->emitULEB128(Size);

776 break;

777 case dwarf::DW_FORM_string: break;

778 case dwarf::DW_FORM_data16: break;

779 }

780

781 for (const auto &V : values())

782 V.emitValue(Asm);

783}

784

785

786

788 switch (Form) {

789 case dwarf::DW_FORM_block1: return Size + sizeof(int8_t);

790 case dwarf::DW_FORM_block2: return Size + sizeof(int16_t);

791 case dwarf::DW_FORM_block4: return Size + sizeof(int32_t);

792 case dwarf::DW_FORM_exprloc:

793 case dwarf::DW_FORM_block: return Size + getULEB128Size(Size);

794 case dwarf::DW_FORM_data16: return 16;

796 }

797}

798

802}

803

804

805

806

807

810 switch (Form) {

811 case dwarf::DW_FORM_loclistx:

813 case dwarf::DW_FORM_data4:

815 "DW_FORM_data4 is not suitable to emit a pointer to a location list "

816 "in the 64-bit DWARF format");

817 return 4;

818 case dwarf::DW_FORM_data8:

820 "DW_FORM_data8 is not suitable to emit a pointer to a location list "

821 "in the 32-bit DWARF format");

822 return 8;

823 case dwarf::DW_FORM_sec_offset:

825 default:

827 }

828}

829

830

831

833 if (Form == dwarf::DW_FORM_loclistx) {

835 return;

836 }

840}

841

844

845

846

847

848

851 return Addr.sizeOf(FormParams, dwarf::DW_FORM_addrx) +

852 Offset.sizeOf(FormParams, dwarf::DW_FORM_data4);

853}

854

855

856

858 Addr.emitValue(AP, dwarf::DW_FORM_addrx);

859 Offset.emitValue(AP, dwarf::DW_FORM_data4);

860}

861

864 O << "AddrOffset: ";

866 O << " + ";

868}

static GCRegistry::Add< StatepointGC > D("statepoint-example", "an example strategy for statepoint")

#define LLVM_DUMP_METHOD

Mark debug helper function definitions like dump() that should not be stripped from debug builds.

static LLVM_DUMP_METHOD void printValues(raw_ostream &O, const DIEValueList &Values, StringRef Type, unsigned Size, unsigned IndentCount)

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

This class is intended to be used as a driving class for all asm writers.

void emitULEB128(uint64_t Value, const char *Desc=nullptr, unsigned PadTo=0) const

Emit the specified unsigned leb128 value.

void emitDwarfSymbolReference(const MCSymbol *Label, bool ForceOffset=false) const

Emit a reference to a symbol for use in dwarf.

virtual void emitDebugValue(const MCExpr *Value, unsigned Size) const

Emit the directive and value for debug thread local expression.

DwarfDebug * getDwarfDebug()

void emitLabelPlusOffset(const MCSymbol *Label, uint64_t Offset, unsigned Size, bool IsSectionRelative=false) const

Emit something like ".long Label+Offset" where the size in bytes of the directive is specified by Siz...

void emitLabelDifference(const MCSymbol *Hi, const MCSymbol *Lo, unsigned Size) const

Emit something like ".long Hi-Lo" where the size in bytes of the directive is specified by Size and H...

void emitInt8(int Value) const

Emit a byte directive and value.

void emitDwarfAbbrevs(const T &Abbrevs) const

Emit Dwarf abbreviation table.

void emitSLEB128(int64_t Value, const char *Desc=nullptr) const

Emit the specified signed leb128 value.

std::unique_ptr< MCStreamer > OutStreamer

This is the MCStreamer object for the file we are generating.

void emitLabelReference(const MCSymbol *Label, unsigned Size, bool IsSectionRelative=false) const

Emit something like ".long Label" where the size in bytes of the directive is specified by Size and L...

uint16_t getDwarfVersion() const

dwarf::FormParams getDwarfFormParams() const

Returns information about the byte size of DW_FORM values.

bool doesDwarfUseRelocationsAcrossSections() const

Dwarf abbreviation data, describes one attribute of a Dwarf abbreviation.

void Profile(FoldingSetNodeID &ID) const

Used to gather unique data for the abbreviation folding set.

Helps unique DIEAbbrev objects and assigns abbreviation numbers.

void Emit(const AsmPrinter *AP, MCSection *Section) const

Print all abbreviations using the specified asm printer.

DIEAbbrev & uniqueAbbreviation(DIE &Die)

Generate the abbreviation declaration for a DIE and return a pointer to the generated abbreviation.

Dwarf abbreviation, describes the organization of a debug information object.

void print(raw_ostream &O) const

void AddImplicitConstAttribute(dwarf::Attribute Attribute, int64_t Value)

Adds attribute with DW_FORM_implicit_const value.

void Emit(const AsmPrinter *AP) const

Print the abbreviation using the specified asm printer.

void AddAttribute(dwarf::Attribute Attribute, dwarf::Form Form)

Adds another set of attribute information to the abbreviation.

void Profile(FoldingSetNodeID &ID) const

Used to gather unique data for the abbreviation folding set.

void print(raw_ostream &O) const

unsigned sizeOf(const dwarf::FormParams &FormParams, dwarf::Form Form) const

void emitValue(const AsmPrinter *AP, dwarf::Form Form) const

EmitValue - Emit label value.

void emitValue(const AsmPrinter *AP, dwarf::Form Form) const

EmitValue - Emit base type reference.

void print(raw_ostream &O) const

unsigned sizeOf(const dwarf::FormParams &, dwarf::Form) const

sizeOf - Determine size of the base type reference in bytes.

unsigned sizeOf(const dwarf::FormParams &, dwarf::Form Form) const

sizeOf - Determine size of block data in bytes.

void print(raw_ostream &O) const

void emitValue(const AsmPrinter *Asm, dwarf::Form Form) const

EmitValue - Emit block data.

unsigned computeSize(const dwarf::FormParams &FormParams) const

Calculate the size of the location expression.

void print(raw_ostream &O) const

unsigned sizeOf(const dwarf::FormParams &FormParams, dwarf::Form Form) const

SizeOf - Determine size of delta value in bytes.

void emitValue(const AsmPrinter *AP, dwarf::Form Form) const

EmitValue - Emit delta value.

void emitValue(const AsmPrinter *AP, dwarf::Form Form) const

EmitValue - Emit debug information entry offset.

void print(raw_ostream &O) const

unsigned sizeOf(const dwarf::FormParams &FormParams, dwarf::Form Form) const

void print(raw_ostream &O) const

void emitValue(const AsmPrinter *AP, dwarf::Form Form) const

EmitValue - Emit expression value.

unsigned sizeOf(const dwarf::FormParams &FormParams, dwarf::Form Form) const

SizeOf - Determine size of expression value in bytes.

void emitValue(const AsmPrinter *AP, dwarf::Form Form) const

void print(raw_ostream &O) const

unsigned sizeOf(const dwarf::FormParams &, dwarf::Form) const

unsigned sizeOf(const dwarf::FormParams &FormParams, dwarf::Form Form) const

sizeOf - Determine size of integer value in bytes.

void print(raw_ostream &O) const

void emitValue(const AsmPrinter *Asm, dwarf::Form Form) const

EmitValue - Emit integer of appropriate size.

void emitValue(const AsmPrinter *AP, dwarf::Form Form) const

EmitValue - Emit label value.

void print(raw_ostream &O) const

unsigned sizeOf(const dwarf::FormParams &FormParams, dwarf::Form Form) const

sizeOf - Determine size of label value in bytes.

void print(raw_ostream &O) const

unsigned sizeOf(const dwarf::FormParams &FormParams, dwarf::Form Form) const

void emitValue(const AsmPrinter *AP, dwarf::Form Form) const

EmitValue - Emit label value.

void print(raw_ostream &O) const

unsigned sizeOf(const dwarf::FormParams &, dwarf::Form Form) const

sizeOf - Determine size of location data in bytes.

void emitValue(const AsmPrinter *Asm, dwarf::Form Form) const

EmitValue - Emit location data.

unsigned computeSize(const dwarf::FormParams &FormParams) const

Calculate the size of the location expression.

void emitValue(const AsmPrinter *AP, dwarf::Form Form) const

EmitValue - Emit string value.

void print(raw_ostream &O) const

unsigned sizeOf(const dwarf::FormParams &FormParams, dwarf::Form Form) const

sizeOf - Determine size of delta value in bytes.

Represents a compile or type unit.

virtual const MCSymbol * getCrossSectionRelativeBaseAddress() const

DIEUnit(dwarf::Tag UnitTag)

void print(raw_ostream &O) const

void emitValue(const AsmPrinter *AP) const

Emit value via the Dwarf writer.

unsigned sizeOf(const dwarf::FormParams &FormParams) const

Return the size of a value in bytes.

A structured debug information entry.

DIEValue findAttribute(dwarf::Attribute Attribute) const

Find a value in the DIE with the attribute given.

void print(raw_ostream &O, unsigned IndentCount=0) const

unsigned getAbbrevNumber() const

DIEAbbrev generateAbbrev() const

Generate the abbreviation for this DIE.

unsigned computeOffsetsAndAbbrevs(const dwarf::FormParams &FormParams, DIEAbbrevSet &AbbrevSet, unsigned CUOffset)

Compute the offset of this DIE and all its children.

DIEUnit * getUnit() const

Climb up the parent chain to get the compile unit or type unit that this DIE belongs to.

const DIE * getUnitDie() const

Climb up the parent chain to get the compile unit or type unit DIE that this DIE belongs to.

void setAbbrevNumber(unsigned I)

Set the abbreviation number for this DIE.

unsigned getOffset() const

Get the compile/type unit relative offset of this DIE.

void setOffset(unsigned O)

uint64_t getDebugSectionOffset() const

Get the absolute offset within the .debug_info or .debug_types section for this DIE.

dwarf::Tag getTag() const

const List & getList(size_t LI) const

Collects and handles dwarf debug information.

const DebugLocStream & getDebugLocs() const

Returns the entries for the .debug_loc section.

bool useSplitDwarf() const

Returns whether or not to change the current debug info for the split dwarf proposal support.

unsigned getIndex() const

StringRef getString() const

uint64_t getOffset() const

MCSymbol * getSymbol() const

FoldingSetNodeID - This class is used to gather all the unique data bits of a node.

Instances of this class represent a uniqued identifier for a section in the current translation unit.

MCSymbol - Instances of this class represent a symbol name in the MC file, and MCSymbols are created ...

StringRef getName() const

getName - Get the symbol name.

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

constexpr size_t size() const

size - Get the string size.

constexpr const char * data() const

data - Get a pointer to the start of the string (which may not be null terminated).

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

LLVM Value Representation.

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

StringRef AttributeString(unsigned Attribute)

StringRef FormEncodingString(unsigned Encoding)

StringRef ChildrenString(unsigned Children)

StringRef TagString(unsigned Tag)

#define llvm_unreachable(msg)

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

unsigned ID

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

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.

This is an optimization pass for GlobalISel generic memory operations.

raw_ostream & dbgs()

dbgs() - This returns a reference to a raw_ostream for debugging messages.

format_object< Ts... > format(const char *Fmt, const Ts &... Vals)

These are helper functions used to produce formatted output.

unsigned getULEB128Size(uint64_t Value)

Utility function to get the size of the ULEB128-encoded value.

unsigned getSLEB128Size(int64_t Value)

Utility function to get the size of the SLEB128-encoded value.

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

bool DwarfUsesRelocationsAcrossSections

True if DWARF v2 output generally uses relocations for references to other .debug_* sections.

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.