Merge remote-tracking branch 'origin/swift-4.1-branch' into stable

Author: swift-ci

include/llvm/DebugInfo/DWARF/DWARFDebugLine.h

@@ -217,7 +217,8 @@ class DWARFDebugLine {
     void clear();
 
     /// Parse prologue and all rows.
-    bool parse(const DWARFDataExtractor &DebugLineData, uint32_t *OffsetPtr);
+    bool parse(const DWARFDataExtractor &DebugLineData, uint32_t *OffsetPtr,
+               raw_ostream *OS = nullptr);
 
     using RowVector = std::vector<Row>;
     using RowIter = RowVector::const_iterator;

lib/DebugInfo/DWARF/DWARFContext.cpp

@@ -335,8 +335,14 @@ void DWARFContext::dump(
                                     isLittleEndian(), savedAddressByteSize);
         DWARFDebugLine::LineTable LineTable;
         uint32_t Offset = *StmtOffset;
-        LineTable.parse(lineData, &Offset);
-        LineTable.dump(OS);
+        // Verbose dumping is done during parsing and not on the intermediate
+        // representation.
+        if (DumpOpts.Verbose) {
+          LineTable.parse(lineData, &Offset, &OS);
+        } else {
+          LineTable.parse(lineData, &Offset);
+          LineTable.dump(OS);
+        }
       }
     }
   }

lib/DebugInfo/DWARF/DWARFDebugLine.cpp

@@ -394,7 +394,7 @@ DWARFDebugLine::getOrParseLineTable(const DWARFDataExtractor &DebugLineData,
 }
 
 bool DWARFDebugLine::LineTable::parse(const DWARFDataExtractor &DebugLineData,
-                                      uint32_t *OffsetPtr) {
+                                      uint32_t *OffsetPtr, raw_ostream *OS) {
   const uint32_t DebugLineOffset = *OffsetPtr;
 
   clear();
@@ -405,14 +405,23 @@ bool DWARFDebugLine::LineTable::parse(const DWARFDataExtractor &DebugLineData,
     return false;
   }
 
+  if (OS)
+    Prologue.dump(*OS);
+
   const uint32_t EndOffset =
       DebugLineOffset + Prologue.TotalLength + Prologue.sizeofTotalLength();
 
   ParsingState State(this);
 
   while (*OffsetPtr < EndOffset) {
+    if (OS)
+      *OS << format("0x%08.08" PRIx32 ": ", *OffsetPtr);
+
     uint8_t Opcode = DebugLineData.getU8(OffsetPtr);
 
+    if (OS)
+      *OS << format("%02.02" PRIx8 " ", Opcode);
+
     if (Opcode == 0) {
       // Extended Opcodes always start with a zero opcode followed by
       // a uleb128 length so you can skip ones you don't know about
@@ -421,6 +430,8 @@ bool DWARFDebugLine::LineTable::parse(const DWARFDataExtractor &DebugLineData,
       uint32_t ArgSize = Len - (*OffsetPtr - ExtOffset);
 
       uint8_t SubOpcode = DebugLineData.getU8(OffsetPtr);
+      if (OS)
+        *OS << LNExtendedString(SubOpcode);
       switch (SubOpcode) {
       case DW_LNE_end_sequence:
         // Set the end_sequence register of the state machine to true and
@@ -432,6 +443,11 @@ bool DWARFDebugLine::LineTable::parse(const DWARFDataExtractor &DebugLineData,
         // of the sequence.
         State.Row.EndSequence = true;
         State.appendRowToMatrix(*OffsetPtr);
+        if (OS) {
+          *OS << "\n";
+          OS->indent(12);
+          State.Row.dump(*OS);
+        }
         State.resetRowAndSequence();
         break;
 
@@ -443,6 +459,8 @@ bool DWARFDebugLine::LineTable::parse(const DWARFDataExtractor &DebugLineData,
         // that affect the address register add a delta to it. This instruction
         // stores a relocatable value into it instead.
         State.Row.Address = DebugLineData.getRelocatedAddress(OffsetPtr);
+        if (OS)
+          *OS << format(" (0x%16.16" PRIx64 ")", State.Row.Address);
         break;
 
       case DW_LNE_define_file:
@@ -473,11 +491,18 @@ bool DWARFDebugLine::LineTable::parse(const DWARFDataExtractor &DebugLineData,
           FileEntry.ModTime = DebugLineData.getULEB128(OffsetPtr);
           FileEntry.Length = DebugLineData.getULEB128(OffsetPtr);
           Prologue.FileNames.push_back(FileEntry);
+          if (OS)
+            *OS << " (" << FileEntry.Name.str()
+                << ", dir=" << FileEntry.DirIdx << ", mod_time="
+                << format("(0x%16.16" PRIx64 ")", FileEntry.ModTime)
+                << ", length=" << FileEntry.Length << ")";
         }
         break;
 
       case DW_LNE_set_discriminator:
         State.Row.Discriminator = DebugLineData.getULEB128(OffsetPtr);
+        if (OS)
+          *OS << " (" << State.Row.Discriminator << ")";
         break;
 
       default:
@@ -487,39 +512,58 @@ bool DWARFDebugLine::LineTable::parse(const DWARFDataExtractor &DebugLineData,
         break;
       }
     } else if (Opcode < Prologue.OpcodeBase) {
+      if (OS)
+        *OS << LNStandardString(Opcode);
       switch (Opcode) {
       // Standard Opcodes
       case DW_LNS_copy:
         // Takes no arguments. Append a row to the matrix using the
         // current values of the state-machine registers. Then set
         // the basic_block register to false.
         State.appendRowToMatrix(*OffsetPtr);
+        if (OS) {
+          *OS << "\n";
+          OS->indent(12);
+          State.Row.dump(*OS);
+          *OS << "\n";
+        }
         break;
 
       case DW_LNS_advance_pc:
         // Takes a single unsigned LEB128 operand, multiplies it by the
         // min_inst_length field of the prologue, and adds the
         // result to the address register of the state machine.
-        State.Row.Address +=
-            DebugLineData.getULEB128(OffsetPtr) * Prologue.MinInstLength;
+        {
+          uint64_t AddrOffset =
+              DebugLineData.getULEB128(OffsetPtr) * Prologue.MinInstLength;
+          State.Row.Address += AddrOffset;
+          if (OS)
+            *OS << " (" << AddrOffset << ")";
+        }
         break;
 
       case DW_LNS_advance_line:
         // Takes a single signed LEB128 operand and adds that value to
         // the line register of the state machine.
         State.Row.Line += DebugLineData.getSLEB128(OffsetPtr);
+        if (OS)
+          *OS << " (" << State.Row.Line << ")";
         break;
 
       case DW_LNS_set_file:
         // Takes a single unsigned LEB128 operand and stores it in the file
         // register of the state machine.
         State.Row.File = DebugLineData.getULEB128(OffsetPtr);
+        if (OS)
+          *OS << " (" << State.Row.File << ")";
         break;
 
       case DW_LNS_set_column:
         // Takes a single unsigned LEB128 operand and stores it in the
         // column register of the state machine.
         State.Row.Column = DebugLineData.getULEB128(OffsetPtr);
+        if (OS)
+          *OS << " (" << State.Row.Column << ")";
         break;
 
       case DW_LNS_negate_stmt:
@@ -551,6 +595,9 @@ bool DWARFDebugLine::LineTable::parse(const DWARFDataExtractor &DebugLineData,
           uint64_t AddrOffset =
               (AdjustOpcode / Prologue.LineRange) * Prologue.MinInstLength;
           State.Row.Address += AddrOffset;
+          if (OS)
+            *OS
+                << format(" (0x%16.16" PRIx64 ")", AddrOffset);
         }
         break;
 
@@ -564,7 +611,13 @@ bool DWARFDebugLine::LineTable::parse(const DWARFDataExtractor &DebugLineData,
         // judge when the computation of a special opcode overflows and
         // requires the use of DW_LNS_advance_pc. Such assemblers, however,
         // can use DW_LNS_fixed_advance_pc instead, sacrificing compression.
-        State.Row.Address += DebugLineData.getU16(OffsetPtr);
+        {
+          uint16_t PCOffset = DebugLineData.getU16(OffsetPtr);
+          State.Row.Address += PCOffset;
+          if (OS)
+            *OS
+                << format(" (0x%16.16" PRIx64 ")", PCOffset);
+        }
         break;
 
       case DW_LNS_set_prologue_end:
@@ -583,6 +636,8 @@ bool DWARFDebugLine::LineTable::parse(const DWARFDataExtractor &DebugLineData,
         // Takes a single unsigned LEB128 operand and stores it in the
         // column register of the state machine.
         State.Row.Isa = DebugLineData.getULEB128(OffsetPtr);
+        if (OS)
+          *OS << " (" << State.Row.Isa << ")";
         break;
 
       default:
@@ -592,8 +647,12 @@ bool DWARFDebugLine::LineTable::parse(const DWARFDataExtractor &DebugLineData,
         {
           assert(Opcode - 1U < Prologue.StandardOpcodeLengths.size());
           uint8_t OpcodeLength = Prologue.StandardOpcodeLengths[Opcode - 1];
-          for (uint8_t I = 0; I < OpcodeLength; ++I)
-            DebugLineData.getULEB128(OffsetPtr);
+          for (uint8_t I = 0; I < OpcodeLength; ++I) {
+            uint64_t Value = DebugLineData.getULEB128(OffsetPtr);
+            if (OS)
+              *OS << format("Skipping ULEB128 value: 0x%16.16" PRIx64 ")\n",
+                            Value);
+          }
         }
         break;
       }
@@ -638,10 +697,20 @@ bool DWARFDebugLine::LineTable::parse(const DWARFDataExtractor &DebugLineData,
           Prologue.LineBase + (AdjustOpcode % Prologue.LineRange);
       State.Row.Line += LineOffset;
       State.Row.Address += AddrOffset;
+
+      if (OS) {
+        *OS << "address += " << ((uint32_t)AdjustOpcode)
+            << ",  line += " << LineOffset << "\n";
+        OS->indent(12);
+        State.Row.dump(*OS);
+      }
+
       State.appendRowToMatrix(*OffsetPtr);
       // Reset discriminator to 0.
       State.Row.Discriminator = 0;
     }
+    if(OS)
+      *OS << "\n";
   }
 
   if (!State.Sequence.Empty) {

test/DebugInfo/Generic/unconditional-branch.ll

@@ -2,7 +2,7 @@
 ; PR 19261
 
 ; RUN: %llc_dwarf -fast-isel=false -O0 -filetype=obj %s -o %t
-; RUN: llvm-dwarfdump -v %t | FileCheck %s
+; RUN: llvm-dwarfdump -a %t | FileCheck %s
 
 ; CHECK: {{0x[0-9a-f]+}}      1      0      1   0             0  is_stmt
 ; CHECK: {{0x[0-9a-f]+}}      2      0      1   0             0  is_stmt

test/DebugInfo/MIR/X86/empty-inline.mir

@@ -1,10 +1,10 @@
-# RUN: llc  -filetype=obj -o - %s | llvm-dwarfdump -v - | FileCheck %s
+# RUN: llc  -filetype=obj -o - %s | llvm-dwarfdump -a - | FileCheck %s
 #
 # This testcase has an implicit def pseudo-iunstruction with a debug location.
 #
 # CHECK: .debug_info contents:
 # CHECK: DW_TAG_subprogram
-# CHECK:	DW_AT_low_pc [DW_FORM_addr]	(0x0000000000000000)
+# CHECK:	DW_AT_low_pc (0x0000000000000000)
 # CHECK-NOT: DW_TAG
 # CHECK:	DW_AT_specification {{.*}} "_ZN1C5m_fn3Ev"
 # CHECK-NOT: DW_TAG
@@ -20,38 +20,38 @@
   source_filename = "t.ll"
   target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
   target triple = "x86_64-apple-macosx"
-  
+
   %class.E = type { %class.D }
   %class.D = type { %class.B }
   %class.B = type { %class.A, %class.A }
   %class.A = type { i8 }
   %class.C = type <{ %class.E*, %class.B, [2 x i8] }>
-  
+
   @a = local_unnamed_addr global %class.E* null, align 4
-  
+
   define i32 @_ZN1C5m_fn3Ev(%class.C* nocapture) local_unnamed_addr align 2 !dbg !6 {
     %2 = alloca %class.B, align 1
     %3 = load %class.E*, %class.E** @a, align 4
     %4 = icmp eq %class.E* %3, null
     br i1 %4, label %10, label %5
-  
+
   ; <label>:5:                                      ; preds = %1
     %6 = bitcast %class.C* %0 to %class.D**
     %7 = load %class.D*, %class.D** %6, align 4
     %8 = bitcast %class.D* %7 to i8*
     %9 = load i8, i8* %8, align 1
     br label %10
-  
+
   ; <label>:10:                                     ; preds = %5, %1
     %11 = phi i8 [ %9, %5 ], [ undef, %1 ], !dbg !10
     %12 = getelementptr inbounds %class.C, %class.C* %0, i32 0, i32 1, i32 0, i32 0
     store i8 %11, i8* %12, align 1, !dbg !14
     ret i32 undef
   }
-  
+
   !llvm.dbg.cu = !{!0}
   !llvm.module.flags = !{!3, !4, !5}
-  
+
   !0 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus, file: !1, producer: "Apple LLVM version 8.1.0 (clang-802.0.30.3)", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, enums: !2, globals: !2)
   !1 = !DIFile(filename: "test.ii", directory: "/")
   !2 = !{}
@@ -77,9 +77,9 @@ legalized:       false
 regBankSelected: false
 selected:        false
 tracksRegLiveness: true
-liveins:         
+liveins:
   - { reg: '%rdi' }
-frameInfo:       
+frameInfo:
   isFrameAddressTaken: false
   isReturnAddressTaken: false
   hasStackMap:     false
@@ -93,27 +93,27 @@ frameInfo:
   hasOpaqueSPAdjustment: false
   hasVAStart:      false
   hasMustTailInVarArgFunc: false
-#stack:           
+#stack:
 #  - { id: 0, name: '<unnamed alloca>', offset: -16, size: 2, alignment: 8 }
 body:             |
   bb.0 (%ir-block.1):
     successors: %bb.1(0x30000000), %bb.2(0x50000000)
     liveins: %rdi
-  
+
     CMP64mi8 %rip, 1, _, @a, _, 0, implicit-def %eflags :: (dereferenceable load 8 from @a, align 4)
     JE_1 %bb.1, implicit %eflags
-  
+
   bb.2 (%ir-block.5):
     liveins: %rdi
-  
+
     %rax = MOV64rm %rdi, 1, _, 0, _ :: (load 8 from %ir.6, align 4)
     %al = MOV8rm killed %rax, 1, _, 0, _ :: (load 1 from %ir.8)
     MOV8mr killed %rdi, 1, _, 8, _, killed %al, debug-location !14 :: (store 1 into %ir.12)
     RETQ undef %eax
-  
+
   bb.1:
     liveins: %rdi
-  
+
     %al = IMPLICIT_DEF debug-location !10
     MOV8mr killed %rdi, 1, _, 8, _, killed %al, debug-location !14 :: (store 1 into %ir.12)
     RETQ undef %eax

test/DebugInfo/Mips/delay-slot.ll

@@ -1,4 +1,4 @@
-; RUN: llc -filetype=obj -O0 -relocation-model=pic < %s -mtriple mips-unknown-linux-gnu | llvm-dwarfdump -v - | FileCheck %s
+; RUN: llc -filetype=obj -O0 -relocation-model=pic < %s -mtriple mips-unknown-linux-gnu | llvm-dwarfdump -a - | FileCheck %s
 ; PR19815
 
 ; Generated using clang -target mips-linux-gnu -g test.c -S -o - -flto|opt -sroa -S

test/MC/ARM/dwarf-asm-multiple-sections-dwarf-2.s

@@ -1,5 +1,5 @@
 // RUN: llvm-mc < %s -triple=armv7-linux-gnueabi -filetype=obj -o %t -g -fdebug-compilation-dir=/tmp -dwarf-version 2 2>&1 | FileCheck -check-prefix MESSAGES %s
-// RUN: llvm-dwarfdump -v %t | FileCheck -check-prefix DWARF %s
+// RUN: llvm-dwarfdump -a %t | FileCheck -check-prefix DWARF %s
 // RUN: llvm-objdump -r %t | FileCheck -check-prefix RELOC %s
 
   .section .text, "ax"
@@ -24,13 +24,13 @@ b:
 // DWARF:         DW_AT_language  DW_FORM_data2
 
 // DWARF: .debug_info contents:
-// DWARF: 0x{{[0-9a-f]+}}: DW_TAG_compile_unit [1]
+// DWARF: DW_TAG_compile_unit
 // DWARF-NOT: DW_TAG_
-// DWARF:               DW_AT_low_pc [DW_FORM_addr]       (0x0000000000000000)
-// DWARF:               DW_AT_high_pc [DW_FORM_addr]      (0x0000000000000004)
+// DWARF:               DW_AT_low_pc {{.*}}(0x0000000000000000)
+// DWARF:               DW_AT_high_pc {{.*}}(0x0000000000000004)
 
-// DWARF: 0x{{[0-9a-f]+}}:   DW_TAG_label [2] *
-// DWARF-NEXT: DW_AT_name [DW_FORM_string]     ("a")
+// DWARF: DW_TAG_label
+// DWARF-NEXT: DW_AT_name {{.*}}("a")
 
 
 // DWARF: .debug_aranges contents: