[LLDB] - Add support for DW_FORM_implicit_const.

[grimar]

Summary

LLDB does not support this DWARF5 form atm.
At least gcc emits it in some cases when doing optimization
for abbreviations.

As far I can tell, clang does not support it yet, though
the rest LLVM code already knows about it.

The patch adds the support.

[vsk]

Could you describe how the test exercises DW_FORM_implicit_const support? It's not immediately clear to me.

[grimar]

In D52689#1253175, @vsk wrote:

Could you describe how the test exercises DW_FORM_implicit_const support? It's not immediately clear to me.

The abbreviation for foo1 and foo2 subprograms use it for DW_AT_decl_file and DW_AT_decl_column:

[1] DW_TAG_subprogram	DW_CHILDREN_no
	DW_AT_external	DW_FORM_flag_present
	DW_AT_name	DW_FORM_strp
	DW_AT_decl_file	DW_FORM_implicit_const	1
	DW_AT_decl_line	DW_FORM_data1
	DW_AT_decl_column	DW_FORM_implicit_const	5
	DW_AT_linkage_name	DW_FORM_strp
	DW_AT_type	DW_FORM_ref4
	DW_AT_low_pc	DW_FORM_addr
	DW_AT_high_pc	DW_FORM_data8
	DW_AT_frame_base	DW_FORM_exprloc
	DW_AT_call_all_calls	DW_FORM_flag_present

[grimar]

Ping.

[clayborg]

See inline comments.

source/Plugins/SymbolFile/DWARF/DWARFAbbreviationDeclaration.h

41

Switch to using a "DWARFFormValue *form_value_ptr" so the form value can be filled in automatically, not just the DWARFFormValue::ValueType. See comments below where this is called.

source/Plugins/SymbolFile/DWARF/DWARFDebugInfoEntry.cpp

387

Remove this as it won't be needed if we do the work of filling in the form value in GetAttrAndFormByIndexUnchecked

426

Remove? See inlined comment below.

428–435

Maybe switch the order here and pass "form_value" to GetAttrAndFormByIndexUnchecked?:

DWARFFormValue form_value(cu, form);
abbrevDecl->GetAttrAndFormByIndexUnchecked(i, attr, form, &form_value);

501

Revert this if we do the work inside "GetAttrAndFormByIndexUnchecked" as form_value will be correct

506

You changed the logic here incorrectly from == to !=

507

Revert this if we do the work inside "GetAttrAndFormByIndexUnchecked" as form_value will be correct

511

You changed the logic here incorrectly from == to !=

512

Revert this if we do the work inside "GetAttrAndFormByIndexUnchecked" as form_value will be correct

516

You changed the logic here incorrectly from == to !=

517

Revert this if we do the work inside "GetAttrAndFormByIndexUnchecked" as form_value will be correct

521

Revert this if we do the work inside "GetAttrAndFormByIndexUnchecked" as form_value will be correct

source/Plugins/SymbolFile/DWARF/DWARFFormValue.cpp

158–159

Revert this if we do the work inside "GetAttrAndFormByIndexUnchecked" as form_value will be filled in by that call

source/Plugins/SymbolFile/DWARF/DWARFFormValue.h

59–60

Revert this if we do the work inside "GetAttrAndFormByIndexUnchecked" as form_value will be filled in by that call

[grimar]

• Addressed review comments.

source/Plugins/SymbolFile/DWARF/DWARFAbbreviationDeclaration.h

41

Answered below.

source/Plugins/SymbolFile/DWARF/DWARFDebugInfoEntry.cpp

387

Answered below.

428–435

DWARFFormValue form_value(cu, form);

We can not do this because at this point form is not yet known.
I changed the code in a bit different way though.

501

The problem I see here is the following:

DWARF5 spec says (2.14 Declaration Coordinates, p50):
"Any debugging information entry representing the declaration of an object,
module, subprogram or type may have DW_AT_decl_file, DW_AT_decl_line and
DW_AT_decl_column attributes, each of whose value is an unsigned integer
constant."

But about DW_FORM_implicit_const it says (p207):

"The attribute form DW_FORM_implicit_const is another special case. For
attributes with this form, the attribute specification contains a third part, which is
a signed LEB128 number. The value of this number is used as the value of the
attribute, and no value is stored in the .debug_info section."

So I read DW_FORM_implicit_const to value.sval and I think we can not
use form_value.Unsigned(); in that case because it reads from uval.
Writing to one union field and reading from the another is undefined behavior in C++ I believe.
Though it works with the modern compilers I think.

DWARFFormValue.h contains dead enum (it is unused)
https://github.com/llvm-mirror/lldb/blob/master/source/Plugins/SymbolFile/DWARF/DWARFFormValue.h#L51
which intention seems was about to keep the value type information.
Should we start to set and check the type of form value?

I removed the helper for now, but this UB should be addressed somehow I think?

Should we create`DWARFFormValue::GetSignedOrUnsigned` may be? It perhaps will be consistent
with DWARFFormValue::Address/AsCStringwhich check the form type and returned value depends
on that.

[clayborg]

A few things inlined. Very close. DumpAttribute will need to take a DWARFFormValue in order to dump the value correctly.

source/Plugins/SymbolFile/DWARF/DWARFAbbreviationDeclaration.h

43–44

It would be nice to be able to access the dw_form_t and DWARFFormValue::ValueType within "form_value" without having to create a temp variables here for both "form" and "val". Fine to add accessors that return references for the form_t and DWARFFormValue::ValueType to DWARFFormValue.

45–46

If we are able to follow my last inline comment, then these go away.

source/Plugins/SymbolFile/DWARF/DWARFAttribute.h

23

Do we need to use a "DWARFFormValue::ValueType" here? Right now we only need a int64_t and DWARFFormValue::ValueType is larger than that. It does future proof us a bit and there aren't all that many abbreviations, even in a large DWARF file. Just thinking out loud here

source/Plugins/SymbolFile/DWARF/DWARFDebugInfoEntry.cpp

630–631

DumpAttribute will need to take the full form_value in order to dump DW_FORM_implicit_const forms correctly. Change DumpAttribute to take a "form_value"

[grimar]

• Addressed review comments.

source/Plugins/SymbolFile/DWARF/DWARFAttribute.h

23

My thoughts to use DWARFFormValue::ValueType were that it seems a bit more generic,
as standard can add other kinds of values rather than int64_t perhaps in future.
And it seems to be a bit cleaner because DWARFFormValue::ValueType is already
existent class representing the form value while int64_t would be kind of exception/special case.
I agree that for now, it is a bit excessive to have DWARFFormValue::ValueType here though.

source/Plugins/SymbolFile/DWARF/DWARFDebugInfoEntry.cpp

630–631

Done. I had to make it non-const DWARFFormValue &form_value because ExtractValue call inside DumpAttribute is not const.
As an alternative, we could probably use pass it by value here. But since there is a only one DumpAttribute call, I think its ok.

[clayborg]

Down to just modifying the DWARFFormValue constructor to be able to take a CU only. Looks good.

source/Plugins/SymbolFile/DWARF/DWARFDebugInfoEntry.cpp

241–242

Make either a constructor that takes just a CU or provide a default value for the dw_form_t form? Then this code will be:

DWARFFormValue form_value(cu);

429–430

Make either a constructor that takes just a CU or provide a default value for the dw_form_t form? Then this code will be:

DWARFFormValue form_value(cu);

625–626

Make either a constructor that takes just a CU or provide a default value for the dw_form_t form? Then this code will be:

DWARFFormValue form_value(cu);

803–804

Make either a constructor that takes just a CU or provide a default value for the dw_form_t form? Then this code will be:

DWARFFormValue form_value(cu);

[grimar]

• Addressed review comments.

[clayborg]

Thanks for making the changes. Looks good!

lit/Breakpoint/Inputs/implicit_const_form_support.yaml

+--- !ELF
+FileHeader:
+  Class:           ELFCLASS64
+  Data:            ELFDATA2LSB
+  Type:            ET_EXEC
+  Machine:         EM_X86_64
+  Entry:           0x00000000004004A0
+Sections:
+  - Name:            .text
+    Type:            SHT_PROGBITS
+    Flags:           [ SHF_ALLOC, SHF_EXECINSTR ]
+    Address:         0x00000000004004A0
+    AddressAlign:    0x0000000000000010
+    Content:         31ED4989D15E4889E24883E4F0505449C7C01006400048C7C1A005400048C7C77E054000E8B7FFFFFFF4660F1F440000B820204000483D202040007413B8000000004885C07409BF20204000FFE06690C30F1F440000662E0F1F840000000000BE202040004881EE2020400048C1FE034889F048C1E83F4801C648D1FE7411B8000000004885C07407BF20204000FFE0C30F1F440000662E0F1F840000000000803DD91A0000007517554889E5E87EFFFFFFC605C71A0000015DC30F1F440000C30F1F440000662E0F1F840000000000EB8EB800000000C3B800000000C3554889E5534883EC08E8E6FFFFFF89C3E8E5FFFFFF01D84883C4085B5DC30F1F4000415741564189FF415541544C8D251618000055488D2D16180000534989F64989D54C29E54883EC0848C1FD03E877FEFFFF4885ED742031DB0F1F8400000000004C89EA4C89F64489FF41FF14DC4883C3014839EB75EA4883C4085B5D415C415D415E415FC390662E0F1F840000000000F3C3
+  - Name:            .debug_frame
+    Type:            SHT_PROGBITS
+    AddressAlign:    0x0000000000000008
+    Content:         14000000FFFFFFFF03000178100C0708900100000000000014000000000000007205400000000000060000000000000014000000000000007805400000000000060000000000000034000000000000007E054000000000001E0000000000000004010000000E10860204030000000D060405000000830304140000000C070800
+  - Name:            .debug_info
+    Type:            SHT_PROGBITS
+    AddressAlign:    0x0000000000000001
+    Content:         900000000500010800000000023A00000021310000000000000072054000000000002A0000000000000000000000039A0000000109054C0000007E054000000000001E00000000000000019C040405696E7400012C000000059F0000004C00000078054000000000000600000000000000019C018C00000001910000004C00000072054000000000000600000000000000019C00
+  - Name:            .debug_abbrev
+    Type:            SHT_PROGBITS
+    AddressAlign:    0x0000000000000001
+    Content:         012E003F19030E3A21013B0B3921056E0E49131101120740187A190000021101250E130B030E1B0E1101120710170000032E003F19030E3A0B3B0B390B49131101120740187C1900000424000B0B3E0B0308000000
+  - Name:            .debug_aranges
+    Type:            SHT_PROGBITS
+    AddressAlign:    0x0000000000000001
+    Content:         2C00000002000000000008000000000072054000000000002A0000000000000000000000000000000000000000000000
+  - Name:            .debug_line
+    Type:            SHT_PROGBITS
+    AddressAlign:    0x0000000000000001
+    Content:         5600000002001F0000000101FB0E0D00010101010000000100000100746573742E6370700000000000050C000902720540000000000001050913050159050C22050913050159050C22050D9105167405175805012F0207000101
+  - Name:            .debug_str
+    Type:            SHT_PROGBITS
+    Flags:           [ SHF_MERGE, SHF_STRINGS ]
+    AddressAlign:    0x0000000000000001
+    Content:         2F686F6D652F756D622F74657374735F323031382F3130315F696D706C696369745F636F6E73742F6E657700666F6F3200746573742E63707000474E5520432B2B313420382E302E3120323031383033313920286578706572696D656E74616C29202D6D74756E653D67656E65726963202D6D617263683D7838362D3634202D67202D6764776172662D3500666F6F31005F5A34666F6F3176006D61696E005F5A34666F6F327600
+Symbols:
+...

lit/Breakpoint/implicit_const_form_support.test

+# RUN: yaml2obj %p/Inputs/implicit_const_form_support.yaml > %ttest
+# RUN: lldb-test breakpoints %ttest %s | FileCheck %s
+
+## The intention of the test is to check that DW_FORM_implicit_const
+## is supported and handled properly.
+
+## About implicit_const_form_support.yaml:
+## The following invocation and code were used to produce the binary
+## which was converted to yaml and reduced:
+## gcc version 8.0.1 20180319 (experimental) (GCC)
+##
+## g++ test.cpp -g -gdwarf-5 -o test
+##
+## // test.cpp
+## int foo1() {
+##  return 0;
+## }
+## 
+## int foo2() {
+##  return 0;
+## }
+## 
+## int main() {
+##  return foo1() + foo2();
+## }
+
+b foo1
+# CHECK-LABEL: b foo1
+# CHECK: Address: {{.*}}foo1() at test.cpp:2:9
+
+b foo2
+# CHECK-LABEL: b foo2
+# CHECK: Address: {{.*}}foo2() at test.cpp:6:9

source/Plugins/SymbolFile/DWARF/DWARFAbbreviationDeclaration.h

public:
   bool HasChildren() const { return m_has_children; }
   size_t NumAttributes() const { return m_attributes.size(); }
   dw_attr_t GetAttrByIndex(uint32_t idx) const {
     return m_attributes.size() > idx ? m_attributes[idx].get_attr() : 0;
   }
   dw_form_t GetFormByIndex(uint32_t idx) const {
     return m_attributes.size() > idx ? m_attributes[idx].get_form() : 0;
   }
-  bool GetAttrAndFormByIndex(uint32_t idx, dw_attr_t &attr,
-                             dw_form_t &form) const {
-    if (m_attributes.size() > idx) {
-      m_attributes[idx].get(attr, form);
-      return true;
-    }
-    attr = form = 0;
-    return false;
-  }
 
-  // idx is assumed to be valid when calling GetAttrAndFormByIndexUnchecked()
-  void GetAttrAndFormByIndexUnchecked(uint32_t idx, dw_attr_t &attr,
-                                      dw_form_t &form) const {
-    m_attributes[idx].get(attr, form);
+  // idx is assumed to be valid when calling GetAttrAndFormByIndex()
+  void GetAttrAndFormValueByIndex(uint32_t idx, dw_attr_t &attr,
+                                  DWARFFormValue &form_value) const {
+    m_attributes[idx].get(attr, form_value.FormRef(), form_value.ValueRef());
   }
   dw_form_t GetFormByIndexUnchecked(uint32_t idx) const {
     return m_attributes[idx].get_form();
   }
   uint32_t FindAttributeIndex(dw_attr_t attr) const;
   bool Extract(const lldb_private::DWARFDataExtractor &data,
                lldb::offset_t *offset_ptr);
   bool Extract(const lldb_private::DWARFDataExtractor &data,
                lldb::offset_t *offset_ptr, dw_uleb128_t code);
   bool IsValid();
   void Dump(lldb_private::Stream *s) const;
   bool operator==(const DWARFAbbreviationDeclaration &rhs) const;

source/Plugins/SymbolFile/DWARF/DWARFAbbreviationDeclaration.cpp

bool DWARFAbbreviationDeclaration::Extract(const DWARFDataExtractor &data,
   m_attributes.clear();
   if (m_code) {
     m_tag = data.GetULEB128(offset_ptr);
     m_has_children = data.GetU8(offset_ptr);
 
     while (data.ValidOffset(*offset_ptr)) {
       dw_attr_t attr = data.GetULEB128(offset_ptr);
       dw_form_t form = data.GetULEB128(offset_ptr);
+      DWARFFormValue::ValueType val;
+
+      if (form == DW_FORM_implicit_const)
+        val.value.sval = data.GetULEB128(offset_ptr);
 
       if (attr && form)
-        m_attributes.push_back(DWARFAttribute(attr, form));
+        m_attributes.push_back(DWARFAttribute(attr, form, val));
       else
         break;
     }
 
     return m_tag != 0;
   } else {
     m_tag = 0;
     m_has_children = 0;

source/Plugins/SymbolFile/DWARF/DWARFAttribute.h

 //===-- DWARFAttribute.h ----------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef SymbolFileDWARF_DWARFAttribute_h_
 #define SymbolFileDWARF_DWARFAttribute_h_
 
 #include "DWARFDefines.h"
+#include "DWARFFormValue.h"
 #include "llvm/ADT/SmallVector.h"
 #include <vector>
 
 class DWARFUnit;
-class DWARFFormValue;
 
 class DWARFAttribute {
 public:
-  DWARFAttribute(dw_attr_t attr, dw_form_t form) : m_attr(attr), m_form(form) {}
+  DWARFAttribute(dw_attr_t attr, dw_form_t form,
+                 DWARFFormValue::ValueType value)
+      : m_attr(attr), m_form(form), m_value(value) {}
 
   void set(dw_attr_t attr, dw_form_t form) {
     m_attr = attr;
     m_form = form;
   }
   void set_attr(dw_attr_t attr) { m_attr = attr; }
   void set_form(dw_form_t form) { m_form = form; }
   dw_attr_t get_attr() const { return m_attr; }
   dw_form_t get_form() const { return m_form; }
-  void get(dw_attr_t &attr, dw_form_t &form) const {
+  void get(dw_attr_t &attr, dw_form_t &form,
+           DWARFFormValue::ValueType &val) const {
     attr = m_attr;
     form = m_form;
+    val = m_value;
   }
   bool operator==(const DWARFAttribute &rhs) const {
     return m_attr == rhs.m_attr && m_form == rhs.m_form;
   }
   typedef std::vector<DWARFAttribute> collection;
   typedef collection::iterator iterator;
   typedef collection::const_iterator const_iterator;
 
 protected:
   dw_attr_t m_attr;
   dw_form_t m_form;
+  DWARFFormValue::ValueType m_value;
 };
 
 class DWARFAttributes {
 public:
   DWARFAttributes();
   ~DWARFAttributes();
 
   void Append(const DWARFUnit *cu, dw_offset_t attr_die_offset,

source/Plugins/SymbolFile/DWARF/DWARFAttribute.cpp

uint32_t DWARFAttributes::FindAttributeIndex(dw_attr_t attr) const {
   collection::const_iterator pos;
   for (pos = beg; pos != end; ++pos) {
     if (pos->attr.get_attr() == attr)
       return std::distance(beg, pos);
   }
   return UINT32_MAX;
 }
 
-void DWARFAttributes::Append(const DWARFUnit *cu,
-                             dw_offset_t attr_die_offset, dw_attr_t attr,
-                             dw_form_t form) {
-  AttributeValue attr_value = {cu, attr_die_offset, {attr, form}};
+void DWARFAttributes::Append(const DWARFUnit *cu, dw_offset_t attr_die_offset,
+                             dw_attr_t attr, dw_form_t form) {
+  AttributeValue attr_value = {
+      cu, attr_die_offset, {attr, form, DWARFFormValue::ValueType()}};
   m_infos.push_back(attr_value);
 }
 
 bool DWARFAttributes::ContainsAttribute(dw_attr_t attr) const {
   return FindAttributeIndex(attr) != UINT32_MAX;
 }
 
 bool DWARFAttributes::RemoveAttribute(dw_attr_t attr) {

source/Plugins/SymbolFile/DWARF/DWARFDebugInfoEntry.h

public:
   void DumpAncestry(SymbolFileDWARF *dwarf2Data, const DWARFUnit *cu,
                     const DWARFDebugInfoEntry *oldest, lldb_private::Stream &s,
                     uint32_t recurse_depth) const;
 
   static void
   DumpAttribute(SymbolFileDWARF *dwarf2Data, const DWARFUnit *cu,
                 const lldb_private::DWARFDataExtractor &debug_info_data,
                 lldb::offset_t *offset_ptr, lldb_private::Stream &s,
-                dw_attr_t attr, dw_form_t form);
+                dw_attr_t attr, DWARFFormValue &form_value);
   // This one dumps the comp unit name, objfile name and die offset for this die
   // so the stream S.
   void DumpLocation(SymbolFileDWARF *dwarf2Data, DWARFUnit *cu,
                     lldb_private::Stream &s) const;
 
   bool
   GetDIENamesAndRanges(SymbolFileDWARF *dwarf2Data, const DWARFUnit *cu,
                        const char *&name, const char *&mangled,

source/Plugins/SymbolFile/DWARF/DWARFDebugInfoEntry.cpp

for (i = 0; i < numAttributes; ++i) {
           case DW_FORM_strp:
           case DW_FORM_sec_offset:
             if (cu->IsDWARF64())
               debug_info_data.GetU64(&offset);
             else
               debug_info_data.GetU32(&offset);
             break;
 
+          case DW_FORM_implicit_const:
+            form_size = 0;
+            break;
+
           default:
             *offset_ptr = m_offset;
             return false;
           }
           offset += form_size;
 
         } while (form_is_indirect);
       }
if (abbr_idx) {
 
         bool isCompileUnitTag = (m_tag == DW_TAG_compile_unit ||
                                  m_tag == DW_TAG_partial_unit);
         if (cu && isCompileUnitTag)
           const_cast<DWARFUnit *>(cu)->SetBaseAddress(0);
 
         // Skip all data in the .debug_info for the attributes
         const uint32_t numAttributes = abbrevDecl->NumAttributes();
-        uint32_t i;
+        for (uint32_t i = 0; i < numAttributes; ++i) {
+          DWARFFormValue form_value;
+          form_value.SetCompileUnit(cu);
+
           dw_attr_t attr;
-        dw_form_t form;
-        for (i = 0; i < numAttributes; ++i) {
-          abbrevDecl->GetAttrAndFormByIndexUnchecked(i, attr, form);
+          abbrevDecl->GetAttrAndFormValueByIndex(i, attr, form_value);
+          dw_form_t form = form_value.Form();
 
           if (isCompileUnitTag &&
               ((attr == DW_AT_entry_pc) || (attr == DW_AT_low_pc))) {
-            DWARFFormValue form_value(cu, form);
             if (form_value.ExtractValue(debug_info_data, &offset)) {
               if (attr == DW_AT_low_pc || attr == DW_AT_entry_pc)
                 const_cast<DWARFUnit *>(cu)->SetBaseAddress(
                     form_value.Address());
             }
           } else {
             bool form_is_indirect = false;
             do {
if (abbr_idx) {
                 if (cu->GetVersion() <= 2)
                   form_size = cu->GetAddressByteSize();
                 else
                   form_size = cu->IsDWARF64() ? 8 : 4;
                 break;
 
               // 0 sized form
               case DW_FORM_flag_present:
+              case DW_FORM_implicit_const:
                 form_size = 0;
                 break;
 
               // 1 byte values
               case DW_FORM_data1:
               case DW_FORM_flag:
               case DW_FORM_ref1:
                 form_size = 1;
void DWARFDebugInfoEntry::DumpAncestry(SymbolFileDWARF *dwarf2Data,
                                        Stream &s,
                                        uint32_t recurse_depth) const {
   const DWARFDebugInfoEntry *parent = GetParent();
   if (parent && parent != oldest)
     parent->DumpAncestry(dwarf2Data, cu, oldest, s, 0);
   Dump(dwarf2Data, cu, s, recurse_depth);
 }
 
 //----------------------------------------------------------------------
 // GetDIENamesAndRanges
 //
 // Gets the valid address ranges for a given DIE by looking for a
 // DW_AT_low_pc/DW_AT_high_pc pair, DW_AT_entry_pc, or DW_AT_ranges attributes.
 //----------------------------------------------------------------------
 bool DWARFDebugInfoEntry::GetDIENamesAndRanges(
     SymbolFileDWARF *dwarf2Data, const DWARFUnit *cu, const char *&name,
     const char *&mangled, DWARFRangeList &ranges, int &decl_file,
bool DWARFDebugInfoEntry::GetDIENamesAndRanges(
 
   if (abbrevDecl) {
     const DWARFDataExtractor &debug_info_data = cu->GetData();
 
     if (!debug_info_data.ValidOffset(offset))
       return false;
 
     const uint32_t numAttributes = abbrevDecl->NumAttributes();
-    uint32_t i;
-    dw_attr_t attr;
-    dw_form_t form;
     bool do_offset = false;
 
-    for (i = 0; i < numAttributes; ++i) {
-      abbrevDecl->GetAttrAndFormByIndexUnchecked(i, attr, form);
-      DWARFFormValue form_value(cu, form);
+    for (uint32_t i = 0; i < numAttributes; ++i) {
+      DWARFFormValue form_value;
+      form_value.SetCompileUnit(cu);
+
+      dw_attr_t attr;
+      abbrevDecl->GetAttrAndFormValueByIndex(i, attr, form_value);
+
       if (form_value.ExtractValue(debug_info_data, &offset)) {
         switch (attr) {
         case DW_AT_low_pc:
           lo_pc = form_value.Address();
 
           if (do_offset)
             hi_pc += lo_pc;
           do_offset = false;
           break;
for (uint32_t i = 0; i < numAttributes; ++i) {
           break;
 
         case DW_AT_specification:
           die_refs.emplace_back(form_value);
           break;
 
         case DW_AT_decl_file:
           if (decl_file == 0)
             decl_file = form_value.Unsigned();
           break;
 
         case DW_AT_decl_line:
           if (decl_line == 0)
             decl_line = form_value.Unsigned();
           break;
 
         case DW_AT_decl_column:
           if (decl_column == 0)
             decl_column = form_value.Unsigned();
           break;
 
         case DW_AT_call_file:
           if (call_file == 0)
             call_file = form_value.Unsigned();
           break;
 
         case DW_AT_call_line:
           if (call_line == 0)
             call_line = form_value.Unsigned();
           break;
 
         case DW_AT_call_column:
           if (call_column == 0)
             call_column = form_value.Unsigned();
           break;
 
         case DW_AT_frame_base:
if (abbrCode != m_abbr_idx) {
           cu->GetAbbreviations()->GetAbbreviationDeclaration(abbrCode);
 
       if (abbrevDecl) {
         s.PutCString(DW_TAG_value_to_name(abbrevDecl->Tag()));
         s.Printf(" [%u] %c\n", abbrCode, abbrevDecl->HasChildren() ? '*' : ' ');
 
         // Dump all data in the .debug_info for the attributes
         const uint32_t numAttributes = abbrevDecl->NumAttributes();
-        uint32_t i;
+        for (uint32_t i = 0; i < numAttributes; ++i) {
+          DWARFFormValue form_value;
+          form_value.SetCompileUnit(cu);
           dw_attr_t attr;
-        dw_form_t form;
-        for (i = 0; i < numAttributes; ++i) {
-          abbrevDecl->GetAttrAndFormByIndexUnchecked(i, attr, form);
+          abbrevDecl->GetAttrAndFormValueByIndex(i, attr, form_value);
 
           DumpAttribute(dwarf2Data, cu, debug_info_data, &offset, s, attr,
-                        form);
+                        form_value);
         }
 
         const DWARFDebugInfoEntry *child = GetFirstChild();
         if (recurse_depth > 0 && child) {
           s.IndentMore();
 
           while (child) {
             child->Dump(dwarf2Data, cu, s, recurse_depth - 1);

 //
 // Dumps a debug information entry attribute along with it's form. Any special
 // display of attributes is done (disassemble location lists, show enumeration
 // values for attributes, etc).
 //----------------------------------------------------------------------
 void DWARFDebugInfoEntry::DumpAttribute(
     SymbolFileDWARF *dwarf2Data, const DWARFUnit *cu,
     const DWARFDataExtractor &debug_info_data, lldb::offset_t *offset_ptr,
-    Stream &s, dw_attr_t attr, dw_form_t form) {
+    Stream &s, dw_attr_t attr, DWARFFormValue &form_value) {
   bool show_form = s.GetFlags().Test(DWARFDebugInfo::eDumpFlag_ShowForm);
 
   s.Printf("            ");
   s.Indent(DW_AT_value_to_name(attr));
 
   if (show_form) {
-    s.Printf("[%s", DW_FORM_value_to_name(form));
+    s.Printf("[%s", DW_FORM_value_to_name(form_value.Form()));
   }
 
-  DWARFFormValue form_value(cu, form);
-
   if (!form_value.ExtractValue(debug_info_data, offset_ptr))
     return;
 
   if (show_form) {
-    if (form == DW_FORM_indirect) {
+    if (form_value.Form() == DW_FORM_indirect) {
       s.Printf(" [%s]", DW_FORM_value_to_name(form_value.Form()));
     }
 
     s.PutCString("] ");
   }
 
   s.PutCString("( ");
 
size_t DWARFDebugInfoEntry::GetAttributes(
   if (abbrevDecl) {
     const DWARFDataExtractor &debug_info_data = cu->GetData();
 
     if (fixed_form_sizes.Empty())
       fixed_form_sizes = DWARFFormValue::GetFixedFormSizesForAddressSize(
           cu->GetAddressByteSize(), cu->IsDWARF64());
 
     const uint32_t num_attributes = abbrevDecl->NumAttributes();
-    uint32_t i;
+    for (uint32_t i = 0; i < num_attributes; ++i) {
+      DWARFFormValue form_value;
+      form_value.SetCompileUnit(cu);
+
       dw_attr_t attr;
-    dw_form_t form;
-    for (i = 0; i < num_attributes; ++i) {
-      abbrevDecl->GetAttrAndFormByIndexUnchecked(i, attr, form);
+      abbrevDecl->GetAttrAndFormValueByIndex(i, attr, form_value);
+      const dw_form_t form = form_value.Form();
 
       // If we are tracking down DW_AT_specification or DW_AT_abstract_origin
       // attributes, the depth will be non-zero. We need to omit certain
       // attributes that don't make sense.
       switch (attr) {
       case DW_AT_sibling:
       case DW_AT_declaration:
         if (curr_depth > 0) {
           // This attribute doesn't make sense when combined with the DIE that
           // references this DIE. We know a DIE is referencing this DIE because
           // curr_depth is not zero
           break;
         }
         LLVM_FALLTHROUGH;
       default:
         attributes.Append(cu, offset, attr, form);
         break;
       }
 
       if ((attr == DW_AT_specification) || (attr == DW_AT_abstract_origin)) {
-        DWARFFormValue form_value(cu, form);
         if (form_value.ExtractValue(debug_info_data, &offset)) {
           dw_offset_t die_offset = form_value.Reference();
           DWARFDIE spec_die =
               const_cast<DWARFUnit *>(cu)->GetDIE(die_offset);
           if (spec_die)
             spec_die.GetAttributes(attributes, curr_depth + 1);
         }
       } else {

source/Plugins/SymbolFile/DWARF/DWARFFormValue.h

enum {
     eValueTypeInvalid = 0,
     eValueTypeUnsigned,
     eValueTypeSigned,
     eValueTypeCStr,
     eValueTypeBlock
   };
 
   DWARFFormValue();
   DWARFFormValue(const DWARFUnit *cu, dw_form_t form);
   const DWARFUnit *GetCompileUnit() const { return m_cu; }
   void SetCompileUnit(const DWARFUnit *cu) { m_cu = cu; }
   dw_form_t Form() const { return m_form; }
+  dw_form_t& FormRef() { return m_form; }
   void SetForm(dw_form_t form) { m_form = form; }
   const ValueType &Value() const { return m_value; }
+  ValueType &ValueRef() { return m_value; }
+  void SetValue(const ValueType &val) { m_value = val; }
+
   void Dump(lldb_private::Stream &s) const;
   bool ExtractValue(const lldb_private::DWARFDataExtractor &data,
                     lldb::offset_t *offset_ptr);
   const uint8_t *BlockData() const;
   uint64_t Reference() const;
   uint64_t Reference(dw_offset_t offset) const;
   bool Boolean() const { return m_value.value.uval != 0; }
   uint64_t Unsigned() const { return m_value.value.uval; }

source/Plugins/SymbolFile/DWARF/DWARFFormValue.cpp

if (!is_dwarf64) {
     // is_dwarf64 && addr_size == 4 : no provider does this.
   }
   return FixedFormSizes();
 }
 
 DWARFFormValue::DWARFFormValue() : m_cu(NULL), m_form(0), m_value() {}
 
 DWARFFormValue::DWARFFormValue(const DWARFUnit *cu, dw_form_t form)
     : m_cu(cu), m_form(form), m_value() {}
 
 void DWARFFormValue::Clear() {
   m_cu = nullptr;
   m_form = 0;
   memset(&m_value, 0, sizeof(m_value));
 }
 
 bool DWARFFormValue::ExtractValue(const DWARFDataExtractor &data,
                                   lldb::offset_t *offset_ptr) {
+  if (m_form == DW_FORM_implicit_const)
+    return true;
+
   bool indirect = false;
   bool is_block = false;
   m_value.data = NULL;
   uint8_t ref_addr_size;
   // Read the value for the form into value and follow and DW_FORM_indirect
   // instances we run into
   do {
     indirect = false;
if (cu->GetVersion() <= 2)
       ref_addr_size = cu->GetAddressByteSize();
     else
       ref_addr_size = cu->IsDWARF64() ? 8 : 4;
     *offset_ptr += ref_addr_size;
     return true;
 
   // 0 bytes values (implied from DW_FORM)
   case DW_FORM_flag_present:
+  case DW_FORM_implicit_const:
     return true;
 
     // 1 byte values
     case DW_FORM_data1:
     case DW_FORM_flag:
     case DW_FORM_ref1:
     case DW_FORM_strx1:
       *offset_ptr += 1;
switch (form) {
     case DW_FORM_ref_udata:
     case DW_FORM_indirect:
     case DW_FORM_sec_offset:
     case DW_FORM_exprloc:
     case DW_FORM_flag_present:
     case DW_FORM_ref_sig8:
     case DW_FORM_GNU_str_index:
     case DW_FORM_GNU_addr_index:
+    case DW_FORM_implicit_const:
       return true;
     default:
       break;
   }
   return false;
 }