DebugInfo: support for DW_FORM_implicit_const

[vleschuk]

Summary

Add support for DW_FORM_implicit_const (http://www.dwarfstd.org/ShowIssue.php?issue=141215.4) DWARFv5 feature. When this form is used attribute value goes to .debug_abbrev section (as SLEB). The functionality is checked with patched binutils-gdb, patch by Jan Kratochvil which will be published upstream this week. As this form would break any debug tool which doesn't support DWARFv5 it is guarded by dwarf version check. Attempt to use this form with dwarf version <= 4 is considered a fatal error.

[vleschuk]

Fix mistype in unittest.

[dblaikie]

include/llvm/DebugInfo/DWARF/DWARFAbbreviationDeclaration.h

34–38 ↗

(On Diff #83572)

These are mutually exclusive, right? (if there's a value, the byte size is zero) - could we coalesce them in some way?

lib/CodeGen/AsmPrinter/DIE.cpp

85–87 ↗

(On Diff #83572)

assert?

413–415 ↗

(On Diff #83572)

Move this up to the form present case at the top?

case dwarf::DW_FORM_implicit_const:
case dwarf::DW_FORM_flag_present:
  ...

467–470 ↗

(On Diff #83572)

This seems strange/incorrect - why does implicit_const have a size? Shouldn't it be zero like flag_present (& could roll this case into the flag-present case as above)

lib/DebugInfo/DWARF/DWARFFormValue.cpp

156 ↗

(On Diff #83572)

typo 'any' where 'and' is intended, perhaps?

[vleschuk]

include/llvm/DebugInfo/DWARF/DWARFAbbreviationDeclaration.h

34–38 ↗

(On Diff #83572)

We could use simply int64_t and bool field, smth like:

int64_t ByteSizeOrValue;
bool IsImplicitConst;

But will it gain us much?

[vleschuk]

• DWARFAbbreviationDeclaration::AttributeSpec struct now uses 1 64bit field for both ByteSize and implicit const attribute value (depends on Form == DW_FORM_implicit_const).
• Fixed few mistypes and reordered switch statements to be more logical.

[vleschuk]

• Classify DW_FORM_implicit_const as DWARFFormValue::FC_Constant
• Get rid of unnecessary assert()

[dblaikie]

A few things to cleanup, but feel free to commit after that. If there are any wrinkles with my suggestions do let me know.

include/llvm/DebugInfo/DWARF/DWARFAbbreviationDeclaration.h

34–38 ↗

(On Diff #83572)

Perhaps doesn't matter - was just wondering about the size of ATtributeSpec, but it's probably not too important and we can easily optimize it later if it turns out to be important.

lib/DebugInfo/DWARF/DWARFAbbreviationDeclaration.cpp

60–61 ↗

(On Diff #83789)

I'd probably roll this condition into the variable:

bool IsImplicitConst = F == DW_FORM_implicit_const;
if (IsImplicitConst)
  V = Data.getSLEB128(OffsetPtr);
else if (auto Size = DWARFFormValue::getFixedByteSize(F))
  V = *Size;
Attributes.push_back(AttributeSpec(A, F, V));
if (IsImplicitConst)
  continue;

But also - why does IsImplicitConst produce the need for this branch here, when flag_present did not? I suspect it's probably better to leave the fixed byte size calculation in and let that handle the implicit const rather than adding a special case.

Ah, I see - you're passing the size-or-implicit-const into the AttributeSpec ctor. It might be more legible if it used a named ctor or the like to differentiate the parameter. How about something like this:

auto FixedFormByteSize = DWARFFormValue::getFixedByteSize(F);
AttributeSpecs.push_back(F == DW_FORM_implicit_const
    ? AttributeSpec::makeImplicitConst(A, Data.getSLEB128(OffsetPtr))
    : AttributeSpec(A, F, FixedFormByteSize));
// If this abbreviation still has a fixed byte size, ...

143 ↗

(On Diff #83789)

An implicit const should always have a value, right? Perhaps this should assert(Spec.ByteSizeOrValue) (or access the value unconditionally without an assert - the Optional will assert if there's no value)

144 ↗

(On Diff #83789)

Using the dereference operator can be a bit less verbose than using 'getValue()':

... << *Spec.ByteSizeOrValue;

177 ↗

(On Diff #83789)

As above, I think it should be the right thing to assert(Spec.ByteSizeOrValue) or assume it's non-empty without an assertion, even.

178 ↗

(On Diff #83789)

As above, probably use Optional's operator*

llvm/trunk/include/llvm/CodeGen/DIE.h

 /// Dwarf abbreviation data, describes one attribute of a Dwarf abbreviation.
 class DIEAbbrevData {
   /// Dwarf attribute code.
   dwarf::Attribute Attribute;
 
   /// Dwarf form code.
   dwarf::Form Form;
 
+  /// Dwarf attribute value for DW_FORM_implicit_const
+  int64_t Value;
+
 public:
-  DIEAbbrevData(dwarf::Attribute A, dwarf::Form F) : Attribute(A), Form(F) {}
+  DIEAbbrevData(dwarf::Attribute A, dwarf::Form F)
+      : Attribute(A), Form(F), Value(0) {}
+  DIEAbbrevData(dwarf::Attribute A, int64_t V)
+      : Attribute(A), Form(dwarf::DW_FORM_implicit_const), Value(V) {}
 
   /// Accessors.
   /// @{
   dwarf::Attribute getAttribute() const { return Attribute; }
   dwarf::Form getForm() const { return Form; }
+  int64_t getValue() const { return Value; }
   /// @}
 
   /// Used to gather unique data for the abbreviation folding set.
   void Profile(FoldingSetNodeID &ID) const;
 };
 
 //===--------------------------------------------------------------------===//
 /// Dwarf abbreviation, describes the organization of a debug information
public:
   void setNumber(unsigned N) { Number = N; }
   /// @}
 
   /// Adds another set of attribute information to the abbreviation.
   void AddAttribute(dwarf::Attribute Attribute, dwarf::Form Form) {
     Data.push_back(DIEAbbrevData(Attribute, Form));
   }
 
+  /// Adds attribute with DW_FORM_implicit_const value
+  void AddImplicitConstAttribute(dwarf::Attribute Attribute, int64_t Value) {
+    Data.push_back(DIEAbbrevData(Attribute, Value));
+  }
+
   /// Used to gather unique data for the abbreviation folding set.
   void Profile(FoldingSetNodeID &ID) const;
 
   /// Print the abbreviation using the specified asm printer.
   void Emit(const AsmPrinter *AP) const;
 
   void print(raw_ostream &O);
   void dump();

llvm/trunk/include/llvm/DebugInfo/DWARF/DWARFAbbreviationDeclaration.h

 
 class DWARFUnit;
 class DWARFFormValue;
 class raw_ostream;
 
 class DWARFAbbreviationDeclaration {
 public:
   struct AttributeSpec {
-    AttributeSpec(dwarf::Attribute A, dwarf::Form F, Optional<uint8_t> S)
-        : Attr(A), Form(F), ByteSize(S) {}
+    AttributeSpec(dwarf::Attribute A, dwarf::Form F, Optional<int64_t> V)
+        : Attr(A), Form(F), ByteSizeOrValue(V) {}
     dwarf::Attribute Attr;
     dwarf::Form Form;
-    /// If ByteSize has a value, then it contains the fixed size in bytes for
-    /// the Form in this object. If ByteSize doesn't have a value, then the
-    /// byte size of Form either varies according to the DWARFUnit that it is
-    /// contained in or the value size varies and must be decoded from the
-    /// debug information in order to determine its size.
-    Optional<uint8_t> ByteSize;
+    /// The following field is used for ByteSize for non-implicit_const
+    /// attributes and as value for implicit_const ones, indicated by
+    /// Form == DW_FORM_implicit_const.
+    /// The following cases are distinguished:
+    /// * Form != DW_FORM_implicit_const and ByteSizeOrValue has a value:
+    ///     ByteSizeOrValue contains the fixed size in bytes
+    ///     for the Form in this object.
+    /// * Form != DW_FORM_implicit_const and ByteSizeOrValue is None:
+    ///     byte size of Form either varies according to the DWARFUnit
+    ///     that it is contained in or the value size varies and must be
+    ///     decoded from the debug information in order to determine its size.
+    /// * Form == DW_FORM_implicit_const:
+    ///     ByteSizeOrValue contains value for the implicit_const attribute.
+    Optional<int64_t> ByteSizeOrValue;
+    bool isImplicitConst() const {
+      return Form == dwarf::DW_FORM_implicit_const;
+    }
     /// Get the fixed byte size of this Form if possible. This function might
     /// use the DWARFUnit to calculate the size of the Form, like for
     /// DW_AT_address and DW_AT_ref_addr, so this isn't just an accessor for
     /// the ByteSize member.
-    Optional<uint8_t> getByteSize(const DWARFUnit &U) const;
+    Optional<int64_t> getByteSize(const DWARFUnit &U) const;
   };
   typedef SmallVector<AttributeSpec, 8> AttributeSpecVector;
 
   DWARFAbbreviationDeclaration();
 
   uint32_t getCode() const { return Code; }
   dwarf::Tag getTag() const { return Tag; }
   bool hasChildren() const { return HasChildren; }

llvm/trunk/include/llvm/DebugInfo/DWARF/DWARFFormValue.h

private:
   dwarf::Form Form; // Form for this value.
   ValueType Value; // Contains all data for the form.
   const DWARFUnit *U; // Remember the DWARFUnit at extract time.
 
 public:
   DWARFFormValue(dwarf::Form F = dwarf::Form(0)) : Form(F), U(nullptr) {}
   dwarf::Form getForm() const { return Form; }
   void setForm(dwarf::Form F) { Form = F; }
+  void setUValue(uint64_t V) { Value.uval = V; }
+  void setSValue(int64_t V) { Value.sval = V; }
+  void setPValue(const char *V) { Value.cstr = V; }
   bool isFormClass(FormClass FC) const;
   const DWARFUnit *getUnit() const { return U; }
   void dump(raw_ostream &OS) const;
 
   /// \brief extracts a value in data at offset *offset_ptr.
   ///
   /// The passed DWARFUnit is allowed to be nullptr, in which
   /// case no relocation processing will be performed and some

llvm/trunk/lib/CodeGen/AsmPrinter/DIE.cpp

for (unsigned i = 0, N = Data.size(); i < N; ++i) {
 
     // Emit attribute type.
     AP->EmitULEB128(AttrData.getAttribute(),
                     dwarf::AttributeString(AttrData.getAttribute()).data());
 
     // Emit form type.
     AP->EmitULEB128(AttrData.getForm(),
                     dwarf::FormEncodingString(AttrData.getForm()).data());
+
+    // Emit value for DW_FORM_implicit_const.
+    if (AttrData.getForm() == dwarf::DW_FORM_implicit_const) {
+      assert(AP->getDwarfVersion() >= 5 &&
+            "DW_FORM_implicit_const is supported starting from DWARFv5");
+      AP->EmitSLEB128(AttrData.getValue());
+    }
   }
 
   // Mark end of abbreviation.
   AP->EmitULEB128(0, "EOM(1)");
   AP->EmitULEB128(0, "EOM(2)");
 }
 
 LLVM_DUMP_METHOD

 
 DIE *DIE::getParent() const {
   return Owner.dyn_cast<DIE*>();
 }
 
 DIEAbbrev DIE::generateAbbrev() const {
   DIEAbbrev Abbrev(Tag, hasChildren());
   for (const DIEValue &V : values())
+    if (V.getForm() == dwarf::DW_FORM_implicit_const)
+      Abbrev.AddImplicitConstAttribute(V.getAttribute(),
+                                       V.getDIEInteger().getValue());
+    else
       Abbrev.AddAttribute(V.getAttribute(), V.getForm());
   return Abbrev;
 }
 
 unsigned DIE::getDebugSectionOffset() const {
   const DIEUnit *Unit = getUnit();
   assert(Unit && "DIE must be owned by a DIEUnit to get its absolute offset");
   return Unit->getDebugSectionOffset() + getOffset();
 }

 //===----------------------------------------------------------------------===//
 // DIEInteger Implementation
 //===----------------------------------------------------------------------===//
 
 /// EmitValue - Emit integer of appropriate size.
 ///
 void DIEInteger::EmitValue(const AsmPrinter *Asm, dwarf::Form Form) const {
   switch (Form) {
+  case dwarf::DW_FORM_implicit_const:
+    LLVM_FALLTHROUGH;
   case dwarf::DW_FORM_flag_present:
     // Emit something to keep the lines and comments in sync.
     // FIXME: Is there a better way to do this?
     Asm->OutStreamer->AddBlankLine();
     return;
   case dwarf::DW_FORM_flag:
     LLVM_FALLTHROUGH;
   case dwarf::DW_FORM_ref1:
void DIEInteger::EmitValue(const AsmPrinter *Asm, dwarf::Form Form) const {
   default: llvm_unreachable("DIE Value form not supported yet");
   }
 }
 
 /// SizeOf - Determine size of integer value in bytes.
 ///
 unsigned DIEInteger::SizeOf(const AsmPrinter *AP, dwarf::Form Form) const {
   switch (Form) {
+  case dwarf::DW_FORM_implicit_const: LLVM_FALLTHROUGH;
   case dwarf::DW_FORM_flag_present: return 0;
   case dwarf::DW_FORM_flag:  LLVM_FALLTHROUGH;
   case dwarf::DW_FORM_ref1:  LLVM_FALLTHROUGH;
   case dwarf::DW_FORM_data1: return sizeof(int8_t);
   case dwarf::DW_FORM_ref2:  LLVM_FALLTHROUGH;
   case dwarf::DW_FORM_data2: return sizeof(int16_t);
   case dwarf::DW_FORM_ref4:  LLVM_FALLTHROUGH;
   case dwarf::DW_FORM_data4: return sizeof(int32_t);

llvm/trunk/lib/CodeGen/AsmPrinter/DwarfUnit.cpp

else
     Die.addValue(DIEValueAllocator, Attribute, dwarf::DW_FORM_flag,
                  DIEInteger(1));
 }
 
 void DwarfUnit::addUInt(DIEValueList &Die, dwarf::Attribute Attribute,
                         Optional<dwarf::Form> Form, uint64_t Integer) {
   if (!Form)
     Form = DIEInteger::BestForm(false, Integer);
+  assert(Form != dwarf::DW_FORM_implicit_const &&
+         "DW_FORM_implicit_const is used only for signed integers");
   Die.addValue(DIEValueAllocator, Attribute, *Form, DIEInteger(Integer));
 }
 
 void DwarfUnit::addUInt(DIEValueList &Block, dwarf::Form Form,
                         uint64_t Integer) {
   addUInt(Block, (dwarf::Attribute)0, Form, Integer);
 }
 

llvm/trunk/lib/DebugInfo/DWARF/DWARFAbbreviationDeclaration.cpp

DWARFAbbreviationDeclaration::extract(DataExtractor Data,
   // all attribute data in this abbreviation declaration has a fixed byte size.
   FixedAttributeSize = FixedSizeInfo();
 
   // Read all of the abbreviation attributes and forms.
   while (true) {
     auto A = static_cast<Attribute>(Data.getULEB128(OffsetPtr));
     auto F = static_cast<Form>(Data.getULEB128(OffsetPtr));
     if (A && F) {
-      auto FixedFormByteSize = DWARFFormValue::getFixedByteSize(F);
-      AttributeSpecs.push_back(AttributeSpec(A, F, FixedFormByteSize));
+      Optional<int64_t> V;
+      bool IsImplicitConst = (F == DW_FORM_implicit_const);
+      if (IsImplicitConst)
+        V = Data.getSLEB128(OffsetPtr);
+      else if (auto Size = DWARFFormValue::getFixedByteSize(F))
+        V = *Size;
+      AttributeSpecs.push_back(AttributeSpec(A, F, V));
+      if (IsImplicitConst)
+        continue;
       // If this abbrevation still has a fixed byte size, then update the
       // FixedAttributeSize as needed.
       if (FixedAttributeSize) {
-        if (FixedFormByteSize)
-          FixedAttributeSize->NumBytes += *FixedFormByteSize;
+        if (V)
+          FixedAttributeSize->NumBytes += *V;
         else {
           switch (F) {
           case DW_FORM_addr:
             ++FixedAttributeSize->NumAddrs;
             break;
 
           case DW_FORM_ref_addr:
             ++FixedAttributeSize->NumRefAddrs;
for (const AttributeSpec &Spec : AttributeSpecs) {
     else
       OS << format("DW_AT_Unknown_%x", Spec.Attr);
     OS << '\t';
     auto formString = FormEncodingString(Spec.Form);
     if (!formString.empty())
       OS << formString;
     else
       OS << format("DW_FORM_Unknown_%x", Spec.Form);
+    if (Spec.isImplicitConst())
+      OS << '\t' << *Spec.ByteSizeOrValue;
     OS << '\n';
   }
   OS << '\n';
 }
 
 Optional<uint32_t>
 DWARFAbbreviationDeclaration::findAttributeIndex(dwarf::Attribute Attr) const {
   for (uint32_t i = 0, e = AttributeSpecs.size(); i != e; ++i) {
Optional<DWARFFormValue> DWARFAbbreviationDeclaration::getAttributeValue(
   // Add the byte size of ULEB that for the abbrev Code so we can start
   // skipping the attribute data.
   uint32_t Offset = DIEOffset + CodeByteSize;
   uint32_t AttrIndex = 0;
   for (const auto &Spec : AttributeSpecs) {
     if (*MatchAttrIndex == AttrIndex) {
       // We have arrived at the attribute to extract, extract if from Offset.
       DWARFFormValue FormValue(Spec.Form);
+      if (Spec.isImplicitConst()) {
+        FormValue.setSValue(*Spec.ByteSizeOrValue);
+        return FormValue;
+      }
       if (FormValue.extractValue(DebugInfoData, &Offset, &U))
         return FormValue;
     }
     // March Offset along until we get to the attribute we want.
-    if (Optional<uint8_t> FixedSize = Spec.getByteSize(U))
+    if (auto FixedSize = Spec.getByteSize(U))
       Offset += *FixedSize;
     else
       DWARFFormValue::skipValue(Spec.Form, DebugInfoData, &Offset, &U);
     ++AttrIndex;
   }
   return None;
 }
 
 size_t DWARFAbbreviationDeclaration::FixedSizeInfo::getByteSize(
     const DWARFUnit &U) const {
   size_t ByteSize = NumBytes;
   if (NumAddrs)
     ByteSize += NumAddrs * U.getAddressByteSize();
   if (NumRefAddrs)
     ByteSize += NumRefAddrs * U.getRefAddrByteSize();
   if (NumDwarfOffsets)
     ByteSize += NumDwarfOffsets * U.getDwarfOffsetByteSize();
   return ByteSize;
 }
 
-Optional<uint8_t> DWARFAbbreviationDeclaration::AttributeSpec::getByteSize(
+Optional<int64_t> DWARFAbbreviationDeclaration::AttributeSpec::getByteSize(
     const DWARFUnit &U) const {
-  return ByteSize ? ByteSize : DWARFFormValue::getFixedByteSize(Form, &U);
+  if (isImplicitConst())
+    return 0;
+  if (ByteSizeOrValue)
+    return ByteSizeOrValue;
+  Optional<int64_t> S;
+  auto FixedByteSize = DWARFFormValue::getFixedByteSize(Form, &U);
+  if (FixedByteSize)
+    S = *FixedByteSize;
+  return S;
 }
 
 Optional<size_t> DWARFAbbreviationDeclaration::getFixedAttributesByteSize(
     const DWARFUnit &U) const {
   if (FixedAttributeSize)
     return FixedAttributeSize->getByteSize(U);
   return None;
 }

llvm/trunk/lib/DebugInfo/DWARF/DWARFDebugInfoEntry.cpp

bool DWARFDebugInfoEntry::extractFast(const DWARFUnit &U, uint32_t *OffsetPtr,
   if (Optional<size_t> FixedSize = AbbrevDecl->getFixedAttributesByteSize(U)) {
     *OffsetPtr += *FixedSize;
     return true;
   }
 
   // Skip all data in the .debug_info for the attributes
   for (const auto &AttrSpec : AbbrevDecl->attributes()) {
     // Check if this attribute has a fixed byte size.
-    if (Optional<uint8_t> FixedSize = AttrSpec.getByteSize(U)) {
+    if (auto FixedSize = AttrSpec.getByteSize(U)) {
       // Attribute byte size if fixed, just add the size to the offset.
       *OffsetPtr += *FixedSize;
     } else if (!DWARFFormValue::skipValue(AttrSpec.Form, DebugInfoData,
                                           OffsetPtr, &U)) {
       // We failed to skip this attribute's value, restore the original offset
       // and return the failure status.
       *OffsetPtr = Offset;
       return false;
     }
   }
   return true;
 }

llvm/trunk/lib/DebugInfo/DWARF/DWARFFormValue.cpp

switch (Form) {
 
     case DW_FORM_flag_present:
       return 0;
 
     case DW_FORM_data16:
       return 16;
 
     case DW_FORM_implicit_const:
-      // The implicit value is stored in the abbreviation as a ULEB128, any
+      // The implicit value is stored in the abbreviation as a SLEB128, and
       // there no data in debug info.
       return 0;
 
     default:
       llvm_unreachable("Handle this form in this switch statement");
   }
   return None;
 }
bool DWARFFormValue::isFormClass(DWARFFormValue::FormClass FC) const {
   case DW_FORM_ref_sig8:
   case DW_FORM_GNU_ref_alt:
     return (FC == FC_Reference);
   case DW_FORM_GNU_addr_index:
     return (FC == FC_Address);
   case DW_FORM_GNU_str_index:
   case DW_FORM_GNU_strp_alt:
     return (FC == FC_String);
+  case DW_FORM_implicit_const:
+    return (FC == FC_Constant);
   default:
     break;
   }
   // In DWARF3 DW_FORM_data4 and DW_FORM_data8 served also as a section offset.
   // Don't check for DWARF version here, as some producers may still do this
   // by mistake.
   return (Form == DW_FORM_data4 || Form == DW_FORM_data8) &&
          FC == FC_SectionOffset;

llvm/trunk/test/DebugInfo/dwarfdump-implicit-const.test

+RUN: llvm-dwarfdump -debug-dump=abbrev %p/Inputs/implicit-const-test.o | FileCheck %s
+CHECK: DW_FORM_implicit_const -9223372036854775808

llvm/trunk/unittests/DebugInfo/DWARF/DWARFDebugInfoTest.cpp

void TestAllForms() {
   const uint32_t BlockSize = sizeof(BlockData);
   const RefAddrType RefAddr = 0x12345678;
   const uint8_t Data1 = 0x01U;
   const uint16_t Data2 = 0x2345U;
   const uint32_t Data4 = 0x6789abcdU;
   const uint64_t Data8 = 0x0011223344556677ULL;
   const uint64_t Data8_2 = 0xAABBCCDDEEFF0011ULL;
   const int64_t SData = INT64_MIN;
+  const int64_t ICSData = INT64_MAX; // DW_FORM_implicit_const SData
   const uint64_t UData[] = {UINT64_MAX - 1, UINT64_MAX - 2, UINT64_MAX - 3,
                             UINT64_MAX - 4, UINT64_MAX - 5, UINT64_MAX - 6,
                             UINT64_MAX - 7, UINT64_MAX - 8, UINT64_MAX - 9};
 #define UDATA_1 18446744073709551614ULL
   const uint32_t Dwarf32Values[] = {1, 2, 3, 4, 5, 6, 7, 8};
   const char *StringValue = "Hello";
   const char *StrpValue = "World";
   initLLVMIfNeeded();
#define UDATA_1 18446744073709551614ULL
   CUDie.addAttribute(Attr_DW_FORM_flag_present, DW_FORM_flag_present);
 
   //----------------------------------------------------------------------
   // Test SLEB128 based forms
   //----------------------------------------------------------------------
   const auto Attr_DW_FORM_sdata = static_cast<dwarf::Attribute>(Attr++);
   CUDie.addAttribute(Attr_DW_FORM_sdata, DW_FORM_sdata, SData);
 
+  const auto Attr_DW_FORM_implicit_const =
+    static_cast<dwarf::Attribute>(Attr++);
+  if (Version >= 5)
+    CUDie.addAttribute(Attr_DW_FORM_implicit_const, DW_FORM_implicit_const,
+                       ICSData);
+
   //----------------------------------------------------------------------
   // Test ULEB128 based forms
   //----------------------------------------------------------------------
   const auto Attr_DW_FORM_udata = static_cast<dwarf::Attribute>(Attr++);
   CUDie.addAttribute(Attr_DW_FORM_udata, DW_FORM_udata, UData[0]);
 
   //----------------------------------------------------------------------
   // Test DWARF32/DWARF64 forms
EXPECT_EQ(DieDG.getAttributeValueAsUnsignedConstant(
             1ULL);
   EXPECT_EQ(DieDG.getAttributeValueAsUnsignedConstant(
                 Attr_DW_FORM_flag_false, 1ULL),
             0ULL);
   EXPECT_EQ(DieDG.getAttributeValueAsUnsignedConstant(
                 Attr_DW_FORM_flag_present, 0ULL),
             1ULL);
 
-  // TODO: test Attr_DW_FORM_implicit_const extraction
-
   //----------------------------------------------------------------------
   // Test SLEB128 based forms
   //----------------------------------------------------------------------
   EXPECT_EQ(DieDG.getAttributeValueAsSignedConstant(Attr_DW_FORM_sdata, 0),
             SData);
+  if (Version >= 5)
+    EXPECT_EQ(DieDG.getAttributeValueAsSignedConstant(
+              Attr_DW_FORM_implicit_const, 0), ICSData);
 
   //----------------------------------------------------------------------
   // Test ULEB128 based forms
   //----------------------------------------------------------------------
   EXPECT_EQ(
       DieDG.getAttributeValueAsUnsignedConstant(Attr_DW_FORM_udata, 0),
       UData[0]);
 
TEST(DWARFDebugInfo, TestDWARF32Version4Addr8AllForms) {
   // Test that we can decode all forms for DWARF32, version 4, with 8 byte
   // addresses.
   typedef uint64_t AddrType;
   // DW_FORM_ref_addr are 4 bytes in DWARF32 for version 3 and later
   typedef uint32_t RefAddrType;
   TestAllForms<4, AddrType, RefAddrType>();
 }
 
+TEST(DWARFDebugInfo, TestDWARF32Version5Addr4AllForms) {
+  // Test that we can decode all forms for DWARF32, version 5, with 4 byte
+  // addresses.
+  typedef uint32_t AddrType;
+  // DW_FORM_ref_addr are 4 bytes in DWARF32 for version 3 and later
+  typedef uint32_t RefAddrType;
+  TestAllForms<5, AddrType, RefAddrType>();
+}
+
+TEST(DWARFDebugInfo, TestDWARF32Version5Addr8AllForms) {
+  // Test that we can decode all forms for DWARF32, version 5, with 8 byte
+  // addresses.
+  typedef uint64_t AddrType;
+  // DW_FORM_ref_addr are 4 bytes in DWARF32 for version 3 and later
+  typedef uint32_t RefAddrType;
+  TestAllForms<5, AddrType, RefAddrType>();
+}
+
 template <uint16_t Version, class AddrType> void TestChildren() {
   // Test that we can decode DW_FORM_ref_addr values correctly in DWARF 2 with
   // 4 byte addresses. DW_FORM_ref_addr values should be 4 bytes when using
   // 8 byte addresses.
 
   const uint8_t AddrSize = sizeof(AddrType);
   initLLVMIfNeeded();
   Triple Triple = getHostTripleForAddrSize(AddrSize);