[DWARF5] Added support for DW_MACRO_import form in llvm-dwarfdump..

[SouraVX]

Summary

GCC emits this new form along with others forms(supported in llvm-dwardump) and since it's support was missing in llvm-dwarfdump, it was not able to correctly dump the content a debug_macro section for GCC generated binaries.

This patch extends llvm-dwarfdump to support this form, now GCC generated debug_macro section can be correctly dumped using llvm-dwarfdump.

[dblaikie]

Sounds good - though I'm curious: under what conditions does GCC use this feature?

llvm/lib/DebugInfo/DWARF/DWARFDebugMacro.cpp

73

Use lowercase to match the other/surrounding format

[SouraVX]

Seems like GCC packs up the compiler(CU unit defined macros) defined in a macro unit then import it -- I'll check if there's any benefit from this, probably put a patch or two in llvm.
.debug_macro contents:
0x00000000:
macro header: version = 0x0005, flags = 0x02, debug_line_offset = 0x0000
DW_MACRO_import - import offset: 0x0000001a
0x0000001a:
macro header: version = 0x0005, flags = 0x00
DW_MACRO_define_strp - lineno: 0 macro: STDC 1
DW_MACRO_define_strp - lineno: 0 macro: STDC_VERSION 201112L
DW_MACRO_define_strp - lineno: 0 macro: STDC_UTF_16 1
DW_MACRO_define_strp - lineno: 0 macro: STDC_UTF_32 1

llvm/include/llvm/DebugInfo/DWARF/DWARFDebugMacro.h

#include "llvm/BinaryFormat/Dwarf.def"
   struct Entry {
     /// The type of the macro entry.
     uint32_t Type;
     union {
       /// The source line where the macro is defined.
       uint64_t Line;
       /// Vendor extension constant value.
       uint64_t ExtConstant;
+      /// Macro unit import offset.
+      uint64_t ImportOffset;
     };
 
     union {
       /// The string (name, value) of the macro entry.
       const char *MacroStr;
       // An unsigned integer indicating the identity of the source file.
       uint64_t File;
       /// Vendor extension string.

llvm/lib/DebugInfo/DWARF/DWARFDebugMacro.cpp

for (const Entry &E : Macros.Macros) {
       case DW_MACRO_undef_strp:
         OS << " - lineno: " << E.Line;
         OS << " macro: " << E.MacroStr;
         break;
       case DW_MACRO_start_file:
         OS << " - lineno: " << E.Line;
         OS << " filenum: " << E.File;
         break;
+      case DW_MACRO_import:
+        OS << format(" - import offset: 0x%08" PRIx64, E.ImportOffset);
+        break;
       case DW_MACRO_end_file:
         break;
       case DW_MACINFO_vendor_ext:
         OS << " - constant: " << E.ExtConstant;
         OS << " string: " << E.ExtStr;
         break;
       }
       OS << "\n";
while (Data.isValidOffset(Offset)) {
     case DW_MACRO_start_file:
       // 2. Source line
       E.Line = Data.getULEB128(&Offset);
       // 3. Source file id
       E.File = Data.getULEB128(&Offset);
       break;
     case DW_MACRO_end_file:
       break;
+    case DW_MACRO_import:
+      // FIXME: Add support for DWARF64
+      E.ImportOffset = Data.getRelocatedValue(/*OffsetSize=*/4, &Offset);
+      break;
     case DW_MACINFO_vendor_ext:
       // 2. Vendor extension constant
       E.ExtConstant = Data.getULEB128(&Offset);
       // 3. Vendor extension string
       E.ExtStr = Data.getCStr(&Offset);
       break;
     }
   }

llvm/test/DebugInfo/X86/debug-macro-v5.s

 ## This test checks llvm-dwarfdump can dump debug_macro section containing
 ## multiple macro units.
 
 # RUN: llvm-mc -triple x86_64-unknown-linux -filetype=obj %s -o -| \
 # RUN:   llvm-dwarfdump -debug-macro - | FileCheck -strict-whitespace -match-full-lines %s
 
 #      CHECK:.debug_macro contents:
 # CHECK-NEXT:0x00000000:
 # CHECK-NEXT:macro header: version = 0x0005, flags = 0x02, debug_line_offset = 0x0000
 # CHECK-NEXT:DW_MACRO_start_file - lineno: 0 filenum: 0
 # CHECK-NEXT:  DW_MACRO_start_file - lineno: 1 filenum: 6
 # CHECK-NEXT:    DW_MACRO_define_strp - lineno: 1 macro: FOO 5
 # CHECK-NEXT:  DW_MACRO_end_file
 # CHECK-NEXT:  DW_MACRO_undef_strp - lineno: 8 macro: WORLD1
+# CHECK-NEXT:  DW_MACRO_import - import offset: 0x[[OFFSET:[0-9]+]]
 # CHECK-NEXT:DW_MACRO_end_file
 
-#      CHECK:0x{{.*}}:
+#      CHECK:0x[[OFFSET]]:
 # CHECK-NEXT:macro header: version = 0x0005, flags = 0x00
 # CHECK-NEXT:DW_MACRO_define_strp - lineno: 0 macro: WORLD 2
 
   .section  .debug_macro,"",@progbits
 .Lcu_macro_begin0:
   .short  5                      # Macro information version
   .byte 2                       # Flags: 32 bit, debug_line_offset present
   .long 0                       # debug_line_offset
   .byte 3                       # DW_MACRO_start_file
   .byte 0                       # Line Number
   .byte 0                       # File Number
   .byte 3                       # DW_MACRO_start_file
   .byte 1                       # Line Number
   .byte 6                       # File Number
   .byte 5                       # DW_MACRO_define_strp
   .byte 1                       # Line Number
   .long .Linfo_string0          # Macro String
   .byte 4                       # DW_MACRO_end_file
   .byte 6                       # DW_MACRO_undef_strp
   .byte 8                       # Line Number
   .long .Linfo_string1          # Macro String
+  .byte 7                       # DW_MACRO_import
+  .long .Lmacro1                # Macro Unit Offset
   .byte 4                       # DW_MACRO_end_file
   .byte 0                       # End Of Macro List Mark
+
+.Lmacro1:
   .short  5                      # Macro information version
   .byte 0                       # Flags: 32 bit
   .byte 5                       # DW_MACRO_define_strp
   .byte 0                       # Line Number
   .long .Linfo_string2          # Macro String
   .byte 0                       # End Of Macro List Mark
 
   .section  .debug_str,"MS",@progbits,1
 .Linfo_string0:
   .asciz  "FOO 5"
 .Linfo_string1:
   .asciz  "WORLD1"
 .Linfo_string2:
   .asciz  "WORLD 2"