Allow epilogue_begin to be emitted when generating DWARF

[Ariel-Burton]

Summary

We identify epilogue code by looking for instructions tagged
with FrameDestroy.

A function may have more than one epilogue, e.g., because of early
returns or code duplicated during optimization. We need only track
the current block, and emit epilogie_begin at most once per block.

We reduce the number of entries in the line table by combining
epilogue_begin with other flags instead of emitting a separate
entry just for epilogue_begin.

[MatzeB]

What is this epilogue information going to be used for?

Generally I find the notion of "epilogue" a bit sketchy, since you can easily imagine the scheduler mixing CSR restore instructions (and whatever else you consider epilogue) with normal computation so you'll have epilogue and non-epilogue code mixed together so a notion of "epilogue starts here" doesn't really mean much...

[Ariel-Burton]

In D133376#3773083, @MatzeB wrote:

What is this epilogue information going to be used for?

Generally I find the notion of "epilogue" a bit sketchy, since you can easily imagine the scheduler mixing CSR restore instructions (and whatever else you consider epilogue) with normal computation so you'll have epilogue and non-epilogue code mixed together so a notion of "epilogue starts here" doesn't really mean much...

As per the DWARF standard, it is intended to identify a location at which am exit breakpoint may be placed before the return.

One use case is for "run-to-end-of-funciton" (which some (e.g., z/OS), but not all debuggers support), instead of the gdb "finish"-like semantics, which will run to just after the current function returns (i.e., it will return to the caller).

I hear that the notion of epilogue might be a bit sketchy with some architectures, or optimization settings. I don't think that matters. Supporting epilogue_begin isn't mandatory, and from what I see in the sources, FrameDestory is not used on all platforms. On those platforms epilogue_begin will not be emitted at all. This change will not affect existing tools which ignore epilogue_begin for the reasons you give, or indeed, any other reasons. But it is useful for tools which do care, and on platforms where the epilogue is identifiable.

[aprantl]

I think this is a reasonable feature to support. As @MatzeB pointed out, it may not be useful in optimized code. Are you primarily targeting optimized or unoptimized code? How much does the debug info size grow in % if you build, e.g., clang?

[Ariel-Burton]

In D133376#3784313, @aprantl wrote:

I think this is a reasonable feature to support. As @MatzeB pointed out, it may not be useful in optimized code. Are you primarily targeting optimized or unoptimized code? How much does the debug info size grow in % if you build, e.g., clang?

I sampled the binaries generated by a x86-64 linux build of clang. As one might expect, the section that grew is .debug_line. I see an increases of about 2%. However, the overall size of just the debug info increases by considerably less, about 0.3%. The increase of the overall file size is even less, at about 0,2%. Interestingly, I saw small reductions in the sizes of the .debug_line_str and .debug_str sections.

[JohnReagan]

Thanks for this. On OpenVMS, our calling convention wants to know about both prologue and epilogue sections. For asych-error handling, we won't call a routine's handler (ie, personality-routine) if it is in its prologue or epilogue since the routine's frame is no longer active. In those cases, we walk back up the stack one frame to begin our handler search. Today, we just look at the instruction sequences and trying to guess as best we can. Having something in the debug_line table will be a big help.

[dblaikie]

In D133376#3822690, @JohnReagan wrote:

Thanks for this. On OpenVMS, our calling convention wants to know about both prologue and epilogue sections. For asych-error handling, we won't call a routine's handler (ie, personality-routine) if it is in its prologue or epilogue since the routine's frame is no longer active. In those cases, we walk back up the stack one frame to begin our handler search. Today, we just look at the instruction sequences and trying to guess as best we can. Having something in the debug_line table will be a big help.

that seems concerning - sounds like the correctness/behavior of the platform depends on the presence/contents of .debug_line? That doesn't sound right. I thought anything relevant to that should be encoded in .debug_frame/.eh_frame, no?

[JohnReagan]

In D133376#3824277, @dblaikie wrote:

In D133376#3822690, @JohnReagan wrote:

Thanks for this. On OpenVMS, our calling convention wants to know about both prologue and epilogue sections. For asych-error handling, we won't call a routine's handler (ie, personality-routine) if it is in its prologue or epilogue since the routine's frame is no longer active. In those cases, we walk back up the stack one frame to begin our handler search. Today, we just look at the instruction sequences and trying to guess as best we can. Having something in the debug_line table will be a big help.

that seems concerning - sounds like the correctness/behavior of the platform depends on the presence/contents of .debug_line? That doesn't sound right. I thought anything relevant to that should be encoded in .debug_frame/.eh_frame, no?

Sorry for the delay, been on the road and only catching up. Yes my bad, we have that in eh_frame, not in the debug_line. The weakness of epilogue support has always been a concern of mine and I'm happy that things are catching up. The debug_line indicators of epilogue will help our debugger and performance analysis tools.

[Ariel-Burton]

ping for approval

[dblaikie]

As one might expect, the section that grew is .debug_line. I see an increases of about 2%. However, the overall size of just the debug info increases by considerably less, about 0.3%. The increase of the overall file size is even less, at about 0,2%.

Under what build configuration/example target? These numbers can vary pretty widely depending on compression, split dwarf, optimized/unoptimized, etc. Might be good to have a few scenarios covered, at least with clang or something similarly large-ish from the LLVM project.

Interestingly, I saw small reductions in the sizes of the .debug_line_str and .debug_str sections.

that seems really suspicious - is there any reason why this change would reduce those?

[Ariel-Burton]

In D133376#3961567, @dblaikie wrote:

As one might expect, the section that grew is .debug_line. I see an increases of about 2%. However, the overall size of just the debug info increases by considerably less, about 0.3%. The increase of the overall file size is even less, at about 0,2%.

Under what build configuration/example target? These numbers can vary pretty widely depending on compression, split dwarf, optimized/unoptimized, etc. Might be good to have a few scenarios covered, at least with clang or something similarly large-ish from the LLVM project.

This was a vanilla x86-64 linux build with debug.

Interestingly, I saw small reductions in the sizes of the .debug_line_str and .debug_str sections.

that seems really suspicious - is there any reason why this change would reduce those?

I've looked more closely at the strings, and I believe this is a false alarm. The reason for the reduction in size is that the path in which the with-the-change was built was shorter than of the without-the-change build.

[dblaikie]

I still suspect more data would be useful, but sure - let's give it a go.

[labath]

I don't think that this indicates a problem with this patch, but you might be interested to know that this broke a test in lldb which was trying to change the PC value to a given line (and it failed because that line was now associated with multiple line entries). I have worked around the problem with a06342d250ec7bee37dc93477f233e43e597aca5 and filed PR59458 to track possible improvements in the lldb implementation.

llvm/include/llvm/CodeGen/DebugHandlerBase.h

protected:
   DebugLoc PrevInstLoc;
   MCSymbol *PrevLabel = nullptr;
   const MachineBasicBlock *PrevInstBB = nullptr;
 
   /// This location indicates end of function prologue and beginning of
   /// function body.
   DebugLoc PrologEndLoc;
 
+  /// This block includes epilogue instructions.
+  const MachineBasicBlock *EpilogBeginBlock;
+
   /// If nonnull, stores the current machine instruction we're processing.
   const MachineInstr *CurMI = nullptr;
 
   LexicalScopes LScopes;
 
   /// History of DBG_VALUE and clobber instructions for each user
   /// variable.  Variables are listed in order of appearance.
   DbgValueHistoryMap DbgValues;

llvm/lib/CodeGen/AsmPrinter/DebugHandlerBase.cpp

void DebugHandlerBase::endFunction(const MachineFunction *MF) {
   DbgValues.clear();
   DbgLabels.clear();
   LabelsBeforeInsn.clear();
   LabelsAfterInsn.clear();
   InstOrdering.clear();
 }
 
 void DebugHandlerBase::beginBasicBlockSection(const MachineBasicBlock &MBB) {
+  EpilogBeginBlock = nullptr;
   if (!MBB.isEntryBlock())
     PrevLabel = MBB.getSymbol();
 }
 
 void DebugHandlerBase::endBasicBlockSection(const MachineBasicBlock &MBB) {
   PrevLabel = nullptr;
 }

llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp

if (NoDebug)
     return;
 
   // Check if source location changes, but ignore DBG_VALUE and CFI locations.
   // If the instruction is part of the function frame setup code, do not emit
   // any line record, as there is no correspondence with any user code.
   if (MI->isMetaInstruction() || MI->getFlag(MachineInstr::FrameSetup))
     return;
   const DebugLoc &DL = MI->getDebugLoc();
+  unsigned Flags = 0;
+
+  if (MI->getFlag(MachineInstr::FrameDestroy) && DL) {
+    const MachineBasicBlock *MBB = MI->getParent();
+    if (MBB && (MBB != EpilogBeginBlock)) {
+      // First time FrameDestroy has been seen in this basic block
+      EpilogBeginBlock = MBB;
+      Flags |= DWARF2_FLAG_EPILOGUE_BEGIN;
+    }
+  }
+
   // When we emit a line-0 record, we don't update PrevInstLoc; so look at
   // the last line number actually emitted, to see if it was line 0.
   unsigned LastAsmLine =
       Asm->OutStreamer->getContext().getCurrentDwarfLoc().getLine();
 
   if (DL == PrevInstLoc) {
     // If we have an ongoing unspecified location, nothing to do here.
     if (!DL)
       return;
     // We have an explicit location, same as the previous location.
     // But we might be coming back to it after a line 0 record.
-    if (LastAsmLine == 0 && DL.getLine() != 0) {
+    if ((LastAsmLine == 0 && DL.getLine() != 0) || Flags) {
       // Reinstate the source location but not marked as a statement.
       const MDNode *Scope = DL.getScope();
-      recordSourceLine(DL.getLine(), DL.getCol(), Scope, /*Flags=*/0);
+      recordSourceLine(DL.getLine(), DL.getCol(), Scope, Flags);
     }
     return;
   }
 
   if (!DL) {
     // We have an unspecified location, which might want to be line 0.
     // If we have already emitted a line-0 record, don't repeat it.
     if (LastAsmLine == 0)
if (!DL) {
     return;
   }
 
   // We have an explicit location, different from the previous location.
   // Don't repeat a line-0 record, but otherwise emit the new location.
   // (The new location might be an explicit line 0, which we do emit.)
   if (DL.getLine() == 0 && LastAsmLine == 0)
     return;
-  unsigned Flags = 0;
   if (DL == PrologEndLoc) {
     Flags |= DWARF2_FLAG_PROLOGUE_END | DWARF2_FLAG_IS_STMT;
     PrologEndLoc = DebugLoc();
   }
   // If the line changed, we call that a new statement; unless we went to
   // line 0 and came back, in which case it is not a new statement.
   unsigned OldLine = PrevInstLoc ? PrevInstLoc.getLine() : LastAsmLine;
   if (DL.getLine() && DL.getLine() != OldLine)

llvm/test/CodeGen/AMDGPU/no-source-locations-in-prologue.ll

 ; CHECK-NEXT:    s_mov_b64 s[0:1], s[20:21]
 ; CHECK-NEXT:    s_mov_b64 s[2:3], s[22:23]
 ; CHECK-NEXT:    s_waitcnt lgkmcnt(0)
 ; CHECK-NEXT:    s_swappc_b64 s[30:31], s[16:17]
 ; CHECK-NEXT:  .Ltmp1:
 ; CHECK-NEXT:    .loc 0 32 1 ; lane-info.cpp:32:1
 ; CHECK-NEXT:    v_readlane_b32 s31, v40, 1
 ; CHECK-NEXT:    v_readlane_b32 s30, v40, 0
+; CHECK-NEXT:    .loc 0 32 1 epilogue_begin is_stmt 0 ; lane-info.cpp:32:1
 ; CHECK-NEXT:    s_add_i32 s32, s32, 0xfffffc00
 ; CHECK-NEXT:    v_readlane_b32 s33, v40, 2
 ; CHECK-NEXT:    s_or_saveexec_b64 s[4:5], -1
 ; CHECK-NEXT:    buffer_load_dword v40, off, s[0:3], s32 ; 4-byte Folded Reload
 ; CHECK-NEXT:    s_mov_b64 exec, s[4:5]
 ; CHECK-NEXT:    s_waitcnt vmcnt(0)
 ; CHECK-NEXT:    s_setpc_b64 s[30:31]
 ; CHECK-NEXT:  .Ltmp2:

llvm/test/CodeGen/X86/dbg-line-0-no-discriminator.ll

 !8 = !{null}
 !9 = !DILocation(line: 4, column: 3, scope: !10)
 !10 = !DILexicalBlockFile(scope: !6, file: !1, discriminator: 1)
 !11 = !DILocation(line: 6, column: 1, scope: !6)
 
 ; Look at the lengths. We can't verify the line-number-program size
 ; directly, but the difference in the two lengths should not change
 ; unexpectedly.
-; CHECK:    total_length: 0x00000044
+; CHECK:    total_length: 0x00000045
 ; CHECK: prologue_length: 0x0000001f
 ;
 ; Verify that we see a line entry with a discriminator, and the next entry
 ; has line 0 and no discriminator.
 ;             line column file ISA discriminator
 ; CHECK:      4    3      1    0   1
 ; CHECK-NEXT: 0    3      1    0   0

llvm/test/DebugInfo/AArch64/line-header.ll

 ; RUN: llc -mtriple=aarch64-none-linux -O0 -fast-isel -filetype=obj - < %S/../Inputs/line.ll | llvm-dwarfdump -v - | FileCheck %s
 ; RUN: llc -mtriple=aarch64_be-none-linux -O0 -fast-isel -filetype=obj - < %S/../Inputs/line.ll | llvm-dwarfdump -v - | FileCheck %s
 
 ; check line table length is correctly calculated for both big and little endian
 CHECK-LABEL: .debug_line contents:
-CHECK: total_length: 0x00000040
+CHECK: total_length: 0x00000043

llvm/test/DebugInfo/Generic/extended-loc-directive.ll

 ; ENABLED: .loc 1 4 3 is_stmt 1{{$}}
 ; DISABLED: .loc 1 4 3{{$}}
 ; CHECK-NOT: .loc
 ; ENABLED: .loc 1 4 9 is_stmt 0{{$}}
 ; DISABLED: .loc 1 4 9{{$}}
 ; CHECK-NOT: .loc
 ; CHECK: .loc 1 4 15{{$}}
 ; CHECK-NOT: .loc
-; ENABLED: .loc 1 5 1 is_stmt 1{{$}}
+; ENABLED: .loc 1 5 1 {{(epilogue_begin )?is_stmt}} 1{{$}}
 ; DISABLED: .loc 1 5 1{{$}}
 
 ; Function Attrs: nounwind uwtable
 define void @f2() #0 !dbg !4 {
 entry:
   call void (...) @f1(), !dbg !11
   call void (...) @f1(), !dbg !12
   call void (...) @f1(), !dbg !13

llvm/test/DebugInfo/Generic/multiline.ll

 ; CHECK: .loc 1 3 15{{$}}
 ; CHECK-NOT: .loc
 ; CHECK: .loc 1 4 3 is_stmt 1{{$}}
 ; CHECK-NOT: .loc
 ; CHECK: .loc 1 4 9 is_stmt 0{{$}}
 ; CHECK-NOT: .loc
 ; CHECK: .loc 1 4 15{{$}}
 ; CHECK-NOT: .loc
-; CHECK: .loc 1 5 1 is_stmt 1{{$}}
+; CHECK: .loc 1 5 1 {{(epilogue_begin )?}}is_stmt 1{{$}}
 
 ; INT: {{^}}Address
 ; INT: -----
 ; INT-NEXT: 2 0 1 0 0 is_stmt{{$}}
 ; INT-NEXT: 3 3 1 0 0 is_stmt prologue_end{{$}}
 ; INT-NEXT: 3 9 1 0 0 {{$}}
 ; INT-NEXT: 3 15 1 0 0 {{$}}
 ; INT-NEXT: 4 3 1 0 0 is_stmt{{$}}
 ; INT-NEXT: 4 9 1 0 0 {{$}}
 ; INT-NEXT: 4 15 1 0 0 {{$}}
-; INT-NEXT: 5 1 1 0 0 is_stmt{{$}}
+; INT-NEXT: 5 1 1 0 0 is_stmt{{( epilogue_begin)?}}{{$}}
 
 
 ; Function Attrs: nounwind uwtable
 define void @f2() #0 !dbg !4 {
 entry:
   call void (...) @f1(), !dbg !11
   call void (...) @f1(), !dbg !12
   call void (...) @f1(), !dbg !13

llvm/test/DebugInfo/RISCV/dwarf-riscv-relocs.ll

 ; DWARF-DUMP: DW_AT_type      (0x00000032 "int")
 ; DWARF-DUMP: DW_AT_name      ("int")
 ; DWARF-DUMP: DW_AT_encoding  (DW_ATE_signed)
 ; DWARF-DUMP: DW_AT_byte_size (0x04)
 
 ; DWARF-DUMP: .debug_line contents:
 ; DWARF-DUMP-NEXT: debug_line[0x00000000]
 ; DWARF-DUMP-NEXT: Line table prologue:
-; DWARF-DUMP-NEXT:     total_length: 0x0000005f
+; DWARF-DUMP-NEXT:     total_length: 0x00000067
 ; DWARF-DUMP-NEXT:           format: DWARF32
 ; DWARF-DUMP-NEXT:          version: 5
 ; DWARF-DUMP-NEXT:     address_size: 4
 ; DWARF-DUMP-NEXT:  seg_select_size: 0
 ; DWARF-DUMP-NEXT:  prologue_length: 0x0000003e
 ; DWARF-DUMP-NEXT:  min_inst_length: 1
 ; DWARF-DUMP-NEXT: max_ops_per_inst: 1
 ; DWARF-DUMP-NEXT:  default_is_stmt: 1

 ; DWARF-DUMP-NEXT:       dir_index: 0
 ; DWARF-DUMP-NEXT:    md5_checksum: 05ab89f5481bc9f2d037e7886641e919
 ; DWARF-DUMP-NEXT:          source: "int main()\n{\n    return 0;\n}\n"
 ; DWARF-DUMP-EMPTY:
 ; DWARF-DUMP-NEXT: Address            Line   Column File   ISA Discriminator Flags
 ; DWARF-DUMP-NEXT: ------------------ ------ ------ ------ --- ------------- -------------
 ; DWARF-DUMP-NEXT: 0x0000000000000000      2      0      0   0             0  is_stmt
 ; DWARF-DUMP-NEXT: 0x0000000000000014      3      5      0   0             0  is_stmt prologue_end
-; DWARF-DUMP-NEXT: 0x0000000000000028      3      5      0   0             0  is_stmt end_sequence
+; DWARF-DUMP-NEXT: 0x0000000000000020      3      5      0   0             0  epilogue_begin
+; DWARF-DUMP-NEXT: 0x0000000000000028      3      5      0   0             0  end_sequence
 
 ; ModuleID = 'dwarf-riscv-relocs.c'
 source_filename = "dwarf-riscv-relocs.c"
 target datalayout = "e-m:e-p:32:32-i64:64-n32-S128"
 target triple = "riscv32"
 
 ; Function Attrs: noinline nounwind optnone
 define dso_local i32 @main() #0 !dbg !7 {

llvm/test/DebugInfo/X86/basic-block-sections_1.ll

 ; BB-SECTIONS-LINE-TABLE:      0x0000000000000000 1 0 1 0 0 is_stmt
 ; BB-SECTIONS-LINE-TABLE-NEXT: 0x0000000000000004 2 9 1 0 0 is_stmt prologue_end
 ; BB-SECTIONS-LINE-TABLE-NEXT: 0x0000000000000008 2 7 1 0 0
 ; BB-SECTIONS-LINE-TABLE-NEXT: 0x000000000000000a 0 7 1 0 0
 ; BB-SECTIONS-LINE-TABLE-NEXT: 0x000000000000000f 3 5 1 0 0 is_stmt
 ; BB-SECTIONS-LINE-TABLE-NEXT: 0x0000000000000015 0 5 1 0 0
 ; BB-SECTIONS-LINE-TABLE-NEXT: 0x000000000000001a 5 5 1 0 0 is_stmt
 ; BB-SECTIONS-LINE-TABLE-NEXT: 0x000000000000001e 6 1 1 0 0 is_stmt
-; BB-SECTIONS-LINE-TABLE-NEXT: 0x0000000000000024 6 1 1 0 0 is_stmt end_sequence
+; BB-SECTIONS-LINE-TABLE-NEXT: 0x0000000000000022 6 1 1 0 0 epilogue_begin
+; BB-SECTIONS-LINE-TABLE-NEXT: 0x0000000000000024 6 1 1 0 0 end_sequence
 
 ; Function Attrs: noinline nounwind optnone uwtable
 define dso_local i32 @_Z3fooi(i32 %0) !dbg !7 !prof !34 !section_prefix !35 {
   %2 = alloca i32, align 4
   %3 = alloca i32, align 4
   store i32 %0, ptr %3, align 4
   call void @llvm.dbg.declare(metadata ptr %3, metadata !11, metadata !DIExpression()), !dbg !12
   %4 = load i32, ptr %3, align 4, !dbg !13

llvm/test/DebugInfo/X86/multiple-epilogue.ll

+; RUN: llc -O1 %s -mtriple=x86_64 -filetype=obj -o %t && llvm-dwarfdump  -debug-line %t | FileCheck -v --check-prefix=LINE-TABLE %s
+
+; based on
+;
+;   1:   int bar();
+;   2:   int baz();
+;   3;
+;   4:   int foo(int a) {
+;   5:     if (a > 20)
+;   6:       return bar();
+;   7:     else
+;   8:       return baz();
+;   9:   }
+;
+; compiled with -g -S -emit-llvm -O1
+
+
+; LINE-TABLE: .debug_line contents:
+; LINE-TABLE: Line table prologue:
+; LINE-TABLE:     total_length: 0x00000069
+; LINE-TABLE:           format: DWARF32
+; LINE-TABLE:          version: 5
+; LINE-TABLE:     address_size: 8
+; LINE-TABLE:  seg_select_size: 0
+; LINE-TABLE:  prologue_length: 0x00000037
+
+; LINE-TABLE:      Address            Line   Column File   ISA Discriminator Flags
+; LINE-TABLE-NEXT: ------------------ ------ ------ ------ --- ------------- -------------
+; LINE-TABLE-NEXT: 0x0000000000000000      4      0      0   0             0  is_stmt
+; LINE-TABLE-NEXT: 0x0000000000000001      5      9      0   0             0  is_stmt prologue_end
+; LINE-TABLE-NEXT: 0x0000000000000004      5      7      0   0             0 
+; LINE-TABLE-NEXT: 0x0000000000000006      6     12      0   0             0  is_stmt
+; LINE-TABLE-NEXT: 0x000000000000000b      9      1      0   0             0  is_stmt epilogue_begin
+; LINE-TABLE-NEXT: 0x000000000000000d      8     12      0   0             0  is_stmt
+; LINE-TABLE-NEXT: 0x0000000000000012      9      1      0   0             0  is_stmt epilogue_begin
+; LINE-TABLE-NEXT: 0x0000000000000014      9      1      0   0             0  is_stmt end_sequence
+
+
+
+
+; Function Attrs: mustprogress uwtable
+define dso_local noundef i32 @_Z3fooi(i32 noundef %a) local_unnamed_addr #0 !dbg !8 {
+entry:
+  call void @llvm.dbg.value(metadata i32 %a, metadata !13, metadata !DIExpression()), !dbg !14
+  %cmp = icmp sgt i32 %a, 20, !dbg !15
+  br i1 %cmp, label %if.then, label %if.else, !dbg !17
+
+if.then:                                          ; preds = %entry
+  %call = call noundef i32 @_Z3barv(), !dbg !18
+  br label %return, !dbg !19
+
+if.else:                                          ; preds = %entry
+  %call1 = call noundef i32 @_Z3bazv(), !dbg !20
+  br label %return, !dbg !21
+
+return:                                           ; preds = %if.else, %if.then
+  %retval.0 = phi i32 [ %call, %if.then ], [ %call1, %if.else ], !dbg !22
+  ret i32 %retval.0, !dbg !23
+}
+
+declare !dbg !24 dso_local noundef i32 @_Z3barv() local_unnamed_addr #1
+
+declare !dbg !28 dso_local noundef i32 @_Z3bazv() local_unnamed_addr #1
+
+; Function Attrs: nofree nosync nounwind readnone speculatable willreturn
+declare void @llvm.dbg.value(metadata, metadata, metadata) #2
+
+!llvm.dbg.cu = !{!0}
+!llvm.module.flags = !{!2, !3, !4, !5, !6}
+!llvm.ident = !{!7}
+
+!0 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus_14, file: !1, producer: "clang version 15.0.0", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, splitDebugInlining: false, nameTableKind: None)
+!1 = !DIFile(filename: "q.cpp", directory: "/", checksumkind: CSK_MD5, checksum: "6b5f6118d466ba2f6510ac0790b09bef")
+!2 = !{i32 7, !"Dwarf Version", i32 5}
+!3 = !{i32 2, !"Debug Info Version", i32 3}
+!4 = !{i32 1, !"wchar_size", i32 4}
+!5 = !{i32 7, !"uwtable", i32 2}
+!6 = !{i32 7, !"frame-pointer", i32 2}
+!7 = !{!"clang version 15.0.0"}
+!8 = distinct !DISubprogram(name: "foo", linkageName: "_Z3fooi", scope: !1, file: !1, line: 4, type: !9, scopeLine: 4, flags: DIFlagPrototyped | DIFlagAllCallsDescribed, spFlags: DISPFlagDefinition | DISPFlagOptimized, unit: !0, retainedNodes: !12)
+!9 = !DISubroutineType(types: !10)
+!10 = !{!11, !11}
+!11 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
+!12 = !{!13}
+!13 = !DILocalVariable(name: "a", arg: 1, scope: !8, file: !1, line: 4, type: !11)
+!14 = !DILocation(line: 0, scope: !8)
+!15 = !DILocation(line: 5, column: 9, scope: !16)
+!16 = distinct !DILexicalBlock(scope: !8, file: !1, line: 5, column: 7)
+!17 = !DILocation(line: 5, column: 7, scope: !8)
+!18 = !DILocation(line: 6, column: 12, scope: !16)
+!19 = !DILocation(line: 6, column: 5, scope: !16)
+!20 = !DILocation(line: 8, column: 12, scope: !16)
+!21 = !DILocation(line: 8, column: 5, scope: !16)
+!22 = !DILocation(line: 0, scope: !16)
+!23 = !DILocation(line: 9, column: 1, scope: !8)
+!24 = !DISubprogram(name: "bar", linkageName: "_Z3barv", scope: !1, file: !1, line: 1, type: !25, flags: DIFlagPrototyped, spFlags: DISPFlagOptimized, retainedNodes: !27)
+!25 = !DISubroutineType(types: !26)
+!26 = !{!11}
+!27 = !{}
+!28 = !DISubprogram(name: "baz", linkageName: "_Z3bazv", scope: !1, file: !1, line: 2, type: !25, flags: DIFlagPrototyped, spFlags: DISPFlagOptimized, retainedNodes: !27)

llvm/test/DebugInfo/X86/stmt-list-multiple-compile-units.ll

 ; CHECK: DW_AT_stmt_list [DW_FORM_sec_offset]   (0x00000000)
 ; CHECK: DW_AT_low_pc [DW_FORM_addr]            (0x0000000000000000)
 ; CHECK: DW_AT_high_pc [DW_FORM_data4]          (0x00000010)
 ; CHECK: DW_TAG_subprogram
 ; CHECK: DW_AT_low_pc [DW_FORM_addr]            (0x0000000000000000)
 ; CHECK: DW_AT_high_pc [DW_FORM_data4]          (0x00000010)
 
 ; CHECK: DW_TAG_compile_unit
-; CHECK: DW_AT_stmt_list [DW_FORM_sec_offset]   (0x0000003d)
+; CHECK: DW_AT_stmt_list [DW_FORM_sec_offset]   (0x00000040)
 ; CHECK: DW_AT_low_pc [DW_FORM_addr]            (0x0000000000000010)
 ; CHECK: DW_AT_high_pc [DW_FORM_data4]          (0x00000009)
 ; CHECK: DW_TAG_subprogram
 ; CHECK: DW_AT_low_pc [DW_FORM_addr]            (0x0000000000000010)
 ; CHECK: DW_AT_high_pc [DW_FORM_data4]          (0x00000009)
 
 
 ; CHECK: .debug_line contents:
 ; CHECK-NEXT: debug_line[{{.*}}]
 ; CHECK-NEXT: Line table prologue:
-; CHECK-NEXT: total_length: 0x00000039
+; CHECK-NEXT: total_length: 0x0000003c
 ; CHECK: file_names[  1]:
 ; CHECK-NEXT: name: "simple.c"
 ; CHECK-NEXT: dir_index: 0
 ; CHECK: debug_line[{{.*}}]
 ; CHECK-NEXT: Line table prologue:
 ; CHECK-NEXT: total_length: 0x0000003a
 ; CHECK: file_names[  1]:
 ; CHECK-NEXT: name: "simple2.c"
 ; CHECK-NEXT: dir_index: 0
 ; CHECK-NOT: file_names
 
 ; DWARF3: .debug_info contents:
 ; DWARF3: DW_TAG_compile_unit
 ; DWARF3: DW_AT_stmt_list [DW_FORM_data4]    (0x00000000)
 
 ; DWARF3: DW_TAG_compile_unit
-; DWARF3: DW_AT_stmt_list [DW_FORM_data4]   (0x0000003c)
+; DWARF3: DW_AT_stmt_list [DW_FORM_data4]   (0x0000003f)
 
 
 ; DWARF3: .debug_line contents:
 ; DWARF3-NEXT: debug_line[{{.*}}]
 ; DWARF3-NEXT: Line table prologue:
-; DWARF3-NEXT: total_length: 0x00000038
+; DWARF3-NEXT: total_length: 0x0000003b
 ; DWARF3: file_names[  1]:
 ; DWARF3-NEXT: name: "simple.c"
 ; DWARF3-NEXT: dir_index: 0
 ; DWARF3: debug_line[{{.*}}]
 ; DWARF3-NEXT: Line table prologue:
 ; DWARF3-NEXT: total_length: 0x00000039
 ; DWARF3: file_names[  1]:
 ; DWARF3-NEXT: name: "simple2.c"