20 #include "llvm/Config/config.h"
48 MCSymbol *Start =
S.getContext().createTempSymbol(
"debug_list_header_start");
49 MCSymbol *End =
S.getContext().createTempSymbol(
"debug_list_header_end");
52 S.AddComment(
"DWARF64 mark");
55 S.AddComment(
"Length");
56 S.emitAbsoluteSymbolDiff(End, Start,
59 S.AddComment(
"Version");
60 S.emitInt16(
S.getContext().getDwarfVersion());
61 S.AddComment(
"Address size");
62 S.emitInt8(
S.getContext().getAsmInfo()->getCodePointerSize());
63 S.AddComment(
"Segment selector size");
69 unsigned MinInsnLength =
Context.getAsmInfo()->getMinInstAlignment();
70 if (MinInsnLength == 1)
72 if (AddrDelta % MinInsnLength != 0) {
76 return AddrDelta / MinInsnLength;
135 static inline const MCExpr *
153 auto I = MCLineDivisions.
find(Sec);
154 if (
I != MCLineDivisions.
end()) {
155 auto &Entries =
I->second;
156 auto EndEntry = Entries.back();
157 EndEntry.setEndLabel(EndLabel);
158 Entries.push_back(EndEntry);
170 unsigned FileNum, LastLine, Column, Flags, Isa, Discriminator;
184 bool EndEntryEmitted =
false;
186 MCSymbol *Label = LineEntry.getLabel();
188 if (LineEntry.IsEndEntry) {
192 EndEntryEmitted =
true;
196 int64_t LineDelta =
static_cast<int64_t
>(LineEntry.getLine()) - LastLine;
198 if (FileNum != LineEntry.getFileNum()) {
199 FileNum = LineEntry.getFileNum();
200 MCOS->
emitInt8(dwarf::DW_LNS_set_file);
203 if (Column != LineEntry.getColumn()) {
204 Column = LineEntry.getColumn();
205 MCOS->
emitInt8(dwarf::DW_LNS_set_column);
208 if (Discriminator != LineEntry.getDiscriminator() &&
210 Discriminator = LineEntry.getDiscriminator();
212 MCOS->
emitInt8(dwarf::DW_LNS_extended_op);
214 MCOS->
emitInt8(dwarf::DW_LNE_set_discriminator);
217 if (Isa != LineEntry.getIsa()) {
218 Isa = LineEntry.getIsa();
219 MCOS->
emitInt8(dwarf::DW_LNS_set_isa);
223 Flags = LineEntry.getFlags();
224 MCOS->
emitInt8(dwarf::DW_LNS_negate_stmt);
227 MCOS->
emitInt8(dwarf::DW_LNS_set_basic_block);
229 MCOS->
emitInt8(dwarf::DW_LNS_set_prologue_end);
231 MCOS->
emitInt8(dwarf::DW_LNS_set_epilogue_begin);
240 LastLine = LineEntry.getLine();
249 if (!EndEntryEmitted)
263 if (LineTables.empty())
275 for (
const auto &CUIDTablePair : LineTables) {
276 CUIDTablePair.second.emitCU(MCOS, Params, LineStr);
285 if (!HasSplitLineTable)
292 std::pair<MCSymbol *, MCSymbol *>
295 static const char StandardOpcodeLengths[] = {
319 assert(!isa<MCSymbolRefExpr>(Expr));
320 if (
Context.getAsmInfo()->hasAggressiveSymbolFolding())
347 LineStrings.
write((uint8_t *)
Data.data());
354 size_t Offset = LineStrings.
add(Path);
362 void MCDwarfLineTableHeader::emitV2FileDirTables(
MCStreamer *MCOS)
const {
383 bool EmitMD5,
bool HasSource,
396 StringRef(
reinterpret_cast<const char *
>(Cksum.data()), Cksum.size()));
409 void MCDwarfLineTableHeader::emitV5FileDirTables(
417 : dwarf::DW_FORM_string);
425 LineStr->
emitRef(MCOS, CompDir);
449 : dwarf::DW_FORM_string);
459 : dwarf::DW_FORM_string);
469 "No root file and no .file directives");
476 std::pair<MCSymbol *, MCSymbol *>
499 if (LineTableVersion >= 5) {
519 if (LineTableVersion >= 4)
527 for (
char Length : StandardOpcodeLengths)
532 if (LineTableVersion >= 5)
533 emitV5FileDirTables(MCOS, LineStr);
535 emitV2FileDirTables(MCOS);
541 return std::make_pair(LineStartSym, LineEndSym);
546 MCSymbol *LineEndSym = Header.
Emit(MCOS, Params, LineStr).second;
550 emitOne(MCOS, LineSec.first, LineSec.second);
562 unsigned FileNumber) {
563 return Header.
tryGetFile(Directory, FileName, Checksum,
Source, DwarfVersion,
571 return RootFile.
Checksum == Checksum;
580 unsigned FileNumber) {
583 if (FileName.
empty()) {
584 FileName =
"<stdin>";
596 if (FileNumber == 0) {
604 if (!IterBool.second)
605 return IterBool.first->second;
615 if (!File.Name.empty())
616 return make_error<StringError>(
"file number already allocated",
621 return make_error<StringError>(
"inconsistent use of embedded source",
624 if (Directory.
empty()) {
627 if (!tFileName.
empty()) {
629 if (!Directory.
empty())
630 FileName = tFileName;
637 if (Directory.
empty()) {
651 File.Name = std::string(FileName);
652 File.DirIndex = DirIndex;
653 File.Checksum = Checksum;
665 int64_t LineDelta,
uint64_t AddrDelta) {
681 int64_t LineDelta,
uint64_t AddrDelta,
684 bool NeedCopy =
false;
696 if (AddrDelta == MaxSpecialAddrDelta)
697 OS << char(dwarf::DW_LNS_const_add_pc);
698 else if (AddrDelta) {
699 OS << char(dwarf::DW_LNS_advance_pc);
702 OS << char(dwarf::DW_LNS_extended_op);
704 OS << char(dwarf::DW_LNE_end_sequence);
715 OS << char(dwarf::DW_LNS_advance_line);
724 if (LineDelta == 0 && AddrDelta == 0) {
725 OS << char(dwarf::DW_LNS_copy);
733 if (AddrDelta < 256 + MaxSpecialAddrDelta) {
742 Opcode = Temp + (AddrDelta - MaxSpecialAddrDelta) * Params.
DWARF2LineRange;
744 OS << char(dwarf::DW_LNS_const_add_pc);
751 OS << char(dwarf::DW_LNS_advance_pc);
755 OS << char(dwarf::DW_LNS_copy);
757 assert(Temp <= 255 &&
"Buggy special opcode encoding.");
780 ? dwarf::DW_FORM_sec_offset
782 : dwarf::DW_FORM_data4);
783 EmitAbbrev(MCOS, dwarf::DW_AT_stmt_list, SecOffsetForm);
786 EmitAbbrev(MCOS, dwarf::DW_AT_ranges, SecOffsetForm);
788 EmitAbbrev(MCOS, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr);
789 EmitAbbrev(MCOS, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr);
791 EmitAbbrev(MCOS, dwarf::DW_AT_name, dwarf::DW_FORM_string);
793 EmitAbbrev(MCOS, dwarf::DW_AT_comp_dir, dwarf::DW_FORM_string);
795 if (!DwarfDebugFlags.
empty())
796 EmitAbbrev(MCOS, dwarf::DW_AT_APPLE_flags, dwarf::DW_FORM_string);
797 EmitAbbrev(MCOS, dwarf::DW_AT_producer, dwarf::DW_FORM_string);
798 EmitAbbrev(MCOS, dwarf::DW_AT_language, dwarf::DW_FORM_data2);
805 EmitAbbrev(MCOS, dwarf::DW_AT_name, dwarf::DW_FORM_string);
806 EmitAbbrev(MCOS, dwarf::DW_AT_decl_file, dwarf::DW_FORM_data4);
807 EmitAbbrev(MCOS, dwarf::DW_AT_decl_line, dwarf::DW_FORM_data4);
808 EmitAbbrev(MCOS, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr);
820 const MCSymbol *InfoSectionSymbol) {
827 unsigned UnitLengthBytes =
833 int Length = UnitLengthBytes + 2 + OffsetSize + 1 + 1;
839 int Pad = 2 * AddrSize - (Length & (2 * AddrSize - 1));
840 if (Pad == 2 * AddrSize)
846 Length += 2 * AddrSize * Sections.size();
848 Length += 2 * AddrSize;
856 MCOS->
emitIntValue(Length - UnitLengthBytes, OffsetSize);
861 if (InfoSectionSymbol)
871 for(
int i = 0;
i < Pad;
i++)
877 const MCSymbol *StartSymbol = Sec->getBeginSymbol();
878 MCSymbol *EndSymbol = Sec->getEndSymbol(context);
879 assert(StartSymbol &&
"StartSymbol must not be NULL");
880 assert(EndSymbol &&
"EndSymbol must not be NULL");
899 const MCSymbol *AbbrevSectionSymbol,
914 unsigned UnitLengthBytes =
936 MCOS->
emitInt8(dwarf::DW_UT_compile);
941 if (AbbrevSectionSymbol)
957 if (LineSectionSymbol)
975 const auto TextSection = Sections.begin();
976 assert(TextSection != Sections.end() &&
"No text section found");
978 MCSymbol *StartSymbol = (*TextSection)->getBeginSymbol();
979 MCSymbol *EndSymbol = (*TextSection)->getEndSymbol(context);
980 assert(StartSymbol &&
"StartSymbol must not be NULL");
981 assert(EndSymbol &&
"EndSymbol must not be NULL");
997 if (MCDwarfDirs.size() > 0) {
1004 assert(MCDwarfFiles.empty() || MCDwarfFiles.size() >= 2);
1006 MCDwarfFiles.empty()
1020 if (!DwarfDebugFlags.
empty()){
1027 if (!DwarfDebugProducer.
empty())
1035 MCOS->
emitInt16(dwarf::DW_LANG_Mips_Assembler);
1040 const std::vector<MCGenDwarfLabelEntry> &Entries =
1042 for (
const auto &Entry : Entries) {
1088 const MCSymbol *StartSymbol = Sec->getBeginSymbol();
1089 const MCSymbol *EndSymbol = Sec->getEndSymbol(context);
1094 MCOS->
emitInt8(dwarf::DW_RLE_start_length);
1095 MCOS->
emitValue(SectionStartAddr, AddrSize);
1098 MCOS->
emitInt8(dwarf::DW_RLE_end_of_list);
1105 const MCSymbol *StartSymbol = Sec->getBeginSymbol();
1106 const MCSymbol *EndSymbol = Sec->getEndSymbol(context);
1112 MCOS->
emitValue(SectionStartAddr, AddrSize);
1126 return RangesSymbol;
1138 bool CreateDwarfSectionSymbols =
1140 MCSymbol *LineSectionSymbol =
nullptr;
1141 if (CreateDwarfSectionSymbols)
1143 MCSymbol *AbbrevSectionSymbol =
nullptr;
1144 MCSymbol *InfoSectionSymbol =
nullptr;
1157 const bool UseRangesSection =
1160 CreateDwarfSectionSymbols |= UseRangesSection;
1163 if (CreateDwarfSectionSymbols) {
1168 if (CreateDwarfSectionSymbols) {
1178 if (UseRangesSection) {
1187 EmitGenDwarfInfo(MCOS, AbbrevSectionSymbol, LineSectionSymbol, RangesSymbol);
1199 if (
Symbol->isTemporary())
1210 if (Name.startswith(
"_"))
1211 Name = Name.substr(1, Name.size()-1);
1244 unsigned symbolEncoding) {
1246 unsigned format = symbolEncoding & 0x0f;
1265 unsigned symbolEncoding,
bool isEH) {
1279 unsigned symbolEncoding) {
1291 class FrameEmitterImpl {
1293 int InitialCFAOffset = 0;
1299 : IsEH(IsEH), Streamer(Streamer) {}
1306 bool LastInSection,
const MCSymbol &SectionStart);
1320 auto *
MRI = Streamer.getContext().getRegisterInfo();
1327 Reg1 =
MRI->getDwarfRegNumFromDwarfEHRegNum(Reg1);
1328 Reg2 =
MRI->getDwarfRegNumFromDwarfEHRegNum(Reg2);
1330 Streamer.emitInt8(dwarf::DW_CFA_register);
1331 Streamer.emitULEB128IntValue(Reg1);
1332 Streamer.emitULEB128IntValue(Reg2);
1336 Streamer.emitInt8(dwarf::DW_CFA_GNU_window_save);
1340 Streamer.emitInt8(dwarf::DW_CFA_AARCH64_negate_ra_state);
1345 Streamer.emitInt8(dwarf::DW_CFA_undefined);
1346 Streamer.emitULEB128IntValue(
Reg);
1351 const bool IsRelative =
1354 Streamer.emitInt8(dwarf::DW_CFA_def_cfa_offset);
1361 Streamer.emitULEB128IntValue(CFAOffset);
1368 Reg =
MRI->getDwarfRegNumFromDwarfEHRegNum(
Reg);
1369 Streamer.emitInt8(dwarf::DW_CFA_def_cfa);
1370 Streamer.emitULEB128IntValue(
Reg);
1372 Streamer.emitULEB128IntValue(CFAOffset);
1379 Reg =
MRI->getDwarfRegNumFromDwarfEHRegNum(
Reg);
1380 Streamer.emitInt8(dwarf::DW_CFA_def_cfa_register);
1381 Streamer.emitULEB128IntValue(
Reg);
1389 Reg =
MRI->getDwarfRegNumFromDwarfEHRegNum(
Reg);
1390 Streamer.emitIntValue(dwarf::DW_CFA_LLVM_def_aspace_cfa, 1);
1391 Streamer.emitULEB128IntValue(
Reg);
1393 Streamer.emitULEB128IntValue(CFAOffset);
1400 const bool IsRelative =
1405 Reg =
MRI->getDwarfRegNumFromDwarfEHRegNum(
Reg);
1413 Streamer.emitInt8(dwarf::DW_CFA_offset_extended_sf);
1414 Streamer.emitULEB128IntValue(
Reg);
1415 Streamer.emitSLEB128IntValue(Offset);
1416 }
else if (
Reg < 64) {
1417 Streamer.emitInt8(dwarf::DW_CFA_offset +
Reg);
1418 Streamer.emitULEB128IntValue(Offset);
1420 Streamer.emitInt8(dwarf::DW_CFA_offset_extended);
1421 Streamer.emitULEB128IntValue(
Reg);
1422 Streamer.emitULEB128IntValue(Offset);
1427 Streamer.emitInt8(dwarf::DW_CFA_remember_state);
1430 Streamer.emitInt8(dwarf::DW_CFA_restore_state);
1434 Streamer.emitInt8(dwarf::DW_CFA_same_value);
1435 Streamer.emitULEB128IntValue(
Reg);
1441 Reg =
MRI->getDwarfRegNumFromDwarfEHRegNum(
Reg);
1443 Streamer.emitInt8(dwarf::DW_CFA_restore |
Reg);
1445 Streamer.emitInt8(dwarf::DW_CFA_restore_extended);
1446 Streamer.emitULEB128IntValue(
Reg);
1451 Streamer.emitInt8(dwarf::DW_CFA_GNU_args_size);
1452 Streamer.emitULEB128IntValue(Instr.
getOffset());
1468 if (Label && !
Label->isDefined())
continue;
1471 if (BaseLabel && Label) {
1473 if (ThisSym != BaseLabel) {
1474 Streamer.emitDwarfAdvanceFrameAddr(BaseLabel, ThisSym);
1475 BaseLabel = ThisSym;
1479 emitCFIInstruction(Instr);
1511 if (!Encoding)
return;
1515 if (!DwarfEHFrameOnly && Frame.
Lsda)
1516 Encoding |= 0x40000000;
1521 Streamer.emitSymbolValue(Frame.
Begin, Size);
1530 Streamer.emitIntValue(Encoding, Size);
1535 Streamer.emitSymbolValue(Frame.
Personality, Size);
1537 Streamer.emitIntValue(0, Size);
1541 if (!DwarfEHFrameOnly && Frame.
Lsda)
1542 Streamer.emitSymbolValue(Frame.
Lsda, Size);
1544 Streamer.emitIntValue(0, Size);
1550 switch (DwarfVersion) {
1563 MCContext &context = Streamer.getContext();
1568 Streamer.emitLabel(sectionStart);
1583 *sectionEnd, UnitLengthBytes);
1589 Streamer.emitIntValue(CIE_ID, OffsetSize);
1593 Streamer.emitInt8(CIEVersion);
1597 Augmentation +=
"z";
1599 Augmentation +=
"P";
1601 Augmentation +=
"L";
1602 Augmentation +=
"R";
1604 Augmentation +=
"S";
1606 Augmentation +=
"B";
1607 Streamer.emitBytes(Augmentation);
1609 Streamer.emitInt8(0);
1611 if (CIEVersion >= 4) {
1616 Streamer.emitInt8(0);
1626 unsigned RAReg = Frame.
RAReg;
1627 if (RAReg ==
static_cast<unsigned>(INT_MAX))
1628 RAReg =
MRI->getDwarfRegNum(
MRI->getRARegister(), IsEH);
1630 if (CIEVersion == 1) {
1632 "DWARF 2 encodes return_address_register in one byte");
1633 Streamer.emitInt8(RAReg);
1635 Streamer.emitULEB128IntValue(RAReg);
1639 unsigned augmentationLength = 0;
1643 augmentationLength += 1;
1645 augmentationLength +=
1649 augmentationLength += 1;
1651 augmentationLength += 1;
1653 Streamer.emitULEB128IntValue(augmentationLength);
1679 InitialCFAOffset = CFAOffset;
1684 Streamer.emitLabel(sectionEnd);
1685 return *sectionStart;
1688 void FrameEmitterImpl::EmitFDE(
const MCSymbol &cieStart,
1692 MCContext &context = Streamer.getContext();
1697 CFAOffset = InitialCFAOffset;
1710 Streamer.emitLabel(fdeStart);
1723 Streamer.emitSymbolValue(&cieStart, OffsetSize,
1728 unsigned PCEncoding =
1740 unsigned augmentationLength = 0;
1745 Streamer.emitULEB128IntValue(augmentationLength);
1760 Streamer.emitValueToAlignment(
Align);
1762 Streamer.emitLabel(fdeEnd);
1768 static const CIEKey getEmptyKey() {
1769 return CIEKey(
nullptr, 0, -1,
false,
false,
static_cast<unsigned>(INT_MAX),
1773 static const CIEKey getTombstoneKey() {
1774 return CIEKey(
nullptr, -1, 0,
false,
false,
static_cast<unsigned>(INT_MAX),
1778 CIEKey(
const MCSymbol *Personality,
unsigned PersonalityEncoding,
1779 unsigned LSDAEncoding,
bool IsSignalFrame,
bool IsSimple,
1780 unsigned RAReg,
bool IsBKeyFrame)
1781 : Personality(Personality), PersonalityEncoding(PersonalityEncoding),
1782 LsdaEncoding(LSDAEncoding), IsSignalFrame(IsSignalFrame),
1783 IsSimple(IsSimple), RAReg(RAReg), IsBKeyFrame(IsBKeyFrame) {}
1786 : Personality(Frame.Personality),
1787 PersonalityEncoding(Frame.PersonalityEncoding),
1788 LsdaEncoding(Frame.LsdaEncoding), IsSignalFrame(Frame.IsSignalFrame),
1789 IsSimple(Frame.IsSimple), RAReg(Frame.RAReg),
1790 IsBKeyFrame(Frame.IsBKeyFrame) {}
1795 return Personality->getName();
1798 bool operator<(
const CIEKey &Other)
const {
1799 return std::make_tuple(PersonalityName(), PersonalityEncoding, LsdaEncoding,
1800 IsSignalFrame, IsSimple, RAReg) <
1801 std::make_tuple(
Other.PersonalityName(),
Other.PersonalityEncoding,
1807 unsigned PersonalityEncoding;
1808 unsigned LsdaEncoding;
1825 Key.Personality,
Key.PersonalityEncoding,
Key.LsdaEncoding,
1826 Key.IsSignalFrame,
Key.IsSimple,
Key.RAReg,
Key.IsBKeyFrame));
1830 return LHS.Personality ==
RHS.Personality &&
1831 LHS.PersonalityEncoding ==
RHS.PersonalityEncoding &&
1832 LHS.LsdaEncoding ==
RHS.LsdaEncoding &&
1833 LHS.IsSignalFrame ==
RHS.IsSignalFrame &&
1834 LHS.IsSimple ==
RHS.IsSimple &&
LHS.RAReg ==
RHS.RAReg &&
1835 LHS.IsBKeyFrame ==
RHS.IsBKeyFrame;
1848 FrameEmitterImpl Emitter(IsEH, Streamer);
1854 bool SectionEmitted =
false;
1857 if (!SectionEmitted) {
1860 SectionEmitted =
true;
1862 NeedsEHFrameSection |=
1865 Emitter.EmitCompactUnwind(Frame);
1869 if (!NeedsEHFrameSection)
return;
1881 const MCSymbol *DummyDebugKey =
nullptr;
1887 std::vector<MCDwarfFrameInfo> FrameArrayX(FrameArray.
begin(), FrameArray.
end());
1890 return CIEKey(
X) < CIEKey(
Y);
1892 for (
auto I = FrameArrayX.begin(),
E = FrameArrayX.end();
I !=
E;) {
1902 const MCSymbol *&CIEStart = IsEH ? CIEStarts[
Key] : DummyDebugKey;
1904 CIEStart = &Emitter.EmitCIE(Frame);
1906 Emitter.EmitFDE(*CIEStart, Frame,
I ==
E, *SectionStart);
1931 uint8_t Opcode = dwarf::DW_CFA_advance_loc | AddrDelta;
1934 OS << uint8_t(dwarf::DW_CFA_advance_loc1);
1935 OS << uint8_t(AddrDelta);
1937 OS << uint8_t(dwarf::DW_CFA_advance_loc2);
1938 support::endian::write<uint16_t>(OS, AddrDelta,
E);
1941 OS << uint8_t(dwarf::DW_CFA_advance_loc4);
1942 support::endian::write<uint32_t>(OS, AddrDelta,
E);