DwarfDebug: Pick next location in case of missing location at block begin

[MatzeB]

Summary

Context: Compiler generated instructions do not have a debug location
assigned to them. However emitting 0-line records for all of them bloats
the line tables for very little benefit so we usually avoid doing that.

Not emitting anything will lead to the previous debug location getting
applied to the locationless instructions. This is not desirable for
block begin and after labels. Previously we would emit simply emit
line-0 records in this case, this patch changes the behavior to do a
forward search for a debug location in these cases before emitting a
line-0 record to further reduce line table bloat.

Inspired by the discussion in https://reviews.llvm.org/D52125

[MatzeB]

Comparing two test-suite builds gives me:

Tests: 1010
Metric: size

Program                                         base   changes diff

SingleSour...itTests/SignlessTypes/cast-bug    4600   4608     0.2%
SingleSour...tTests/ms_struct_pack_layout-1    4632   4640     0.2%
SingleSour...tTests/2010-05-24-BitfieldTest    4632   4640     0.2%
SingleSour...ion-C-2003-06-16-VolatileError    4720   4728     0.2%
SingleSour...egression-C-pointer_arithmetic    4864   4872     0.2%
SingleSour...ression/C/Regression-C-PR10189    5552   5560     0.1%
MultiSourc...enchmarks/VersaBench/dbms/dbms    50456  50504    0.1%
SingleSour...nitTests/2006-12-01-float_varg    8800   8808     0.1%
SingleSour...nitTests/2003-10-13-SwitchTest    8800   8808     0.1%
SingleSour...tTests/2007-04-10-BitfieldTest    8808   8816     0.1%
SingleSour...ession-C-2008-01-07-LongDouble    8832   8840     0.1%
SingleSour...s/Shootout/Shootout-nestedloop    8840   8848     0.1%
SingleSour.../2004-06-20-StaticBitfieldInit    8880   8888     0.1%
SingleSour...sion-C-2004-03-15-IndirectGoto    8888   8896     0.1%
SingleSour...UnitTests/2002-08-02-CastTest2    8896   8904     0.1%
               base       changes         diff
count  1.010000e+03  1.010000e+03  1010.000000
mean   1.773759e+05  1.773819e+05  0.000102
std    8.762489e+05  8.762656e+05  0.000246
min    4.600000e+03  4.608000e+03  0.000000
25%    1.456500e+04  1.456500e+04  0.000000
50%    6.281800e+04  6.283400e+04  0.000000
75%    9.593600e+04  9.593600e+04  0.000023
max    1.585930e+07  1.585930e+07  0.001739

> 0.1% smaller files on average.

[vsk]

The core idea and test updates look good to me. I'm curious about the size changes: are you just measuring the size of executables, or of .o's? If it's the former, on Darwin, any size change resulting from this patch might indicate bugs.

lib/CodeGen/AsmPrinter/DwarfDebug.cpp

1317

Why not use MachineBasicBlock::findDebugLoc?

1344

DebugLoc is pointer-sized, so it's fine to just copy it instead of returning a reference. This might create a little extra traffic through TrackingMDRef's operator=, but in the common case I'd expect the optimizer to get rid of most of it.

[MatzeB]

In D52862#1255529, @vsk wrote:

The core idea and test updates look good to me. I'm curious about the size changes: are you just measuring the size of executables, or of .o's? If it's the former, on Darwin, any size change resulting from this patch might indicate bugs.

I measured executable sizes. I tried some flags of llvm-size or llvm-dwarfdump but could not figure out how to measure the size of the line tables directly...

[vsk]

In D52862#1255533, @MatzeB wrote:

In D52862#1255529, @vsk wrote:

The core idea and test updates look good to me. I'm curious about the size changes: are you just measuring the size of executables, or of .o's? If it's the former, on Darwin, any size change resulting from this patch might indicate bugs.

I measured executable sizes.

Ah, ok. Well, we know we have more work to do to eliminate codegen differences with/without debug info. We're planning on discussing this at the debug info BoF. (It's not a blocker for this patch.)

I tried some flags of llvm-size or llvm-dwarfdump but could not figure out how to measure the size of the line tables directly...

You can look at the .dSYMs or .o's if you have those around:
$ size -m main.dSYM/Contents/Resources/DWARF/main | grep debug_line
Section __debug_line: 60

[dblaikie]

In D52862#1255533, @MatzeB wrote:

In D52862#1255529, @vsk wrote:

The core idea and test updates look good to me. I'm curious about the size changes: are you just measuring the size of executables, or of .o's? If it's the former, on Darwin, any size change resulting from this patch might indicate bugs.

I measured executable sizes. I tried some flags of llvm-size or llvm-dwarfdump but could not figure out how to measure the size of the line tables directly...

llvm-objdump -h is what I usually use. 'bloaty' (a 3rd party tool) does slightly more precise accounting, though (can account for object file headers, etc), but only ELF I think. Be sure to measure both the section and the .rela section containing the relocations - though I suppose your change shouldn't be changing the number of relocations.

(& absolute changes - compared to the file size as a whole, as well as changes within the section are useful measures)

[MatzeB]

In D52862#1255543, @vsk wrote:

In D52862#1255533, @MatzeB wrote:

In D52862#1255529, @vsk wrote:

The core idea and test updates look good to me. I'm curious about the size changes: are you just measuring the size of executables, or of .o's? If it's the former, on Darwin, any size change resulting from this patch might indicate bugs.

I measured executable sizes.

Ah, ok. Well, we know we have more work to do to eliminate codegen differences with/without debug info. We're planning on discussing this at the debug info BoF. (It's not a blocker for this patch.)

The actual instructions are exactly the same, at least in the couple examples I picked.

I tried some flags of llvm-size or llvm-dwarfdump but could not figure out how to measure the size of the line tables directly...

You can look at the .dSYMs or .o's if you have those around:
$ size -m main.dSYM/Contents/Resources/DWARF/main | grep debug_line
Section __debug_line: 60

There are no .dSYM files around, should there be? Example compilation of 1 of the benchmarks:

$ /var/tmp/locbase/bin/clang -DNDEBUG  -save-temps=obj   -O0 -g -isysroot /Volumes/XCode/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX10.14.sdk   -w -Werror=date-time -MD -MT SingleSource/Benchmarks/Misc/CMakeFiles/pi.dir/pi.c.o -MF SingleSource/Benchmarks/Misc/CMakeFiles/pi.dir/pi.c.o.d -o SingleSource/Benchmarks/Misc/CMakeFiles/pi.dir/pi.c.o   -c /Users/mbraun/dev/test-suite/SingleSource/Benchmarks/Misc/pi.c
$ /var/tmp/locbase/bin/clang -save-temps=obj   -O0 -g -isysroot /Volumes/XCode/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX10.14.sdk -Wl,-search_paths_first -Wl,-headerpad_max_install_names  SingleSource/Benchmarks/Misc/CMakeFiles/pi.dir/pi.c.o  -o SingleSource/Benchmarks/Misc/pi  -Wl,-no_pie -lm

lib/CodeGen/AsmPrinter/DwarfDebug.cpp

1317

As far as I can tell findDebugLoc will only give you the DebugLoc of the next non-DEBUG_VALUE instruction. This here will work better if there are mutliple instructions without DebugLoc in sequence.

[MatzeB]

lib/CodeGen/AsmPrinter/DwarfDebug.cpp

1344

I was trying to avoid unnecessary refcounting operations. But I'd happy change this to DebugLoc DL as that indeed makes the code look simpler.

[vsk]

In D52862#1255547, @MatzeB wrote:

In D52862#1255543, @vsk wrote:

In D52862#1255533, @MatzeB wrote:

In D52862#1255529, @vsk wrote:

The core idea and test updates look good to me. I'm curious about the size changes: are you just measuring the size of executables, or of .o's? If it's the former, on Darwin, any size change resulting from this patch might indicate bugs.

I measured executable sizes.

Ah, ok. Well, we know we have more work to do to eliminate codegen differences with/without debug info. We're planning on discussing this at the debug info BoF. (It's not a blocker for this patch.)

The actual instructions are exactly the same, at least in the couple examples I picked.

Hm, I wonder what changed, then.

I tried some flags of llvm-size or llvm-dwarfdump but could not figure out how to measure the size of the line tables directly...

You can look at the .dSYMs or .o's if you have those around:
$ size -m main.dSYM/Contents/Resources/DWARF/main | grep debug_line
Section __debug_line: 60

There are no .dSYM files around, should there be?

On macOS, typically, yes. You can check whether or not your compiler is doing this with: xcrun clang -g -x c - -o - '-###'. The last step is usually a dsymutil link.

Is it possible that your test harness is removing .dSYMs? .. ah, no, what's happening is that clang declines to add a dsymutil step when it's being used to link .o's into an executable.

Maybe it'd be easier to run measurements on the .o's?

Example compilation of 1 of the benchmarks:

$ /var/tmp/locbase/bin/clang -DNDEBUG  -save-temps=obj   -O0 -g -isysroot /Volumes/XCode/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX10.14.sdk   -w -Werror=date-time -MD -MT SingleSource/Benchmarks/Misc/CMakeFiles/pi.dir/pi.c.o -MF SingleSource/Benchmarks/Misc/CMakeFiles/pi.dir/pi.c.o.d -o SingleSource/Benchmarks/Misc/CMakeFiles/pi.dir/pi.c.o   -c /Users/mbraun/dev/test-suite/SingleSource/Benchmarks/Misc/pi.c
$ /var/tmp/locbase/bin/clang -save-temps=obj   -O0 -g -isysroot /Volumes/XCode/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX10.14.sdk -Wl,-search_paths_first -Wl,-headerpad_max_install_names  SingleSource/Benchmarks/Misc/CMakeFiles/pi.dir/pi.c.o  -o SingleSource/Benchmarks/Misc/pi  -Wl,-no_pie -lm

[vsk]

lib/CodeGen/AsmPrinter/DwarfDebug.cpp

1317

Sounds good.

[MatzeB]

Is it possible that your test harness is removing .dSYMs? .. ah, no, what's happening is that clang declines to add a dsymutil step when it's being used to link .o's into an executable.

So I assume when linking .o files the debug information is still part of the executable afterwards. And running dsymutil is an optional step that a buildsystem can do to split up the dwarf data into a .dSYM...

[vsk]

In D52862#1255596, @MatzeB wrote:

Is it possible that your test harness is removing .dSYMs? .. ah, no, what's happening is that clang declines to add a dsymutil step when it's being used to link .o's into an executable.

So I assume when linking .o files the debug information is still part of the executable afterwards. And running dsymutil is an optional step that a buildsystem can do to split up the dwarf data into a .dSYM...

That's how it works on most non-Apple platforms, I think. ld64 is different in that it doesn't copy any debug info into the final executable: it just embeds pointers to .o's in the mach-o header. Later, the debugger (or dsymutil) can find debug info for the program by chasing these pointers.

[MatzeB]

That explains why I couldn't find those line tables in the executables :)

So here's a comparison of the line table sections in the .o files:

Tests: 5100
Metric: size.__DWARF_debug_line

Program                                         debug_line  debug_line0 diff

External/S...PU2006/403.gcc/src/insn-opinit    9345        6081        -34.9%
External/S...ec/CPU2006/458.sjeng/src/sjeng    4829        3529        -26.9%
External/S...pec/CPU2006/458.sjeng/src/eval    4524        3353        -25.9%
External/S...spec/CINT95/124.m88ksim/src/go    1622        1208        -25.5%
MultiSourc...Files/timberwolfmc.dir/findloc    4667        3488        -25.3%
External/S...CINT2000/186.crafty/src/option    20585       15408       -25.1%
External/S...U2006/403.gcc/src/insn-attrtab    198287      148800      -25.0%
External/S...nchspec/CINT95/099.go/src/g27a    5325        4025        -24.4%
External/S...nchspec/CINT95/099.go/src/g27b    2073        1567        -24.4%
External/S...c/CINT2000/186.crafty/src/time    2405        1819        -24.4%
MultiSourc...CMakeFiles/compiler.dir/parser    7185        5443        -24.2%
External/S...ec/CPU2006/458.sjeng/src/moves    18948       14424       -23.9%
External/S...c/CINT2000/254.gap/src/scanner    8954        6840        -23.6%
External/S...enchspec/CINT95/099.go/src/g25    41351       31651       -23.5%
External/S...c/CINT2000/186.crafty/src/edit    1649        1263        -23.4%
          debug_line    debug_line0         diff
count  5100.000000    5100.000000    5100.000000
mean   7859.688627    7537.172157   -0.030294
std    17028.127781   16122.239159   0.044775
min    135.000000     136.000000    -0.349278
25%    1242.000000    1200.750000   -0.043018
50%    3508.500000    3341.000000   -0.012748
75%    9079.500000    8857.750000    0.000462
max    521041.000000  515397.000000  0.025559

So it's an average 3% reduction of the line table section ranging from -2% to 35% reduction. (Looking at the few size increases I see less .loc files in the assembly diff, so I suspect it is just an effect of the directory name being 1 character longer in the patched version...)

[vsk]

Looks great, thanks!

lib/CodeGen/AsmPrinter/DwarfDebug.cpp

1344

I don't feel strongly about this, I'll leave it to you.

[MatzeB]

lib/CodeGen/AsmPrinter/DwarfDebug.cpp

1344

I reorganized the code a bit so I don't need to switch to a pointer for reassignment and we can keep using a const reference.

[MatzeB]

Landed in rL343874

lib/CodeGen/AsmPrinter/DwarfDebug.cpp

if (auto *DV = dyn_cast<DILocalVariable>(DN)) {
       Scope = LScopes.findLexicalScope(DL->getScope());
     }
 
     if (Scope)
       createConcreteEntity(TheCU, *Scope, DN, nullptr);
   }
 }
 
+static const DebugLoc &
+findNextDebugLoc(MachineBasicBlock::const_iterator MBBI,
+                 MachineBasicBlock::const_iterator MBBE) {
+  static DebugLoc NoLocation;
+  for ( ; MBBI != MBBE; ++MBBI) {
+    if (MBBI->isDebugInstr())
+      continue;
+    const DebugLoc &DL = MBBI->getDebugLoc();
+    if (DL)
+      return DL;
+  }
+  return NoLocation;
+}
+
 // Process beginning of an instruction.
 void DwarfDebug::beginInstruction(const MachineInstr *MI) {
   DebugHandlerBase::beginInstruction(MI);
   assert(CurMI);
 
   const auto *SP = MI->getMF()->getFunction().getSubprogram();
   if (!SP || SP->getUnit()->getEmissionKind() == DICompileUnit::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();
+  const DebugLoc *DL = &MI->getDebugLoc();
   // 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 (*DL == PrevInstLoc) {
     // If we have an ongoing unspecified location, nothing to do here.
-    if (!DL)
+    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) {
       // Reinstate the source location but not marked as a statement.
-      const MDNode *Scope = DL.getScope();
-      recordSourceLine(DL.getLine(), DL.getCol(), Scope, /*Flags=*/0);
+      const MDNode *Scope = DL->getScope();
+      recordSourceLine(DL->getLine(), DL->getCol(), Scope, /*Flags=*/0);
     }
     return;
   }
 
-  if (!DL) {
+  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)
       return;
+    // By default we emit nothing to avoid line table bloat. However at the
+    // beginning of a basic block or after a label it is undesirable to let
+    // the previous location unchanged. In these cases do a forward search for
+    // the next valid debug location.
+    if (UnknownLocations == Default) {
+      const MachineBasicBlock &MBB = *MI->getParent();
+      if (PrevLabel || PrevInstBB != &MBB) {
+        DL = &findNextDebugLoc(MI->getIterator(), MBB.end());
+      } else {
+        return;
+      }
+    }
+    if (!*DL) {
       // If user said Don't Do That, don't do that.
       if (UnknownLocations == Disable)
         return;
-    // See if we have a reason to emit a line-0 record now.
-    // Reasons to emit a line-0 record include:
-    // - User asked for it (UnknownLocations).
-    // - Instruction has a label, so it's referenced from somewhere else,
-    //   possibly debug information; we want it to have a source location.
-    // - Instruction is at the top of a block; we don't want to inherit the
-    //   location from the physically previous (maybe unrelated) block.
-    if (UnknownLocations == Enable || PrevLabel ||
-        (PrevInstBB && PrevInstBB != MI->getParent())) {
+      // Emit a line-0 record now.
       // Preserve the file and column numbers, if we can, to save space in
       // the encoded line table.
       // Do not update PrevInstLoc, it remembers the last non-0 line.
       const MDNode *Scope = nullptr;
       unsigned Column = 0;
       if (PrevInstLoc) {
         Scope = PrevInstLoc.getScope();
         Column = PrevInstLoc.getCol();
       }
       recordSourceLine(/*Line=*/0, Column, Scope, /*Flags=*/0);
-    }
       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 (PrevInstLoc && DL.getLine() == 0 && LastAsmLine == 0)
+  unsigned Line = DL->getLine();
+  if (PrevInstLoc && Line == 0 && LastAsmLine == 0)
     return;
   unsigned Flags = 0;
-  if (DL == PrologEndLoc) {
+  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)
+  if (Line && Line != OldLine)
     Flags |= DWARF2_FLAG_IS_STMT;
 
-  const MDNode *Scope = DL.getScope();
-  recordSourceLine(DL.getLine(), DL.getCol(), Scope, Flags);
+  const MDNode *Scope = DL->getScope();
+  recordSourceLine(Line, DL->getCol(), Scope, Flags);
 
   // If we're not at line 0, remember this location.
-  if (DL.getLine())
-    PrevInstLoc = DL;
+  if (Line)
+    PrevInstLoc = *DL;
 }
 
 static DebugLoc findPrologueEndLoc(const MachineFunction *MF) {
   // First known non-DBG_VALUE and non-frame setup location marks
   // the beginning of the function body.
   for (const auto &MBB : *MF)
     for (const auto &MI : MBB)
       if (!MI.isMetaInstruction() && !MI.getFlag(MachineInstr::FrameSetup) &&

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: 0x0000003f
+CHECK: total_length: 0x0000003c

test/DebugInfo/ARM/single-constant-use-preserves-dbgloc.ll

 
 if.then:                                          ; preds = %entry
   %1 = load i32, i32* %x, align 4, !dbg !17
   store i32 %1, i32* %retval, !dbg !18
   br label %return, !dbg !18
 
 if.end:                                           ; preds = %entry
 ; Materialize the constant.
-; CHECK:      .loc    1 0
+; CHECK:      .loc    1 7 5
 ; CHECK-NEXT: mvn     r0, #0
 
 ; The backend performs the store to %retval first, for some reason.
-; CHECK-NEXT: .loc    1 7 5
 ; CHECK-NEXT: str     r0, [sp, #4]
   store i32 -1, i32* %x, align 4, !dbg !19
 
 ; CHECK-NEXT: .loc    1 6 7
 ; CHECK-NEXT: str     r0, [sp]
   store i32 -1, i32* %retval, !dbg !20
   br label %return, !dbg !20
 

test/DebugInfo/Mips/delay-slot.ll

 ; }
 
 ; CHECK: Address            Line   Column File   ISA Discriminator Flags
 ; CHECK: ------------------ ------ ------ ------ --- ------------- -------------
 ; CHECK: 0x0000000000000000      1      0      1   0             0  is_stmt
 ; CHECK: 0x0000000000000004      2      0      1   0             0  is_stmt prologue_end
 ; CHECK: 0x0000000000000024      3      0      1   0             0  is_stmt
 ; CHECK: 0x0000000000000034      4      0      1   0             0  is_stmt
-; CHECK: 0x0000000000000048      5      0      1   0             0  is_stmt
+; CHECK: 0x0000000000000044      5      0      1   0             0  is_stmt
 ; CHECK: 0x0000000000000058      5      0      1   0             0  is_stmt end_sequence
 
 
 target datalayout = "E-m:m-p:32:32-i8:8:32-i16:16:32-i64:64-n32-S64"
 target triple = "mips--linux-gnu"
 
 ; Function Attrs: nounwind
 define i32 @foo(i32 %x) #0 !dbg !4 {

test/DebugInfo/NVPTX/debug-info.ll

 ; CHECK: .loc [[BUILTUIN_VARS_H]] 67 180
 ; CHECK: mov.u32         %r{{.+}}, %tid.x;
 ; CHECK: .loc [[DEBUG_INFO_CU]] 6 35
 ; CHECK: mad.lo.s32      %r{{.+}}, %r{{.+}}, %r{{.+}}, %r{{.+}};
 ; CHECK: .loc [[DEBUG_INFO_CU]] 7 9
 ; CHECK: setp.ge.s32     %p{{.+}}, %r{{.+}}, %r{{.+}};
 ; CHECK: .loc [[DEBUG_INFO_CU]] 7 7
 ; CHECK: @%p{{.+}} bra   [[BB:.+]];
+; CHECK: .loc [[DEBUG_INFO_CU]] 8 13
 ; CHECK: ld.param.f32    %f{{.+}}, [{{.+}}];
 ; CHECK: ld.param.u64    %rd{{.+}}, [{{.+}}];
 ; CHECK: cvta.to.global.u64      %rd{{.+}}, %rd{{.+}};
 ; CHECK: ld.param.u64    %rd{{.+}}, [{{.+}}];
 ; CHECK: cvta.to.global.u64      %rd{{.+}}, %rd{{.+}};
 ; CHECK: mul.wide.u32    %rd{{.+}}, %r{{.+}}, 4;
 ; CHECK: add.s64         %rd{{.+}}, %rd{{.+}}, %rd{{.+}};
-; CHECK: .loc [[DEBUG_INFO_CU]] 8 13
 ; CHECK: ld.global.f32   %f{{.+}}, [%rd{{.+}}];
 ; CHECK: add.s64         %rd{{.+}}, %rd{{.+}}, %rd{{.+}};
 ; CHECK: .loc [[DEBUG_INFO_CU]] 8 19
 ; CHECK: ld.global.f32   %f{{.+}}, [%rd{{.+}}];
 ; CHECK: .loc [[DEBUG_INFO_CU]] 3 82
 ; CHECK: fma.rn.f32      %f{{.+}}, %f{{.+}}, %f{{.+}}, %f{{.+}};
 ; CHECK: .loc [[DEBUG_INFO_CU]] 3 78
 ; CHECK: st.global.f32   [%rd{{.+}}], %f{{.+}};

test/DebugInfo/X86/dwarf-no-source-loc.ll

if.then:                                          ; preds = %entry
   call void @_Z3barPi(i32* %z), !dbg !9
   br label %if.end, !dbg !9
 
 if.end:                                           ; preds = %if.then, %entry
   call void @_Z3bazPi(i32* %z), !dbg !12
   ret void, !dbg !14
 }
 
-; CHECK:      .loc 1 7 7
+; CHECK:      .loc 1 7 7 prologue_end
 ; CHECK-NOT:  .loc
-; CHECK:      .loc 1 0 7 is_stmt 0
+; CHECK:      # %bb.1
+; CHECK-NEXT: .file 2 "/tests/include.h"
+; CHECK-NEXT: .loc 2 20 5
 ; CHECK-NOT:  .loc
-; CHECK:      .loc 2 20 5 is_stmt 1
 ; CHECK:      .LBB0_2:
-; CHECK-NEXT: .loc 2 0 5 is_stmt 0
-; CHECK-NOT:  .loc
-; CHECK:      .loc 1 10 3 is_stmt 1
+; CHECK:      .loc 1 10 3
 ;
 ; DISABLE-NOT: .loc 1 0
 
 declare void @_Z3barPi(i32*)
 
 declare void @_Z3bazPi(i32*)
 
 !llvm.dbg.cu = !{!0}

test/DebugInfo/X86/dwarf-no-source-loc.mir

+# RUN: llc -o - %s -start-before=patchable-function -use-unknown-locations=Default | FileCheck %s --check-prefixes=CHECK,DEFAULT
+# RUN: llc -o - %s -start-before=patchable-function -use-unknown-locations=Enable | FileCheck %s --check-prefixes=CHECK,ENABLE
+# RUN: llc -o - %s -start-before=patchable-function -use-unknown-locations=Disable | FileCheck %s --check-prefixes=CHECK,DISABLE
+--- |
+  target triple = "x86_64--"
+  
+  !0 = !DIFile(filename: "dwarf-no-source-loc.mir", directory: "/")
+  !1 = distinct !DICompileUnit(file: !0, language: DW_LANG_C, emissionKind: LineTablesOnly)
+  !2 = distinct !DISubprogram(name: "func", unit: !1)
+  !3 = !DILocation(line: 17, scope: !2)
+  !4 = !DILocation(line: 42, scope: !2)
+
+  !llvm.dbg.cu = !{!1}
+  !llvm.module.flags = !{!10, !11}
+  !10 = !{i32 2, !"Dwarf Version", i32 4}
+  !11 = !{i32 2, !"Debug Info Version", i32 3}
+  
+  define void @func() !dbg !2 {
+    unreachable
+  }
+...
+---
+name: func
+body: |
+  bb.0:
+    NOOP
+    NOOP
+    $eax = MOV32ri 1, debug-location !3
+    ; CHECK-LABEL: bb.0
+    ; CHECK: nop
+    ; CHECK: nop
+    ; CHECK: .loc 1 17 0 prologue_end
+    ; CHECK: movl $1, %eax
+
+  bb.1:
+    NOOP
+    $ebx = MOV32ri 2, debug-location !4
+    ; CHECK-LABEL: bb.1
+    ; DEFAULT: .loc 1 42 0
+    ; ENABLE: .loc 1 0
+    ; DISABLE-NOT: .loc 1 0
+    ; CHECK: nop
+    ; ENABLE: .loc 1 42 0
+    ; CHECK: movl $2, %ebx
+
+  bb.2:
+    NOOP
+    ; CHECK-LABEL: bb.2
+    ; DEFAULT: .loc 1 0 0 is_stmt 0
+    ; ENABLE: .loc 1 0 0 is_stmt 0
+    ; DISABLE-NOT: .loc 1 0
+    ; CHECK: nop
+
+  bb.3:
+    NOOP
+    $ecx = MOV32ri 3, debug-location !3
+    ; CHECK-LABEL: bb.3
+    ; CHECK: nop
+    ; DEFAULT: .loc 1 17 0 is_stmt 1
+    ; ENABLE: .loc 1 17 0 is_stmt 1
+    ; DISABLE-NOT: .loc 1 0
+    ; CHECK: movl $3, %ecx
+
+  bb.4:
+    NOOP
+    $edx = MOV32ri 4, debug-location !4
+    ; CHECK: bb.4
+    ; DEFAULT: .loc 1 42 0
+    ; ENABLE: .loc 1 0 0 is_stmt 0
+    ; DISABLE-NOT: .loc 1 0
+    ; CHECK: nop
+    ; ENABLE: .loc 1 42 0 is_stmt 1
+    ; CHECK: movl $4, %edx
+...