[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

51

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

386

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

435

Remove? See inlined comment below.

439–440

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

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

508

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

512

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

513

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

517

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

518

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

522

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

523

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

528

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

source/Plugins/SymbolFile/DWARF/DWARFFormValue.cpp

157–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

51

Answered below.

source/Plugins/SymbolFile/DWARF/DWARFDebugInfoEntry.cpp

386

Answered below.

439–440

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.

508

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

53–54

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.

55–56

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

637–638

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

637–638

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

245–246

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);

440–441

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);

636–637

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);

816–817

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

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);
+  void GetAttrAndFormByIndexUnchecked(
+      uint32_t idx, dw_attr_t &attr, dw_form_t &form,
+      DWARFFormValue::ValueType *val = nullptr) const {
+    m_attributes[idx].get(attr, form, val);
   }
   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 = nullptr) const {
     attr = m_attr;
     form = m_form;
+    if (val)
+      *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.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) {
 
         // Skip all data in the .debug_info for the attributes
         const uint32_t numAttributes = abbrevDecl->NumAttributes();
         uint32_t i;
         dw_attr_t attr;
         dw_form_t form;
         for (i = 0; i < numAttributes; ++i) {
           abbrevDecl->GetAttrAndFormByIndexUnchecked(i, attr, 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 {
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);
 }
 
+static void setUnsignedOrSigned(int &dest, DWARFFormValue &val) {
+  if (val.Form() == DW_FORM_implicit_const)
+    dest = val.Signed();
+  else
+    dest = val.Unsigned();
+}
+
 //----------------------------------------------------------------------
 // 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,
if (abbrevDecl) {
 
     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;
+    DWARFFormValue::ValueType val;
     bool do_offset = false;
 
     for (i = 0; i < numAttributes; ++i) {
-      abbrevDecl->GetAttrAndFormByIndexUnchecked(i, attr, form);
-      DWARFFormValue form_value(cu, form);
+      abbrevDecl->GetAttrAndFormByIndexUnchecked(i, attr, form, &val);
+      DWARFFormValue form_value(cu, form, val);
+
       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;
for (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();
+            setUnsignedOrSigned(decl_file, form_value);
           break;
 
         case DW_AT_decl_line:
-          if (decl_line == 0)
-            decl_line = form_value.Unsigned();
+          if (decl_line != 0)
+            setUnsignedOrSigned(decl_line, form_value);
           break;
 
         case DW_AT_decl_column:
-          if (decl_column == 0)
-            decl_column = form_value.Unsigned();
+          if (decl_column != 0)
+            setUnsignedOrSigned(decl_column, form_value);
           break;
 
         case DW_AT_call_file:
-          if (call_file == 0)
-            call_file = form_value.Unsigned();
+          if (call_file != 0)
+            setUnsignedOrSigned(call_file, form_value);
           break;
 
         case DW_AT_call_line:
           if (call_line == 0)
-            call_line = form_value.Unsigned();
+            setUnsignedOrSigned(call_line, form_value);
           break;
 
         case DW_AT_call_column:
           if (call_column == 0)
-            call_column = form_value.Unsigned();
+            setUnsignedOrSigned(call_column, form_value);
           break;
 
         case DW_AT_frame_base:
           if (frame_base) {
             if (form_value.BlockData()) {
               uint32_t block_offset =
                   form_value.BlockData() - debug_info_data.GetDataStart();
               uint32_t block_length = form_value.Unsigned();
if (abbrCode != m_abbr_idx) {
 
         // Dump all data in the .debug_info for the attributes
         const uint32_t numAttributes = abbrevDecl->NumAttributes();
         uint32_t i;
         dw_attr_t attr;
         dw_form_t form;
         for (i = 0; i < numAttributes; ++i) {
           abbrevDecl->GetAttrAndFormByIndexUnchecked(i, attr, form);
 
           DumpAttribute(dwarf2Data, cu, debug_info_data, &offset, s, attr,
                         form);
         }
 
         const DWARFDebugInfoEntry *child = GetFirstChild();
         if (recurse_depth > 0 && child) {
           s.IndentMore();
 
           while (child) {
             child->Dump(dwarf2Data, cu, s, recurse_depth - 1);
if (fixed_form_sizes.Empty())
           cu->GetAddressByteSize(), cu->IsDWARF64());
 
     const uint32_t num_attributes = abbrevDecl->NumAttributes();
     uint32_t i;
     dw_attr_t attr;
     dw_form_t form;
     for (i = 0; i < num_attributes; ++i) {
       abbrevDecl->GetAttrAndFormByIndexUnchecked(i, attr, 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

source/Plugins/SymbolFile/DWARF/DWARFFormValue.h

enum {
     eValueTypeInvalid = 0,
     eValueTypeUnsigned,
     eValueTypeSigned,
     eValueTypeCStr,
     eValueTypeBlock
   };
 
   DWARFFormValue();
-  DWARFFormValue(const DWARFUnit *cu, dw_form_t form);
+  DWARFFormValue(const DWARFUnit *cu, dw_form_t form,
+                 ValueType val = ValueType());
   const DWARFUnit *GetCompileUnit() const { return m_cu; }
   void SetCompileUnit(const DWARFUnit *cu) { m_cu = cu; }
   dw_form_t Form() const { return m_form; }
   void SetForm(dw_form_t form) { m_form = form; }
   const ValueType &Value() const { return m_value; }
   void Dump(lldb_private::Stream &s) const;
   bool ExtractValue(const lldb_private::DWARFDataExtractor &data,
                     lldb::offset_t *offset_ptr);

source/Plugins/SymbolFile/DWARF/DWARFFormValue.cpp

if (addr_size == 8)
                             sizeof(g_form_sizes_addr8_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() {}
+DWARFFormValue::DWARFFormValue(const DWARFUnit *cu, dw_form_t form,
+                               ValueType val)
+    : m_cu(cu), m_form(form), m_value(val) {}
 
 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;
 }