From 5ab3e9f1f4716f0a05612f88f454fce1081a7fdf Mon Sep 17 00:00:00 2001 From: Orlando Cazalet-Hyams Date: Thu, 12 Jun 2025 13:59:12 +0100 Subject: [PATCH 1/2] [KeyInstr] Use DISubprogram's is-key-instructions-on flag at DWARF emission A non-key-instructions function inlined into a key-instructions function uses non-key-instructions is_stmt placement (without `findForceIsStmtInstrs`). A key-instructions function inlined into a non-key-instructions function currently results in falling back to non-key-instructions for the inlined scope too. Both of these consessions (not using `findForceIsStmtInstrs` in the 1st case, and not using Key Instructions for the inlined scope in the 2nd) are for performance reasons; to do the right thing we'd need to run both `findForceIsStmtInstrs` and `computeKeyInstructions` - in case that's controversial I've got a seperate PR for that. --- llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp | 27 ++++- .../X86/dwarf-inline-modes.mir | 98 +++++++++++++++++++ 2 files changed, 120 insertions(+), 5 deletions(-) create mode 100644 llvm/test/DebugInfo/KeyInstructions/X86/dwarf-inline-modes.mir diff --git a/llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp b/llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp index 0edfca78b0886..96ae175cd632b 100644 --- a/llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp +++ b/llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp @@ -169,8 +169,10 @@ static cl::opt MinimizeAddrInV5Option( "Stuff")), cl::init(DwarfDebug::MinimizeAddrInV5::Default)); -static cl::opt KeyInstructionsAreStmts("dwarf-use-key-instructions", - cl::Hidden, cl::init(false)); +/// Set to false to ignore Key Instructions metadata. +static cl::opt 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; @@ -2077,8 +2079,17 @@ void DwarfDebug::beginInstruction(const MachineInstr *MI) { unsigned LastAsmLine = Asm->OutStreamer->getContext().getCurrentDwarfLoc().getLine(); + // Not-Key-Instructions functions inlined into Key Instructions functions + // should use default 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) { @@ -2158,7 +2169,7 @@ void DwarfDebug::beginInstruction(const MachineInstr *MI) { PrologEndLoc = nullptr; } - if (KeyInstructionsAreStmts) { + if (ScopeUsesKeyInstructions) { if (IsKey) Flags |= DWARF2_FLAG_IS_STMT; } else { @@ -2651,7 +2662,13 @@ 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 beneit from findForceIsStmtInstrs). + if (KeyInstructionsAreStmts && SP->getKeyInstructionsEnabled()) computeKeyInstructions(MF); else findForceIsStmtInstrs(MF); diff --git a/llvm/test/DebugInfo/KeyInstructions/X86/dwarf-inline-modes.mir b/llvm/test/DebugInfo/KeyInstructions/X86/dwarf-inline-modes.mir new file mode 100644 index 0000000000000..e304b8fd8b00a --- /dev/null +++ b/llvm/test/DebugInfo/KeyInstructions/X86/dwarf-inline-modes.mir @@ -0,0 +1,98 @@ +# 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 + + + +--- | + 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 : + ; 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 : + ; 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) +... From dc94eeccd4532872b1deca225dccc4166bc87f57 Mon Sep 17 00:00:00 2001 From: Orlando Cazalet-Hyams Date: Fri, 13 Jun 2025 14:28:38 +0100 Subject: [PATCH 2/2] [KeyInstr] Fully support mixed key/non-key inlining modes --- llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp | 25 ++++++++----------- .../X86/dwarf-inline-modes.mir | 8 +----- 2 files changed, 11 insertions(+), 22 deletions(-) diff --git a/llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp b/llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp index 96ae175cd632b..44fa223a35635 100644 --- a/llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp +++ b/llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp @@ -2080,13 +2080,12 @@ void DwarfDebug::beginInstruction(const MachineInstr *MI) { Asm->OutStreamer->getContext().getCurrentDwarfLoc().getLine(); // Not-Key-Instructions functions inlined into Key Instructions functions - // should use default 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. + // should use default is_stmt handling. Key instructions functions + // inlined into not-key-instructions functions should use Key Instructions + // is_stmt handling. bool ScopeUsesKeyInstructions = - KeyInstructionsAreStmts && DL && SP->getKeyInstructionsEnabled(); + KeyInstructionsAreStmts && DL && + DL->getScope()->getSubprogram()->getKeyInstructionsEnabled(); bool IsKey = false; if (ScopeUsesKeyInstructions && DL && DL.getLine()) @@ -2662,16 +2661,12 @@ void DwarfDebug::beginFunctionImpl(const MachineFunction *MF) { PrologEndLoc = emitInitialLocDirective( *MF, Asm->OutStreamer->getContext().getDwarfCompileUnitID()); - // 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 beneit from findForceIsStmtInstrs). - if (KeyInstructionsAreStmts && SP->getKeyInstructionsEnabled()) + // Run both `findForceIsStmtInstrs` and `computeKeyInstructions` because + // not-key-instructions functions may be inlined into key-instructions + // functions and vice versa. + if (KeyInstructionsAreStmts) computeKeyInstructions(MF); - else - findForceIsStmtInstrs(MF); + findForceIsStmtInstrs(MF); } unsigned diff --git a/llvm/test/DebugInfo/KeyInstructions/X86/dwarf-inline-modes.mir b/llvm/test/DebugInfo/KeyInstructions/X86/dwarf-inline-modes.mir index e304b8fd8b00a..39fb4126332e5 100644 --- a/llvm/test/DebugInfo/KeyInstructions/X86/dwarf-inline-modes.mir +++ b/llvm/test/DebugInfo/KeyInstructions/X86/dwarf-inline-modes.mir @@ -78,19 +78,13 @@ body: | ; 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: 0x0000000000000025 2 0 0 0 0 0 ; 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)