[DWARF] Add CIE header fields address_size and segment_size when generating dwarf-4

[keith.walker.arm]

Summary

The DWARF-4 specification added 2 new fields in the CIE header called address_size and segment_size.
Create these 2 new fields when generating dwarf-4 CIE entries, print out the new fields when dumping the CIE and update tests

[keith.walker.arm]

Forgot to subscribe llvm-commits to the phabricator subscriber field, so repeating the initial summary as a comment in the hope this will make it to the mailing list.

The DWARF-4 specification added 2 new fields in the CIE header called address_size and segment_size.
Create these 2 new fields when generating dwarf-4 CIE entries, print out the new fields when dumping the CIE and update tests

[probinson]

Granted DWARF calls the field "segment_size" but actually it's a segment _selector_ size. (Maybe we should fix that name for DWARF 5...)

lib/MC/MCDwarf.cpp

1310

LLVM doesn't support any targets with segmented addresses?

test/MC/ARM/dwarf-cfi-initial-state.s

17

It's not clear to me where these extra nops came from.

[keith.walker.arm]

Paul,

Thanks for review my patch. I agree that segment_descriptor-size does appear to be a more appropriate name.

lib/MC/MCDwarf.cpp

1310

I believe not. The existing similar field in the header in the .debug_aranges section generated by the function EmitGenDwarfAranges() in the same source file does the same and just puts 0 in the segment (descriptor) size field.

test/MC/ARM/dwarf-cfi-initial-state.s

17

They are the DW_CFA_nop entries in the "padding" field in the CIE that are added to make the CIE the length specified in the length field. Adding the 2 new fields changed the length of the CIE and as a side-effect this inserts the 2 bytes of padding.

I'll add a comment to the test to make this clearer

[keith.walker.arm]

Changed SegmentSize to SegmentDescriptorSize.
Added comment to CIE test to explain that the DW_CFA_nop instructions are padding.

[probinson]

One nit in the dump routine and LGTM.

lib/DebugInfo/DWARF/DWARFDebugFrame.cpp

217

"Segment desc size:" here, or something similar.

lib/DebugInfo/DWARF/DWARFDebugFrame.cpp

 
 namespace {
 /// \brief DWARF Common Information Entry (CIE)
 class CIE : public FrameEntry {
 public:
   // CIEs (and FDEs) are simply container classes, so the only sensible way to
   // create them is by providing the full parsed contents in the constructor.
   CIE(uint64_t Offset, uint64_t Length, uint8_t Version,
-      SmallString<8> Augmentation, uint64_t CodeAlignmentFactor,
+      SmallString<8> Augmentation, uint8_t AddressSize,
+      uint8_t SegmentSize, uint64_t CodeAlignmentFactor,
       int64_t DataAlignmentFactor, uint64_t ReturnAddressRegister)
       : FrameEntry(FK_CIE, Offset, Length), Version(Version),
         Augmentation(std::move(Augmentation)),
+        AddressSize(AddressSize),
+        SegmentSize(SegmentSize),
         CodeAlignmentFactor(CodeAlignmentFactor),
         DataAlignmentFactor(DataAlignmentFactor),
         ReturnAddressRegister(ReturnAddressRegister) {}
 
   ~CIE() override {}
 
   uint64_t getCodeAlignmentFactor() const { return CodeAlignmentFactor; }
   int64_t getDataAlignmentFactor() const { return DataAlignmentFactor; }
 
   void dumpHeader(raw_ostream &OS) const override {
     OS << format("%08x %08x %08x CIE",
                  (uint32_t)Offset, (uint32_t)Length, DW_CIE_ID)
        << "\n";
     OS << format("  Version:               %d\n", Version);
     OS << "  Augmentation:          \"" << Augmentation << "\"\n";
+    if (Version >= 4) {
+      OS << format("  Address size:          %u\n",
+                   (uint32_t)AddressSize);
+      OS << format("  Segment size:          %u\n",
+                   (uint32_t)SegmentSize);
+    }
     OS << format("  Code alignment factor: %u\n",
                  (uint32_t)CodeAlignmentFactor);
     OS << format("  Data alignment factor: %d\n",
                  (int32_t)DataAlignmentFactor);
     OS << format("  Return address column: %d\n",
                  (int32_t)ReturnAddressRegister);
     OS << "\n";
   }
 
   static bool classof(const FrameEntry *FE) {
     return FE->getKind() == FK_CIE;
   }
 
 private:
-  /// The following fields are defined in section 6.4.1 of the DWARF standard v3
+  /// The following fields are defined in section 6.4.1 of the DWARF standard v4
   uint8_t Version;
   SmallString<8> Augmentation;
+  uint8_t AddressSize;
+  uint8_t SegmentSize;
   uint64_t CodeAlignmentFactor;
   int64_t DataAlignmentFactor;
   uint64_t ReturnAddressRegister;
 };
 
 
 /// \brief DWARF Frame Description Entry (FDE)
 class FDE : public FrameEntry {
while (Data.isValidOffset(Offset)) {
     //       offset_ptr as uint64_t*
     uint32_t EndStructureOffset = Offset + static_cast<uint32_t>(Length);
 
     // The Id field's size depends on the DWARF format
     Id = Data.getUnsigned(&Offset, IsDWARF64 ? 8 : 4);
     bool IsCIE = ((IsDWARF64 && Id == DW64_CIE_ID) || Id == DW_CIE_ID);
 
     if (IsCIE) {
-      // Note: this is specifically DWARFv3 CIE header structure. It was
-      // changed in DWARFv4. We currently don't support reading DWARFv4
-      // here because LLVM itself does not emit it (and LLDB doesn't
-      // support it either).
       uint8_t Version = Data.getU8(&Offset);
       const char *Augmentation = Data.getCStr(&Offset);
+      uint8_t AddressSize = Version < 4 ? Data.getAddressSize() : Data.getU8(&Offset);
+      Data.setAddressSize(AddressSize);
+      uint8_t SegmentSize = Version < 4 ? 0 : Data.getU8(&Offset);
       uint64_t CodeAlignmentFactor = Data.getULEB128(&Offset);
       int64_t DataAlignmentFactor = Data.getSLEB128(&Offset);
       uint64_t ReturnAddressRegister = Data.getULEB128(&Offset);
 
       auto Cie = make_unique<CIE>(StartOffset, Length, Version,
-                                  StringRef(Augmentation), CodeAlignmentFactor,
+                                  StringRef(Augmentation), AddressSize,
+                                  SegmentSize, CodeAlignmentFactor,
                                   DataAlignmentFactor, ReturnAddressRegister);
       CIEs[StartOffset] = Cie.get();
       Entries.emplace_back(std::move(Cie));
     } else {
       // FDE
       uint64_t CIEPointer = Id;
       uint64_t InitialLocation = Data.getAddress(&Offset);
       uint64_t AddressRange = Data.getAddress(&Offset);

lib/MC/MCDwarf.cpp

if (lsda)
       Augmentation += "L";
     Augmentation += "R";
     if (IsSignalFrame)
       Augmentation += "S";
     streamer.EmitBytes(Augmentation);
   }
   streamer.EmitIntValue(0, 1);
 
+  if (CIEVersion >= 4) {
+    // Address Size
+    streamer.EmitIntValue(context.getAsmInfo()->getPointerSize(), 1);
+
+    // Segment Size
+    streamer.EmitIntValue(0, 1);
+  }
+
   // Code Alignment Factor
   streamer.EmitULEB128IntValue(context.getAsmInfo()->getMinInstAlignment());
 
   // Data Alignment Factor
   streamer.EmitSLEB128IntValue(getDataAlignmentFactor(streamer));
 
   // Return Address Register
   if (CIEVersion == 1) {

test/MC/ARM/dwarf-cfi-initial-state.s

 # RUN: llvm-mc < %s -triple=armv7-linux-gnueabi -filetype=obj -o - \
 # RUN:     | llvm-dwarfdump - | FileCheck %s
 
 _proc:
 .cfi_sections .debug_frame
 .cfi_startproc
 bx lr
 .cfi_endproc
 
 # CHECK: .debug_frame contents:
 # CHECK: CIE
 # CHECK-NOT: DW_CFA
 # When llvm-dwarfdump prints the full info for the DW_CFA_def_cfa
 # field, we can check that here too.
 # CHECK: DW_CFA_def_cfa:
+# CHECK: DW_CFA_nop:
+# CHECK: DW_CFA_nop:
 # CHECK-NOT: DW_CFA
 # CHECK: FDE

test/MC/ELF/cfi-sections.s

-// RUN: llvm-mc -filetype=obj -triple x86_64-pc-linux-gnu %s -o - | llvm-readobj -s -sd | FileCheck -check-prefix=ELF_64 %s
-// RUN: llvm-mc -filetype=obj -triple i686-pc-linux-gnu %s -o - | llvm-readobj -s -sd | FileCheck -check-prefix=ELF_32 %s
+// RUN: llvm-mc -filetype=obj -triple x86_64-pc-linux-gnu -dwarf-version 2 %s -o - | llvm-readobj -s -sd | FileCheck -check-prefix=ELF_64 -check-prefix=ELF_64_DWARF_2 %s
+// RUN: llvm-mc -filetype=obj -triple i686-pc-linux-gnu -dwarf-version 2 %s -o - | llvm-readobj -s -sd | FileCheck -check-prefix=ELF_32 -check-prefix=ELF_32_DWARF_2 %s
+
+// RUN: llvm-mc -filetype=obj -triple x86_64-pc-linux-gnu -dwarf-version 3 %s -o - | llvm-readobj -s -sd | FileCheck -check-prefix=ELF_64 -check-prefix=ELF_64_DWARF_3 %s
+// RUN: llvm-mc -filetype=obj -triple i686-pc-linux-gnu -dwarf-version 3 %s -o - | llvm-readobj -s -sd | FileCheck -check-prefix=ELF_32 -check-prefix=ELF_32_DWARF_3 %s
+
+// RUN: llvm-mc -filetype=obj -triple x86_64-pc-linux-gnu -dwarf-version 4 %s -o - | llvm-readobj -s -sd | FileCheck -check-prefix=ELF_64 -check-prefix=ELF_64_DWARF_4 %s
+// RUN: llvm-mc -filetype=obj -triple i686-pc-linux-gnu -dwarf-version 4 %s -o - | llvm-readobj -s -sd | FileCheck -check-prefix=ELF_32 -check-prefix=ELF_32_DWARF_4 %s
 
 .cfi_sections .debug_frame
 
 f1:
         .cfi_startproc
         nop
         .cfi_endproc
 

 // ELF_64-NEXT:     Address: 0x0
 // ELF_64-NEXT:     Offset: 0x48
 // ELF_64-NEXT:     Size: 72
 // ELF_64-NEXT:     Link: 0
 // ELF_64-NEXT:     Info: 0
 // ELF_64-NEXT:     AddressAlignment: 8
 // ELF_64-NEXT:     EntrySize: 0
 // ELF_64-NEXT:     SectionData (
-// ELF_64-NEXT:       0000: 14000000 FFFFFFFF 04000178 100C0708
-// ELF_64-NEXT:       0010: 90010000 00000000 14000000 00000000
+// ELF_64_DWARF_2-NEXT:       0000: 14000000 FFFFFFFF 01000178 100C0708
+// ELF_64_DWARF_2-NEXT:       0010: 90010000 00000000 14000000 00000000
+// ELF_64_DWARF_3-NEXT:       0000: 14000000 FFFFFFFF 03000178 100C0708
+// ELF_64_DWARF_3-NEXT:       0010: 90010000 00000000 14000000 00000000
+// ELF_64_DWARF_4-NEXT:       0000: 14000000 FFFFFFFF 04000800 0178100C
+// ELF_64_DWARF_4-NEXT:       0010: 07089001 00000000 14000000 00000000
 // ELF_64-NEXT:       0020: 00000000 00000000 01000000 00000000
 // ELF_64-NEXT:       0030: 14000000 00000000 00000000 00000000
 // ELF_64-NEXT:       0040: 01000000 00000000
 // ELF_64-NEXT:     )
 // ELF_64-NEXT:   }
 
 // ELF_32:        Section {
 // ELF_32:          Name: .debug_frame
 // ELF_32-NEXT:     Type: SHT_PROGBITS
 // ELF_32-NEXT:     Flags [
 // ELF_32-NEXT:     ]
 // ELF_32-NEXT:     Address: 0x0
 // ELF_32-NEXT:     Offset: 0x38
 // ELF_32-NEXT:     Size: 52
 // ELF_32-NEXT:     Link: 0
 // ELF_32-NEXT:     Info: 0
 // ELF_32-NEXT:     AddressAlignment: 4
 // ELF_32-NEXT:     EntrySize: 0
 // ELF_32-NEXT:     SectionData (
-// ELF_32-NEXT:       0000: 10000000 FFFFFFFF 0400017C 080C0404
-// ELF_32-NEXT:       0010: 88010000 0C000000 00000000 00000000
+// ELF_32_DWARF_2-NEXT:       0000: 10000000 FFFFFFFF 0100017C 080C0404
+// ELF_32_DWARF_2-NEXT:       0010: 88010000 0C000000 00000000 00000000
+// ELF_32_DWARF_3-NEXT:       0000: 10000000 FFFFFFFF 0300017C 080C0404
+// ELF_32_DWARF_3-NEXT:       0010: 88010000 0C000000 00000000 00000000
+// ELF_32_DWARF_4-NEXT:       0000: 10000000 FFFFFFFF 04000400 017C080C
+// ELF_32_DWARF_4-NEXT:       0010: 04048801 0C000000 00000000 00000000
 // ELF_32-NEXT:       0020: 01000000 0C000000 00000000 01000000
 // ELF_32-NEXT:       0030: 01000000
+
 // ELF_32-NEXT:     )
 // ELF_32-NEXT:   }

test/MC/ELF/cfi-version.ll

 !9 = !{i32 2, !"Dwarf Version", i32 4}
 !10 = !{i32 1, !"Debug Info Version", i32 3}
 !11 = !{!"clang version 3.5.0 "}
 !12 = !DILocation(line: 2, scope: !4)
 
 ; DWARF2:      .debug_frame contents:
 ; DWARF2:        Version:               1
 ; DWARF2-NEXT:   Augmentation:
+; DWARF2-NOT:    Address size:
+; DWARF2-NOT:    Segment size:
 
 ; DWARF3:      .debug_frame contents:
 ; DWARF3:        Version:               3
 ; DWARF3-NEXT:   Augmentation:
+; DWARF3-NOT:    Address size:
+; DWARF3-NOT:    Segment size:
 
 ; DWARF4:      .debug_frame contents:
 ; DWARF4:        Version:               4
 ; DWARF4-NEXT:   Augmentation:
+; DWARF4:        Address size:
+; DWARF4:        Segment size: