llvm-dwarfdump: Improve/fix pretty printing of array dimensions

[dblaikie]

Summary

This is to address post-commit feedback from Paul Robinson on r348954.

The original commit misinterprets count and upper bound as the same thing (I thought I saw GCC producing an upper bound the same as Clang's count, but GCC correctly produces an upper bound that's one less than the count (in C, that is, where arrays are zero indexed)).

I want to preserve the C-like output for the common case, so in the absence of a lower bound the count (or one greater than the upper bound) is rendered between []. In the trickier cases, where a lower bound is specified, a half-open range is used (eg: lower bound 1, count 2 would be "[1, 3)" and an unknown parts use a '?' (eg: "[1, ?)" or "[?, 7)" or "[?, ? + 3)").

[probinson]

Note that the lower-bound might be implicit, but it's never "unknown."
We do need to account for the cases where the implicit lower-bound is 1. The Fortran people will need this, and the OpenVMS folks support several other languages that also have a default LB of 1.

Using [C] (C = count) for both the count-only and upper-bound-only cases suggests that we're being descriptive rather than carefully reflecting the attributes that are in the subrange DIE, which is fine. So, if an explicit LB matches the language default, then the display should also be [C] (where C = count if we have a count, or C = U + (1 - L) if we have upper_bound).

We'd show two values [L,U] or [L,C) only if L was specified and non-default. If we don't have either U or C, we get [L,?).

How does that sound?

[dblaikie]

In D55721#1331812, @probinson wrote:

Note that the lower-bound might be implicit, but it's never "unknown."
We do need to account for the cases where the implicit lower-bound is 1. The Fortran people will need this, and the OpenVMS folks support several other languages that also have a default LB of 1.

Using [C] (C = count) for both the count-only and upper-bound-only cases suggests that we're being descriptive rather than carefully reflecting the attributes that are in the subrange DIE, which is fine. So, if an explicit LB matches the language default, then the display should also be [C] (where C = count if we have a count, or C = U + (1 - L) if we have upper_bound).

The only change you're suggesting is to detect when an explicit LB matches the language default, and treating that case the same as if the LB were not specified (in terms of how it's printed out)?

I'd say it's a nice improvement, but not a requirement & not sure the balance of encoding the lower bound defaults table from the DWARF spec is worth that improvement in printing? But I don't feel super strongly either way.

We'd show two values [L,U] or [L,C) only if L was specified and non-default. If we don't have either U or C, we get [L,?).

How does that sound?

[probinson]

In D55721#1331847, @dblaikie wrote:

In D55721#1331812, @probinson wrote:

Note that the lower-bound might be implicit, but it's never "unknown."
We do need to account for the cases where the implicit lower-bound is 1. The Fortran people will need this, and the OpenVMS folks support several other languages that also have a default LB of 1.

Using [C] (C = count) for both the count-only and upper-bound-only cases suggests that we're being descriptive rather than carefully reflecting the attributes that are in the subrange DIE, which is fine. So, if an explicit LB matches the language default, then the display should also be [C] (where C = count if we have a count, or C = U + (1 - L) if we have upper_bound).

The only change you're suggesting is to detect when an explicit LB matches the language default, and treating that case the same as if the LB were not specified (in terms of how it's printed out)?

Sorry, no, in the course of editing the comment I lost the important part: When converting UB-only to Count, you need to correctly factor in the default LB: C = UB + (1 - DefaultLBForLanguage) otherwise the display for 1-based languages will be incorrect.

Then, since you have to know the default LB anyway, the rest seems not too hard.

[dblaikie]

Use language default lower bound to inform size calculation from upper_bound with no lower bound
Use [size] rendering when explicit lower bound matches language default

[dblaikie]

In D55721#1333018, @probinson wrote:

In D55721#1331847, @dblaikie wrote:

In D55721#1331812, @probinson wrote:

Note that the lower-bound might be implicit, but it's never "unknown."
We do need to account for the cases where the implicit lower-bound is 1. The Fortran people will need this, and the OpenVMS folks support several other languages that also have a default LB of 1.

Using [C] (C = count) for both the count-only and upper-bound-only cases suggests that we're being descriptive rather than carefully reflecting the attributes that are in the subrange DIE, which is fine. So, if an explicit LB matches the language default, then the display should also be [C] (where C = count if we have a count, or C = U + (1 - L) if we have upper_bound).

The only change you're suggesting is to detect when an explicit LB matches the language default, and treating that case the same as if the LB were not specified (in terms of how it's printed out)?

Sorry, no, in the course of editing the comment I lost the important part: When converting UB-only to Count, you need to correctly factor in the default LB: C = UB + (1 - DefaultLBForLanguage) otherwise the display for 1-based languages will be incorrect.

Then, since you have to know the default LB anyway, the rest seems not too hard.

Ah, fair enough - done those two things (omitting the lower bound when an explicit lower bound matches the language default & using the lower bound to accurately compute the size for [size] rendering).

I chose to use half open ranges always (even in the case where the input was lower/upper_bound, not lower_bound+count) to avoid visual ambiguity of "int[[x, y]]" - it's not clear what those x and y mean, why there are double squares around them, etc. Whereas "int[[x, y)]" is hopefully a bit more clear.

[JDevlieghere]

Cool, I find these thing really helpful when looking at DWARF output so I'm excited to see them getting more advanced.

lib/DebugInfo/DWARF/DWARFDie.cpp

207

nit: Could we maybe extract this into a static dumpArray helper?

[dblaikie]

Pull out array printing into a helper function

[probinson]

A couple small things. If Jonas is happy, I'm happy.

lib/DebugInfo/DWARF/DWARFDie.cpp

157

dumpArrayType as it's not actually dumping an array of anything

180

else if here? Otherwise it looks like the no-attributes-at-all case would dump
[][[?,?)] which seems like overkill.

[dblaikie]

Rename dumpArray to dumpArrayType
Implement & test behavior for subrange without any attributes (no low/high/count).

[dblaikie]

lib/DebugInfo/DWARF/DWARFDie.cpp

180

Ah, thanks - good catch. Added a test & fixed the issue.

207

Sure - done!

[JDevlieghere]

Looks like everybody's happy! LGTM

include/llvm/BinaryFormat/Dwarf.h

 
 enum DefaultedMemberAttribute {
 #define HANDLE_DW_DEFAULTED(ID, NAME) DW_DEFAULTED_##NAME = ID,
 #include "llvm/BinaryFormat/Dwarf.def"
   DW_DEFAULTED_max = 0x02
 };
 
 enum SourceLanguage {
-#define HANDLE_DW_LANG(ID, NAME, VERSION, VENDOR) DW_LANG_##NAME = ID,
+#define HANDLE_DW_LANG(ID, NAME, LOWER_BOUND, VERSION, VENDOR)                 \
+  DW_LANG_##NAME = ID,
 #include "llvm/BinaryFormat/Dwarf.def"
   DW_LANG_lo_user = 0x8000,
   DW_LANG_hi_user = 0xffff
 };
 
 enum CaseSensitivity {
   // Identifier case codes
   DW_ID_case_sensitive = 0x00,

 unsigned TagVendor(Tag T);
 unsigned AttributeVendor(Attribute A);
 unsigned FormVendor(Form F);
 unsigned OperationVendor(LocationAtom O);
 unsigned AttributeEncodingVendor(TypeKind E);
 unsigned LanguageVendor(SourceLanguage L);
 /// @}
 
+Optional<unsigned> LanguageLowerBound(SourceLanguage L);
+
 /// A helper struct providing information about the byte size of DW_FORM
 /// values that vary in size depending on the DWARF version, address byte
 /// size, or DWARF32/DWARF64.
 struct FormParams {
   uint16_t Version;
   uint8_t AddrSize;
   DwarfFormat Format;
 

include/llvm/BinaryFormat/Dwarf.def

 #define HANDLE_DW_FORM(ID, NAME, VERSION, VENDOR)
 #endif
 
 #ifndef HANDLE_DW_OP
 #define HANDLE_DW_OP(ID, NAME, VERSION, VENDOR)
 #endif
 
 #ifndef HANDLE_DW_LANG
-#define HANDLE_DW_LANG(ID, NAME, VERSION, VENDOR)
+#define HANDLE_DW_LANG(ID, NAME, LOWER_BOUND, VERSION, VENDOR)
 #endif
 
 #ifndef HANDLE_DW_ATE
 #define HANDLE_DW_ATE(ID, NAME, VERSION, VENDOR)
 #endif
 
 #ifndef HANDLE_DW_VIRTUALITY
 #define HANDLE_DW_VIRTUALITY(ID, NAME)

 // Vendor extensions:
 // Extensions for GNU-style thread-local storage.
 HANDLE_DW_OP(0xe0, GNU_push_tls_address, 0, GNU)
 // Extensions for Fission proposal.
 HANDLE_DW_OP(0xfb, GNU_addr_index, 0, GNU)
 HANDLE_DW_OP(0xfc, GNU_const_index, 0, GNU)
 
 // DWARF languages.
-HANDLE_DW_LANG(0x0001, C89, 2, DWARF)
-HANDLE_DW_LANG(0x0002, C, 2, DWARF)
-HANDLE_DW_LANG(0x0003, Ada83, 2, DWARF)
-HANDLE_DW_LANG(0x0004, C_plus_plus, 2, DWARF)
-HANDLE_DW_LANG(0x0005, Cobol74, 2, DWARF)
-HANDLE_DW_LANG(0x0006, Cobol85, 2, DWARF)
-HANDLE_DW_LANG(0x0007, Fortran77, 2, DWARF)
-HANDLE_DW_LANG(0x0008, Fortran90, 2, DWARF)
-HANDLE_DW_LANG(0x0009, Pascal83, 2, DWARF)
-HANDLE_DW_LANG(0x000a, Modula2, 2, DWARF)
+HANDLE_DW_LANG(0x0001, C89, 0, 2, DWARF)
+HANDLE_DW_LANG(0x0002, C, 0, 2, DWARF)
+HANDLE_DW_LANG(0x0003, Ada83, 1, 2, DWARF)
+HANDLE_DW_LANG(0x0004, C_plus_plus, 0, 2, DWARF)
+HANDLE_DW_LANG(0x0005, Cobol74, 1, 2, DWARF)
+HANDLE_DW_LANG(0x0006, Cobol85, 1, 2, DWARF)
+HANDLE_DW_LANG(0x0007, Fortran77, 1, 2, DWARF)
+HANDLE_DW_LANG(0x0008, Fortran90, 1, 2, DWARF)
+HANDLE_DW_LANG(0x0009, Pascal83, 1, 2, DWARF)
+HANDLE_DW_LANG(0x000a, Modula2, 1, 2, DWARF)
 // New in DWARF v3:
-HANDLE_DW_LANG(0x000b, Java, 3, DWARF)
-HANDLE_DW_LANG(0x000c, C99, 3, DWARF)
-HANDLE_DW_LANG(0x000d, Ada95, 3, DWARF)
-HANDLE_DW_LANG(0x000e, Fortran95, 3, DWARF)
-HANDLE_DW_LANG(0x000f, PLI, 3, DWARF)
-HANDLE_DW_LANG(0x0010, ObjC, 3, DWARF)
-HANDLE_DW_LANG(0x0011, ObjC_plus_plus, 3, DWARF)
-HANDLE_DW_LANG(0x0012, UPC, 3, DWARF)
-HANDLE_DW_LANG(0x0013, D, 3, DWARF)
+HANDLE_DW_LANG(0x000b, Java, 0, 3, DWARF)
+HANDLE_DW_LANG(0x000c, C99, 0, 3, DWARF)
+HANDLE_DW_LANG(0x000d, Ada95, 1, 3, DWARF)
+HANDLE_DW_LANG(0x000e, Fortran95, 1, 3, DWARF)
+HANDLE_DW_LANG(0x000f, PLI, 1, 3, DWARF)
+HANDLE_DW_LANG(0x0010, ObjC, 0, 3, DWARF)
+HANDLE_DW_LANG(0x0011, ObjC_plus_plus, 0, 3, DWARF)
+HANDLE_DW_LANG(0x0012, UPC, 0, 3, DWARF)
+HANDLE_DW_LANG(0x0013, D, 0, 3, DWARF)
 // New in DWARF v4:
-HANDLE_DW_LANG(0x0014, Python, 4, DWARF)
+HANDLE_DW_LANG(0x0014, Python, 0, 4, DWARF)
 // New in DWARF v5:
-HANDLE_DW_LANG(0x0015, OpenCL, 5, DWARF)
-HANDLE_DW_LANG(0x0016, Go, 5, DWARF)
-HANDLE_DW_LANG(0x0017, Modula3, 5, DWARF)
-HANDLE_DW_LANG(0x0018, Haskell, 5, DWARF)
-HANDLE_DW_LANG(0x0019, C_plus_plus_03, 5, DWARF)
-HANDLE_DW_LANG(0x001a, C_plus_plus_11, 5, DWARF)
-HANDLE_DW_LANG(0x001b, OCaml, 5, DWARF)
-HANDLE_DW_LANG(0x001c, Rust, 5, DWARF)
-HANDLE_DW_LANG(0x001d, C11, 5, DWARF)
-HANDLE_DW_LANG(0x001e, Swift, 5, DWARF)
-HANDLE_DW_LANG(0x001f, Julia, 5, DWARF)
-HANDLE_DW_LANG(0x0020, Dylan, 5, DWARF)
-HANDLE_DW_LANG(0x0021, C_plus_plus_14, 5, DWARF)
-HANDLE_DW_LANG(0x0022, Fortran03, 5, DWARF)
-HANDLE_DW_LANG(0x0023, Fortran08, 5, DWARF)
-HANDLE_DW_LANG(0x0024, RenderScript, 5, DWARF)
-HANDLE_DW_LANG(0x0025, BLISS, 5, DWARF)
+HANDLE_DW_LANG(0x0015, OpenCL, 0, 5, DWARF)
+HANDLE_DW_LANG(0x0016, Go, 0, 5, DWARF)
+HANDLE_DW_LANG(0x0017, Modula3, 1, 5, DWARF)
+HANDLE_DW_LANG(0x0018, Haskell, 0, 5, DWARF)
+HANDLE_DW_LANG(0x0019, C_plus_plus_03, 0, 5, DWARF)
+HANDLE_DW_LANG(0x001a, C_plus_plus_11, 0, 5, DWARF)
+HANDLE_DW_LANG(0x001b, OCaml, 0, 5, DWARF)
+HANDLE_DW_LANG(0x001c, Rust, 0, 5, DWARF)
+HANDLE_DW_LANG(0x001d, C11, 0, 5, DWARF)
+HANDLE_DW_LANG(0x001e, Swift, 0, 5, DWARF)
+HANDLE_DW_LANG(0x001f, Julia, 1, 5, DWARF)
+HANDLE_DW_LANG(0x0020, Dylan, 0, 5, DWARF)
+HANDLE_DW_LANG(0x0021, C_plus_plus_14, 0, 5, DWARF)
+HANDLE_DW_LANG(0x0022, Fortran03, 1, 5, DWARF)
+HANDLE_DW_LANG(0x0023, Fortran08, 1, 5, DWARF)
+HANDLE_DW_LANG(0x0024, RenderScript, 0, 5, DWARF)
+HANDLE_DW_LANG(0x0025, BLISS, 0, 5, DWARF)
 // Vendor extensions:
-HANDLE_DW_LANG(0x8001, Mips_Assembler, 0, MIPS)
-HANDLE_DW_LANG(0x8e57, GOOGLE_RenderScript, 0, GOOGLE)
-HANDLE_DW_LANG(0xb000, BORLAND_Delphi, 0, BORLAND)
+HANDLE_DW_LANG(0x8001, Mips_Assembler, None, 0, MIPS)
+HANDLE_DW_LANG(0x8e57, GOOGLE_RenderScript, 0, 0, GOOGLE)
+HANDLE_DW_LANG(0xb000, BORLAND_Delphi, 0, 0, BORLAND)
 
 // DWARF attribute type encodings.
 HANDLE_DW_ATE(0x01, address, 2, DWARF)
 HANDLE_DW_ATE(0x02, boolean, 2, DWARF)
 HANDLE_DW_ATE(0x03, complex_float, 2, DWARF)
 HANDLE_DW_ATE(0x04, float, 2, DWARF)
 HANDLE_DW_ATE(0x05, signed, 2, DWARF)
 HANDLE_DW_ATE(0x06, signed_char, 2, DWARF)

lib/BinaryFormat/Dwarf.cpp

 #include "llvm/BinaryFormat/Dwarf.def"
       .Default(DW_VIRTUALITY_invalid);
 }
 
 StringRef llvm::dwarf::LanguageString(unsigned Language) {
   switch (Language) {
   default:
     return StringRef();
-#define HANDLE_DW_LANG(ID, NAME, VERSION, VENDOR)                              \
+#define HANDLE_DW_LANG(ID, NAME, LOWER_BOUND, VERSION, VENDOR)                 \
   case DW_LANG_##NAME:                                                         \
     return "DW_LANG_" #NAME;
 #include "llvm/BinaryFormat/Dwarf.def"
   }
 }
 
 unsigned llvm::dwarf::getLanguage(StringRef LanguageString) {
   return StringSwitch<unsigned>(LanguageString)
-#define HANDLE_DW_LANG(ID, NAME, VERSION, VENDOR)                              \
+#define HANDLE_DW_LANG(ID, NAME, LOWER_BOUND, VERSION, VENDOR)                 \
   .Case("DW_LANG_" #NAME, DW_LANG_##NAME)
 #include "llvm/BinaryFormat/Dwarf.def"
       .Default(0);
 }
 
 unsigned llvm::dwarf::LanguageVersion(dwarf::SourceLanguage Lang) {
   switch (Lang) {
   default:
     return 0;
-#define HANDLE_DW_LANG(ID, NAME, VERSION, VENDOR)                              \
+#define HANDLE_DW_LANG(ID, NAME, LOWER_BOUND, VERSION, VENDOR)                 \
   case DW_LANG_##NAME:                                                         \
     return VERSION;
 #include "llvm/BinaryFormat/Dwarf.def"
   }
 }
 
 unsigned llvm::dwarf::LanguageVendor(dwarf::SourceLanguage Lang) {
   switch (Lang) {
   default:
     return 0;
-#define HANDLE_DW_LANG(ID, NAME, VERSION, VENDOR)                              \
+#define HANDLE_DW_LANG(ID, NAME, LOWER_BOUND, VERSION, VENDOR)                 \
   case DW_LANG_##NAME:                                                         \
     return DWARF_VENDOR_##VENDOR;
 #include "llvm/BinaryFormat/Dwarf.def"
   }
 }
 
+Optional<unsigned> llvm::dwarf::LanguageLowerBound(dwarf::SourceLanguage Lang) {
+  switch (Lang) {
+  default:
+    return None;
+#define HANDLE_DW_LANG(ID, NAME, LOWER_BOUND, VERSION, VENDOR)                 \
+  case DW_LANG_##NAME:                                                         \
+    return LOWER_BOUND;
+#include "llvm/BinaryFormat/Dwarf.def"
+  }
+}
+
 StringRef llvm::dwarf::CaseString(unsigned Case) {
   switch (Case) {
   case DW_ID_case_sensitive:
     return "DW_ID_case_sensitive";
   case DW_ID_up_case:
     return "DW_ID_up_case";
   case DW_ID_down_case:
     return "DW_ID_down_case";

lib/DebugInfo/DWARF/DWARFDie.cpp

 /// Dump the name encoded in the type tag.
 static void dumpTypeTagName(raw_ostream &OS, dwarf::Tag T) {
   StringRef TagStr = TagString(T);
   if (!TagStr.startswith("DW_TAG_") || !TagStr.endswith("_type"))
     return;
   OS << TagStr.substr(7, TagStr.size() - 12) << " ";
 }
 
 /// Recursively dump the DIE type name when applicable.
 static void dumpTypeName(raw_ostream &OS, const DWARFDie &D) {
   if (!D.isValid())
     return;
 
   if (const char *Name = D.getName(DINameKind::LinkageName)) {
     OS << Name;
     return;
   }
 
   // FIXME: We should have pretty printers per language. Currently we print
   // everything as if it was C++ and fall back to the TAG type name.
   const dwarf::Tag T = D.getTag();
   switch (T) {
   case DW_TAG_array_type:
   case DW_TAG_pointer_type:
   case DW_TAG_ptr_to_member_type:
   case DW_TAG_reference_type:
   case DW_TAG_rvalue_reference_type:
   case DW_TAG_subroutine_type:
     break;
   default:
     dumpTypeTagName(OS, T);
   }
 
   // Follow the DW_AT_type if possible.
   DWARFDie TypeDie = D.getAttributeValueAsReferencedDie(DW_AT_type);
   dumpTypeName(OS, TypeDie);
 
   switch (T) {
   case DW_TAG_subroutine_type: {
     if (!TypeDie)
case DW_TAG_subroutine_type: {
     }
     OS << ')';
     break;
   }
   case DW_TAG_array_type: {
     Optional<uint64_t> Bound;
     for (const DWARFDie &C : D.children())
       if (C.getTag() == DW_TAG_subrange_type) {
-        OS << '[';
-        uint64_t LowerBound = 0;
+        Optional<uint64_t> LB;
+        Optional<uint64_t> Count;
+        Optional<uint64_t> UB;
+        Optional<unsigned> DefaultLB;
         if (Optional<DWARFFormValue> L = C.find(DW_AT_lower_bound))
-          if (Optional<uint64_t> LB = L->getAsUnsignedConstant()) {
-            LowerBound = *LB;
-            OS << LowerBound << '-';
-          }
-        if (Optional<DWARFFormValue> CountV = C.find(DW_AT_count)) {
-          if (Optional<uint64_t> C = CountV->getAsUnsignedConstant())
-            OS << (*C + LowerBound);
-        } else if (Optional<DWARFFormValue> UpperV = C.find(DW_AT_upper_bound))
-          if (Optional<uint64_t> U = UpperV->getAsUnsignedConstant())
-            OS << *U;
-        OS << ']';
+          LB = L->getAsUnsignedConstant();
+        if (Optional<DWARFFormValue> CountV = C.find(DW_AT_count))
+          Count = CountV->getAsUnsignedConstant();
+        if (Optional<DWARFFormValue> UpperV = C.find(DW_AT_upper_bound))
+          UB = UpperV->getAsUnsignedConstant();
+        if (Optional<DWARFFormValue> LV =
+                D.getDwarfUnit()->getUnitDIE().find(DW_AT_language))
+          if (Optional<uint64_t> LC = LV->getAsUnsignedConstant())
+            if ((DefaultLB = LanguageLowerBound(
+                     static_cast<dwarf::SourceLanguage>(*LC))))
+              if (LB && *LB == *DefaultLB)
+                LB = None;
+        if (!LB && !Count && !UB)
+          OS << "[]";
+        if (!LB && (Count || UB) && DefaultLB)
+          OS << '[' << (Count ? *Count : *UB - *DefaultLB + 1) << ']';
+        else {
+          OS << "[[";
+          if (LB)
+            OS << *LB;
+          else
+            OS << '?';
+          OS << ", ";
+          if (Count)
+            if (LB)
+              OS << *LB + *Count;
+            else
+              OS << "? + " << *Count;
+          else if (UB)
+            OS << *UB + 1;
+          else
+            OS << '?';
+          OS << ")]";
+        }
       }
     break;
   }
   case DW_TAG_pointer_type:
     OS << '*';
     break;
   case DW_TAG_ptr_to_member_type:
     if (DWARFDie Cont =

lib/IR/DebugInfo.cpp

 }
 
 //===----------------------------------------------------------------------===//
 // LLVM C API implementations.
 //===----------------------------------------------------------------------===//
 
 static unsigned map_from_llvmDWARFsourcelanguage(LLVMDWARFSourceLanguage lang) {
   switch (lang) {
-#define HANDLE_DW_LANG(ID, NAME, VERSION, VENDOR) \
-case LLVMDWARFSourceLanguage##NAME: return ID;
+#define HANDLE_DW_LANG(ID, NAME, LOWER_BOUND, VERSION, VENDOR)                 \
+  case LLVMDWARFSourceLanguage##NAME:                                          \
+    return ID;
 #include "llvm/BinaryFormat/Dwarf.def"
 #undef HANDLE_DW_LANG
   }
   llvm_unreachable("Unhandled Tag");
 }
 
 template <typename DIT> DIT *unwrapDI(LLVMMetadataRef Ref) {
   return (DIT *)(Ref ? unwrap<MDNode>(Ref) : nullptr);

test/tools/llvm-dwarfdump/X86/prettyprint_types.s

 
 # rvalue_reference_type
 # CHECK:   DW_AT_type{{.*}}"int&&"
 
 # ptr_to_member_type
 # CHECK:   DW_AT_type{{.*}}"int foo::*"
 
 # array_type
-# Testing lower_bound, upper_bound, lower and upper, lower and count, and count separately.
-# CHECK:   DW_AT_type{{.*}}"int[1-][2][1-2][1-3][2]"
+# CHECK:   DW_AT_type{{.*}}"int
+# Testing with a default lower bound of 0 and the following explicit bounds:
+#   lower_bound(1)
+# CHECK-SAME: {{\[}}[1, ?)]
+#   upper_bound(2)
+# CHECK-SAME: [3]
+#   lower(1) and upper(2)
+# CHECK-SAME: {{\[}}[1, 3)]
+#   lower(1) and count(3)
+# CHECK-SAME: {{\[}}[1, 4)]
+#   lower(0) and count(4) - testing that the lower bound matching language
+#   default is not rendered
+# CHECK-SAME: [4]
+#   count(2)
+# CHECK-SAME: [2]
 
 # subroutine types
 # CHECK:   DW_AT_type{{.*}}"int()"
 # CHECK:   DW_AT_type{{.*}}"void(int)"
 # CHECK:   DW_AT_type{{.*}}"void(int, int)"
+
+# array_type with a language with a default lower bound of 1 instead of 0 and
+# an upper bound of 2. This describes an array with 2 elements (whereas with a
+# default lower bound of 0 it would be an array of 3 elements)
+# CHECK: DW_AT_type{{.*}}"int[2]"
+
   .section  .debug_str,"MS",@progbits,1
 .Lint_name:
   .asciz  "int"
 .Lfoo_name:
   .asciz  "foo"
   .section  .debug_abbrev,"",@progbits
   .byte 1                       # Abbreviation Code
   .byte 17                      # DW_TAG_compile_unit
.Larray_type:
   .byte   1                       #     DW_AT_lower_bound
   .byte 10                      #   DW_AT_subrange_type
   .byte   2                       #     DW_AT_upper_bound
   .byte 11                      #   DW_AT_subrange_type
   .byte   1                       #     DW_AT_lower_bound
   .byte   2                       #     DW_AT_upper_bound
   .byte 12                      #   DW_AT_subrange_type
   .byte   1                       #     DW_AT_lower_bound
-  .byte   2                       #     DW_AT_count
+  .byte   3                       #     DW_AT_count
+  .byte 12                      #   DW_AT_subrange_type
+  .byte   0                       #     DW_AT_lower_bound
+  .byte   4                       #     DW_AT_count
   .byte 13                      #   DW_AT_subrange_type
   .byte   2                       #     DW_AT_count
   .byte 0                       # End Of Children Mark
 .Lsub_int_empty_type:
   .byte 15                      # DW_TAG_subroutine_type
   .long .Lint_type - .Lcu_begin #   DW_AT_type
 .Lsub_void_int_type:
   .byte 16                      # DW_TAG_subroutine_type
.Lsub_void_int_int_type:
   .byte 3                       # DW_TAG_variable
   .long .Lsub_int_empty_type - .Lcu_begin #   DW_AT_type
   .byte 3                       # DW_TAG_variable
   .long .Lsub_void_int_type - .Lcu_begin #   DW_AT_type
   .byte 3                       # DW_TAG_variable
   .long .Lsub_void_int_int_type - .Lcu_begin #   DW_AT_type
   .byte 0                       # End Of Children Mark
 .Lunit_end:
+.Lcu2_begin:
+  .long .Lcu2_unit_end - .Lcu2_unit_start # Length of Unit
+.Lcu2_unit_start:
+  .short  4                       # DWARF version number
+  .long .debug_abbrev           # Offset Into Abbrev. Section
+  .byte 8                       # Address Size (in bytes)
+  .byte 1                       # DW_TAG_compile_unit
+  .short  13                      #   DW_AT_language
+.Lcu2_int_type:
+  .byte 2                       # DW_TAG_base_type
+  .long .Lint_name              #   DW_AT_name
+.Lcu2_array_type:
+  .byte 8                       # DW_TAG_array_type
+  .long .Lcu2_int_type - .Lcu2_begin #   DW_AT_type
+  .byte 10                      #   DW_AT_subrange_type
+  .byte   2                       #     DW_AT_upper_bound
+  .byte 3                       # DW_TAG_variable
+  .long .Lcu2_array_type - .Lcu2_begin #   DW_AT_type
+.Lcu2_unit_end: