Read discriminators correctly from object file.

[danielcdh]

Summary

This is the follow-up patch for http://reviews.llvm.org/D19436

• Update the discriminator reading algorithm to match the assignment algorithm.
• Add test to cover the new algorithm.

[echristo]

Formatting, a comment about the discriminator in the comment there and
lgtm.

[danielcdh]

Add comment and reformat.

[dblaikie]

Usually we try to reduce the source code before generating the IR test case
(looks like this IR may've been hand reduced further? But I may be
mistaken) for debug info tests & include the source in a comment at the top
of the test so it's easy to understand the basic intent of the test case -
since reconstructing the intent/semantics from the metadata is somewhat
non-trivial.

(also, sometimes we checkin binaries to test the dumper - we don't always,
and I'm not suggesting it here, just mentioning it as a thought - sometimes
we just treat the dumper as "golden" and assume we're just testing the LLVM
IR/CodeGen behavior)

• Dave

[danielcdh]

Add comment about the original source file.

[dblaikie]

test/DebugInfo/X86/discriminator2.ll

10

Would it be simpler/sufficient to do this:

void f1();
void f2() {
  f1(); f1();
  f1(); f1();
}

(with column info off? Or, to keep column info on, #define CALLS f1(); f1() and have the body of the function be:

CALLS;
CALLS;

)

[danielcdh]

Unfortunately, we can't because I need to have two consecutive
instructions that are both from discriminator 1, but different lines
to trigger this bug. With your proposed change, the code sequence will
be:

line 4 discriminator 0
line 4 discriminator 1
line 5 discriminator 0
line 5 discriminator 1

But with my test case, the code sequence will be:

line 4 discriminator 0
line 5 discriminator 0
line 4 discriminator 1
line 5 discriminator 1

[danielcdh]

comment about the test.

[danielcdh]

Fixed another bug in the implemantation to make it consistent with gnu assembler.

PTAL, Thanks

[echristo]

What did you fix? :)

-eric

lib/DebugInfo/DWARF/DWARFDebugLine.cpp

 #include "llvm/Support/Format.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/raw_ostream.h"
 #include <algorithm>
 using namespace llvm;
 using namespace dwarf;
 typedef DILineInfoSpecifier::FileLineInfoKind FileLineInfoKind;
 
-DWARFDebugLine::Prologue::Prologue() {
-  clear();
-}
+DWARFDebugLine::Prologue::Prologue() { clear(); }
 
 void DWARFDebugLine::Prologue::clear() {
   TotalLength = Version = PrologueLength = 0;
   MinInstLength = MaxOpsPerInst = DefaultIsStmt = LineBase = LineRange = 0;
   OpcodeBase = 0;
   IsDWARF64 = false;
   StandardOpcodeLengths.clear();
   IncludeDirectories.clear();
   FileNames.clear();
 }
 
 void DWARFDebugLine::Prologue::dump(raw_ostream &OS) const {
   OS << "Line table prologue:\n"
      << format("    total_length: 0x%8.8" PRIx64 "\n", TotalLength)
      << format("         version: %u\n", Version)
      << format(" prologue_length: 0x%8.8" PRIx64 "\n", PrologueLength)
      << format(" min_inst_length: %u\n", MinInstLength)
      << format(Version >= 4 ? "max_ops_per_inst: %u\n" : "", MaxOpsPerInst)
      << format(" default_is_stmt: %u\n", DefaultIsStmt)
      << format("       line_base: %i\n", LineBase)
      << format("      line_range: %u\n", LineRange)
      << format("     opcode_base: %u\n", OpcodeBase);
 
   for (uint32_t i = 0; i < StandardOpcodeLengths.size(); ++i)
-    OS << format("standard_opcode_lengths[%s] = %u\n", LNStandardString(i+1),
+    OS << format("standard_opcode_lengths[%s] = %u\n", LNStandardString(i + 1),
                  StandardOpcodeLengths[i]);
 
   if (!IncludeDirectories.empty())
     for (uint32_t i = 0; i < IncludeDirectories.size(); ++i)
-      OS << format("include_directories[%3u] = '", i+1)
+      OS << format("include_directories[%3u] = '", i + 1)
          << IncludeDirectories[i] << "'\n";
 
   if (!FileNames.empty()) {
     OS << "                Dir  Mod Time   File Len   File Name\n"
        << "                ---- ---------- ---------- -----------"
           "----------------\n";
     for (uint32_t i = 0; i < FileNames.size(); ++i) {
-      const FileNameEntry& fileEntry = FileNames[i];
-      OS << format("file_names[%3u] %4" PRIu64 " ", i+1, fileEntry.DirIdx)
-         << format("0x%8.8" PRIx64 " 0x%8.8" PRIx64 " ",
-                   fileEntry.ModTime, fileEntry.Length)
+      const FileNameEntry &fileEntry = FileNames[i];
+      OS << format("file_names[%3u] %4" PRIu64 " ", i + 1, fileEntry.DirIdx)
+         << format("0x%8.8" PRIx64 " 0x%8.8" PRIx64 " ", fileEntry.ModTime,
+                   fileEntry.Length)
          << fileEntry.Name << '\n';
     }
   }
 }
 
 bool DWARFDebugLine::Prologue::parse(DataExtractor debug_line_data,
                                      uint32_t *offset_ptr) {
   const uint64_t prologue_offset = *offset_ptr;
 
   clear();
   TotalLength = debug_line_data.getU32(offset_ptr);
   if (TotalLength == UINT32_MAX) {
     IsDWARF64 = true;
     TotalLength = debug_line_data.getU64(offset_ptr);
   } else if (TotalLength > 0xffffff00) {
     return false;
   }
   Version = debug_line_data.getU16(offset_ptr);
   if (Version < 2)
     return false;
 
-  PrologueLength = debug_line_data.getUnsigned(offset_ptr,
-                                               sizeofPrologueLength());
+  PrologueLength =
+      debug_line_data.getUnsigned(offset_ptr, sizeofPrologueLength());
   const uint64_t end_prologue_offset = PrologueLength + *offset_ptr;
   MinInstLength = debug_line_data.getU8(offset_ptr);
   if (Version >= 4)
     MaxOpsPerInst = debug_line_data.getU8(offset_ptr);
   DefaultIsStmt = debug_line_data.getU8(offset_ptr);
   LineBase = debug_line_data.getU8(offset_ptr);
   LineRange = debug_line_data.getU8(offset_ptr);
   OpcodeBase = debug_line_data.getU8(offset_ptr);
fprintf(stderr, "warning: parsing line table prologue at 0x%8.8" PRIx64
                     " should have ended at 0x%8.8" PRIx64
                     " but it ended at 0x%8.8" PRIx64 "\n",
             prologue_offset, end_prologue_offset, (uint64_t)*offset_ptr);
     return false;
   }
   return true;
 }
 
-DWARFDebugLine::Row::Row(bool default_is_stmt) {
-  reset(default_is_stmt);
-}
+DWARFDebugLine::Row::Row(bool default_is_stmt) { reset(default_is_stmt); }
 
 void DWARFDebugLine::Row::postAppend() {
   BasicBlock = false;
   PrologueEnd = false;
   EpilogueBegin = false;
 }
 
 void DWARFDebugLine::Row::reset(bool default_is_stmt) {
   Address = 0;
   Line = 1;
   Column = 0;
   File = 1;
   Isa = 0;
   Discriminator = 0;
   IsStmt = default_is_stmt;
   BasicBlock = false;
   EndSequence = false;
   PrologueEnd = false;
   EpilogueBegin = false;
 }
 
 void DWARFDebugLine::Row::dump(raw_ostream &OS) const {
   OS << format("0x%16.16" PRIx64 " %6u %6u", Address, Line, Column)
      << format(" %6u %3u %13u ", File, Isa, Discriminator)
-     << (IsStmt ? " is_stmt" : "")
-     << (BasicBlock ? " basic_block" : "")
+     << (IsStmt ? " is_stmt" : "") << (BasicBlock ? " basic_block" : "")
      << (PrologueEnd ? " prologue_end" : "")
      << (EpilogueBegin ? " epilogue_begin" : "")
-     << (EndSequence ? " end_sequence" : "")
-     << '\n';
+     << (EndSequence ? " end_sequence" : "") << '\n';
 }
 
-DWARFDebugLine::Sequence::Sequence() {
-  reset();
-}
+DWARFDebugLine::Sequence::Sequence() { reset(); }
 
 void DWARFDebugLine::Sequence::reset() {
   LowPC = 0;
   HighPC = 0;
   FirstRowIndex = 0;
   LastRowIndex = 0;
   Empty = true;
 }
 
-DWARFDebugLine::LineTable::LineTable() {
-  clear();
-}
+DWARFDebugLine::LineTable::LineTable() { clear(); }
 
 void DWARFDebugLine::LineTable::dump(raw_ostream &OS) const {
   Prologue.dump(OS);
   OS << '\n';
 
   if (!Rows.empty()) {
     OS << "Address            Line   Column File   ISA Discriminator Flags\n"
        << "------------------ ------ ------ ------ --- ------------- "
if (pos != LineTableMap.end())
     return &pos->second;
   return nullptr;
 }
 
 const DWARFDebugLine::LineTable *
 DWARFDebugLine::getOrParseLineTable(DataExtractor debug_line_data,
                                     uint32_t offset) {
   std::pair<LineTableIter, bool> pos =
       LineTableMap.insert(LineTableMapTy::value_type(offset, LineTable()));
   LineTable *LT = &pos.first->second;
   if (pos.second) {
     if (!LT->parse(debug_line_data, RelocMap, &offset))
       return nullptr;
   }
   return LT;
 }
 
 bool DWARFDebugLine::LineTable::parse(DataExtractor debug_line_data,
                                       const RelocAddrMap *RMap,
                                       uint32_t *offset_ptr) {
   const uint32_t debug_line_offset = *offset_ptr;
 
   clear();
 
   if (!Prologue.parse(debug_line_data, offset_ptr)) {
     // Restore our offset and return false to indicate failure!
     *offset_ptr = debug_line_offset;
     return false;
   }
 
-  const uint32_t end_offset = debug_line_offset + Prologue.TotalLength +
-                              Prologue.sizeofTotalLength();
+  const uint32_t end_offset =
+      debug_line_offset + Prologue.TotalLength + Prologue.sizeofTotalLength();
 
   ParsingState State(this);
 
   while (*offset_ptr < end_offset) {
     uint8_t opcode = debug_line_data.getU8(offset_ptr);
 
     if (opcode == 0) {
       // Extended Opcodes always start with a zero opcode followed by
if (opcode == 0) {
         // machine. Set the address register to the value given by the
         // relocatable address. All of the other statement program opcodes
         // that affect the address register add a delta to it. This instruction
         // stores a relocatable value into it instead.
         {
           // If this address is in our relocation map, apply the relocation.
           RelocAddrMap::const_iterator AI = RMap->find(*offset_ptr);
           if (AI != RMap->end()) {
-             const std::pair<uint8_t, int64_t> &R = AI->second;
-             State.Row.Address =
-                 debug_line_data.getAddress(offset_ptr) + R.second;
           } else
             State.Row.Address = debug_line_data.getAddress(offset_ptr);
         }
         break;
 
       case DW_LNE_define_file:
         // Takes 4 arguments. The first is a null terminated string containing
         // a source file name. The second is an unsigned LEB128 number
if (opcode == 0) {
       uint8_t adjust_opcode = opcode - Prologue.OpcodeBase;
       uint64_t addr_offset =
           (adjust_opcode / Prologue.LineRange) * Prologue.MinInstLength;
       int32_t line_offset =
           Prologue.LineBase + (adjust_opcode % Prologue.LineRange);
       State.Row.Line += line_offset;
       State.Row.Address += addr_offset;
       State.appendRowToMatrix(*offset_ptr);
+      // Reset discriminator to 0.
+      State.Row.Discriminator = 0;
     }
   }
 
   if (!State.Sequence.Empty) {
     fprintf(stderr, "warning: last sequence in debug line table is not"
                     "terminated!\n");
   }
 

 uint32_t DWARFDebugLine::LineTable::lookupAddress(uint64_t address) const {
   if (Sequences.empty())
     return UnknownRowIndex;
   // First, find an instruction sequence containing the given address.
   DWARFDebugLine::Sequence sequence;
   sequence.LowPC = address;
   SequenceIter first_seq = Sequences.begin();
   SequenceIter last_seq = Sequences.end();
-  SequenceIter seq_pos = std::lower_bound(first_seq, last_seq, sequence,
-      DWARFDebugLine::Sequence::orderByLowPC);
+  SequenceIter seq_pos = std::lower_bound(
+      first_seq, last_seq, sequence, DWARFDebugLine::Sequence::orderByLowPC);
   DWARFDebugLine::Sequence found_seq;
   if (seq_pos == last_seq) {
     found_seq = Sequences.back();
   } else if (seq_pos->LowPC == address) {
     found_seq = *seq_pos;
   } else {
     if (seq_pos == first_seq)
       return UnknownRowIndex;
     found_seq = *(seq_pos - 1);
   }
   return findRowInSeq(found_seq, address);
 }
 
 bool DWARFDebugLine::LineTable::lookupAddressRange(
     uint64_t address, uint64_t size, std::vector<uint32_t> &result) const {
   if (Sequences.empty())
     return false;
   uint64_t end_addr = address + size;
   // First, find an instruction sequence containing the given address.
   DWARFDebugLine::Sequence sequence;
   sequence.LowPC = address;
   SequenceIter first_seq = Sequences.begin();
   SequenceIter last_seq = Sequences.end();
-  SequenceIter seq_pos = std::lower_bound(first_seq, last_seq, sequence,
-      DWARFDebugLine::Sequence::orderByLowPC);
+  SequenceIter seq_pos = std::lower_bound(
+      first_seq, last_seq, sequence, DWARFDebugLine::Sequence::orderByLowPC);
   if (seq_pos == last_seq || seq_pos->LowPC != address) {
     if (seq_pos == first_seq)
       return false;
     seq_pos--;
   }
   if (!seq_pos->containsPC(address))
     return false;
 
while (seq_pos != last_seq && seq_pos->LowPC < end_addr) {
     }
 
     ++seq_pos;
   }
 
   return true;
 }
 
-bool
-DWARFDebugLine::LineTable::getFileNameByIndex(uint64_t FileIndex,
+bool DWARFDebugLine::LineTable::getFileNameByIndex(uint64_t FileIndex,
                                                    const char *CompDir,
                                                    FileLineInfoKind Kind,
                                                    std::string &Result) const {
   if (FileIndex == 0 || FileIndex > Prologue.FileNames.size() ||
       Kind == FileLineInfoKind::None)
     return false;
   const FileNameEntry &Entry = Prologue.FileNames[FileIndex - 1];
   const char *FileName = Entry.Name;
   if (Kind != FileLineInfoKind::AbsoluteFilePath ||
       sys::path::is_absolute(FileName)) {
     Result = FileName;
if (CompDir && Kind == FileLineInfoKind::AbsoluteFilePath &&
     sys::path::append(FilePath, CompDir);
 
   // sys::path::append skips empty strings.
   sys::path::append(FilePath, IncludeDir, FileName);
   Result = FilePath.str();
   return true;
 }
 
-bool
-DWARFDebugLine::LineTable::getFileLineInfoForAddress(uint64_t Address,
-                                                     const char *CompDir,
-                                                     FileLineInfoKind Kind,
-                                                     DILineInfo &Result) const {
+bool DWARFDebugLine::LineTable::getFileLineInfoForAddress(
+    uint64_t Address, const char *CompDir, FileLineInfoKind Kind,
   // Get the index of row we're looking for in the line table.
   uint32_t RowIndex = lookupAddress(Address);
   if (RowIndex == -1U)
     return false;
   // Take file number and line/column from the row.
   const auto &Row = Rows[RowIndex];
   if (!getFileNameByIndex(Row.File, CompDir, Kind, Result.FileName))
     return false;
   Result.Line = Row.Line;
   Result.Column = Row.Column;
   return true;
 }

lib/MC/MCDwarf.cpp

EmitDwarfLineTable(MCObjectStreamer *MCOS, MCSection *Section,
 
   // Loop through each MCDwarfLineEntry and encode the dwarf line number table.
   for (auto it = LineEntries.begin(),
             ie = LineEntries.end();
        it != ie; ++it) {
 
     int64_t LineDelta = static_cast<int64_t>(it->getLine()) - LastLine;
 
-    // Discriminator will be cleared if there is line change.
-    if (LineDelta != 0)
-      Discriminator = 0;
-
     if (FileNum != it->getFileNum()) {
       FileNum = it->getFileNum();
       MCOS->EmitIntValue(dwarf::DW_LNS_set_file, 1);
       MCOS->EmitULEB128IntValue(FileNum);
     }
     if (Column != it->getColumn()) {
       Column = it->getColumn();
       MCOS->EmitIntValue(dwarf::DW_LNS_set_column, 1);
for (auto it = LineEntries.begin(),
 
     // At this point we want to emit/create the sequence to encode the delta in
     // line numbers and the increment of the address from the previous Label
     // and the current Label.
     const MCAsmInfo *asmInfo = MCOS->getContext().getAsmInfo();
     MCOS->EmitDwarfAdvanceLineAddr(LineDelta, LastLabel, Label,
                                    asmInfo->getPointerSize());
 
+    Discriminator = 0;
     LastLine = it->getLine();
     LastLabel = Label;
   }
 
   // Emit a DW_LNE_end_sequence for the end of the section.
   // Use the section end label to compute the address delta and use INT64_MAX
   // as the line delta which is the signal that this is actually a
   // DW_LNE_end_sequence.

test/DebugInfo/X86/discriminator2.ll

+; RUN: llc -mtriple=i386-unknown-unknown -mcpu=core2 %s -o %t -filetype=obj
+; RUN: llvm-dwarfdump -debug-dump=line %t | FileCheck %s
+;
+; Generated from:
+;
+; #1 void foo(int, int);
+; #2 int bar();
+; #3 void baz() {
+; #4   foo/*discriminator 1*/(bar(),
+; #5       bar());bar()/*discriminator 1*/;
+; #6 }
+;
+; The intent is to test discriminator 1 generated for both line #4 and #5.
+; The instruction sequence in the final binary is:
+; line 4 discriminator 0
+; line 5 discriminator 0
+; line 4 discriminator 1
+; line 5 discriminator 1
+; We need to ensure that the discriminators for the last two instructions
+; are both 1.
+
+; Function Attrs: uwtable
+define void @_Z3bazv() #0 !dbg !6 {
+  %1 = call i32 @_Z3barv(), !dbg !9
+  %2 = call i32 @_Z3barv(), !dbg !10
+  call void @_Z3fooii(i32 %1, i32 %2), !dbg !11
+  %3 = call i32 @_Z3barv(), !dbg !13
+  ret void, !dbg !14
+}
+
+declare void @_Z3fooii(i32, i32) #1
+
+declare i32 @_Z3barv() #1
+
+attributes #0 = { uwtable "disable-tail-calls"="false" "less-precise-fpmad"="false" "no-frame-pointer-elim"="true" "no-frame-pointer-elim-non-leaf" "no-infs-fp-math"="false" "no-jump-tables"="false" "no-nans-fp-math"="false" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+fxsr,+mmx,+sse,+sse2,+x87" "unsafe-fp-math"="false" "use-soft-float"="false" }
+attributes #1 = { "disable-tail-calls"="false" "less-precise-fpmad"="false" "no-frame-pointer-elim"="true" "no-frame-pointer-elim-non-leaf" "no-infs-fp-math"="false" "no-nans-fp-math"="false" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+fxsr,+mmx,+sse,+sse2,+x87" "unsafe-fp-math"="false" "use-soft-float"="false" }
+
+!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 3.9.0 (trunk 267219)", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug, enums: !2)
+!1 = !DIFile(filename: "test.cc", directory: ".")
+!2 = !{}
+!3 = !{i32 2, !"Dwarf Version", i32 4}
+!4 = !{i32 2, !"Debug Info Version", i32 3}
+!5 = !{!"clang version 3.9.0 (trunk 267219)"}
+!6 = distinct !DISubprogram(name: "baz", linkageName: "_Z3bazv", scope: !1, file: !1, line: 3, type: !7, isLocal: false, isDefinition: true, scopeLine: 3, flags: DIFlagPrototyped, isOptimized: false, unit: !0, variables: !2)
+!7 = !DISubroutineType(types: !8)
+!8 = !{null}
+!9 = !DILocation(line: 4, column: 7, scope: !6)
+!10 = !DILocation(line: 5, column: 14, scope: !6)
+!11 = !DILocation(line: 4, column: 3, scope: !12)
+!12 = !DILexicalBlockFile(scope: !6, file: !1, discriminator: 1)
+!13 = !DILocation(line: 5, column: 21, scope: !12)
+!14 = !DILocation(line: 6, column: 1, scope: !6)
+
+; CHECK: Address            Line   Column File   ISA Discriminator Flags
+; CHECK: ------------------ ------ ------ ------ --- ------------- -------------
+; CHECK: {{.*}}      4      3      1   0             1  {{.*}}
+; CHECK: {{.*}}      5     21      1   0             1  {{.*}}

test/DebugInfo/X86/discriminator3.ll

+; RUN: llc -mtriple=i386-unknown-unknown -mcpu=core2 %s -o %t -filetype=obj
+; RUN: llvm-dwarfdump -debug-dump=line %t | FileCheck %s
+;
+; Generated from:
+;
+; #1 void foo(int);
+; #2 void baz(int i) {
+; #3   if (i) {foo(i+1);/*discriminator 1*/}
+; #4 }
+;
+; The intent is to test discriminator 1 generated for all instructions in
+; the taken branch.
+
+; Function Attrs: uwtable
+define void @_Z3bazi(i32) #0 !dbg !6 {
+  %2 = alloca i32, align 4
+  store i32 %0, i32* %2, align 4
+  call void @llvm.dbg.declare(metadata i32* %2, metadata !10, metadata !11), !dbg !12
+  %3 = load i32, i32* %2, align 4, !dbg !13
+  %4 = icmp ne i32 %3, 0, !dbg !13
+  br i1 %4, label %5, label %8, !dbg !15
+
+; <label>:5:                                      ; preds = %1
+  %6 = load i32, i32* %2, align 4, !dbg !16
+  %7 = add nsw i32 %6, 1, !dbg !19
+  call void @_Z3fooi(i32 %7), !dbg !20
+  br label %8, !dbg !21
+
+; <label>:8:                                      ; preds = %5, %1
+  ret void, !dbg !22
+}
+
+; Function Attrs: nounwind readnone
+declare void @llvm.dbg.declare(metadata, metadata, metadata) #1
+
+declare void @_Z3fooi(i32) #2
+
+attributes #0 = { uwtable "disable-tail-calls"="false" "less-precise-fpmad"="false" "no-frame-pointer-elim"="true" "no-frame-pointer-elim-non-leaf" "no-infs-fp-math"="false" "no-jump-tables"="false" "no-nans-fp-math"="false" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+fxsr,+mmx,+sse,+sse2,+x87" "unsafe-fp-math"="false" "use-soft-float"="false" }
+attributes #1 = { nounwind readnone }
+attributes #2 = { "disable-tail-calls"="false" "less-precise-fpmad"="false" "no-frame-pointer-elim"="true" "no-frame-pointer-elim-non-leaf" "no-infs-fp-math"="false" "no-nans-fp-math"="false" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+fxsr,+mmx,+sse,+sse2,+x87" "unsafe-fp-math"="false" "use-soft-float"="false" }
+
+!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 3.9.0 (trunk 267518)", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug, enums: !2)
+!1 = !DIFile(filename: "test.cc", directory: ".")
+!2 = !{}
+!3 = !{i32 2, !"Dwarf Version", i32 4}
+!4 = !{i32 2, !"Debug Info Version", i32 3}
+!5 = !{!"clang version 3.9.0 (trunk 267518)"}
+!6 = distinct !DISubprogram(name: "baz", linkageName: "_Z3bazi", scope: !1, file: !1, line: 2, type: !7, isLocal: false, isDefinition: true, scopeLine: 2, flags: DIFlagPrototyped, isOptimized: false, unit: !0, variables: !2)
+!7 = !DISubroutineType(types: !8)
+!8 = !{null, !9}
+!9 = !DIBasicType(name: "int", size: 32, align: 32, encoding: DW_ATE_signed)
+!10 = !DILocalVariable(name: "i", arg: 1, scope: !6, file: !1, line: 2, type: !9)
+!11 = !DIExpression()
+!12 = !DILocation(line: 2, column: 14, scope: !6)
+!13 = !DILocation(line: 3, column: 7, scope: !14)
+!14 = distinct !DILexicalBlock(scope: !6, file: !1, line: 3, column: 7)
+!15 = !DILocation(line: 3, column: 7, scope: !6)
+!16 = !DILocation(line: 3, column: 15, scope: !17)
+!17 = !DILexicalBlockFile(scope: !18, file: !1, discriminator: 1)
+!18 = distinct !DILexicalBlock(scope: !14, file: !1, line: 3, column: 10)
+!19 = !DILocation(line: 3, column: 16, scope: !17)
+!20 = !DILocation(line: 3, column: 11, scope: !17)
+!21 = !DILocation(line: 3, column: 21, scope: !17)
+!22 = !DILocation(line: 4, column: 1, scope: !6)
+
+; CHECK: Address            Line   Column File   ISA Discriminator Flags
+; CHECK: ------------------ ------ ------ ------ --- ------------- -------------
+; CHECK: {{.*}}      3     15      1   0             1 
+; CHECK: {{.*}}      3     16      1   0             1 
+; CHECK: {{.*}}      3     11      1   0             1