Support DWARF discriminators in object streamer.

[dnovillo]

Summary

This adds support for emitting DWARF path discriminator values in
the object streamer. It also changes the DWARF dumper to show
discriminator values in the line table output.

[• rafael]

test/MC/ELF/discriminator.s

2 ↗

(On Diff #7096)

I don't think -g is what you want in here. That will produce debug info for the assembly file.

[dnovillo]

Remove -g from one of the calls to llvm-mc.

[dnovillo]

I still haven't woken up. I need -g in *both* cases:

1- llvm-dwarfdump needs a -g .o or it will not generate its report.
2- If I do not use -g, I need to write a .file directive so .loc won't

get confused.

3- I cannot write a .file directive if I'm using -g.

So, the only way to get both tests here is to always run llvm-mc with
-g.

[• rafael]

We really shouldn't be mixing debug information *in* the .s and debug
information generated *for* a .s.

It might be that dwarfdump has a bug and needs more information to
work. In which case that information should be in the .s or we should
fix dwarfdump.

Give me a sec. I am applying you patch and will debug it a bit to see
what is the issue.

[• rafael]

It might be that dwarfdump has a bug and needs more information to
work. In which case that information should be in the .s or we should
fix dwarfdump.

It does look like an issue with how llvm-dwarfdump (and plain system
dwarfdump work). I removed the -g and added a .flie. With that
"readelf --debug-dump=rawline" can show the discriminator, but
dwarfdump and llvm-dwarfdump cannot. What dwarfdump tries to do is
dump on compilation unit at a time, and because of that it needs
.debug_info.

The proper fix is probably to implement something like "readelf
--debug-dump=rawline" or what we have right now in "llvm-readobj
-codeview-linetables".

For now, two options are

• Just check the binary contents of the .debug_line section
• extentd the .s to include a .debug_info (attached).

but lets please not mix debug info in the .s and debug info about the .s.

Cheers,
Rafael

• {F37555, layout=link}

[dnovillo]

Remove -g from llvm-mc call. Hand-code DWARF directives to work
around llvm-dwarfdump limitations (http://llvm.org/bugs/show_bug.cgi?id=18840).

[echristo]

LGTM.

[dnovillo]

Closed by commit rL201427 (authored by @dnovillo).

llvm/trunk/lib/DebugInfo/DWARFDebugLine.h

struct Row {
     // that a statement begins at the 'left edge' of the line.
     uint16_t Column;
     // An unsigned integer indicating the identity of the source file
     // corresponding to a machine instruction.
     uint16_t File;
     // An unsigned integer whose value encodes the applicable instruction set
     // architecture for the current instruction.
     uint8_t Isa;
+    // An unsigned integer representing the DWARF path discriminator value
+    // for this location.
+    uint32_t Discriminator;
     // A boolean indicating that the current instruction is the beginning of a
     // statement.
     uint8_t IsStmt:1,
             // A boolean indicating that the current instruction is the
             // beginning of a basic block.
             BasicBlock:1,
             // A boolean indicating that the current address is that of the
             // first byte after the end of a sequence of target machine

llvm/trunk/lib/DebugInfo/DWARFDebugLine.cpp

 }
 
 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 ", File, Isa)
+     << format(" %6u %3u %13u ", File, Isa, Discriminator)
      << (IsStmt ? " is_stmt" : "")
      << (BasicBlock ? " basic_block" : "")
      << (PrologueEnd ? " prologue_end" : "")
      << (EpilogueBegin ? " epilogue_begin" : "")
      << (EndSequence ? " end_sequence" : "")
      << '\n';
 }
 
 void DWARFDebugLine::LineTable::dump(raw_ostream &OS) const {
   Prologue.dump(OS);
   OS << '\n';
 
   if (!Rows.empty()) {
-    OS << "Address            Line   Column File   ISA Flags\n"
-       << "------------------ ------ ------ ------ --- -------------\n";
+    OS << "Address            Line   Column File   ISA Discriminator Flags\n"
+       << "------------------ ------ ------ ------ --- ------------- "
+          "-------------\n";
     for (std::vector<Row>::const_iterator pos = Rows.begin(),
          end = Rows.end(); pos != end; ++pos)
       pos->dump(OS);
   }
 }
 
 DWARFDebugLine::State::~State() {}
 
if (opcode == 0) {
           fileEntry.Name = debug_line_data.getCStr(offset_ptr);
           fileEntry.DirIdx = debug_line_data.getULEB128(offset_ptr);
           fileEntry.ModTime = debug_line_data.getULEB128(offset_ptr);
           fileEntry.Length = debug_line_data.getULEB128(offset_ptr);
           prologue->FileNames.push_back(fileEntry);
         }
         break;
 
+      case DW_LNE_set_discriminator:
+        state.Discriminator = debug_line_data.getULEB128(offset_ptr);
+        break;
+
       default:
         // Length doesn't include the zero opcode byte or the length itself, but
         // it does include the sub_opcode, so we have to adjust for that below
         (*offset_ptr) += arg_size;
         break;
       }
     } else if (opcode < prologue->OpcodeBase) {
       switch (opcode) {

llvm/trunk/lib/MC/MCDwarf.cpp

static inline void EmitDwarfLineTable(MCStreamer *MCOS,
   if (!LineSection->containEntriesForID(CUID))
     return;
 
   unsigned FileNum = 1;
   unsigned LastLine = 1;
   unsigned Column = 0;
   unsigned Flags = DWARF2_LINE_DEFAULT_IS_STMT ? DWARF2_FLAG_IS_STMT : 0;
   unsigned Isa = 0;
+  unsigned Discriminator = 0;
   MCSymbol *LastLabel = NULL;
 
   // Loop through each MCLineEntry and encode the dwarf line number table.
   for (MCLineSection::const_iterator
          it = LineSection->getMCLineEntries(CUID).begin(),
          ie = LineSection->getMCLineEntries(CUID).end(); it != ie; ++it) {
 
     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);
       MCOS->EmitULEB128IntValue(Column);
     }
+    if (Discriminator != it->getDiscriminator()) {
+      Discriminator = it->getDiscriminator();
+      unsigned Size =
+          MCOS->getContext().getAsmInfo()->getULEB128Size(Discriminator);
+      MCOS->EmitIntValue(dwarf::DW_LNS_extended_op, 1);
+      MCOS->EmitULEB128IntValue(Size + 1);
+      MCOS->EmitIntValue(dwarf::DW_LNE_set_discriminator, 1);
+      MCOS->EmitULEB128IntValue(Discriminator);
+    }
     if (Isa != it->getIsa()) {
       Isa = it->getIsa();
       MCOS->EmitIntValue(dwarf::DW_LNS_set_isa, 1);
       MCOS->EmitULEB128IntValue(Isa);
     }
     if ((it->getFlags() ^ Flags) & DWARF2_FLAG_IS_STMT) {
       Flags = it->getFlags();
       MCOS->EmitIntValue(dwarf::DW_LNS_negate_stmt, 1);

llvm/trunk/test/DebugInfo/X86/ending-run.ll

 ; RUN: llc -mtriple=x86_64-apple-darwin %s -o %t -filetype=obj
 ; RUN: llvm-dwarfdump -debug-dump=line %t | FileCheck %s
 
 ; Check that the line table starts at 7, not 4, but that the first
 ; statement isn't until line 8.
 
-; CHECK-NOT: 0x0000000000000000      7      0      1   0  is_stmt
+; CHECK-NOT: 0x0000000000000000      7      0      1   0  0  is_stmt
 ; CHECK: 0x0000000000000000      7      0      1   0
-; CHECK: 0x0000000000000004      8     18      1   0  is_stmt prologue_end
+; CHECK: 0x0000000000000004      8     18      1   0  0  is_stmt prologue_end
 
 define i32 @callee(i32 %x) nounwind uwtable ssp {
 entry:
   %x.addr = alloca i32, align 4
   %y = alloca i32, align 4
   store i32 %x, i32* %x.addr, align 4
   call void @llvm.dbg.declare(metadata !{i32* %x.addr}, metadata !12), !dbg !13
   call void @llvm.dbg.declare(metadata !{i32* %y}, metadata !14), !dbg !16

llvm/trunk/test/DebugInfo/X86/line-info.ll

 ; RUN: llc -mtriple=x86_64-apple-darwin -filetype=obj -O0 < %s > %t
 ; RUN: llvm-dwarfdump %t | FileCheck %s
 
 ; CHECK: [[FILEID:[0-9]+]]]{{.*}}list0.h
-; CHECK: [[FILEID]]      0      1   0  is_stmt{{$}}
+; CHECK: [[FILEID]]      0      1   0  0 is_stmt{{$}}
 
 ; IR generated from clang -g -emit-llvm with the following source:
 ; list0.h:
 ; int foo (int x) {
 ;     return ++x;
 ; }
 ; list0.c:
 ; #include "list0.h"

llvm/trunk/test/MC/ELF/discriminator.s

+# RUN: llvm-mc -triple i386-unknown-unknown %s -filetype=obj -o %t.o
+# RUN: llvm-readobj -r %t.o | FileCheck %s
+# RUN: llvm-dwarfdump -debug-dump=line %t.o | FileCheck %s -check-prefix=DWARF-DUMP
+
+    .file 1 "foo.c"
+    .text
+    .globl foo
+    .type foo, @function
+    .align 4
+foo:
+    .loc 1 2 discriminator 1
+    ret
+    .size foo, .-foo
+
+        .section        .debug_info,"",@progbits
+.L.debug_info_begin0:
+        .long   34                      # Length of Unit
+        .short  4                       # DWARF version number
+        .long   .L.debug_abbrev_begin   # Offset Into Abbrev. Section
+        .byte   8                       # Address Size (in bytes)
+        .byte   1                       # Abbrev [1] 0xb:0x1b DW_TAG_compile_unit
+        .long   .Linfo_string0          # DW_AT_producer
+        .short  12                      # DW_AT_language
+        .long   .Linfo_string1          # DW_AT_name
+        .quad   0                       # DW_AT_low_pc
+        .long   0                       # DW_AT_stmt_list
+        .long   .Linfo_string2          # DW_AT_comp_dir
+                                        # DW_AT_APPLE_optimized
+        .section        .debug_abbrev,"",@progbits
+.L.debug_abbrev_begin:
+        .byte   1                       # Abbreviation Code
+        .byte   17                      # DW_TAG_compile_unit
+        .byte   0                       # DW_CHILDREN_no
+        .byte   37                      # DW_AT_producer
+        .byte   14                      # DW_FORM_strp
+        .byte   19                      # DW_AT_language
+        .byte   5                       # DW_FORM_data2
+        .byte   3                       # DW_AT_name
+        .byte   14                      # DW_FORM_strp
+        .byte   17                      # DW_AT_low_pc
+        .byte   1                       # DW_FORM_addr
+        .byte   16                      # DW_AT_stmt_list
+        .byte   23                      # DW_FORM_sec_offset
+        .byte   27                      # DW_AT_comp_dir
+        .byte   14                      # DW_FORM_strp
+        .ascii  "\341\177"              # DW_AT_APPLE_optimized
+        .byte   25                      # DW_FORM_flag_present
+        .byte   0                       # EOM(1)
+        .byte   0                       # EOM(2)
+        .byte   0                       # EOM(3)
+.L.debug_abbrev_end:
+
+
+# CHECK:      Relocations [
+# CHECK:        Section ({{[^ ]+}}) .rel.debug_line {
+# CHECK-NEXT:     0x2D R_386_32 .text 0x0
+# CHECK-NEXT:   }
+
+# DWARF-DUMP: Address            Line   Column File   ISA Discriminator Flags
+# DWARF-DUMP: ------------------ ------ ------ ------ --- ------------- -------------
+# DWARF-DUMP: 0x0001021300000000     1      0      1   0             1  is_stmt

llvm/trunk/test/MC/MachO/gen-dwarf-cpp.s

 
 // We check that the source name "t.s" is picked up
 // CHECK:                 Dir  Mod Time   File Len   File Name
 // CHECK:                 ---- ---------- ---------- ---------------------------
 // CHECK: file_names[  1]    1 0x00000000 0x00000000 gen-dwarf-cpp.s
 // CHECK: file_names[  2]    0 0x00000000 0x00000000 t.s
 
 // We check that the source line number 100 is picked up before the "movl"
-// CHECK: Address            Line   Column File   ISA Flags
-// CHECK: ------------------ ------ ------ ------ --- -------------
-// CHECK: 0x0000000000000000    102      0      2   0  is_stmt
+// CHECK: Address            Line   Column File   ISA Discriminator Flags
+// CHECK: ------------------ ------ ------ ------ --- ------------- -------------
+// CHECK: 0x0000000000000000    102      0      2   0             0  is_stmt

llvm/trunk/test/MC/MachO/gen-dwarf.s

 // CHECK: standard_opcode_lengths[DW_LNS_set_prologue_end] = 0
 // CHECK: standard_opcode_lengths[DW_LNS_set_epilogue_begin] = 0
 // CHECK: standard_opcode_lengths[DW_LNS_set_isa] = 1
 // We don't check include_directories as it has a temp path
 // CHECK:                 Dir  Mod Time   File Len   File Name
 // CHECK:                 ---- ---------- ---------- ---------------------------
 // CHECK: file_names[  1]    1 0x00000000 0x00000000 gen-dwarf.s
 
-// CHECK: Address            Line   Column File   ISA Flags
-// CHECK: ------------------ ------ ------ ------ --- -------------
-// CHECK: 0x0000000000000000      6      0      1   0  is_stmt
-// CHECK: 0x0000000000000005      7      0      1   0  is_stmt
-// CHECK: 0x0000000000000006      8      0      1   0  is_stmt
-// CHECK: 0x0000000000000007     11      0      1   0  is_stmt
-// CHECK: 0x0000000000000008     11      0      1   0  is_stmt end_sequence
+// CHECK: Address            Line   Column File   ISA Discriminator Flags
+// CHECK: ------------------ ------ ------ ------ --- ------------- -------------
+// CHECK: 0x0000000000000000      6      0      1   0             0  is_stmt
+// CHECK: 0x0000000000000005      7      0      1   0             0  is_stmt
+// CHECK: 0x0000000000000006      8      0      1   0             0  is_stmt
+// CHECK: 0x0000000000000007     11      0      1   0             0  is_stmt
+// CHECK: 0x0000000000000008     11      0      1   0             0  is_stmt end_sequence