DWP.cpp Source File (original) (raw)

23#include

25using namespace llvm;

33 if (DwarfVersion <= 4)

34 return 0;

38 return 16;

39 return 8;

40}

52 ;

53 }

55}

60 if (Form == dwarf::DW_FORM_string)

61 return InfoData.getCStr(&InfoOffset);

63 switch (Form) {

64 case dwarf::DW_FORM_strx1:

65 StrIndex = InfoData.getU8(&InfoOffset);

66 break;

67 case dwarf::DW_FORM_strx2:

68 StrIndex = InfoData.getU16(&InfoOffset);

69 break;

70 case dwarf::DW_FORM_strx3:

71 StrIndex = InfoData.getU24(&InfoOffset);

72 break;

73 case dwarf::DW_FORM_strx4:

74 StrIndex = InfoData.getU32(&InfoOffset);

75 break;

76 case dwarf::DW_FORM_strx:

77 case dwarf::DW_FORM_GNU_str_index:

78 StrIndex = InfoData.getULEB128(&InfoOffset);

79 break;

80 default:

81 return make_error(

82 "string field must be encoded with one of the following: "

83 "DW_FORM_string, DW_FORM_strx, DW_FORM_strx1, DW_FORM_strx2, "

84 "DW_FORM_strx3, DW_FORM_strx4, or DW_FORM_GNU_str_index.");

85 }

86 DataExtractor StrOffsetsData(StrOffsets, true, 0);

87 uint64_t StrOffsetsOffset = 4 * StrIndex;

90 uint64_t StrOffset = StrOffsetsData.getU32(&StrOffsetsOffset);

92 return StrData.getCStr(&StrOffset);

93}

100 if (Header.Version >= 5 && Header.UnitType != dwarf::DW_UT_split_compile)

101 return make_error(

102 std::string("unit type DW_UT_split_compile type not found in "

103 "debug_info header. Unexpected unit type 0x" +

104 utostr(Header.UnitType) + " found"));

105

107

112 if (Tag != dwarf::DW_TAG_compile_unit)

113 return make_error("top level DIE is not a compile unit");

114

115 AbbrevData.getU8(&AbbrevOffset);

118 while ((Name = AbbrevData.getULEB128(&AbbrevOffset)) |

120 AbbrevData.getULEB128(&AbbrevOffset))) &&

121 (Name != 0 || Form != 0)) {

122 switch (Name) {

123 case dwarf::DW_AT_name: {

125 Form, InfoData, Offset, StrOffsets, Str, Header.Version);

126 if (!EName)

128 ID.Name = *EName;

129 break;

130 }

131 case dwarf::DW_AT_GNU_dwo_name:

132 case dwarf::DW_AT_dwo_name: {

134 Form, InfoData, Offset, StrOffsets, Str, Header.Version);

135 if (!EName)

137 ID.DWOName = *EName;

138 break;

139 }

140 case dwarf::DW_AT_GNU_dwo_id:

142 break;

143 default:

145 Form, InfoData, &Offset,

146 dwarf::FormParams({Header.Version, Header.AddrSize, Header.Format}));

147 }

148 }

149 if (!Header.Signature)

150 return make_error("compile unit missing dwo_id");

151 ID.Signature = *Header.Signature;

152 return ID;

153}

154

157}

158

159namespace llvm {

160

161

165}

166}

167

168

169

171 return Index + DW_SECT_INFO;

172}

173

177 const auto *Off = Entry.getContribution(Kind);

178 if (!Off)

180 return Section.substr(Off->getOffset(), Off->getLength());

181}

182

187 bool &AnySectionOverflow) {

188 std::string Msg =

190 Twine(" Section Contribution Offset overflow 4G. Previous Offset ") +

191 Twine(PrevOffset) + Twine(", After overflow offset ") +

192 Twine(OverflowedOffset) + Twine("."))

193 .str();

194 if (OverflowOptValue == OnCuIndexOverflow::Continue) {

197 } else if (OverflowOptValue == OnCuIndexOverflow::SoftStop) {

198 AnySectionOverflow = true;

201 }

202 return make_error(Msg);

203}

204

209 unsigned TypesContributionIndex, OnCuIndexOverflow OverflowOptValue,

210 bool &AnySectionOverflow) {

213 auto *I = E.getContributions();

214 if ()

215 continue;

216 auto P = TypeIndexEntries.insert(std::make_pair(E.getSignature(), TUEntry));

217 if (.second)

218 continue;

219 auto &Entry = P.first->second;

220

221 Entry.Contributions[0] = {};

224 continue;

225 auto &C =

227 C.setOffset(C.getOffset() + I->getOffset());

228 C.setLength(I->getLength());

229 ++I;

230 }

231 auto &C = Entry.Contributions[TypesContributionIndex];

233 C.getOffset() -

235 C.getLength()));

236 C.setOffset(TypesOffset);

237 uint32_t OldOffset = TypesOffset;

238 static_assert(sizeof(OldOffset) == sizeof(TypesOffset));

239 TypesOffset += C.getLength();

240 if (OldOffset > TypesOffset) {

242 "Types", OverflowOptValue,

243 AnySectionOverflow))

244 return Err;

245 if (AnySectionOverflow) {

246 TypesOffset = OldOffset;

248 }

249 }

250 }

252}

253

256 MCSection *OutputTypes, const std::vector &TypesSections,

259 for (StringRef Types : TypesSections) {

263 while (Data.isValidOffset(Offset)) {

265

266 Entry.Contributions[0] = {};

268 C.setOffset(TypesOffset);

269 auto PrevOffset = Offset;

270

271 C.setLength(Data.getU32(&Offset) + 4);

272

273 Data.getU16(&Offset);

274 Data.getU32(&Offset);

275 Data.getU8(&Offset);

276 auto Signature = Data.getU64(&Offset);

277 Offset = PrevOffset + C.getLength32();

278

279 auto P = TypeIndexEntries.insert(std::make_pair(Signature, Entry));

280 if (.second)

281 continue;

282

283 Out.emitBytes(Types.substr(PrevOffset, C.getLength32()));

284 uint32_t OldOffset = TypesOffset;

285 TypesOffset += C.getLength32();

286 if (OldOffset > TypesOffset) {

288 "Types", OverflowOptValue,

289 AnySectionOverflow))

290 return Err;

291 if (AnySectionOverflow) {

292 TypesOffset = OldOffset;

294 }

295 }

296 }

297 }

299}

300

303 std::string Text = "\'";

304 Text += Name;

305 Text += '\'';

306 bool HasDWO = !DWOName.empty();

307 bool HasDWP = !DWPName.empty();

308 if (HasDWO || HasDWP) {

309 Text += " (from ";

310 if (HasDWO) {

311 Text += '\'';

312 Text += DWOName;

313 Text += '\'';

314 }

315 if (HasDWO && HasDWP)

316 Text += " in ";

317 if (!DWPName.empty()) {

318 Text += '\'';

319 Text += DWPName;

320 Text += '\'';

321 }

322 Text += ")";

323 }

324 return Text;

325}

326

328 return make_error(

329 ("failure while decompressing compressed section: '" + Name + "', " +

331 .str());

332}

333

337 auto *Obj = dyn_cast(Sec.getObject());

338 if (!Obj ||

341 bool IsLE = isaobject::ELF32LEObjectFile(Obj) ||

342 isaobject::ELF64LEObjectFile(Obj);

343 bool Is64 = isaobject::ELF64LEObjectFile(Obj) ||

344 isaobject::ELF64BEObjectFile(Obj);

346 if (!Dec)

348

349 UncompressedSections.emplace_back();

350 if (Error E = Dec->resizeAndDecompress(UncompressedSections.back()))

352

353 Contents = UncompressedSections.back();

355}

356

357namespace llvm {

358

364 std::tie(Header.Length, Header.Format) =

366 if (Err)

367 return make_error("cannot parse compile unit length: " +

369

371 return make_error(

372 "compile unit exceeds .debug_info section range: " +

373 utostr(Offset + Header.Length) + " >= " + utostr(InfoData.size()));

374 }

375

376 Header.Version = InfoData.getU16(&Offset, &Err);

377 if (Err)

378 return make_error("cannot parse compile unit version: " +

380

382 if (Header.Version >= 5) {

383

384

385 MinHeaderLength = 16;

386 } else {

387

388 MinHeaderLength = 7;

389 }

390 if (Header.Length < MinHeaderLength) {

391 return make_error("unit length is too small: expected at least " +

392 utostr(MinHeaderLength) + " got " +

393 utostr(Header.Length) + ".");

394 }

395 if (Header.Version >= 5) {

396 Header.UnitType = InfoData.getU8(&Offset);

397 Header.AddrSize = InfoData.getU8(&Offset);

398 Header.DebugAbbrevOffset = InfoData.getU32(&Offset);

400 if (Header.UnitType == dwarf::DW_UT_split_type) {

401

402 MinHeaderLength += 4;

403 if (Header.Length < MinHeaderLength)

404 return make_error("type unit is missing type offset");

406 }

407 } else {

408

409

410 Header.DebugAbbrevOffset = InfoData.getU32(&Offset);

411 Header.AddrSize = InfoData.getU8(&Offset);

412 }

413

414 Header.HeaderSize = Offset;

415 return Header;

416}

417

421

423 auto OldOffset = Data.getU32(&Offset);

424 auto NewOffset = OffsetRemapping[OldOffset];

426 }

427}

428

433

434

435 if (CurStrSection.empty() || CurStrOffsetSection.empty())

436 return;

437

439

443 while (const char *S = Data.getCStr(&LocalOffset)) {

444 OffsetRemapping[PrevOffset] =

445 Strings.getOffset(S, LocalOffset - PrevOffset);

446 PrevOffset = LocalOffset;

447 }

448

450

452

459 "StrOffsetSection size is less than its header");

460

461 uint64_t ContributionEnd = 0;

462 uint64_t ContributionSize = 0;

464 if (HeaderSize == 8) {

465 ContributionSize = Data.getU32(&HeaderLengthOffset);

466 } else if (HeaderSize == 16) {

467 HeaderLengthOffset += 4;

468 ContributionSize = Data.getU64(&HeaderLengthOffset);

469 }

470 ContributionEnd = ContributionSize + HeaderLengthOffset;

473 }

474

475 } else {

477 }

478}

479

484 for (const auto &E : IndexEntries)

485 for (size_t I = 0; I != std::size(E.second.Contributions); ++I)

486 if (ContributionOffsets[I])

488 ? E.second.Contributions[I].getOffset32()

489 : E.second.Contributions[I].getLength32()),

490 4);

491}

492

497 if (IndexEntries.empty())

498 return;

499

500 unsigned Columns = 0;

501 for (auto &C : ContributionOffsets)

502 if (C)

503 ++Columns;

504

505 std::vector Buckets(NextPowerOf2(3 * IndexEntries.size() / 2));

506 uint64_t Mask = Buckets.size() - 1;

507 size_t I = 0;

508 for (const auto &P : IndexEntries) {

509 auto S = P.first;

510 auto H = S & Mask;

511 auto HP = ((S >> 32) & Mask) | 1;

512 while (Buckets[H]) {

513 assert(S != IndexEntries.begin()[Buckets[H] - 1].first &&

514 "Duplicate unit");

515 H = (H + HP) & Mask;

516 }

517 Buckets[H] = I + 1;

518 ++I;

519 }

520

522 Out.emitIntValue(IndexVersion, 4);

525 Out.emitIntValue(Buckets.size(), 4);

526

527

528 for (const auto &I : Buckets)

530

531

532 for (const auto &I : Buckets)

534

535

536 for (size_t I = 0; I != ContributionOffsets.size(); ++I)

537 if (ContributionOffsets[I])

539

540

542

543

545}

546

549 return make_error(

550 std::string("duplicate DWO ID (") + utohexstr(PrevE.first) + ") in " +

552 PrevE.second.DWOName) +

554}

555

557 const StringMap<std::pair<MCSection *, DWARFSectionKind>> &KnownSections,

565 std::vector &CurTypesSection,

566 std::vector &CurInfoSection, StringRef &AbbrevSection,

568 std::vector<std::pair<DWARFSectionKind, uint32_t>> &SectionLength) {

569 if (Section.isBSS())

571

572 if (Section.isVirtual())

574

576 if (!NameOrErr)

579

581 if (!ContentsOrErr)

582 return ContentsOrErr.takeError();

583 StringRef Contents = *ContentsOrErr;

584

586 Contents))

587 return Err;

588

589 Name = Name.substr(Name.find_first_not_of("._"));

590

591 auto SectionPair = KnownSections.find(Name);

592 if (SectionPair == KnownSections.end())

594

597 SectionLength.push_back(std::make_pair(Kind, Contents.size()));

598 }

599

600 if (Kind == DW_SECT_ABBREV) {

601 AbbrevSection = Contents;

602 }

603 }

604

605 MCSection *OutSection = SectionPair->second.first;

606 if (OutSection == StrOffsetSection)

607 CurStrOffsetSection = Contents;

608 else if (OutSection == StrSection)

609 CurStrSection = Contents;

610 else if (OutSection == TypesSection)

611 CurTypesSection.push_back(Contents);

612 else if (OutSection == CUIndexSection)

613 CurCUIndexSection = Contents;

614 else if (OutSection == TUIndexSection)

615 CurTUIndexSection = Contents;

616 else if (OutSection == InfoSection)

617 CurInfoSection.push_back(Contents);

618 else {

621 }

623}

624

628 MCSection *const StrSection = MCOFI.getDwarfStrDWOSection();

629 MCSection *const StrOffsetSection = MCOFI.getDwarfStrOffDWOSection();

630 MCSection *const TypesSection = MCOFI.getDwarfTypesDWOSection();

631 MCSection *const CUIndexSection = MCOFI.getDwarfCUIndexSection();

632 MCSection *const TUIndexSection = MCOFI.getDwarfTUIndexSection();

633 MCSection *const InfoSection = MCOFI.getDwarfInfoDWOSection();

635 {"debug_info.dwo", {InfoSection, DW_SECT_INFO}},

636 {"debug_types.dwo", {MCOFI.getDwarfTypesDWOSection(), DW_SECT_EXT_TYPES}},

637 {"debug_str_offsets.dwo", {StrOffsetSection, DW_SECT_STR_OFFSETS}},

638 {"debug_str.dwo", {StrSection, static_cast<DWARFSectionKind>(0)}},

639 {"debug_loc.dwo", {MCOFI.getDwarfLocDWOSection(), DW_SECT_EXT_LOC}},

640 {"debug_line.dwo", {MCOFI.getDwarfLineDWOSection(), DW_SECT_LINE}},

641 {"debug_macro.dwo", {MCOFI.getDwarfMacroDWOSection(), DW_SECT_MACRO}},

642 {"debug_abbrev.dwo", {MCOFI.getDwarfAbbrevDWOSection(), DW_SECT_ABBREV}},

643 {"debug_loclists.dwo",

644 {MCOFI.getDwarfLoclistsDWOSection(), DW_SECT_LOCLISTS}},

645 {"debug_rnglists.dwo",

646 {MCOFI.getDwarfRnglistsDWOSection(), DW_SECT_RNGLISTS}},

647 {"debug_cu_index", {CUIndexSection, static_cast<DWARFSectionKind>(0)}},

648 {"debug_tu_index", {TUIndexSection, static_cast<DWARFSectionKind>(0)}}};

649

652

653 uint32_t ContributionOffsets[8] = {};

656 bool AnySectionOverflow = false;

657

659

662

663 std::deque<SmallString<32>> UncompressedSections;

664

665 for (const auto &Input : Inputs) {

667 if (!ErrOrObj) {

669 [&](std::unique_ptr EC) -> Error {

670 return createFileError(Input, Error(std::move(EC)));

671 });

672 }

673

674 auto &Obj = *ErrOrObj->getBinary();

675 Objects.push_back(std::move(*ErrOrObj));

676

678

681 std::vector CurTypesSection;

682 std::vector CurInfoSection;

686

687

688

689

690 std::vector<std::pair<DWARFSectionKind, uint32_t>> SectionLength;

691

692 for (const auto &Section : Obj.sections())

694 KnownSections, StrSection, StrOffsetSection, TypesSection,

695 CUIndexSection, TUIndexSection, InfoSection, Section, Out,

696 UncompressedSections, ContributionOffsets, CurEntry,

697 CurStrSection, CurStrOffsetSection, CurTypesSection,

698 CurInfoSection, AbbrevSection, CurCUIndexSection,

699 CurTUIndexSection, SectionLength))

700 return Err;

701

702 if (CurInfoSection.empty())

703 continue;

704

707 if (!HeaderOrErr)

710

712 Version = Header.Version;

713 IndexVersion = Version < 5 ? 2 : 5;

714 } else if (Version != Header.Version) {

715 return make_error("incompatible DWARF compile unit versions.");

716 }

717

719 CurStrOffsetSection, Header.Version);

720

721 for (auto Pair : SectionLength) {

725 uint32_t OldOffset = ContributionOffsets[Index];

727 if (OldOffset > ContributionOffsets[Index]) {

729 for (auto &Section : Obj.sections()) {

730 if (SectionIndex == Index) {

732 OldOffset, ContributionOffsets[Index], *Section.getName(),

733 OverflowOptValue, AnySectionOverflow))

734 return Err;

735 }

736 ++SectionIndex;

737 }

738 if (AnySectionOverflow)

739 break;

740 }

741 }

742

743 uint32_t &InfoSectionOffset =

745 if (CurCUIndexSection.empty()) {

746 bool FoundCUUnit = false;

750 while (Info.size() > UnitOffset) {

753 if (!HeaderOrError)

754 return HeaderOrError.takeError();

756

759 IndexVersion)];

760 C.setOffset(InfoSectionOffset);

761 C.setLength(Header.Length + 4);

762

763 if (std::numeric_limits<uint32_t>::max() - InfoSectionOffset <

764 C.getLength32()) {

766 InfoSectionOffset, InfoSectionOffset + C.getLength32(),

767 "debug_info", OverflowOptValue, AnySectionOverflow))

768 return Err;

769 if (AnySectionOverflow) {

770 if (Header.Version < 5 ||

771 Header.UnitType == dwarf::DW_UT_split_compile)

772 FoundCUUnit = true;

773 break;

774 }

775 }

776

777 UnitOffset += C.getLength32();

778 if (Header.Version < 5 ||

779 Header.UnitType == dwarf::DW_UT_split_compile) {

781 Header, AbbrevSection,

782 Info.substr(UnitOffset - C.getLength32(), C.getLength32()),

783 CurStrOffsetSection, CurStrSection);

784

785 if (!EID)

787 const auto &ID = *EID;

788 auto P = IndexEntries.insert(std::make_pair(ID.Signature, Entry));

789 if (.second)

791 P.first->second.Name = ID.Name;

792 P.first->second.DWOName = ID.DWOName;

793

794 FoundCUUnit = true;

795 } else if (Header.UnitType == dwarf::DW_UT_split_type) {

796 auto P = TypeIndexEntries.insert(

797 std::make_pair(*Header.Signature, Entry));

798 if (.second)

799 continue;

800 }

802 Info.substr(UnitOffset - C.getLength32(), C.getLength32()));

803 InfoSectionOffset += C.getLength32();

804 }

805 if (AnySectionOverflow)

806 break;

807 }

808

809 if (!FoundCUUnit)

810 return make_error("no compile unit found in file: " + Input);

811

812 if (IndexVersion == 2) {

813

815 Out, TypeIndexEntries, TypesSection, CurTypesSection, CurEntry,

817 OverflowOptValue, AnySectionOverflow))

818 return Err;

819 }

820 if (AnySectionOverflow)

821 break;

822 continue;

823 }

824

825 if (CurInfoSection.size() != 1)

826 return make_error("expected exactly one occurrence of a debug "

827 "info section in a .dwp file");

828 StringRef DwpSingleInfoSection = CurInfoSection.front();

829

831 DataExtractor CUIndexData(CurCUIndexSection, Obj.isLittleEndian(), 0);

832 if (!CUIndex.parse(CUIndexData))

833 return make_error("failed to parse cu_index");

834 if (CUIndex.getVersion() != IndexVersion)

835 return make_error("incompatible cu_index versions, found " +

837 " and expecting " + utostr(IndexVersion));

838

841 auto *I = E.getContributions();

842 if ()

843 continue;

844 auto P = IndexEntries.insert(std::make_pair(E.getSignature(), CurEntry));

846 getSubsection(DwpSingleInfoSection, E, DW_SECT_INFO);

849 if (!HeaderOrError)

850 return HeaderOrError.takeError();

852

854 Header, getSubsection(AbbrevSection, E, DW_SECT_ABBREV),

855 CUInfoSection,

856 getSubsection(CurStrOffsetSection, E, DW_SECT_STR_OFFSETS),

857 CurStrSection);

858 if (!EID)

860 const auto &ID = *EID;

861 if (.second)

863 auto &NewEntry = P.first->second;

864 NewEntry.Name = ID.Name;

865 NewEntry.DWOName = ID.DWOName;

866 NewEntry.DWPName = Input;

869 continue;

870 auto &C =

872 C.setOffset(C.getOffset() + I->getOffset());

873 C.setLength(I->getLength());

874 ++I;

875 }

877 auto &C = NewEntry.Contributions[Index];

879 C.setOffset(InfoSectionOffset);

880 InfoSectionOffset += C.getLength32();

881 }

882

883 if (!CurTUIndexSection.empty()) {

887

889 TUSectionKind = DW_SECT_INFO;

890 OutSection = InfoSection;

891 TypeInputSection = DwpSingleInfoSection;

892 } else {

893

894 if (CurTypesSection.size() != 1)

895 return make_error(

896 "multiple type unit sections in .dwp file");

897

899 OutSection = TypesSection;

900 TypeInputSection = CurTypesSection.front();

901 }

902

904 DataExtractor TUIndexData(CurTUIndexSection, Obj.isLittleEndian(), 0);

905 if (!TUIndex.parse(TUIndexData))

906 return make_error("failed to parse tu_index");

907 if (TUIndex.getVersion() != IndexVersion)

908 return make_error("incompatible tu_index versions, found " +

910 " and expecting " + utostr(IndexVersion));

911

912 unsigned TypesContributionIndex =

915 Out, TypeIndexEntries, TUIndex, OutSection, TypeInputSection,

916 CurEntry, ContributionOffsets[TypesContributionIndex],

917 TypesContributionIndex, OverflowOptValue, AnySectionOverflow))

918 return Err;

919 }

920 if (AnySectionOverflow)

921 break;

922 }

923

925

926

927

928 ContributionOffsets[0] = 0;

929 }

930 writeIndex(Out, MCOFI.getDwarfTUIndexSection(), ContributionOffsets,

931 TypeIndexEntries, IndexVersion);

932

934

935

937

938 ContributionOffsets[0] = 1;

939 }

940

941 writeIndex(Out, MCOFI.getDwarfCUIndexSection(), ContributionOffsets,

942 IndexEntries, IndexVersion);

943

945}

946}

Analysis containing CSE Info

static uint64_t getCUAbbrev(StringRef Abbrev, uint64_t AbbrCode)

static Error handleCompressedSection(std::deque< SmallString< 32 > > &UncompressedSections, SectionRef Sec, StringRef Name, StringRef &Contents)

static std::string buildDWODescription(StringRef Name, StringRef DWPName, StringRef DWOName)

static uint64_t debugStrOffsetsHeaderSize(DataExtractor StrOffsetsData, uint16_t DwarfVersion)

static Expected< const char * > getIndexedString(dwarf::Form Form, DataExtractor InfoData, uint64_t &InfoOffset, StringRef StrOffsets, StringRef Str, uint16_t Version)

static Error addAllTypesFromTypesSection(MCStreamer &Out, MapVector< uint64_t, UnitIndexEntry > &TypeIndexEntries, MCSection *OutputTypes, const std::vector< StringRef > &TypesSections, const UnitIndexEntry &CUEntry, uint32_t &TypesOffset, OnCuIndexOverflow OverflowOptValue, bool &AnySectionOverflow)

static unsigned getOnDiskSectionId(unsigned Index)

static Expected< CompileUnitIdentifiers > getCUIdentifiers(InfoSectionUnitHeader &Header, StringRef Abbrev, StringRef Info, StringRef StrOffsets, StringRef Str)

static Error sectionOverflowErrorOrWarning(uint32_t PrevOffset, uint32_t OverflowedOffset, StringRef SectionName, OnCuIndexOverflow OverflowOptValue, bool &AnySectionOverflow)

static mc::RegisterMCTargetOptionsFlags MCTargetOptionsFlags

static StringRef getSubsection(StringRef Section, const DWARFUnitIndex::Entry &Entry, DWARFSectionKind Kind)

static Error createError(StringRef Name, Error E)

static bool isSupportedSectionKind(DWARFSectionKind Kind)

static Error addAllTypesFromDWP(MCStreamer &Out, MapVector< uint64_t, UnitIndexEntry > &TypeIndexEntries, const DWARFUnitIndex &TUIndex, MCSection *OutputTypes, StringRef Types, const UnitIndexEntry &TUEntry, uint32_t &TypesOffset, unsigned TypesContributionIndex, OnCuIndexOverflow OverflowOptValue, bool &AnySectionOverflow)

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

static uint32_t getFlags(const Symbol *Sym)

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

size_t size() const

size - Get the array size.

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.

void setOffset(uint64_t Value)

void setLength(uint64_t Value)

uint32_t getLength32() const

uint64_t getOffset() const

uint32_t getVersion() const

bool parse(DataExtractor IndexData)

ArrayRef< DWARFSectionKind > getColumnKinds() const

ArrayRef< Entry > getRows() const

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.

const MCObjectFileInfo * getObjectFileInfo() const

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

Streaming machine code generation interface.

MCContext & getContext() const

virtual void emitIntValue(uint64_t Value, unsigned Size)

Special case of EmitValue that avoids the client having to pass in a MCExpr for constant integers.

virtual void switchSection(MCSection *Section, uint32_t Subsec=0)

Set the current section where code is being emitted to Section.

virtual void emitBytes(StringRef Data)

Emit the bytes in Data into the output.

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

std::pair< iterator, bool > insert(const std::pair< KeyT, ValueT > &KV)

SmallString - A SmallString is just a SmallVector with methods and accessors that make it work better...

void reserve(size_type N)

void push_back(const T &Elt)

This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.

StringMap - This is an unconventional map that is specialized for handling keys that are "strings",...

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

constexpr bool empty() const

empty - Check if the string is empty.

char back() const

back - Get the last character in the string.

constexpr size_t size() const

size - Get the string size.

char front() const

front - Get the first character in the string.

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

static void defaultWarningHandler(Error Warning)

Implement default handling for Warning.

static Expected< Decompressor > create(StringRef Name, StringRef Data, bool IsLE, bool Is64Bit)

Create decompressor object.

static Expected< OwningBinary< ObjectFile > > createObjectFile(StringRef ObjectPath)

This is a value type class that represents a single section in the list of sections in the object fil...

const ObjectFile * getObject() const

@ C

The default llvm calling convention, compatible with C.

unsigned ID

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

@ DW_LENGTH_DWARF64

Indicator of 64-bit DWARF format.

This is an optimization pass for GlobalISel generic memory operations.

Error createFileError(const Twine &F, Error E)

Concatenate a source file path and/or name with an Error.

Error buildDuplicateError(const std::pair< uint64_t, UnitIndexEntry > &PrevE, const CompileUnitIdentifiers &ID, StringRef DWPName)

void writeIndex(MCStreamer &Out, MCSection *Section, ArrayRef< unsigned > ContributionOffsets, const MapVector< uint64_t, UnitIndexEntry > &IndexEntries, uint32_t IndexVersion)

Error handleErrors(Error E, HandlerTs &&... Hs)

Pass the ErrorInfo(s) contained in E to their respective handlers.

static void writeNewOffsetsTo(MCStreamer &Out, DataExtractor &Data, DenseMap< uint64_t, uint32_t > &OffsetRemapping, uint64_t &Offset, uint64_t &Size)

void writeStringsAndOffsets(MCStreamer &Out, DWPStringPool &Strings, MCSection *StrOffsetSection, StringRef CurStrSection, StringRef CurStrOffsetSection, uint16_t Version)

DWARFSectionKind

The enum of section identifiers to be used in internal interfaces.

@ DW_SECT_EXT_unknown

Denotes a value read from an index section that does not correspond to any of the supported standards...

uint32_t serializeSectionKind(DWARFSectionKind Kind, unsigned IndexVersion)

Convert the internal value for a section kind to an on-disk value.

Error write(MCStreamer &Out, ArrayRef< std::string > Inputs, OnCuIndexOverflow OverflowOptValue)

Error handleSection(const StringMap< std::pair< MCSection *, DWARFSectionKind > > &KnownSections, const MCSection *StrSection, const MCSection *StrOffsetSection, const MCSection *TypesSection, const MCSection *CUIndexSection, const MCSection *TUIndexSection, const MCSection *InfoSection, const object::SectionRef &Section, MCStreamer &Out, std::deque< SmallString< 32 > > &UncompressedSections, uint32_t(&ContributionOffsets)[8], UnitIndexEntry &CurEntry, StringRef &CurStrSection, StringRef &CurStrOffsetSection, std::vector< StringRef > &CurTypesSection, std::vector< StringRef > &CurInfoSection, StringRef &AbbrevSection, StringRef &CurCUIndexSection, StringRef &CurTUIndexSection, std::vector< std::pair< DWARFSectionKind, uint32_t > > &SectionLength)

void writeIndexTable(MCStreamer &Out, ArrayRef< unsigned > ContributionOffsets, const MapVector< uint64_t, UnitIndexEntry > &IndexEntries, const AccessField &Field)

unsigned getContributionIndex(DWARFSectionKind Kind, uint32_t IndexVersion)

Expected< InfoSectionUnitHeader > parseInfoSectionUnitHeader(StringRef Info)

const char * toString(DWARFSectionKind Kind)

constexpr uint64_t NextPowerOf2(uint64_t A)

Returns the next power of two (in 64-bits) that is strictly greater than A.

DWARFUnitIndex::Entry::SectionContribution Contributions[8]

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

Create this object with static storage to register mc-related command line options.