Skip to content

[KeyInstr] Use DISubprogram's is-key-instructions-on flag at DWARF emission #144104

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Open
wants to merge 2 commits into
base: main
Choose a base branch
from
+123 −5
Open

[KeyInstr] Use DISubprogram's is-key-instructions-on flag at DWARF emission #144104

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
2 commits
Select commit Hold shift + click to select a range
5ab3e9f
[KeyInstr] Use DISubprogram's is-key-instructions-on flag at DWARF em…
OCHyams Jun 12, 2025
380156e
address review comments
OCHyams Jun 23, 2025
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
29 changes: 24 additions & 5 deletions llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -169,8 +169,10 @@ static cl::opt<DwarfDebug::MinimizeAddrInV5> MinimizeAddrInV5Option(
"Stuff")),
cl::init(DwarfDebug::MinimizeAddrInV5::Default));

static cl::opt<bool> KeyInstructionsAreStmts("dwarf-use-key-instructions",
cl::Hidden, cl::init(false));
/// Set to false to ignore Key Instructions metadata.
static cl::opt<bool> KeyInstructionsAreStmts(
"dwarf-use-key-instructions", cl::Hidden, cl::init(true),
cl::desc("Set to false to ignore Key Instructions metadata"));

static constexpr unsigned ULEB128PadSize = 4;

Expand Down Expand Up @@ -2077,8 +2079,18 @@ void DwarfDebug::beginInstruction(const MachineInstr *MI) {
unsigned LastAsmLine =
Asm->OutStreamer->getContext().getCurrentDwarfLoc().getLine();

Copy link
Member

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

This is an immense nitpick, but IMO the comment should open by stating the premise "There may be a mixture of scopes using KIs, and not using KIs" or something similar. It's sufficiently non-obvious that it should be made explicit to the future reader.

// There may be a mixture of scopes using and not using Key Instructions.
// Not-Key-Instructions functions inlined into Key Instructions functions
// should use not-key is_stmt handling. Key Instructions functions inlined
// into not-key-instructions functions currently fall back to not-key
// handling to avoid having to run computeKeyInstructions for all functions
// (which will impact non-key-instructions builds).
// TODO: Investigate the performance impact of doing that.
bool ScopeUsesKeyInstructions =
KeyInstructionsAreStmts && DL && SP->getKeyInstructionsEnabled();

bool IsKey = false;
if (KeyInstructionsAreStmts && DL && DL.getLine())
if (ScopeUsesKeyInstructions && DL && DL.getLine())
IsKey = KeyInstructions.contains(MI);

if (!DL && MI == PrologEndLoc) {
Expand Down Expand Up @@ -2158,7 +2170,7 @@ void DwarfDebug::beginInstruction(const MachineInstr *MI) {
PrologEndLoc = nullptr;
}

if (KeyInstructionsAreStmts) {
if (ScopeUsesKeyInstructions) {
if (IsKey)
Flags |= DWARF2_FLAG_IS_STMT;
} else {
Expand Down Expand Up @@ -2651,7 +2663,14 @@ void DwarfDebug::beginFunctionImpl(const MachineFunction *MF) {
PrologEndLoc = emitInitialLocDirective(
*MF, Asm->OutStreamer->getContext().getDwarfCompileUnitID());

if (KeyInstructionsAreStmts)
// If this function wasn't built with Key Instructions but has a function
// inlined into it that was, we treat the inlined instance as if it wasn't
// built with Key Instructions. If this function was built with Key
// Instructions but a function inlined into it wasn't then we continue to use
// Key Instructions for this function and fall back to non-key behaviour for
// the inlined function (except it doesn't benefit from
// findForceIsStmtInstrs).
if (KeyInstructionsAreStmts && SP->getKeyInstructionsEnabled())
computeKeyInstructions(MF);
else
findForceIsStmtInstrs(MF);
Expand Down
99 changes: 99 additions & 0 deletions llvm/test/DebugInfo/KeyInstructions/X86/dwarf-inline-modes.mir
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -0,0 +1,99 @@
# RUN: llc %s --start-after=livedebugvalues --dwarf-use-key-instructions --filetype=obj -o - \
# RUN: | llvm-objdump -d - --no-show-raw-insn \
# RUN: | FileCheck %s --check-prefix=OBJ

# RUN: llc %s --start-after=livedebugvalues --dwarf-use-key-instructions --filetype=obj -o - \
# RUN: | llvm-dwarfdump - --debug-line \
# RUN: | FileCheck %s --check-prefix=DBG

# Test is_stmt emission for a key-instructions function inlined into a
# not-key-instructions function, and vice versa.

--- |
target triple = "x86_64-unknown-linux-gnu"

define hidden noundef i32 @key() local_unnamed_addr !dbg !5 {
entry:
ret i32 0
}

define hidden noundef i32 @not_key() local_unnamed_addr !dbg !9 {
entry:
ret i32 0
}

!llvm.dbg.cu = !{!0}
!llvm.module.flags = !{!2, !3}
!llvm.ident = !{!4}

!0 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus_17, file: !1, producer: "clang version 21.0.0", isOptimized: true, runtimeVersion: 0, emissionKind: LineTablesOnly, splitDebugInlining: false, nameTableKind: None)
!1 = !DIFile(filename: "test.cpp", directory: "/")
!2 = !{i32 7, !"Dwarf Version", i32 5}
!3 = !{i32 2, !"Debug Info Version", i32 3}
!4 = !{!"clang version 21.0.0"}
!5 = distinct !DISubprogram(name: "key", scope: !1, file: !1, line: 1, type: !6, scopeLine: 1, flags: DIFlagPrototyped | DIFlagAllCallsDescribed, spFlags: DISPFlagDefinition | DISPFlagOptimized, unit: !0, keyInstructions: true)
!6 = !DISubroutineType(types: !7)
!7 = !{}
!9 = distinct !DISubprogram(name: "not_key", scope: !1, file: !1, line: 1, type: !6, scopeLine: 1, flags: DIFlagPrototyped | DIFlagAllCallsDescribed, spFlags: DISPFlagDefinition | DISPFlagOptimized, unit: !0, keyInstructions: false)
!10 = distinct !DILocation(line: 5, scope: !5)
!11 = distinct !DILocation(line: 9, scope: !9)
...
---
name: key
alignment: 16
body: |
bb.0.entry:

; OBJ: 0000000000000000 <key>:
; OBJ-NEXT: 0: movl $0x1, %eax
; OBJ-NEXT: 5: movl $0x2, %eax
; OBJ-NEXT: a: movl $0x3, %eax
; OBJ-NEXT: f: movl $0x4, %eax
; OBJ-NEXT: 14: movl $0x5, %eax
; OBJ-NEXT: 19: retq
;
; DBG: Address Line Column File ISA Discriminator OpIndex Flags
; DBG-NEXT: ------------------ ------ ------ ------ --- ------------- ------- -------------
; DBG-NEXT: 0x0000000000000000 1 0 0 0 0 0 is_stmt prologue_end
; DBG-NEXT: 0x0000000000000005 2 0 0 0 0 0 is_stmt
; DBG-NEXT: 0x000000000000000a 2 0 0 0 0 0
; DBG-NEXT: 0x000000000000000f 3 0 0 0 0 0 is_stmt
; DBG-NEXT: 0x0000000000000014 3 0 0 0 0 0
;
$eax = MOV32ri 1, debug-location !DILocation(line: 1, scope: !5) ; is_stmt (prologue_end)
$eax = MOV32ri 2, debug-location !DILocation(line: 2, scope: !5, atomGroup: 1, atomRank: 1) ; is_stmt (key)
$eax = MOV32ri 3, debug-location !DILocation(line: 2, scope: !9, inlinedAt: !10)
$eax = MOV32ri 4, debug-location !DILocation(line: 3, scope: !9, inlinedAt: !10) ; is_stmt (not_key)
$eax = MOV32ri 5, debug-location !DILocation(line: 3, scope: !5, atomGroup: 1, atomRank: 2) ; is_stmt (key)
RET64 $eax, debug-location !DILocation(line: 3, scope: !5, atomGroup: 1, atomRank: 1)
...
---
name: not_key
alignment: 16
body: |
bb.0.entry:

; OBJ: 0000000000000020 <not_key>:
; OBJ-NEXT: 20: movl $0x1, %eax
; OBJ-NEXT: 25: movl $0x2, %eax
; OBJ-NEXT: 2a: movl $0x3, %eax
; OBJ-NEXT: 2f: retq
;
; TODO: Currently key inlined into not-key is treated as not-key. Investigate
; performance implications of honouring the flag in this scenario.
;
; Address Line Column File ISA Discriminator OpIndex Flags
; ------------------ ------ ------ ------ --- ------------- ------- -------------
; DBG-NEXT: 0x0000000000000020 1 0 0 0 0 0 is_stmt prologue_end
; DBG-NEXT: 0x0000000000000025 2 0 0 0 0 0 is_stmt
; DBG-NEXT: 0x000000000000002a 3 0 0 0 0 0 is_stmt
; DBG-NEXT: 0x000000000000002f 3 0 0 0 0 0
;
; NOTE: The `is_stmt` comments at the end of the lines reflects what we want
; to see if the TODO above is resolved.
;
$eax = MOV32ri 1, debug-location !DILocation(line: 1, scope: !9) ; is_stmt (prologue_end)
$eax = MOV32ri 2, debug-location !DILocation(line: 2, scope: !5, inlinedAt: !11, atomGroup: 1, atomRank: 2)
$eax = MOV32ri 3, debug-location !DILocation(line: 3, scope: !5, inlinedAt: !11, atomGroup: 1, atomRank: 1) ; is_stmt (key)
RET64 $eax, debug-location !DILocation(line: 3, scope: !9)
...
Loading