[llvm] [DWARFLinker] Adjust DW_AT_LLVM_stmt_sequence for rewritten line tables (PR #128953)
via llvm-commits
llvm-commits at lists.llvm.org
Wed Mar 12 22:09:50 PDT 2025
https://github.com/alx32 updated https://github.com/llvm/llvm-project/pull/128953
>From 027ad8c8c990085d5c82aa0b52faaffd22413b96 Mon Sep 17 00:00:00 2001
From: Alex Borcan <alexborcan at fb.com>
Date: Wed, 26 Feb 2025 14:14:04 -0800
Subject: [PATCH 1/2] [DWARFLinker] Adjust DW_AT_LLVM_stmt_sequence for
rewritten line tables
---
.../llvm/DWARFLinker/Classic/DWARFLinker.h | 11 +-
.../Classic/DWARFLinkerCompileUnit.h | 17 ++
.../llvm/DWARFLinker/Classic/DWARFStreamer.h | 14 +-
llvm/lib/DWARFLinker/Classic/DWARFLinker.cpp | 153 ++++++++++++++----
.../Classic/DWARFLinkerCompileUnit.cpp | 4 +
.../lib/DWARFLinker/Classic/DWARFStreamer.cpp | 12 +-
.../tools/dsymutil/ARM/stmt-seq-macho.test | 74 +++++++++
.../private/tmp/stmt_seq/stmt_seq_macho.exe | Bin 0 -> 17216 bytes
.../private/tmp/stmt_seq/stmt_seq_macho.o | Bin 0 -> 3384 bytes
9 files changed, 244 insertions(+), 41 deletions(-)
create mode 100644 llvm/test/tools/dsymutil/ARM/stmt-seq-macho.test
create mode 100755 llvm/test/tools/dsymutil/Inputs/private/tmp/stmt_seq/stmt_seq_macho.exe
create mode 100644 llvm/test/tools/dsymutil/Inputs/private/tmp/stmt_seq/stmt_seq_macho.o
diff --git a/llvm/include/llvm/DWARFLinker/Classic/DWARFLinker.h b/llvm/include/llvm/DWARFLinker/Classic/DWARFLinker.h
index b1d3f03394f5e..3608e7821bbc4 100644
--- a/llvm/include/llvm/DWARFLinker/Classic/DWARFLinker.h
+++ b/llvm/include/llvm/DWARFLinker/Classic/DWARFLinker.h
@@ -122,10 +122,13 @@ class DwarfEmitter {
const AddressRanges &LinkedRanges) = 0;
/// Emit specified \p LineTable into .debug_line table.
- virtual void emitLineTableForUnit(const DWARFDebugLine::LineTable &LineTable,
- const CompileUnit &Unit,
- OffsetsStringPool &DebugStrPool,
- OffsetsStringPool &DebugLineStrPool) = 0;
+ /// The optional parameter RowOffsets, if provided, will be populated with the
+ /// offsets of each line table row in the output .debug_line section.
+ virtual void
+ emitLineTableForUnit(const DWARFDebugLine::LineTable &LineTable,
+ const CompileUnit &Unit, OffsetsStringPool &DebugStrPool,
+ OffsetsStringPool &DebugLineStrPool,
+ std::vector<uint64_t> *RowOffsets = nullptr) = 0;
/// Emit the .debug_pubnames contribution for \p Unit.
virtual void emitPubNamesForUnit(const CompileUnit &Unit) = 0;
diff --git a/llvm/include/llvm/DWARFLinker/Classic/DWARFLinkerCompileUnit.h b/llvm/include/llvm/DWARFLinker/Classic/DWARFLinkerCompileUnit.h
index cdb6f4a4443ab..9fae62a62e442 100644
--- a/llvm/include/llvm/DWARFLinker/Classic/DWARFLinkerCompileUnit.h
+++ b/llvm/include/llvm/DWARFLinker/Classic/DWARFLinkerCompileUnit.h
@@ -57,6 +57,7 @@ struct PatchLocation {
using RngListAttributesTy = SmallVector<PatchLocation>;
using LocListAttributesTy = SmallVector<PatchLocation>;
+using StmtSeqListAttributesTy = SmallVector<PatchLocation>;
/// Stores all information relating to a compile unit, be it in its original
/// instance in the object file to its brand new cloned and generated DIE tree.
@@ -175,6 +176,12 @@ class CompileUnit {
return LocationAttributes;
}
+ // Provide access to the list of DW_AT_LLVM_stmt_sequence attributes that may
+ // need to be patched
+ const StmtSeqListAttributesTy &getStmtSeqListAttributes() const {
+ return StmtSeqListAttributes;
+ }
+
/// Mark every DIE in this unit as kept. This function also
/// marks variables as InDebugMap so that they appear in the
/// reconstructed accelerator tables.
@@ -210,6 +217,10 @@ class CompileUnit {
/// debug_loc section.
void noteLocationAttribute(PatchLocation Attr);
+ // Record that the given DW_AT_LLVM_stmt_sequence attribute may need to be
+ // patched later
+ void noteStmtSeqListAttribute(PatchLocation Attr);
+
/// Add a name accelerator entry for \a Die with \a Name.
void addNamespaceAccelerator(const DIE *Die, DwarfStringPoolEntryRef Name);
@@ -309,6 +320,12 @@ class CompileUnit {
/// location expression.
LocListAttributesTy LocationAttributes;
+ // List of DW_AT_LLVM_stmt_sequence attributes that may need to be patched
+ // after the dwarf linker rewrites the line table. During line table rewrite
+ // the line table format might change, so we have to patch any offsets that
+ // reference its contents.
+ StmtSeqListAttributesTy StmtSeqListAttributes;
+
/// Accelerator entries for the unit, both for the pub*
/// sections and the apple* ones.
/// @{
diff --git a/llvm/include/llvm/DWARFLinker/Classic/DWARFStreamer.h b/llvm/include/llvm/DWARFLinker/Classic/DWARFStreamer.h
index e7a1a3cd838c2..40740a3f2210b 100644
--- a/llvm/include/llvm/DWARFLinker/Classic/DWARFStreamer.h
+++ b/llvm/include/llvm/DWARFLinker/Classic/DWARFStreamer.h
@@ -149,10 +149,13 @@ class DwarfStreamer : public DwarfEmitter {
}
/// Emit .debug_line table entry for specified \p LineTable
- void emitLineTableForUnit(const DWARFDebugLine::LineTable &LineTable,
- const CompileUnit &Unit,
- OffsetsStringPool &DebugStrPool,
- OffsetsStringPool &DebugLineStrPool) override;
+ /// The optional parameter RowOffsets, if provided, will be populated with the
+ /// offsets of each line table row in the output .debug_line section.
+ void
+ emitLineTableForUnit(const DWARFDebugLine::LineTable &LineTable,
+ const CompileUnit &Unit, OffsetsStringPool &DebugStrPool,
+ OffsetsStringPool &DebugLineStrPool,
+ std::vector<uint64_t> *RowOffsets = nullptr) override;
uint64_t getLineSectionSize() const override { return LineSectionSize; }
@@ -266,7 +269,8 @@ class DwarfStreamer : public DwarfEmitter {
const DWARFDebugLine::Prologue &P, OffsetsStringPool &DebugStrPool,
OffsetsStringPool &DebugLineStrPool);
void emitLineTableRows(const DWARFDebugLine::LineTable &LineTable,
- MCSymbol *LineEndSym, unsigned AddressByteSize);
+ MCSymbol *LineEndSym, unsigned AddressByteSize,
+ std::vector<uint64_t> *RowOffsets = nullptr);
void emitIntOffset(uint64_t Offset, dwarf::DwarfFormat Format,
uint64_t &SectionSize);
void emitLabelDifference(const MCSymbol *Hi, const MCSymbol *Lo,
diff --git a/llvm/lib/DWARFLinker/Classic/DWARFLinker.cpp b/llvm/lib/DWARFLinker/Classic/DWARFLinker.cpp
index d2b3561ee1c80..db0684e56e0c0 100644
--- a/llvm/lib/DWARFLinker/Classic/DWARFLinker.cpp
+++ b/llvm/lib/DWARFLinker/Classic/DWARFLinker.cpp
@@ -1447,6 +1447,18 @@ unsigned DWARFLinker::DIECloner::cloneScalarAttribute(
->sizeOf(Unit.getOrigUnit().getFormParams());
}
+ if (AttrSpec.Attr == dwarf::DW_AT_LLVM_stmt_sequence) {
+ // If needed, we'll patch this sec_offset later with the correct offset.
+ auto Patch = Die.addValue(DIEAlloc, dwarf::Attribute(AttrSpec.Attr),
+ dwarf::DW_FORM_sec_offset,
+ DIEInteger(*Val.getAsSectionOffset()));
+
+ // Record this patch location so that it can be fixed up later.
+ Unit.noteStmtSeqListAttribute(Patch);
+
+ return Unit.getOrigUnit().getFormParams().getDwarfOffsetByteSize();
+ }
+
if (LLVM_UNLIKELY(Linker.Options.Update)) {
if (auto OptionalValue = Val.getAsUnsignedConstant())
Value = *OptionalValue;
@@ -2081,29 +2093,43 @@ void DWARFLinker::DIECloner::emitDebugAddrSection(
Emitter->emitDwarfDebugAddrsFooter(Unit, EndLabel);
}
+/// A helper struct to help keep track of the association between the input and
+/// output rows during line table rewriting. This is used to patch
+/// DW_AT_LLVM_stmt_sequence attributes, which reference a particular line table
+/// row.
+struct TrackedRow {
+ DWARFDebugLine::Row Row;
+ size_t OriginalRowIndex;
+ bool isStartSeqInOutput;
+};
+
/// Insert the new line info sequence \p Seq into the current
/// set of already linked line info \p Rows.
-static void insertLineSequence(std::vector<DWARFDebugLine::Row> &Seq,
- std::vector<DWARFDebugLine::Row> &Rows) {
+static void insertLineSequence(std::vector<TrackedRow> &Seq,
+ std::vector<TrackedRow> &Rows) {
if (Seq.empty())
return;
- if (!Rows.empty() && Rows.back().Address < Seq.front().Address) {
+ // Mark the first row in Seq to indicate it is the start of a sequence
+ // in the output line table.
+ Seq.front().isStartSeqInOutput = true;
+
+ if (!Rows.empty() && Rows.back().Row.Address < Seq.front().Row.Address) {
llvm::append_range(Rows, Seq);
Seq.clear();
return;
}
- object::SectionedAddress Front = Seq.front().Address;
+ object::SectionedAddress Front = Seq.front().Row.Address;
auto InsertPoint = partition_point(
- Rows, [=](const DWARFDebugLine::Row &O) { return O.Address < Front; });
+ Rows, [=](const TrackedRow &O) { return O.Row.Address < Front; });
// FIXME: this only removes the unneeded end_sequence if the
// sequences have been inserted in order. Using a global sort like
- // described in generateLineTableForUnit() and delaying the end_sequene
+ // described in generateLineTableForUnit() and delaying the end_sequence
// elimination to emitLineTableForUnit() we can get rid of all of them.
- if (InsertPoint != Rows.end() && InsertPoint->Address == Front &&
- InsertPoint->EndSequence) {
+ if (InsertPoint != Rows.end() && InsertPoint->Row.Address == Front &&
+ InsertPoint->Row.EndSequence) {
*InsertPoint = Seq.front();
Rows.insert(InsertPoint + 1, Seq.begin() + 1, Seq.end());
} else {
@@ -2171,14 +2197,24 @@ void DWARFLinker::DIECloner::generateLineTableForUnit(CompileUnit &Unit) {
LineTable.Rows.clear();
LineTable.Sequences = LT->Sequences;
+
+ Emitter->emitLineTableForUnit(LineTable, Unit, DebugStrPool,
+ DebugLineStrPool);
} else {
- // This vector is the output line table.
- std::vector<DWARFDebugLine::Row> NewRows;
- NewRows.reserve(LT->Rows.size());
+ // Create TrackedRow objects for all input rows.
+ std::vector<TrackedRow> AllTrackedRows;
+ AllTrackedRows.reserve(LT->Rows.size());
+ for (size_t i = 0; i < LT->Rows.size(); i++)
+ AllTrackedRows.emplace_back(TrackedRow{LT->Rows[i], i, false});
+
+ // This vector is the output line table (still in TrackedRow form).
+ std::vector<TrackedRow> NewRows;
+ NewRows.reserve(AllTrackedRows.size());
// Current sequence of rows being extracted, before being inserted
// in NewRows.
- std::vector<DWARFDebugLine::Row> Seq;
+ std::vector<TrackedRow> Seq;
+ Seq.reserve(AllTrackedRows.size());
const auto &FunctionRanges = Unit.getFunctionRanges();
std::optional<AddressRangeValuePair> CurrRange;
@@ -2194,27 +2230,30 @@ void DWARFLinker::DIECloner::generateLineTableForUnit(CompileUnit &Unit) {
// Iterate over the object file line info and extract the sequences
// that correspond to linked functions.
- for (DWARFDebugLine::Row Row : LT->Rows) {
+ for (size_t i = 0; i < AllTrackedRows.size(); i++) {
+ TrackedRow TR = AllTrackedRows[i];
+
// Check whether we stepped out of the range. The range is
- // half-open, but consider accept the end address of the range if
+ // half-open, but consider accepting the end address of the range if
// it is marked as end_sequence in the input (because in that
// case, the relocation offset is accurate and that entry won't
// serve as the start of another function).
- if (!CurrRange || !CurrRange->Range.contains(Row.Address.Address)) {
- // We just stepped out of a known range. Insert a end_sequence
+ if (!CurrRange || !CurrRange->Range.contains(TR.Row.Address.Address)) {
+ // We just stepped out of a known range. Insert an end_sequence
// corresponding to the end of the range.
uint64_t StopAddress =
CurrRange ? CurrRange->Range.end() + CurrRange->Value : -1ULL;
- CurrRange = FunctionRanges.getRangeThatContains(Row.Address.Address);
+ CurrRange =
+ FunctionRanges.getRangeThatContains(TR.Row.Address.Address);
if (StopAddress != -1ULL && !Seq.empty()) {
// Insert end sequence row with the computed end address, but
// the same line as the previous one.
auto NextLine = Seq.back();
- NextLine.Address.Address = StopAddress;
- NextLine.EndSequence = 1;
- NextLine.PrologueEnd = 0;
- NextLine.BasicBlock = 0;
- NextLine.EpilogueBegin = 0;
+ NextLine.Row.Address.Address = StopAddress;
+ NextLine.Row.EndSequence = 1;
+ NextLine.Row.PrologueEnd = 0;
+ NextLine.Row.BasicBlock = 0;
+ NextLine.Row.EpilogueBegin = 0;
Seq.push_back(NextLine);
insertLineSequence(Seq, NewRows);
}
@@ -2224,22 +2263,78 @@ void DWARFLinker::DIECloner::generateLineTableForUnit(CompileUnit &Unit) {
}
// Ignore empty sequences.
- if (Row.EndSequence && Seq.empty())
+ if (TR.Row.EndSequence && Seq.empty())
continue;
// Relocate row address and add it to the current sequence.
- Row.Address.Address += CurrRange->Value;
- Seq.emplace_back(Row);
+ TR.Row.Address.Address += CurrRange->Value;
+ Seq.push_back(TR);
- if (Row.EndSequence)
+ if (TR.Row.EndSequence)
insertLineSequence(Seq, NewRows);
}
- LineTable.Rows = std::move(NewRows);
+ // Materialize the tracked rows into final DWARFDebugLine::Row objects.
+ LineTable.Rows.clear();
+ LineTable.Rows.reserve(NewRows.size());
+ for (auto &TR : NewRows)
+ LineTable.Rows.push_back(TR.Row);
+
+ // Use OutputRowOffsets to store the offsets of each line table row in the
+ // output .debug_line section.
+ std::vector<uint64_t> OutputRowOffsets;
+
+ // The unit might not have any DW_AT_LLVM_stmt_sequence attributes, so use
+ // hasStmtSeq to skip the patching logic.
+ bool hasStmtSeq = Unit.getStmtSeqListAttributes().size() > 0;
+ Emitter->emitLineTableForUnit(LineTable, Unit, DebugStrPool,
+ DebugLineStrPool,
+ hasStmtSeq ? &OutputRowOffsets : nullptr);
+
+ if (hasStmtSeq) {
+ assert(OutputRowOffsets.size() == NewRows.size() &&
+ "OutputRowOffsets size mismatch");
+
+ // Create a map of stmt sequence offsets to original row indices.
+ DenseMap<uint64_t, unsigned> SeqOffToOrigRow;
+ for (const DWARFDebugLine::Sequence &Seq : LT->Sequences)
+ SeqOffToOrigRow[Seq.StmtSeqOffset] = Seq.FirstRowIndex;
+
+ // Create a map of original row indices to new row indices.
+ DenseMap<size_t, size_t> OrigRowToNewRow;
+ for (size_t i = 0; i < NewRows.size(); ++i)
+ OrigRowToNewRow[NewRows[i].OriginalRowIndex] = i;
+
+ // Patch DW_AT_LLVM_stmt_sequence attributes in the compile unit DIE
+ // with the correct offset into the .debug_line section.
+ for (const auto &StmtSeq : Unit.getStmtSeqListAttributes()) {
+ uint64_t OrigStmtSeq = StmtSeq.get();
+ // 1. Get the original row index from the stmt list offset.
+ auto OrigRowIter = SeqOffToOrigRow.find(OrigStmtSeq);
+ assert(OrigRowIter != SeqOffToOrigRow.end() &&
+ "Stmt list offset not found in sequence offsets map");
+ size_t OrigRowIndex = OrigRowIter->second;
+
+ // 2. Get the new row index from the original row index.
+ auto NewRowIter = OrigRowToNewRow.find(OrigRowIndex);
+ if (NewRowIter == OrigRowToNewRow.end()) {
+ // If the original row index is not found in the map, update the
+ // stmt_sequence attribute to the 'invalid offset' magic value.
+ StmtSeq.set(UINT64_MAX);
+ continue;
+ }
+
+ // 3. Get the offset of the new row in the output .debug_line section.
+ assert(NewRowIter->second < OutputRowOffsets.size() &&
+ "New row index out of bounds");
+ uint64_t NewStmtSeqOffset = OutputRowOffsets[NewRowIter->second];
+
+ // 4. Patch the stmt_list attribute with the new offset.
+ StmtSeq.set(NewStmtSeqOffset);
+ }
+ }
}
- Emitter->emitLineTableForUnit(LineTable, Unit, DebugStrPool,
- DebugLineStrPool);
} else
Linker.reportWarning("Cann't load line table.", ObjFile);
}
diff --git a/llvm/lib/DWARFLinker/Classic/DWARFLinkerCompileUnit.cpp b/llvm/lib/DWARFLinker/Classic/DWARFLinkerCompileUnit.cpp
index 1eb3a70a55135..66bf158e60f1d 100644
--- a/llvm/lib/DWARFLinker/Classic/DWARFLinkerCompileUnit.cpp
+++ b/llvm/lib/DWARFLinker/Classic/DWARFLinkerCompileUnit.cpp
@@ -185,6 +185,10 @@ void CompileUnit::noteLocationAttribute(PatchLocation Attr) {
LocationAttributes.emplace_back(Attr);
}
+void CompileUnit::noteStmtSeqListAttribute(PatchLocation Attr) {
+ StmtSeqListAttributes.emplace_back(Attr);
+}
+
void CompileUnit::addNamespaceAccelerator(const DIE *Die,
DwarfStringPoolEntryRef Name) {
Namespaces.emplace_back(Name, Die);
diff --git a/llvm/lib/DWARFLinker/Classic/DWARFStreamer.cpp b/llvm/lib/DWARFLinker/Classic/DWARFStreamer.cpp
index 55e40cd779cbf..d4f62d351548e 100644
--- a/llvm/lib/DWARFLinker/Classic/DWARFStreamer.cpp
+++ b/llvm/lib/DWARFLinker/Classic/DWARFStreamer.cpp
@@ -809,7 +809,8 @@ void DwarfStreamer::emitDwarfDebugLocListsTableFragment(
void DwarfStreamer::emitLineTableForUnit(
const DWARFDebugLine::LineTable &LineTable, const CompileUnit &Unit,
- OffsetsStringPool &DebugStrPool, OffsetsStringPool &DebugLineStrPool) {
+ OffsetsStringPool &DebugStrPool, OffsetsStringPool &DebugLineStrPool,
+ std::vector<uint64_t> *RowOffsets) {
// Switch to the section where the table will be emitted into.
MS->switchSection(MC->getObjectFileInfo()->getDwarfLineSection());
@@ -830,7 +831,7 @@ void DwarfStreamer::emitLineTableForUnit(
// Emit rows.
emitLineTableRows(LineTable, LineEndSym,
- Unit.getOrigUnit().getAddressByteSize());
+ Unit.getOrigUnit().getAddressByteSize(), RowOffsets);
}
void DwarfStreamer::emitLineTablePrologue(const DWARFDebugLine::Prologue &P,
@@ -1036,7 +1037,7 @@ void DwarfStreamer::emitLineTableProloguePayload(
void DwarfStreamer::emitLineTableRows(
const DWARFDebugLine::LineTable &LineTable, MCSymbol *LineEndSym,
- unsigned AddressByteSize) {
+ unsigned AddressByteSize, std::vector<uint64_t> *RowOffsets) {
MCDwarfLineTableParams Params;
Params.DWARF2LineOpcodeBase = LineTable.Prologue.OpcodeBase;
@@ -1068,6 +1069,11 @@ void DwarfStreamer::emitLineTableRows(
unsigned RowsSinceLastSequence = 0;
for (const DWARFDebugLine::Row &Row : LineTable.Rows) {
+ // If we're tracking row offsets, record the current section size as the
+ // offset of this row.
+ if (RowOffsets)
+ RowOffsets->push_back(LineSectionSize);
+
int64_t AddressDelta;
if (Address == -1ULL) {
MS->emitIntValue(dwarf::DW_LNS_extended_op, 1);
diff --git a/llvm/test/tools/dsymutil/ARM/stmt-seq-macho.test b/llvm/test/tools/dsymutil/ARM/stmt-seq-macho.test
new file mode 100644
index 0000000000000..b5093ba767894
--- /dev/null
+++ b/llvm/test/tools/dsymutil/ARM/stmt-seq-macho.test
@@ -0,0 +1,74 @@
+RUN: dsymutil --flat -oso-prepend-path %p/../Inputs %p/../Inputs/private/tmp/stmt_seq/stmt_seq_macho.exe -o %t.stmt_seq_macho.dSYM
+RUN: llvm-dwarfdump --debug-info --debug-line -v %t.stmt_seq_macho.dSYM | sort | FileCheck %s -check-prefix=CHECK_DSYM
+
+# CHECK_DSYM: DW_AT_LLVM_stmt_sequence [DW_FORM_sec_offset] ([[OFFSET1:(0x[0-9a-f]+)]])
+# CHECK_DSYM: DW_AT_LLVM_stmt_sequence [DW_FORM_sec_offset] ([[OFFSET2:(0x[0-9a-f]+)]])
+# CHECK_DSYM: DW_AT_LLVM_stmt_sequence [DW_FORM_sec_offset] ([[OFFSET3:(0x[0-9a-f]+)]])
+# CHECK_DSYM: DW_AT_LLVM_stmt_sequence [DW_FORM_sec_offset] ([[OFFSET4:(0x[0-9a-f]+)]])
+
+# CHECK_DSYM: [[OFFSET1]]: 00 DW_LNE_set_address
+# CHECK_DSYM: [[OFFSET2]]: 00 DW_LNE_set_address
+# CHECK_DSYM: [[OFFSET3]]: 00 DW_LNE_set_address
+# CHECK_DSYM: [[OFFSET4]]: 00 DW_LNE_set_address
+
+
+######## Generate stmt_seq_macho.exe & stmt_seq_macho.o via script: ##########
+# ------------------------------------------------------------------------------
+#!/bin/bash
+TOOLCHAIN=/path/to/llvm/bin
+
+# ------------------------------------------------------------------------------
+# Create the stmt_seq_macho.cpp source file
+# ------------------------------------------------------------------------------
+cat > stmt_seq_macho.cpp << 'EOF'
+#define ATTRIB extern "C" __attribute__((noinline))
+
+ATTRIB int function3_copy1(int a) {
+ int b = a + 3;
+ return b + 1;
+}
+
+ATTRIB int function2_copy1(int a) {
+ return a - 22;
+}
+
+ATTRIB int function3_copy2(int a) {
+ int b = a + 3;
+ return b + 1;
+}
+
+ATTRIB int function2_copy2(int a) {
+ int result = a - 22;
+ return result;
+}
+
+int main() {
+ int sum = 0;
+ sum += function2_copy2(3);
+ sum += function3_copy2(41);
+ sum += function2_copy1(11);
+ return sum;
+}
+EOF
+
+"$TOOLCHAIN/clang" \
+ --target=arm64-apple-macos11 \
+ -c \
+ -g \
+ -gdwarf-4 \
+ -fno-unwind-tables \
+ -mllvm -emit-func-debug-line-table-offsets \
+ -fno-exceptions \
+ -mno-outline \
+ -Oz \
+ stmt_seq_macho.cpp \
+ -o stmt_seq_macho.o
+
+"$TOOLCHAIN/ld64.lld" \
+ -arch arm64 \
+ -platform_version macos 11.0.0 11.0.0 \
+ -o stmt_seq_macho.exe \
+ stmt_seq_macho.o \
+ -dead_strip \
+ --icf=all \
+ --keep-icf-stabs
diff --git a/llvm/test/tools/dsymutil/Inputs/private/tmp/stmt_seq/stmt_seq_macho.exe b/llvm/test/tools/dsymutil/Inputs/private/tmp/stmt_seq/stmt_seq_macho.exe
new file mode 100755
index 0000000000000000000000000000000000000000..138c418aa37b2ac5dde530d68778dc85697878a9
GIT binary patch
literal 17216
zcmeI4Ur1A76u{5!oCsPeQYjIvknI0;vz{uL=1 at tR4TV(?-_~~5M$S#W#?*l$kceKA
zpnQpD5NUr%BIv0SgL)~%m!cl(*@t>4DKTuFbN{F_%&3Q6&SB?%-#O>|&Ufzb+v~ZL
zb02>c0ayS<LS2LE$H at TLaRyM1+JGuVb4|Vbgxl*OZ?0&Yb6vk!lxGN4h!(f6B{!_?
zcjfxPux;ojHO~-2Rg&uB+U5B&SUat4GM12yzeUM|^rEr!{hAt&9&y(-nzgy~JT9xT
z8f_BOrZdc%$iEdJT}6}C#D#ou4b at bJ8gT&>(^vzL!Lbmv8I^?Qr1bu@=5J&zZnC4|
z9fRE6)hV|{PsyR4wh-DRn^38arlvY*ZFSTQ-|!4&uG=0t(Pu~1-%+oG=6R?9>tQ>-
zFYO!4feWw=eN?O81yF$F4#TGRB-xBg@#0#5Dm^*5R~8=}8 at GzrxT%E38PAi^`990&
z{9zdML)tr=&0hUth1+&p+WQUXrBGVvx1_zFaqgF(aK5i*bjC9=qUBim6pk<fCcp%k
z025#WOn?b60Vco%m;e)C0!)AjFaajO1egF5U;<2l2`~XBzyz286JP>NfC(@GCcp%k
z025#WOn?b60Vco%m;e)C0!)AjFaajO1egF5U;<2l2`~XBzy$t30gJ%?a;u0%gpyQ(
z-KruYN+6_k!md~#+75EKyFI8z<L$7II=!thhTZ6rQv~CQ9;mO at MkgEx$pIcGv{)g7
z+4RQ<^{r=Y1=I!(^w|Kj=bY>$YS`#5C!3O2U_UtZlT%wbX$9&*R1!);@yxQgmK<aB
zeF2J(tPtP1%6>X8L=Qu#o^@!O_0TzFo9EMcWSi$v{-yB)nyq*3Q(8L+ji)eq>IfaM
z;4oP(IP?`x{A9wfmm?=Sqh|xEBCD~4+@;1;(WP`OOz@~+B)&J8NWdR0jAMa@%)Kuf
zNBUK0QrRTb<`3v6vSlFQ7XT#fy66gh6hpzQt}V7p+GhrI&u^bDGiotwH%i9;pc&G~
zR}=XilhZGrmc0DF at sRJDGu4xSWy|HS@!=1FU^qGGz1M&DfiM1iIy|2DW at _q;<nh_E
zsfVfFfp?EDHeA?!>tExR>N~c|{cj_mQoVcn!<CiiFWoOs&z^jC({VbxK|bgE2{APY
A!T<mO
literal 0
HcmV?d00001
diff --git a/llvm/test/tools/dsymutil/Inputs/private/tmp/stmt_seq/stmt_seq_macho.o b/llvm/test/tools/dsymutil/Inputs/private/tmp/stmt_seq/stmt_seq_macho.o
new file mode 100644
index 0000000000000000000000000000000000000000..0da06940a023c2af7c5ac3c39a17ce2e9b23b6ba
GIT binary patch
literal 3384
zcmb7HU1%It6uz^wGflFaH9xgUwCXAmjF{ccr0FK9)fWHqQ)&7G=0Tk7ZZ^rr{d0E`
z(>6AtPc0OrwO|pof-kN3SRtTD at k#I at 1x55hut-rsL9l&MqJHPjxsztH#rD9t=jWdD
z-E;3fb2nN2>-T at cLTCa+LlE3gLlg|^0I%p$tvM`gaoyvT15!4*i9_TB*|w8ia9rKB
z4?j14c->ao%d8My0Qyw`$mN4#S;dgF?a6F<ZraY5GSY3^&%U(x;PYOH!Z{^(Cd6f~
z&kJzjJyYSO(&<Wep71x~U1yxLoUz;VQk6pGdZh4j#i<fG{dli)^l`>rWxQXo-+C9N
zCSKL4$XP$$O}?W)++6Wu9V_d?hnFgs^I5x?DrBpO@#9_R^ZJ<ccXLteaPoRQ)3#l_
zQhHWih#&8a;f8i{#;<pXC+jPxGJd>Ie0YrwUMWhcxnJi<x#oVqXS^3UyXSxL-2R)Y
z-~f^1uP at 5?`2piC0FSOHfsc)s^3})voGTLCCcG<*x59Ys{9%pX2G2rVJJ at Y6^%c5J
zPyS`(5#*1M<B$|F1}35$Vycsug?5+JB$}`2_O}2(Af?Z~vH$Z+Ysa)pYtM)?6Jq%w
z(9iv;i;tp)tG9~Q(1hmd69ExgJGS at Ijs0I-lvrGf`lK~6rc~ASLGhtBcHwp<t7u)6
z^-Vzv0tX`r=t^y3S8a4PyLCNLsdVB*ca~VQECsRMMZyJ*DK*Nj+UWi$Byzkbo?xw?
zr7oJq1!e4GrzYH&*2_YZG;5DWS`9sNVlmRxc7NpBQb)7af|d!yFx6uIywq`ev29QL
z(GEQ_7}^yYZhg7~G58V;5ol9B9LtUkrr~DSPBn+LrPeplo?C`Rp#3<GrLI%xk*7i-
zYT=`paBsJcI#@g`3K*A31)Xq(9O(zb`vU3CcYw9hc^dV3B+Cc&nr8+Fp#DT=kY+_d
z^$E!l@|P~sSSNE|fhu#QDFUiDD0qUxN-H#mW$@cjWw11ZS7FM98r_AkMM;#q0M<%h
z(%39>Z$g#1(hSB>+I5<3k-0_`I?<EhH^ExrI~upqZ14bv-^gqu)BGAL9Rkr7ZA|MG
zCRMhFY!F<5rY>R5LRUROVY_exKfq at MMJAsrPDkgnm1?e3j9NXhL at Y6#bE1#UI8M1b
z7>~o4nM=nqr9wQFU+A^s`TTsLyId*FW;0HVLU&r(Ofua+nH at -`dIpjitIx7}lF3w`
zm7dHb`>jM at UvgleH_;`kPQkIO+1KnsDl=1xWy)m{7x8i>H=lB{ai>s at s|YbQSIjsl
zsn^bw%13%U+w$4&yycs>L?M+cid at kVDUlYHY;`X0i0WKH3?14#gp-pGB|Vm5FcJAQ
zemY727ewtuoq6)BovX7;?<}5z9IorxJ_4p*%!3!fr@`-nWivt2aTCdVgS>|TL9z!R
z>DGwOgJ~*8251FLHeDf+s+H3>)k-zqZ46<lCyw?<d)9FpLH at HZv3xQ_9YyUyvD9Xr
zkRVE<C4-_)XbTU9AClg6I5sisl3GUDN-F=Y9~fmQe>>-^cwSya*-sw^(Z28lP48>(
z1>Vxn(JhI~;GlRMqo!$pM;b}c7QkAq*29!AA`PP6dsDU<hB<;X*Q?gQZ-ZA=tv71Q
zzm+gl)p|4hqX2;~N=tzBdo?56 at Y$zEy?Me2o1;=1W at t1JM&J-4P-8dk3mfT9K%%7X
zX<4{153$_CvWew4Zl1|)WWLIFoaG}dms!rR9AnwfGRpES%i}DkSgQCzwnrf&s6i3=
zsm0ZK(Mgc4PNa)%6;J<T(7ZZHf+9Pr0`NTG<Fz+F0oJ<1eFJWBs7Jy}QLjWEZwei!
Gr2hacaDgTO
literal 0
HcmV?d00001
>From b8491fab40bffcd7d6fbd87a784e12c774fbd2cf Mon Sep 17 00:00:00 2001
From: Alex B <alexborcan at meta.com>
Date: Wed, 12 Mar 2025 21:43:20 -0700
Subject: [PATCH 2/2] Address Feedback nr.1
---
.../Classic/DWARFLinkerCompileUnit.h | 4 +-
llvm/lib/DWARFLinker/Classic/DWARFLinker.cpp | 38 +++++++++----------
2 files changed, 21 insertions(+), 21 deletions(-)
diff --git a/llvm/include/llvm/DWARFLinker/Classic/DWARFLinkerCompileUnit.h b/llvm/include/llvm/DWARFLinker/Classic/DWARFLinkerCompileUnit.h
index 9fae62a62e442..7106889d8ec76 100644
--- a/llvm/include/llvm/DWARFLinker/Classic/DWARFLinkerCompileUnit.h
+++ b/llvm/include/llvm/DWARFLinker/Classic/DWARFLinkerCompileUnit.h
@@ -177,7 +177,7 @@ class CompileUnit {
}
// Provide access to the list of DW_AT_LLVM_stmt_sequence attributes that may
- // need to be patched
+ // need to be patched.
const StmtSeqListAttributesTy &getStmtSeqListAttributes() const {
return StmtSeqListAttributes;
}
@@ -218,7 +218,7 @@ class CompileUnit {
void noteLocationAttribute(PatchLocation Attr);
// Record that the given DW_AT_LLVM_stmt_sequence attribute may need to be
- // patched later
+ // patched later.
void noteStmtSeqListAttribute(PatchLocation Attr);
/// Add a name accelerator entry for \a Die with \a Name.
diff --git a/llvm/lib/DWARFLinker/Classic/DWARFLinker.cpp b/llvm/lib/DWARFLinker/Classic/DWARFLinker.cpp
index db0684e56e0c0..f66773ad2e694 100644
--- a/llvm/lib/DWARFLinker/Classic/DWARFLinker.cpp
+++ b/llvm/lib/DWARFLinker/Classic/DWARFLinker.cpp
@@ -2202,27 +2202,27 @@ void DWARFLinker::DIECloner::generateLineTableForUnit(CompileUnit &Unit) {
DebugLineStrPool);
} else {
// Create TrackedRow objects for all input rows.
- std::vector<TrackedRow> AllTrackedRows;
- AllTrackedRows.reserve(LT->Rows.size());
+ std::vector<TrackedRow> InputRows;
+ InputRows.reserve(LT->Rows.size());
for (size_t i = 0; i < LT->Rows.size(); i++)
- AllTrackedRows.emplace_back(TrackedRow{LT->Rows[i], i, false});
+ InputRows.emplace_back(TrackedRow{LT->Rows[i], i, false});
// This vector is the output line table (still in TrackedRow form).
- std::vector<TrackedRow> NewRows;
- NewRows.reserve(AllTrackedRows.size());
+ std::vector<TrackedRow> OutputRows;
+ OutputRows.reserve(InputRows.size());
// Current sequence of rows being extracted, before being inserted
- // in NewRows.
+ // in OutputRows.
std::vector<TrackedRow> Seq;
- Seq.reserve(AllTrackedRows.size());
+ Seq.reserve(InputRows.size());
const auto &FunctionRanges = Unit.getFunctionRanges();
std::optional<AddressRangeValuePair> CurrRange;
// FIXME: This logic is meant to generate exactly the same output as
// Darwin's classic dsymutil. There is a nicer way to implement this
- // by simply putting all the relocated line info in NewRows and simply
- // sorting NewRows before passing it to emitLineTableForUnit. This
+ // by simply putting all the relocated line info in OutputRows and simply
+ // sorting OutputRows before passing it to emitLineTableForUnit. This
// should be correct as sequences for a function should stay
// together in the sorted output. There are a few corner cases that
// look suspicious though, and that required to implement the logic
@@ -2230,8 +2230,8 @@ void DWARFLinker::DIECloner::generateLineTableForUnit(CompileUnit &Unit) {
// Iterate over the object file line info and extract the sequences
// that correspond to linked functions.
- for (size_t i = 0; i < AllTrackedRows.size(); i++) {
- TrackedRow TR = AllTrackedRows[i];
+ for (size_t i = 0; i < InputRows.size(); i++) {
+ TrackedRow TR = InputRows[i];
// Check whether we stepped out of the range. The range is
// half-open, but consider accepting the end address of the range if
@@ -2255,7 +2255,7 @@ void DWARFLinker::DIECloner::generateLineTableForUnit(CompileUnit &Unit) {
NextLine.Row.BasicBlock = 0;
NextLine.Row.EpilogueBegin = 0;
Seq.push_back(NextLine);
- insertLineSequence(Seq, NewRows);
+ insertLineSequence(Seq, OutputRows);
}
if (!CurrRange)
@@ -2271,13 +2271,13 @@ void DWARFLinker::DIECloner::generateLineTableForUnit(CompileUnit &Unit) {
Seq.push_back(TR);
if (TR.Row.EndSequence)
- insertLineSequence(Seq, NewRows);
+ insertLineSequence(Seq, OutputRows);
}
// Materialize the tracked rows into final DWARFDebugLine::Row objects.
LineTable.Rows.clear();
- LineTable.Rows.reserve(NewRows.size());
- for (auto &TR : NewRows)
+ LineTable.Rows.reserve(OutputRows.size());
+ for (auto &TR : OutputRows)
LineTable.Rows.push_back(TR.Row);
// Use OutputRowOffsets to store the offsets of each line table row in the
@@ -2292,8 +2292,8 @@ void DWARFLinker::DIECloner::generateLineTableForUnit(CompileUnit &Unit) {
hasStmtSeq ? &OutputRowOffsets : nullptr);
if (hasStmtSeq) {
- assert(OutputRowOffsets.size() == NewRows.size() &&
- "OutputRowOffsets size mismatch");
+ assert(OutputRowOffsets.size() == OutputRows.size() &&
+ "must have an offset for each row");
// Create a map of stmt sequence offsets to original row indices.
DenseMap<uint64_t, unsigned> SeqOffToOrigRow;
@@ -2302,8 +2302,8 @@ void DWARFLinker::DIECloner::generateLineTableForUnit(CompileUnit &Unit) {
// Create a map of original row indices to new row indices.
DenseMap<size_t, size_t> OrigRowToNewRow;
- for (size_t i = 0; i < NewRows.size(); ++i)
- OrigRowToNewRow[NewRows[i].OriginalRowIndex] = i;
+ for (size_t i = 0; i < OutputRows.size(); ++i)
+ OrigRowToNewRow[OutputRows[i].OriginalRowIndex] = i;
// Patch DW_AT_LLVM_stmt_sequence attributes in the compile unit DIE
// with the correct offset into the .debug_line section.
More information about the llvm-commits
mailing list