Emit 'no line' information for interesting 'orphan' instructions

[probinson]

Summary

(Based on D16569 by friss; that revision was 'abandoned' so I needed to
create a new one. The following description is derived from his.)

There will always be instructions with no line information attached.
One example is the LocalValue constants generated by FastISel, but
it's by far not the only one. Compiler generated code will have no
line info and might get inlined. SelectionDAG is full of nodes that
won't have any line information (because they could be shared).

Multiple attempts have been made over time to fix the FastISel issue,
but none have felt satisfactory enough to be committed. As the problem
is much more general than just FastISel, this patch addresses it
at line table emission time rather than instruction selection time.

It also doesn't try to give accurate line information for these
instructions, but rather marks them with a 'no line' indicator so that
the debugger can safely ignore them.

The implemented heuristic will add 'no line' information to every insn
without explicit line information and either:

• at the beginning of a basic-block
• first instruction after a label

The first condition handles the FastISel case, while the second
enforces that any instruction referenced by anything (including debug
info) has line information.

The patch handles both DWARF and Codeview, using line number 0 for
DWARF and the reserved 'NeverStepIntoLineNumber' value for Codeview.
(I know almost nothing about Codeview so that might not be best...)

The initial measurements on DWARF line table size show an impact
between 5% and 15% (the latter is for a control-flow heavy code
eg. ASANified).

There was already an option to use DWARF 'line 0' information for all
the instructions with no debug locations. The commit history for this
code show that it was disabled because it caused issues with GDB and
with the line table size. Note that this code was unconditionally
emitting the line 0 information and not using a heuristic to find
interesting instructions like this one.

This patch has been tested on GDB-7.8 and current LLDB (pretty
sure I got the LLDB part right, but it's hard to tell). GDB showed no
differences, and LLDB had one XPASS (but I am not sure that isn't
just a fluke, as it was 'test_process_interrupt_dwarf' and I've had
flakiness problems with GDB thread-related tests in the past).
I don't know how to test the Codeview side.

[probinson]

Ping.

[rnk]

I don't know if you have the time or interest in doing this, but here's how I'd test the codeview side.

First, compile something like a main function with ~5 volatile stores to a .s file with clang -g -gcodeview foo.c -o foo.s. Manually insert nops and .cv_loc directives in between the stores. Assemble it and link it into a complete program with clang. Run windbg -Q foo.exe, break on foo!main, and step by line from there and see what happens.

Once we do that, then we can know what NeverStepIntoLineNumber really does. Right now, I have no idea what it does, and without some information about that, I'd rather not record anything for these kinds of instructions so that we can have more compact line tables.

[probinson]

Thanks for the codeview recipe! I'll try that when I get a chance.

[probinson]

In D24180#545101, @rnk wrote:

I don't know if you have the time or interest in doing this, but here's how I'd test the codeview side.

Even with spending most of a day on it, I completely fail at getting windbg to find 'main' and set a breakpoint. Even for a test program built with Visual Studio, I can't figure out how to persuade windbg to find the symbols.

Once we do that, then we can know what NeverStepIntoLineNumber really does. Right now, I have no idea what it does, and without some information about that, I'd rather not record anything for these kinds of instructions so that we can have more compact line tables.

I guess that means I should undo the CV parts of this patch.

We will need to figure out *something* for CV, because it is already the case that some places are explicitly setting a DebugLoc with line 0, and actually emitting line 0 into CV seems like the wrong result.

[probinson]

Updated patch to take care of four things.

1. Internal testing came up with situations where the patch would emit multiple line-0 records in a row. We now avoid that.

2. We also found cases along these lines:

.loc 1 9 0
instr1
instr2
.loc 1 0 0
instr3
.loc 1 9 0
instr4

The naive statement-marking algorithm would put is_stmt 1 on both instr1 and instr4, which is not good for debugging. The updated patch detects this situation and puts is_stmt 0 on instr4.

3. We aren't sure what to emit for CodeView, so as advised by @rnk this patch now does nothing for CodeView.

4. The updated patch exposed an inadvertent flaw in test/CodeGen/X86/stack-protector.ll where a function marked as having debug info actually had no source location attached to any instructions. This led to emitting .loc 1 0 0 prologue_end which is obviously flawed. Attaching an actual source location to one of the instructions emits a much more sensible line table.

[rnk]

I'm fine leaving CV alone for now until we learn more.

lib/CodeGen/AsmPrinter/DebugHandlerBase.h

45

If you initialize this here to nullptr, you don't have to change the constructor.

[dblaikie]

Haven't fully followed the change, but did some tests at least - about a 7-7.5% regression (compressed or uncompressed) on a large program at Google. The line table's already larger (in absolute, and relative to the .text size (which is about about 11% smaller for LLVM)) than GCC's, but not by much (also somewhat not surprising that smaller .text might have larger line table - code might've been shuffled around more, have finer grained line table entries, etc).

Seems acceptable to me - just need to understand the code better when I or someone else gets a chance.

[probinson]

I was wondering if maybe I should restructure the DwarfDebug.cpp bit. Currently it's like

beginInstruction() {
  if (!MI->isDebugValue()) {
    if (DL != PrevInstLoc) {
      if (DL) {
        // case for a new, explicit location
      } else if (somewhat complicated condition) {
        // case for emitting line-0
      }
    } else if (DL) {
      if (DL.getLine() != LastAsmLine) {
        // case for restoring a previous line after emitting line-0
      }
    }
  }
} // end of function

and this could easily be redone as a sequence of much-less-indented cases:

beginInstruction() {
  if (MI->isDebugValue())
    return;
  if (DL == PrevInstLoc) {
    if (DL && DL.getLine() != LastAsmLine) {
      // case for restoring a previous line after emitting line-0
    }
    return;
  }
  // DL != PrevInstLoc
  if (DL) {
    // case for a new, explicit location
    return;
  }
  if (somewhat complicated condition) {
    // case for emitting line-0
  }
}

Would that help? The diff would be harder to read but the result might make more sense.

[probinson]

Refactor patch after r287686 (D26982). Also took this opportunity to try to clarify the commentary.
Hopefully it's all rather easier to follow now.

[dblaikie]

Looks good (you could reduce some indentation in nthe newly introduced blocks if you like by using "if (!cond) return; work; return; " rather than "if (cond) { work; }" but leave it up to you if it feels better or not.

lib/CodeGen/AsmPrinter/DwarfDebug.cpp

1007–1015

I would've expected this conditional to be:

if (UnknownLocations || (...))

(essentially UnknownLocations triggers this in all cases, otherwise we trigger it in the subset of cases you're trying to implement (at the beginning of BB's, etc))

I'm assuming recordSourceLine does the appropriate thing to avoid producing redundant entries (eg: calling it with 0 twice is a no-op) - so the reordering of the condition you've done here is a minor optimization (to avoid calling recordSourceLine(0..) when it was already called last anyway), not a functional change?

1012

Yeah - we have column info off by default (& it does make the line table significantly larger) if I recall correctly. But would be nice to have this improvement to this change at some point.

[probinson]

In D24180#604826, @dblaikie wrote:

Looks good (you could reduce some indentation in nthe newly introduced blocks if you like by using "if (!cond) return; work; return; " rather than "if (cond) { work; }" but leave it up to you if it feels better or not.

I did a little bit of that, it does help break out the cases better. Thanks!

lib/CodeGen/AsmPrinter/DwarfDebug.cpp

1007–1015

Actually no, recordSourceLine does not suppress duplicates. And because I don't set PrevInstLoc = DL; here anymore, I have to use LastAsmLine to determine whether I've already emitted a line-0 record.
But I think it does make sense to pull out

if (LastAsmLine == 0)
  return;

separately, it makes the commentary flow better and makes UnknownLocations etc condition easier to understand.

1012

Can do.

lib/CodeGen/AsmPrinter/CodeViewDebug.h

class LLVM_LIBRARY_VISIBILITY CodeViewDebug : public DebugHandlerBase {
   typedef std::map<const DIFile *, std::string> FileToFilepathMapTy;
   FileToFilepathMapTy FileToFilepathMap;
   StringRef getFullFilepath(const DIFile *S);
 
   unsigned maybeRecordFile(const DIFile *F);
 
   void maybeRecordLocation(const DebugLoc &DL, const MachineFunction *MF);
 
+  /// Mark this instruction as having no true source location.
+  void recordNoLocation();
+
   void clear();
 
   void setCurrentSubprogram(const DISubprogram *SP) {
     CurrentSubprogram = SP;
     LocalUDTs.clear();
   }
 
   /// Emit the magic version number at the start of a CodeView type or symbol

lib/CodeGen/AsmPrinter/CodeViewDebug.cpp

if (const DILocation *SiteLoc = DL->getInlinedAt()) {
     addLocIfNotPresent(CurFn->ChildSites, Loc);
   }
 
   OS.EmitCVLocDirective(FuncId, FileId, DL.getLine(), DL.getCol(),
                         /*PrologueEnd=*/false,
                         /*IsStmt=*/false, DL->getFilename());
 }
 
+void CodeViewDebug::recordNoLocation() {
+  // This depends on having previous info to work from.
+  assert(CurFn->HaveLineInfo);
+
+  // Work out the correct FuncId, depends on inlining info.
+  unsigned FuncId = CurFn->FuncId;
+  if (const DILocation *SiteLoc = CurFn->LastLoc->getInlinedAt()) {
+    const DILocation *Loc = CurFn->LastLoc.get();
+    FuncId =
+        getInlineSite(SiteLoc, Loc->getScope()->getSubprogram()).SiteFuncId;
+  }
+  OS.EmitCVLocDirective(FuncId, CurFn->LastFileId,
+                        LineInfo::NeverStepIntoLineNumber,
+                        CurFn->LastLoc.getCol(), /*PrologueEnd=*/false,
+                        /*IsStmt=*/false, CurFn->LastLoc->getFilename());
+}
+
 void CodeViewDebug::emitCodeViewMagicVersion() {
   OS.EmitValueToAlignment(4);
   OS.AddComment("Debug section magic");
   OS.EmitIntValue(COFF::DEBUG_SECTION_MAGIC, 4);
 }
 
 void CodeViewDebug::endModule() {
   if (!Asm || !MMI->hasDebugInfo())
void CodeViewDebug::endFunction(const MachineFunction *MF) {
 
   collectVariableInfo(GV->getSubprogram());
 
   DebugHandlerBase::endFunction(MF);
 
   // Don't emit anything if we don't have any line tables.
   if (!CurFn->HaveLineInfo) {
     FnDebugInfo.erase(GV);
+    PrevLabel = nullptr;
     CurFn = nullptr;
     return;
   }
 
   CurFn->End = Asm->getFunctionEnd();
 
+  PrevLabel = nullptr;
   CurFn = nullptr;
 }
 
 void CodeViewDebug::beginInstruction(const MachineInstr *MI) {
   DebugHandlerBase::beginInstruction(MI);
 
   // Ignore DBG_VALUE locations and function prologue.
   if (!Asm || !CurFn || MI->isDebugValue() ||
       MI->getFlag(MachineInstr::FrameSetup))
     return;
   DebugLoc DL = MI->getDebugLoc();
-  if (DL == PrevInstLoc || !DL)
+  if (DL == PrevInstLoc)
     return;
+  if (DL) {
     maybeRecordLocation(DL, Asm->MF);
+    PrevInstLoc = DL;
+  } else if (PrevLabel || PrevInstBB != MI->getParent()) {
+    recordNoLocation();
+    PrevInstLoc = DL;
+  }
 }
 
 MCSymbol *CodeViewDebug::beginCVSubsection(ModuleSubstreamKind Kind) {
   MCSymbol *BeginLabel = MMI->getContext().createTempSymbol(),
            *EndLabel = MMI->getContext().createTempSymbol();
   OS.EmitIntValue(unsigned(Kind), 4);
   OS.AddComment("Subsection size");
   OS.emitAbsoluteSymbolDiff(EndLabel, BeginLabel, 4);

lib/CodeGen/AsmPrinter/DebugHandlerBase.h

protected:
   /// Collected machine module information.
   MachineModuleInfo *MMI;
 
   /// Previous instruction's location information. This is used to
   /// determine label location to indicate scope boundries in dwarf
   /// debug info.
   DebugLoc PrevInstLoc;
   MCSymbol *PrevLabel = nullptr;
+  const MachineBasicBlock *PrevInstBB;
 
   /// This location indicates end of function prologue and beginning of
   /// function body.
   DebugLoc PrologEndLoc;
 
   /// If nonnull, stores the current machine instruction we're processing.
   const MachineInstr *CurMI = nullptr;
 

lib/CodeGen/AsmPrinter/DebugHandlerBase.cpp

for (const auto &Range : Ranges) {
       requestLabelBeforeInsn(Range.first);
       if (Range.second)
         requestLabelAfterInsn(Range.second);
     }
   }
 
   PrevInstLoc = DebugLoc();
   PrevLabel = Asm->getFunctionBegin();
+  PrevInstBB = nullptr;
 }
 
 void DebugHandlerBase::beginInstruction(const MachineInstr *MI) {
   if (!MMI->hasDebugInfo())
     return;
 
   assert(CurMI == nullptr);
   CurMI = MI;

 
 void DebugHandlerBase::endInstruction() {
   if (!MMI->hasDebugInfo())
     return;
 
   assert(CurMI != nullptr);
   // Don't create a new label after DBG_VALUE instructions.
   // They don't generate code.
-  if (!CurMI->isDebugValue())
+  if (!CurMI->isDebugValue()) {
     PrevLabel = nullptr;
+    PrevInstBB = CurMI->getParent();
+  }
 
   DenseMap<const MachineInstr *, MCSymbol *>::iterator I =
       LabelsAfterInsn.find(CurMI);
   CurMI = nullptr;
 
   // No label needed.
   if (I == LabelsAfterInsn.end())
     return;

lib/CodeGen/AsmPrinter/DwarfDebug.cpp

void DwarfDebug::beginInstruction(const MachineInstr *MI) {
   // Check if source location changes, but ignore DBG_VALUE locations.
   if (!MI->isDebugValue()) {
     const DebugLoc &DL = MI->getDebugLoc();
     if (DL != PrevInstLoc) {
       if (DL) {
         unsigned Flags = 0;
         PrevInstLoc = DL;
         if (DL == PrologEndLoc) {
           Flags |= DWARF2_FLAG_PROLOGUE_END;
           PrologEndLoc = DebugLoc();
           Flags |= DWARF2_FLAG_IS_STMT;
         }
         if (DL.getLine() !=
             Asm->OutStreamer->getContext().getCurrentDwarfLoc().getLine())
           Flags |= DWARF2_FLAG_IS_STMT;
 
         const MDNode *Scope = DL.getScope();
         recordSourceLine(DL.getLine(), DL.getCol(), Scope, Flags);
-      } else if (UnknownLocations) {
+      } else if (UnknownLocations || PrevLabel ||
+                 PrevInstBB != MI->getParent()) {
+        // We want to ensure that any instruction starting a block or
+        // referenced from somewhere else (e.g. debug information) has
+        // a source location. Instead of making up a location from the
+        // surrounding instructions, just use a line 0 location that the
+        // debugger will ignore. Preserve the file number, if we can,
+        // which saves space in the encoded line table.
+        // FIXME: Also preserve the column number, for the same reason?
+        const MDNode *Scope = PrevInstLoc ? PrevInstLoc.getScope() : nullptr;
         PrevInstLoc = DL;
-        recordSourceLine(0, 0, nullptr, 0);
+        recordSourceLine(0, 0, Scope, 0);
       }
     }
   }
 }
 
 static DebugLoc findPrologueEndLoc(const MachineFunction *MF) {
   // First known non-DBG_VALUE and non-frame setup location marks
   // the beginning of the function body.

test/DebugInfo/AArch64/line-header.ll

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

test/DebugInfo/COFF/cv-no-source-loc.ll

+; Verify "no source location" directives appear in appropriate places.
+; RUN: llc %s -o - | FileCheck %s
+
+; Generated from this .cpp targeting Windows with -g -gcodeview
+; and then removed function attributes as clutter.
+;
+; void bar(int *);
+; void baz(int *);
+; # 5 "no-source-loc.cpp"
+; void foo(int x) {
+;   int z;
+;   if (x)
+; # 20 "include.h"
+;     bar(&z);
+; # 10 "no-source-loc.cpp"
+;   baz(&z);
+; }
+
+target datalayout = "e-m:w-i64:64-f80:128-n8:16:32:64-S128"
+target triple = "x86_64-pc-windows-msvc18.0.0"
+
+; Function Attrs: uwtable
+define void @"\01?foo@@YAXH@Z"(i32 %x) !dbg !7 {
+entry:
+  %x.addr = alloca i32, align 4
+  %z = alloca i32, align 4
+  store i32 %x, i32* %x.addr, align 4
+  call void @llvm.dbg.declare(metadata i32* %x.addr, metadata !12, metadata !13), !dbg !14
+  call void @llvm.dbg.declare(metadata i32* %z, metadata !15, metadata !13), !dbg !16
+  %0 = load i32, i32* %x.addr, align 4, !dbg !17
+  %tobool = icmp ne i32 %0, 0, !dbg !17
+  br i1 %tobool, label %if.then, label %if.end, !dbg !19
+
+if.then:                                          ; preds = %entry
+  call void @"\01?bar@@YAXPEAH@Z"(i32* %z), !dbg !20
+  br label %if.end, !dbg !20
+
+if.end:                                           ; preds = %if.then, %entry
+  call void @"\01?baz@@YAXPEAH@Z"(i32* %z), !dbg !23
+  ret void, !dbg !24
+}
+
+; CHECK:      .cv_loc 0 1 7 7
+; CHECK-NOT:  .cv_loc
+; CHECK:      .cv_loc 0 1 15732480 7
+; CHECK-NOT:  .cv_loc
+; CHECK:      .cv_loc 0 2 20 5
+; CHECK:      .LBB0_2:
+; CHECK-NEXT: .cv_loc 0 2 15732480 5
+; CHECK-NOT:  .cv_loc
+; CHECK:      .cv_loc 0 1 10 3
+
+
+
+declare void @llvm.dbg.declare(metadata, metadata, metadata)
+
+declare void @"\01?bar@@YAXPEAH@Z"(i32*)
+
+declare void @"\01?baz@@YAXPEAH@Z"(i32*)
+
+
+!llvm.dbg.cu = !{!0}
+!llvm.module.flags = !{!3, !4, !5}
+!llvm.ident = !{!6}
+
+!0 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus, file: !1, producer: "clang version 4.0.0 (trunk 280200)", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug, enums: !2)
+!1 = !DIFile(filename: "no-source-loc.cpp", directory: "/tests")
+!2 = !{}
+!3 = !{i32 2, !"CodeView", i32 1}
+!4 = !{i32 2, !"Debug Info Version", i32 3}
+!5 = !{i32 1, !"PIC Level", i32 2}
+!6 = !{!"clang version 4.0.0 (trunk 280200)"}
+!7 = distinct !DISubprogram(name: "foo", linkageName: "\01?foo@@YAXH@Z", scope: !8, file: !8, line: 5, type: !9, isLocal: false, isDefinition: true, scopeLine: 5, flags: DIFlagPrototyped, isOptimized: false, unit: !0, variables: !2)
+!8 = !DIFile(filename: "no-source-loc.cpp", directory: "/tests")
+!9 = !DISubroutineType(types: !10)
+!10 = !{null, !11}
+!11 = !DIBasicType(name: "int", size: 32, align: 32, encoding: DW_ATE_signed)
+!12 = !DILocalVariable(name: "x", arg: 1, scope: !7, file: !8, line: 5, type: !11)
+!13 = !DIExpression()
+!14 = !DILocation(line: 5, column: 14, scope: !7)
+!15 = !DILocalVariable(name: "z", scope: !7, file: !8, line: 6, type: !11)
+!16 = !DILocation(line: 6, column: 7, scope: !7)
+!17 = !DILocation(line: 7, column: 7, scope: !18)
+!18 = distinct !DILexicalBlock(scope: !7, file: !8, line: 7, column: 7)
+!19 = !DILocation(line: 7, column: 7, scope: !7)
+!20 = !DILocation(line: 20, column: 5, scope: !21)
+!21 = !DILexicalBlockFile(scope: !18, file: !22, discriminator: 0)
+!22 = !DIFile(filename: "include.h", directory: "/tests")
+!23 = !DILocation(line: 10, column: 3, scope: !7)
+!24 = !DILocation(line: 11, column: 1, scope: !7)

test/DebugInfo/COFF/local-variables.ll

 ; ASM:         .cv_loc 0 1 9 9                 # t.cpp:9:9
 ; ASM:         movl    $42, 40(%rsp)
 ; ASM: [[inline_site1:\.Ltmp.*]]:
 ; ASM:         .cv_loc 1 1 4 7                 # t.cpp:4:7
 ; ASM:         movl    $3, 44(%rsp)
 ; ASM:         leaq    44(%rsp), %rcx
 ; ASM:         .cv_loc 1 1 5 3                 # t.cpp:5:3
 ; ASM:         callq   capture
+; ASM:         .cv_loc 1 1 15732480 3
 ; ASM:         leaq    40(%rsp), %rcx
 ; ASM:         jmp     .LBB0_3
 ; ASM: [[else_start:\.Ltmp.*]]:
 ; ASM: .LBB0_2:                                # %if.else
 ; ASM:         #DEBUG_VALUE: f:param <- [%RSP+52]
 ; ASM:         #DEBUG_VALUE: b <- [%RSP+36]
 ; ASM:         .cv_loc 0 1 13 9                # t.cpp:13:9
 ; ASM:         movl    $42, 36(%rsp)
 ; ASM: [[inline_site2:\.Ltmp.*]]:
 ; ASM:         .cv_loc 2 1 4 7                 # t.cpp:4:7
 ; ASM:         movl    $3, 48(%rsp)
 ; ASM:         leaq    48(%rsp), %rcx
 ; ASM:         .cv_loc 2 1 5 3                 # t.cpp:5:3
 ; ASM:         callq   capture
+; ASM:        .cv_loc 2 1 15732480 3
 ; ASM:         leaq    36(%rsp), %rcx
 ; ASM: [[inline_site2_end:\.Ltmp.*]]:
 ; ASM: .LBB0_3:                                # %if.end
 ; ASM:         .cv_loc 0 1 15 5                # t.cpp:15:5
 ; ASM:         callq   capture
 ; ASM: [[else_end:\.Ltmp.*]]:
 ; ASM:         .cv_loc 0 1 17 1                # t.cpp:17:1
 ; ASM:         nop

 ; OBJ:    InlineSite {
 ; OBJ:      PtrParent: 0x0
 ; OBJ:      PtrEnd: 0x0
 ; OBJ:      Inlinee: will_be_inlined (0x1002)
 ; OBJ:      BinaryAnnotations [
 ; OBJ:        ChangeLineOffset: 1
 ; OBJ:        ChangeCodeOffset: 0x14
 ; OBJ:        ChangeCodeOffsetAndLineOffset: {CodeOffset: 0xD, LineOffset: 1}
-; OBJ:        ChangeCodeLength: 0xC
+; OBJ:        ChangeLineOffset: 15732475
+; OBJ:        ChangeCodeOffset: 0x5
+; OBJ:        ChangeCodeLength: 0x7
 ; OBJ:      ]
 ; OBJ:    }
 ; OBJ:    Local {
 ; OBJ:      Type: int (0x74)
 ; OBJ:      Flags [ (0x0)
 ; OBJ:      ]
 ; OBJ:      VarName: v
 ; OBJ:    }

 ; OBJ:    InlineSite {
 ; OBJ:      PtrParent: 0x0
 ; OBJ:      PtrEnd: 0x0
 ; OBJ:      Inlinee: will_be_inlined (0x1002)
 ; OBJ:      BinaryAnnotations [
 ; OBJ:        ChangeLineOffset: 1
 ; OBJ:        ChangeCodeOffset: 0x35
 ; OBJ:        ChangeCodeOffsetAndLineOffset: {CodeOffset: 0xD, LineOffset: 1}
-; OBJ:        ChangeCodeLength: 0xA
+; OBJ:        ChangeLineOffset: 15732475
+; OBJ:        ChangeCodeOffset: 0x5
+; OBJ:        ChangeCodeLength: 0x5
 ; OBJ:      ]
 ; OBJ:    }
 ; OBJ:    Local {
 ; OBJ:      Type: int (0x74)
 ; OBJ:      Flags [ (0x0)
 ; OBJ:      ]
 ; OBJ:      VarName: v
 ; OBJ:    }

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

+; Verify "no source location" directives appear in appropriate places.
+; RUN: llc %s -o - | FileCheck %s
+
+; Generated from this .cpp targeting linux using -g
+; and then removed function attributes as clutter.
+;
+; void bar(int *);
+; void baz(int *);
+; # 5 "no-source-loc.cpp"
+; void foo(int x) {
+;   int z;
+;   if (x)
+; # 20 "include.h"
+;     bar(&z);
+; # 10 "no-source-loc.cpp"
+;   baz(&z);
+; }
+
+target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
+target triple = "x86_64-unknown-linux-gnu"
+
+; Function Attrs: uwtable
+define void @_Z3fooi(i32 %x) !dbg !6 {
+entry:
+  %x.addr = alloca i32, align 4
+  %z = alloca i32, align 4
+  store i32 %x, i32* %x.addr, align 4
+  %0 = load i32, i32* %x.addr, align 4, !dbg !8
+  %tobool = icmp ne i32 %0, 0, !dbg !8
+  br i1 %tobool, label %if.then, label %if.end, !dbg !8
+
+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-NOT:  .loc
+; CHECK:      .loc 1 0 0 is_stmt 0
+; CHECK-NOT:  .loc
+; CHECK:      .loc 2 20 5 is_stmt 1
+; CHECK:      .LBB0_2:
+; CHECK-NEXT: .loc 2 0 0 is_stmt 0
+; CHECK-NOT:  .loc
+; CHECK:      .loc 1 10 3 is_stmt 1
+
+
+declare void @_Z3barPi(i32*)
+
+declare void @_Z3bazPi(i32*)
+
+!llvm.dbg.cu = !{!0}
+!llvm.module.flags = !{!3, !4}
+!llvm.ident = !{!5}
+
+!0 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus, file: !1, producer: "clang version 4.0.0 (trunk 278782)", isOptimized: false, runtimeVersion: 0, emissionKind: LineTablesOnly, enums: !2)
+!1 = !DIFile(filename: "no-source-loc.cpp", directory: "/tests")
+!2 = !{}
+!3 = !{i32 2, !"Dwarf Version", i32 4}
+!4 = !{i32 2, !"Debug Info Version", i32 3}
+!5 = !{!"clang version 4.0.0 (trunk 278782)"}
+!6 = distinct !DISubprogram(name: "foo", scope: !1, file: !1, line: 5, type: !7, isLocal: false, isDefinition: true, scopeLine: 5, flags: DIFlagPrototyped, isOptimized: false, unit: !0, variables: !2)
+!7 = !DISubroutineType(types: !2)
+!8 = !DILocation(line: 7, column: 7, scope: !6)
+!9 = !DILocation(line: 20, column: 5, scope: !10)
+!10 = !DILexicalBlockFile(scope: !6, file: !11, discriminator: 0)
+!11 = !DIFile(filename: "include.h", directory: "/tests")
+!12 = !DILocation(line: 10, column: 3, scope: !13)
+!13 = !DILexicalBlockFile(scope: !6, file: !1, discriminator: 0)
+!14 = !DILocation(line: 11, column: 1, scope: !13)