DWARFFormValue.cpp Source File (original) (raw)

23#include

24#include

25#include

26#include

28using namespace llvm;

29using namespace dwarf;

97 V.uval = D.size();

98 V.data = D.data();

99 return DWARFFormValue(F, V);

100}

101

104 DWARFFormValue FormValue(F);

105 FormValue.extractValue(U->getDebugInfoExtractor(), OffsetPtr,

106 U->getFormParams(), U);

107 return FormValue;

108}

109

113 bool Indirect = false;

114 do {

115 switch (Form) {

116

117

118 case DW_FORM_exprloc:

119 case DW_FORM_block: {

121 *OffsetPtr += size;

122 return true;

123 }

124 case DW_FORM_block1: {

126 *OffsetPtr += size;

127 return true;

128 }

129 case DW_FORM_block2: {

131 *OffsetPtr += size;

132 return true;

133 }

134 case DW_FORM_block4: {

136 *OffsetPtr += size;

137 return true;

138 }

139

140

141 case DW_FORM_string:

142 DebugInfoData.getCStr(OffsetPtr);

143 return true;

144

145 case DW_FORM_addr:

146 case DW_FORM_ref_addr:

147 case DW_FORM_flag_present:

148 case DW_FORM_data1:

149 case DW_FORM_data2:

150 case DW_FORM_data4:

151 case DW_FORM_data8:

152 case DW_FORM_data16:

153 case DW_FORM_flag:

154 case DW_FORM_ref1:

155 case DW_FORM_ref2:

156 case DW_FORM_ref4:

157 case DW_FORM_ref8:

158 case DW_FORM_ref_sig8:

159 case DW_FORM_ref_sup4:

160 case DW_FORM_ref_sup8:

161 case DW_FORM_strx1:

162 case DW_FORM_strx2:

163 case DW_FORM_strx3:

164 case DW_FORM_strx4:

165 case DW_FORM_addrx1:

166 case DW_FORM_addrx2:

167 case DW_FORM_addrx3:

168 case DW_FORM_addrx4:

169 case DW_FORM_sec_offset:

170 case DW_FORM_strp:

171 case DW_FORM_strp_sup:

172 case DW_FORM_line_strp:

173 case DW_FORM_GNU_ref_alt:

174 case DW_FORM_GNU_strp_alt:

175 case DW_FORM_implicit_const:

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

178 *OffsetPtr += *FixedSize;

179 return true;

180 }

181 return false;

182

183

184 case DW_FORM_sdata:

186 return true;

187

188 case DW_FORM_udata:

189 case DW_FORM_ref_udata:

190 case DW_FORM_strx:

191 case DW_FORM_addrx:

192 case DW_FORM_loclistx:

193 case DW_FORM_rnglistx:

194 case DW_FORM_GNU_addr_index:

195 case DW_FORM_GNU_str_index:

197 return true;

198

199 case DW_FORM_LLVM_addrx_offset:

201 *OffsetPtr += 4;

202 return true;

203

204 case DW_FORM_indirect:

205 Indirect = true;

207 break;

208

209 default:

210 return false;

211 }

212 } while (Indirect);

213 return true;

214}

215

219

224 if (!Ctx && CU)

225 Ctx = &CU->getContext();

226 C = Ctx;

227 U = CU;

228 Format = FP.Format;

229 bool Indirect = false;

230 bool IsBlock = false;

231 Value.data = nullptr;

232

233

235 do {

236 Indirect = false;

237 switch (Form) {

238 case DW_FORM_addr:

239 case DW_FORM_ref_addr: {

241 (Form == DW_FORM_addr) ? FP.AddrSize : FP.getRefAddrByteSize();

242 Value.uval =

243 Data.getRelocatedValue(Size, OffsetPtr, &Value.SectionIndex, &Err);

244 break;

245 }

246 case DW_FORM_exprloc:

247 case DW_FORM_block:

248 Value.uval = Data.getULEB128(OffsetPtr, &Err);

249 IsBlock = true;

250 break;

251 case DW_FORM_block1:

252 Value.uval = Data.getU8(OffsetPtr, &Err);

253 IsBlock = true;

254 break;

255 case DW_FORM_block2:

256 Value.uval = Data.getU16(OffsetPtr, &Err);

257 IsBlock = true;

258 break;

259 case DW_FORM_block4:

260 Value.uval = Data.getU32(OffsetPtr, &Err);

261 IsBlock = true;

262 break;

263 case DW_FORM_data1:

264 case DW_FORM_ref1:

265 case DW_FORM_flag:

266 case DW_FORM_strx1:

267 case DW_FORM_addrx1:

268 Value.uval = Data.getU8(OffsetPtr, &Err);

269 break;

270 case DW_FORM_data2:

271 case DW_FORM_ref2:

272 case DW_FORM_strx2:

273 case DW_FORM_addrx2:

274 Value.uval = Data.getU16(OffsetPtr, &Err);

275 break;

276 case DW_FORM_strx3:

277 case DW_FORM_addrx3:

278 Value.uval = Data.getU24(OffsetPtr, &Err);

279 break;

280 case DW_FORM_data4:

281 case DW_FORM_ref4:

282 case DW_FORM_ref_sup4:

283 case DW_FORM_strx4:

284 case DW_FORM_addrx4:

285 Value.uval = Data.getRelocatedValue(4, OffsetPtr, nullptr, &Err);

286 break;

287 case DW_FORM_data8:

288 case DW_FORM_ref8:

289 case DW_FORM_ref_sup8:

290 Value.uval = Data.getRelocatedValue(8, OffsetPtr, nullptr, &Err);

291 break;

292 case DW_FORM_data16:

293

294 Value.uval = 16;

295 IsBlock = true;

296 break;

297 case DW_FORM_sdata:

298 Value.sval = Data.getSLEB128(OffsetPtr, &Err);

299 break;

300 case DW_FORM_udata:

301 case DW_FORM_ref_udata:

302 case DW_FORM_rnglistx:

303 case DW_FORM_loclistx:

304 case DW_FORM_GNU_addr_index:

305 case DW_FORM_GNU_str_index:

306 case DW_FORM_addrx:

307 case DW_FORM_strx:

308 Value.uval = Data.getULEB128(OffsetPtr, &Err);

309 break;

310 case DW_FORM_LLVM_addrx_offset:

311 Value.uval = Data.getULEB128(OffsetPtr, &Err) << 32;

312 Value.uval |= Data.getU32(OffsetPtr, &Err);

313 break;

314 case DW_FORM_string:

315 Value.cstr = Data.getCStr(OffsetPtr, &Err);

316 break;

317 case DW_FORM_indirect:

318 Form = static_cast<dwarf::Form>(Data.getULEB128(OffsetPtr, &Err));

319 Indirect = true;

320 break;

321 case DW_FORM_strp:

322 case DW_FORM_sec_offset:

323 case DW_FORM_GNU_ref_alt:

324 case DW_FORM_GNU_strp_alt:

325 case DW_FORM_line_strp:

326 case DW_FORM_strp_sup: {

327 Value.uval = Data.getRelocatedValue(FP.getDwarfOffsetByteSize(),

328 OffsetPtr, nullptr, &Err);

329 break;

330 }

331 case DW_FORM_flag_present:

332 Value.uval = 1;

333 break;

334 case DW_FORM_ref_sig8:

335 Value.uval = Data.getU64(OffsetPtr, &Err);

336 break;

337 case DW_FORM_implicit_const:

338

339 break;

340 default:

341

342

344 }

345 } while (Indirect && !Err);

346

347 if (IsBlock)

348 Value.data = Data.getBytes(OffsetPtr, Value.uval, &Err).bytes_begin();

349

351}

352

355 uint8_t HexDigits = AddressSize * 2;

356 OS << format("0x%*.*" PRIx64, HexDigits, HexDigits, Address);

357}

358

366

370 if (!DumpOpts.Verbose || SectionIndex == -1ULL)

371 return;

373 const auto &SecRef = SectionNames[SectionIndex];

374

375 OS << " \"" << SecRef.Name << '\"';

376

377

378 if (!SecRef.IsNameUnique)

379 OS << format(" [%" PRIu64 "]", SectionIndex);

380}

381

383 uint64_t UValue = Value.uval;

384 bool CURelativeOffset = false;

389 switch (Form) {

390 case DW_FORM_addr:

392 break;

393 case DW_FORM_addrx:

394 case DW_FORM_addrx1:

395 case DW_FORM_addrx2:

396 case DW_FORM_addrx3:

397 case DW_FORM_addrx4:

398 case DW_FORM_GNU_addr_index:

399 case DW_FORM_LLVM_addrx_offset: {

400 if (U == nullptr) {

401 OS << "";

402 break;

403 }

405 if ( || DumpOpts.Verbose) {

406 if (Form == DW_FORM_LLVM_addrx_offset) {

409 AddrOS << format("indexed (%8.8x) + 0x%x address = ", Index, Offset);

410 } else

411 AddrOS << format("indexed (%8.8x) address = ", (uint32_t)UValue);

412 }

413 if (A)

415 else

416 OS << "";

417 break;

418 }

419 case DW_FORM_flag_present:

420 OS << "true";

421 break;

422 case DW_FORM_flag:

423 case DW_FORM_data1:

425 break;

426 case DW_FORM_data2:

428 break;

429 case DW_FORM_data4:

431 break;

432 case DW_FORM_ref_sig8:

433 AddrOS << format("0x%016" PRIx64, UValue);

434 break;

435 case DW_FORM_data8:

436 OS << format("0x%016" PRIx64, UValue);

437 break;

438 case DW_FORM_data16:

439 OS << format_bytes(ArrayRef<uint8_t>(Value.data, 16), std::nullopt, 16, 16);

440 break;

441 case DW_FORM_string:

442 OS << '"';

444 OS << '"';

445 break;

446 case DW_FORM_exprloc:

447 case DW_FORM_block:

448 case DW_FORM_block1:

449 case DW_FORM_block2:

450 case DW_FORM_block4:

451 if (UValue > 0) {

452 switch (Form) {

453 case DW_FORM_exprloc:

454 case DW_FORM_block:

455 AddrOS << format("<0x%" PRIx64 "> ", UValue);

456 break;

457 case DW_FORM_block1:

459 break;

460 case DW_FORM_block2:

462 break;

463 case DW_FORM_block4:

465 break;

466 default:

467 break;

468 }

469

470 const uint8_t *DataPtr = Value.data;

471 if (DataPtr) {

472

473 const uint8_t *EndDataPtr = DataPtr + UValue;

474 while (DataPtr < EndDataPtr) {

475 AddrOS << format("%2.2x ", *DataPtr);

476 ++DataPtr;

477 }

478 } else

479 OS << "NULL";

480 }

481 break;

482

483 case DW_FORM_sdata:

484 case DW_FORM_implicit_const:

485 OS << Value.sval;

486 break;

487 case DW_FORM_udata:

488 OS << Value.uval;

489 break;

490 case DW_FORM_strp:

492 OS << format(" .debug_str[0x%0*" PRIx64 "] = ", OffsetDumpWidth, UValue);

493 dumpString(OS);

494 break;

495 case DW_FORM_line_strp:

497 OS << format(" .debug_line_str[0x%0*" PRIx64 "] = ", OffsetDumpWidth,

498 UValue);

499 dumpString(OS);

500 break;

501 case DW_FORM_strx:

502 case DW_FORM_strx1:

503 case DW_FORM_strx2:

504 case DW_FORM_strx3:

505 case DW_FORM_strx4:

506 case DW_FORM_GNU_str_index:

508 OS << format("indexed (%8.8x) string = ", (uint32_t)UValue);

509 dumpString(OS);

510 break;

511 case DW_FORM_GNU_strp_alt:

513 OS << format("alt indirect string, offset: 0x%" PRIx64 "", UValue);

514 dumpString(OS);

515 break;

516 case DW_FORM_ref_addr:

517 AddrOS << format("0x%016" PRIx64, UValue);

518 break;

519 case DW_FORM_ref1:

520 CURelativeOffset = true;

522 AddrOS << format("cu + 0x%2.2x", (uint8_t)UValue);

523 break;

524 case DW_FORM_ref2:

525 CURelativeOffset = true;

528 break;

529 case DW_FORM_ref4:

530 CURelativeOffset = true;

533 break;

534 case DW_FORM_ref8:

535 CURelativeOffset = true;

537 AddrOS << format("cu + 0x%8.8" PRIx64, UValue);

538 break;

539 case DW_FORM_ref_udata:

540 CURelativeOffset = true;

542 AddrOS << format("cu + 0x%" PRIx64, UValue);

543 break;

544 case DW_FORM_GNU_ref_alt:

545 AddrOS << format("<alt 0x%" PRIx64 ">", UValue);

546 break;

547

548

549

550 case DW_FORM_indirect:

551 OS << "DW_FORM_indirect";

552 break;

553

554 case DW_FORM_rnglistx:

555 OS << format("indexed (0x%x) rangelist = ", (uint32_t)UValue);

556 break;

557

558 case DW_FORM_loclistx:

559 OS << format("indexed (0x%x) loclist = ", (uint32_t)UValue);

560 break;

561

562 case DW_FORM_sec_offset:

563 AddrOS << format("0x%0*" PRIx64, OffsetDumpWidth, UValue);

564 break;

565

566 default:

567 OS << format("DW_FORM(0x%4.4x)", Form);

568 break;

569 }

570

571 if (CURelativeOffset) {

573 OS << " => {";

576 << format("0x%8.8" PRIx64, UValue + (U ? U->getOffset() : 0));

578 OS << "}";

579 }

580}

581

582void DWARFFormValue::dumpString(raw_ostream &OS) const {

585 COS.get() << '"';

586 COS.get().write_escaped(*DbgStr);

587 COS.get() << '"';

588 }

589}

590

595 if (Form == DW_FORM_string)

596 return Value.cstr;

597

598 if (Form == DW_FORM_GNU_strp_alt || C == nullptr)

602 std::optional<uint32_t> Index;

603 if (Form == DW_FORM_GNU_str_index || Form == DW_FORM_strx ||

604 Form == DW_FORM_strx1 || Form == DW_FORM_strx2 || Form == DW_FORM_strx3 ||

605 Form == DW_FORM_strx4) {

606 if (!U)

608 "available without a DWARFUnit",

612 if (!StrOffset)

615 }

616

617

618 bool IsDebugLineString = Form == DW_FORM_line_strp;

620 IsDebugLineString ? C->getLineStringExtractor()

621 : U ? U->getStringExtractor() : C->getStringExtractor();

623 return Str;

626 Msg += (" uses index " + Twine(*Index) + ", but the referenced string").str();

627 Msg += (" offset " + Twine(Offset) + " is beyond " +

628 (IsDebugLineString ? ".debug_line_str" : ".debug_str") + " bounds")

629 .str();

632}

633

636 return SA->Address;

637 return std::nullopt;

638}

639

643 return std::nullopt;

644 bool AddrOffset = Form == dwarf::DW_FORM_LLVM_addrx_offset;

645 if (Form == DW_FORM_GNU_addr_index || Form == DW_FORM_addrx ||

646 Form == DW_FORM_addrx1 || Form == DW_FORM_addrx2 ||

647 Form == DW_FORM_addrx3 || Form == DW_FORM_addrx4 || AddrOffset) {

648

649 uint32_t Index = AddrOffset ? (Value.uval >> 32) : Value.uval;

650 if (!U)

651 return std::nullopt;

652 std::optionalobject::SectionedAddress SA =

653 U->getAddrOffsetSectionItem(Index);

654 if (!SA)

655 return std::nullopt;

656 if (AddrOffset)

657 SA->Address += (Value.uval & 0xffffffff);

658 return SA;

659 }

660 return {{Value.uval, Value.SectionIndex}};

661}

662

663std::optionalobject::SectionedAddress

667

669 switch (Form) {

670 case DW_FORM_ref1:

671 case DW_FORM_ref2:

672 case DW_FORM_ref4:

673 case DW_FORM_ref8:

674 case DW_FORM_ref_udata:

675 if (!U)

676 return std::nullopt;

677 return Value.uval;

678 default:

679 return std::nullopt;

680 }

681}

682

684 if (Form == DW_FORM_ref_addr)

685 return Value.uval;

686 return std::nullopt;

687}

688

690 if (Form == DW_FORM_ref_sig8)

691 return Value.uval;

692 return std::nullopt;

693}

694

696 switch (Form) {

697 case DW_FORM_GNU_ref_alt:

698 case DW_FORM_ref_sup4:

699 case DW_FORM_ref_sup8:

700 return Value.uval;

701 default:

702 return std::nullopt;

703 }

704}

705

708 return std::nullopt;

709 return Value.uval;

710}

711

714 Form == DW_FORM_sdata)

715 return std::nullopt;

716 return Value.uval;

717}

718

721 (Form == DW_FORM_udata &&

722 uint64_t(std::numeric_limits<int64_t>::max()) < Value.uval))

723 return std::nullopt;

724 switch (Form) {

725 case DW_FORM_data4:

726 return int32_t(Value.uval);

727 case DW_FORM_data2:

728 return int16_t(Value.uval);

729 case DW_FORM_data1:

730 return int8_t(Value.uval);

731 case DW_FORM_sdata:

732 case DW_FORM_data8:

733 default:

734 return Value.sval;

735 }

736}

737

740 Form != DW_FORM_data16)

741 return std::nullopt;

742 return ArrayRef(Value.data, Value.uval);

743}

744

747 return std::nullopt;

748 return Value.uval;

749}

750

753 return std::nullopt;

754 return Value.uval;

755}

756

757std::optionalstd::string

760 return std::nullopt;

763 std::string FileName;

764 if (LT->getFileNameByIndex(Value.uval, DLU->getCompilationDir(), Kind,

765 FileName))

766 return FileName;

767 }

768 return std::nullopt;

769}

770

773

775 return true;

776

777 switch (Form) {

778 case DW_FORM_GNU_ref_alt:

780 case DW_FORM_GNU_addr_index:

782 case DW_FORM_GNU_str_index:

783 case DW_FORM_GNU_strp_alt:

785 case DW_FORM_LLVM_addrx_offset:

787 case DW_FORM_strp:

788 case DW_FORM_line_strp:

790 case DW_FORM_data4:

791 case DW_FORM_data8:

792

793

795 default:

796 return false;

797 }

798}

static GCRegistry::Add< ErlangGC > A("erlang", "erlang-compatible garbage collector")

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

static const DWARFFormValue::FormClass DWARF5FormClasses[]

Definition DWARFFormValue.cpp:31

This file contains constants used for implementing Dwarf debug support.

ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...

DWARFContext This data structure is the top level entity that deals with dwarf debug information pars...

const DWARFDebugLine::LineTable * getLineTableForUnit(DWARFUnit *U)

Get a pointer to a parsed line table corresponding to a compile unit.

static LLVM_ABI void dumpAddressSection(const DWARFObject &Obj, raw_ostream &OS, DIDumpOptions DumpOpts, uint64_t SectionIndex)

Definition DWARFFormValue.cpp:367

static LLVM_ABI DWARFFormValue createFromPValue(dwarf::Form F, const char *V)

Definition DWARFFormValue.cpp:90

LLVM_ABI std::optional< uint64_t > getAsCStringOffset() const

Definition DWARFFormValue.cpp:745

static LLVM_ABI DWARFFormValue createFromUValue(dwarf::Form F, uint64_t V)

Definition DWARFFormValue.cpp:86

LLVM_ABI std::optional< uint64_t > getAsSupplementaryReference() const

Definition DWARFFormValue.cpp:695

LLVM_ABI std::optional< std::string > getAsFile(DILineInfoSpecifier::FileLineInfoKind Kind) const

Correctly extract any file paths from a form value.

Definition DWARFFormValue.cpp:758

LLVM_ABI std::optional< ArrayRef< uint8_t > > getAsBlock() const

Definition DWARFFormValue.cpp:738

LLVM_ABI std::optional< uint64_t > getAsSectionOffset() const

Definition DWARFFormValue.cpp:706

LLVM_ABI void dumpSectionedAddress(raw_ostream &OS, DIDumpOptions DumpOpts, object::SectionedAddress SA) const

Definition DWARFFormValue.cpp:359

LLVM_ABI bool isFormClass(FormClass FC) const

Definition DWARFFormValue.cpp:216

LLVM_ABI std::optional< object::SectionedAddress > getAsSectionedAddress() const

Definition DWARFFormValue.cpp:664

LLVM_ABI std::optional< uint64_t > getAsReferenceUVal() const

Definition DWARFFormValue.cpp:751

LLVM_ABI void dumpAddress(raw_ostream &OS, uint64_t Address) const

LLVM_ABI std::optional< int64_t > getAsSignedConstant() const

Definition DWARFFormValue.cpp:719

LLVM_ABI std::optional< uint64_t > getAsAddress() const

Definition DWARFFormValue.cpp:634

LLVM_ABI bool extractValue(const DWARFDataExtractor &Data, uint64_t *OffsetPtr, dwarf::FormParams FormParams, const DWARFContext *Context=nullptr, const DWARFUnit *Unit=nullptr)

Extracts a value in Data at offset *OffsetPtr.

Definition DWARFFormValue.cpp:220

LLVM_ABI std::optional< uint64_t > getAsRelativeReference() const

getAsFoo functions below return the extracted value as Foo if only DWARFFormValue has form class is s...

Definition DWARFFormValue.cpp:668

LLVM_ABI std::optional< uint64_t > getAsSignatureReference() const

Definition DWARFFormValue.cpp:689

LLVM_ABI std::optional< uint64_t > getAsDebugInfoReference() const

Definition DWARFFormValue.cpp:683

static LLVM_ABI DWARFFormValue createFromBlockValue(dwarf::Form F, ArrayRef< uint8_t > D)

Definition DWARFFormValue.cpp:94

LLVM_ABI void dump(raw_ostream &OS, DIDumpOptions DumpOpts=DIDumpOptions()) const

Definition DWARFFormValue.cpp:382

static LLVM_ABI DWARFFormValue createFromSValue(dwarf::Form F, int64_t V)

Definition DWARFFormValue.cpp:82

LLVM_ABI std::optional< uint64_t > getAsUnsignedConstant() const

Definition DWARFFormValue.cpp:712

bool skipValue(DataExtractor DebugInfoData, uint64_t *OffsetPtr, const dwarf::FormParams Params) const

Skip a form's value in DebugInfoData at the offset specified by OffsetPtr.

static LLVM_ABI DWARFFormValue createFromUnit(dwarf::Form F, const DWARFUnit *Unit, uint64_t *OffsetPtr)

Definition DWARFFormValue.cpp:102

LLVM_ABI Expected< const char * > getAsCString() const

Definition DWARFFormValue.cpp:591

DWARFContext & getContext() const

const char * getCompilationDir()

Lightweight error class with error context and mandatory checking.

static ErrorSuccess success()

Create a success value.

Tagged union holding either a T or a Error.

Error takeError()

Take ownership of the stored error.

std::string str() const

str - Get the contents as an std::string.

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

An RAII object that temporarily switches an output stream to a specific color.

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

raw_ostream & write_escaped(StringRef Str, bool UseHexEscapes=false)

Output Str, turning '\', '\t', ' ', '"', and anything that doesn't satisfy llvm::isPrint into an esca...

LLVM_ABI StringRef FormEncodingString(unsigned Encoding)

#define llvm_unreachable(msg)

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

static constexpr StringLiteral SectionNames[SectionKindsNum]

Calculates the starting offsets for various sections within the .debug_names section.

std::optional< const char * > toString(const std::optional< DWARFFormValue > &V)

Take an optional DWARFFormValue and try to extract a string value from it.

LLVM_ABI bool doesFormBelongToClass(dwarf::Form Form, DWARFFormValue::FormClass FC, uint16_t DwarfVersion)

Check whether specified Form belongs to the FC class.

Definition DWARFFormValue.cpp:771

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

Get the fixed byte size for a given form.

uint8_t getDwarfOffsetByteSize(DwarfFormat Format)

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

This is an optimization pass for GlobalISel generic memory operations.

bool errorToBool(Error Err)

Helper for converting an Error to a bool.

auto size(R &&Range, std::enable_if_t< std::is_base_of< std::random_access_iterator_tag, typename std::iterator_traits< decltype(Range.begin())>::iterator_category >::value, void > *=nullptr)

Get the size of a range.

LLVM_ABI std::error_code inconvertibleErrorCode()

The value returned by this function can be returned from convertToErrorCode for Error values where no...

LLVM_ABI raw_ostream & nulls()

This returns a reference to a raw_ostream which simply discards output.

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

These are helper functions used to produce formatted output.

Error make_error(ArgTs &&... Args)

Make a Error instance representing failure using the given error info type.

FunctionAddr VTableAddr uintptr_t uintptr_t Data

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

PointerUnion< const Value *, const PseudoSourceValue * > ValueType

Container for dump options that control which debug information will be dumped.

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