[DebugInfoMetadata] Added support to generate packed_decimal encoding related dwarf info.

[Chirag]

Summary

supports to mark DW_TAG_base_type with DW_AT_picture_string, DW_AT_digit_count, DW_AT_decimal_scale and DW_AT_decimal_sign.

[aprantl]

Thanks!, Comments are inline. Please also update the metadata unit test, to test the stuff in LLVMContext.

include/llvm/BinaryFormat/Dwarf.def

707

Thanks! Looks like none of these were introduced recently so we can get away with not encoding the version number this was introduced in.

include/llvm/IR/DIBuilder.h

211

I think I would prefer a

struct DecimalInfo {
 unsigned DigitCount;
 unsigned DecimalSign;
 int DecimalScale;
};

DIBasicType *createBasicType(..., Optional<DecimalInfo>() = {}, ...

Since this is more of an all-or-nothing affair.

include/llvm/IR/DebugInfoMetadata.h

742

Perhaps you could reuse this struct for the optional arg I mentioned above?

743

Doxygen comments?

751

I don't think this is needed?

854

I think these assertions are redundant and can be removed, because the Optional deref operation would also assert.

lib/IR/DIBuilder.cpp

268

Same here, I think having an Optional<> for all the decimal info would be preferable. (Do all of these values even have a N/A-sentinel value otherwise?)

[Chirag]

I will also include the metadata unit test with listed changes, thanks.

include/llvm/IR/DebugInfoMetadata.h

854

i will remove them, thanks.

lib/IR/DIBuilder.cpp

268

All those are optional and one or more may be absent for some encoding type, i will re-factor the code instead of all-or-nothing to all-optional.

After having one more look, currently scale is one which does not have invalid value to mark with, yes it would be better to use optional so all of them will have same N/A-sentinal values instead of different for each of them.

Thanks! , i will make the changes.

[Chirag]

• Updated metatdata unittest
• Fixed optional issues with decimal attributes.
• Added doxygen comments.
• Updated asm roundtrip tests.

[aprantl]

include/llvm/IR/DIBuilder.h

211

Ok according to you comment later, these are all optional by themselves.

213

You will also need to provide a clang patch to use the new interface.

include/llvm/IR/DebugInfoMetadata.h

744

.

746

We don't typically combine Optional<> with pointer types but use the nullptr value as a sentinel instead.

747

Do you need the full 32 bits here, or could you pack this tighter?
With the optional this may use up to 64 bits...?

758

What's the point of having this Optional and all fields inside Optional, too?
If we want to save space, we could optionally allocate trailing memory, or created a derived class DIDecimalType with the extra fields.

lib/AsmParser/LLParser.cpp

4356

clang-format please

lib/Bitcode/Reader/MetadataLoader.cpp

1226

clang-format please

unittests/IR/MetadataTest.cpp

1149

It might be better to use a fully populated DecimalInfo here?

1160

The idea of these tests is that you change exactly one argument each time, here' you're changing the picture string, too, so all the other differences don't matter any more.

[Chirag]

include/llvm/IR/DIBuilder.h

213

correct me if i am wrong, clang do not support the languages which uses the related data type encoding, which uses this optional dwarf generation for base type.

include/llvm/IR/DebugInfoMetadata.h

746

i will use nullptr for N/A-sentinal value instead of None.

747

not really, i will try to decrease the memory footprint for this struct.

[aprantl]

include/llvm/IR/DIBuilder.h

213

I was blindly assuming that clang was setting the DIFlags argument. If it leaves it blank, then you don't need to do anything.

[probinson]

+llvm-commits

clang-format-diff is your friend.

Remind me of your use case? Clang does not support any decimal types, although there is work in progress to support scaled binary.

include/llvm/BinaryFormat/Dwarf.def

702

Need a space after the //

707

Right the decimal stuff was all added in DWARF 3 and I'm pretty sure has not changed since. As these are enums used in an attribute that is correctly identified as v3, I don't think these need a version.

include/llvm/IR/DIBuilder.h

203

I don't know that DW_ATE_float is an appropriate example here.

204

Does it have to be "packed" decimal type? That may be your use case but as you are passing the encoding as a parameter, I think this would work for all the decimal types.

206

DecimalScale

lib/AsmParser/LLParser.cpp

4335

I'd prefer the example to be self-consistent (digits/scale matching the pic string).

lib/Bitcode/Writer/BitcodeWriter.cpp

1500

LLVM style uses full sentences in comments (with proper capitalization and punctuation).

lib/CodeGen/AsmPrinter/DwarfUnit.cpp

753

Space before the =.

[Chirag]

@aprantl yes, at the moment clang is not generating bi-endian code, hence not using DIFlags.

@probinson, thanks i will fix format/typos related changes.
about the use cases, this patch will provide containers to convey and generate optional DWARF attributes for base type tag with below listed encodings,
DW_ATE_packed_decimal
DW_ATE_numeric_string
DW_ATE_edited
DW_ATE_signed_fixed
DW_ATE_unsigned_fixed

[probinson]

What I meant by "use case" is, do you have a front end that will make use of these new features?

Are you supporting binary scale as well as decimal scale, for [un]signed_fixed encodings? It looks like you are supporting only decimal scale.

[Chirag]

In D52295#1248346, @probinson wrote:

What I meant by "use case" is, do you have a front end that will make use of these new features?

Are you supporting binary scale as well as decimal scale, for [un]signed_fixed encodings? It looks like you are supporting only decimal scale.

Apologies for late reply.
Yes, with this patch, only decimal scale is supported and i will add binary scale as well. (will modify this patch), and related changes too.
and about the front-end, we have a pl1/cobol llvm based front-end (in development) which generates this info.

[probinson]

In D52295#1251426, @Chirag wrote:

Yes, with this patch, only decimal scale is supported and i will add binary scale as well. (will modify this patch), and related changes too.
and about the front-end, we have a pl1/cobol llvm based front-end (in development) which generates this info.

Awesome; is this the OpenVMS port or something else? I had thought there were maybe two people in the world with both COBOL and LLVM experience.
COBOL doesn't need binary scale but I believe PL/I does (not that I've used PL/I in the past 25 years). You'll want to think about whether it's simpler to use a single API for any scaled type, or split out decimal from binary. Binary scaled obviously doesn't need most of the new parameters.

[Chirag]

• Added DW_AT_binary_scale attribute.
• Fixed llvm type code formatting
• Fixed minor typos.

@probinson - no, it is not openvms port, instead we have our own PLI/Cobol compiler for which we are adding debugging support.

@aprantl - apartt from saving memory, here optional in optional is used to mark if basictype is extended or not, so instead of checking all underlying optional attributes only one check is needed.

[Chirag]

• clang-format

[Chirag]

Ping.

[aprantl]

include/llvm/IR/DebugInfoFlags.def

54

The space in DIFLags is precious. Can you explain why we need this as a generic DIFlag and not just a bit in DIBasicType?

[Chirag]

include/llvm/IR/DebugInfoFlags.def

54

Thanks for reply. i am thinking this is a bad design as data seems scattered and basicType is getting bloated also you are right about DIFlags' bit being reserved and used only in rare cases is not good.
i am thinking of adding new DIDecimalType class as you suggested earlier in DebugInfoMetaData.h inherited from Type and scrap this review if it is okay with you guys.

include/llvm/BinaryFormat/Dwarf.h

 #define HANDLE_DW_ATE(ID, NAME, VERSION, VENDOR) DW_ATE_##NAME = ID,
 #include "llvm/BinaryFormat/Dwarf.def"
   DW_ATE_lo_user = 0x80,
   DW_ATE_hi_user = 0xff
 };
 
 enum DecimalSignEncoding {
   // Decimal sign attribute values
-  DW_DS_unsigned = 0x01,
-  DW_DS_leading_overpunch = 0x02,
-  DW_DS_trailing_overpunch = 0x03,
-  DW_DS_leading_separate = 0x04,
-  DW_DS_trailing_separate = 0x05
+  DW_DS_Invalid = 0,
+#define HANDLE_DW_DS(ID, NAME) DW_DS_##NAME = ID,
+#include "llvm/BinaryFormat/Dwarf.def"
 };
 
 enum EndianityEncoding {
   // Endianity attribute values
 #define HANDLE_DW_END(ID, NAME) DW_END_##NAME = ID,
 #include "llvm/BinaryFormat/Dwarf.def"
   DW_END_lo_user = 0x40,
   DW_END_hi_user = 0xff

 /// value or return 0 if there is none, except for these exceptions:
 ///
 /// \li \a getTag() returns \a DW_TAG_invalid on invalid input.
 /// \li \a getVirtuality() returns \a DW_VIRTUALITY_invalid on invalid input.
 /// \li \a getMacinfo() returns \a DW_MACINFO_invalid on invalid input.
 ///
 /// @{
 unsigned getTag(StringRef TagString);
+unsigned getDecimalSign(StringRef DSString);
 unsigned getOperationEncoding(StringRef OperationEncodingString);
 unsigned getVirtuality(StringRef VirtualityString);
 unsigned getLanguage(StringRef LanguageString);
 unsigned getCallingConvention(StringRef LanguageString);
 unsigned getAttributeEncoding(StringRef EncodingString);
 unsigned getMacinfo(StringRef MacinfoString);
 /// @}
 

include/llvm/BinaryFormat/Dwarf.def

#if !(                                                                         \
     defined HANDLE_DW_TAG || defined HANDLE_DW_AT || defined HANDLE_DW_FORM || \
     defined HANDLE_DW_OP || defined HANDLE_DW_LANG || defined HANDLE_DW_ATE || \
     defined HANDLE_DW_VIRTUALITY || defined HANDLE_DW_DEFAULTED ||             \
     defined HANDLE_DW_CC || defined HANDLE_DW_LNS || defined HANDLE_DW_LNE ||  \
     defined HANDLE_DW_LNCT || defined HANDLE_DW_MACRO ||                       \
     defined HANDLE_DW_RLE || defined HANDLE_DW_CFA ||                          \
     defined HANDLE_DW_APPLE_PROPERTY || defined HANDLE_DW_UT ||                \
     defined HANDLE_DWARF_SECTION || defined HANDLE_DW_IDX ||                   \
-    defined HANDLE_DW_END)
+    defined HANDLE_DW_END || defined HANDLE_DW_DS)
 #error "Missing macro definition of HANDLE_DW*"
 #endif
 
 #ifndef HANDLE_DW_TAG
 #define HANDLE_DW_TAG(ID, NAME, VERSION, VENDOR)
 #endif
 
 #ifndef HANDLE_DW_AT

 #ifndef HANDLE_DW_IDX
 #define HANDLE_DW_IDX(ID, NAME)
 #endif
 
 #ifndef HANDLE_DW_END
 #define HANDLE_DW_END(ID, NAME)
 #endif
 
+#ifndef HANDLE_DW_DS
+#define HANDLE_DW_DS(ID, NAME)
+#endif
+
 HANDLE_DW_TAG(0x0000, null, 2, DWARF)
 HANDLE_DW_TAG(0x0001, array_type, 2, DWARF)
 HANDLE_DW_TAG(0x0002, class_type, 2, DWARF)
 HANDLE_DW_TAG(0x0003, entry_point, 2, DWARF)
 HANDLE_DW_TAG(0x0004, enumeration_type, 2, DWARF)
 HANDLE_DW_TAG(0x0005, formal_parameter, 2, DWARF)
 HANDLE_DW_TAG(0x0008, imported_declaration, 2, DWARF)
 HANDLE_DW_TAG(0x000a, label, 2, DWARF)

 HANDLE_DW_ATE(0x0e, unsigned_fixed, 3, DWARF)
 HANDLE_DW_ATE(0x0f, decimal_float, 3, DWARF)
 // New in DWARF v4:
 HANDLE_DW_ATE(0x10, UTF, 4, DWARF)
 // New in DWARF v5:
 HANDLE_DW_ATE(0x11, UCS, 5, DWARF)
 HANDLE_DW_ATE(0x12, ASCII, 5, DWARF)
 
+// DWARF decimal sign
+HANDLE_DW_DS(0x01, unsigned)
+HANDLE_DW_DS(0x02, leading_overpunch)
+HANDLE_DW_DS(0x03, trailing_overpunch)
+HANDLE_DW_DS(0x04, leading_separate)
+HANDLE_DW_DS(0x05, trailing_separate)
+
 // DWARF attribute endianity
 HANDLE_DW_END(0x00, default)
 HANDLE_DW_END(0x01, big)
 HANDLE_DW_END(0x02, little)
 
 // DWARF virtuality codes.
 HANDLE_DW_VIRTUALITY(0x00, none)
 HANDLE_DW_VIRTUALITY(0x01, virtual)

 #undef HANDLE_DW_MACRO
 #undef HANDLE_DW_RLE
 #undef HANDLE_DW_CFA
 #undef HANDLE_DW_APPLE_PROPERTY
 #undef HANDLE_DW_UT
 #undef HANDLE_DWARF_SECTION
 #undef HANDLE_DW_IDX
 #undef HANDLE_DW_END
+#undef HANDLE_DW_DS

include/llvm/IR/DIBuilder.h

public:
     /// \param Name        Type name.
     /// \param SizeInBits  Size of the type.
     /// \param Encoding    DWARF encoding code, e.g., dwarf::DW_ATE_float.
     /// \param Flags       Optional DWARF attributes, e.g., DW_AT_endianity.
     DIBasicType *createBasicType(StringRef Name, uint64_t SizeInBits,
                                  unsigned Encoding,
                                  DINode::DIFlags Flags = DINode::FlagZero);
 
+    /// Create debugging information entry for a basic type with packed decimal
+    /// type.
+    /// \param Name        Type name.
+    /// \param Pic         Picture String
+    /// \param SizeInBits  Size of the type.
+    /// \param Encoding    DWARF encoding code, e.g., dwarf::DW_ATE_edited_type.
+    /// \param DigitCount  digit count
+    /// \param DecimalSign decimal sign
+    /// \param scale       scale
+    /// \param Flags       Optional DWARF attributes, e.g., DIFlagsBinaryScale
+    DIBasicType *createBasicType(StringRef Name, StringRef Pic,
+                                 uint64_t SizeInBits, unsigned Encoding,
+                                 Optional<uint16_t> DigitCount = None,
+                                 Optional<uint16_t> DecimalSign = None,
+                                 Optional<int16_t> Scale = None,
+                                 DINode::DIFlags Flags = DINode::FlagZero);
+
     /// Create debugging information entry for a qualified
     /// type, e.g. 'const int'.
     /// \param Tag         Tag identifing type, e.g. dwarf::TAG_volatile_type
     /// \param FromTy      Base Type.
     DIDerivedType *createQualifiedType(unsigned Tag, DIType *FromTy);
 
     /// Create debugging information entry for a pointer.
     /// \param PointeeTy         Type pointed by this pointer.

include/llvm/IR/DebugInfoFlags.def

 HANDLE_DI_FLAG((1 << 22), TypePassByValue)
 HANDLE_DI_FLAG((1 << 23), TypePassByReference)
 HANDLE_DI_FLAG((1 << 24), FixedEnum)
 HANDLE_DI_FLAG((1 << 25), Thunk)
 HANDLE_DI_FLAG((1 << 26), Trivial)
 HANDLE_DI_FLAG((1 << 27), BigEndian)
 HANDLE_DI_FLAG((1 << 28), LittleEndian)
 HANDLE_DI_FLAG((1 << 29), AllCallsDescribed)
+HANDLE_DI_FLAG((1 << 30), BinaryScale)
 
 // To avoid needing a dedicated value for IndirectVirtualBase, we use
 // the bitwise or of Virtual and FwdDecl, which does not otherwise
 // make sense for inheritance.
 HANDLE_DI_FLAG((1 << 2) | (1 << 5), IndirectVirtualBase)
 
 #ifdef DI_FLAG_LARGEST_NEEDED
 // intended to be used with ADT/BitmaskEnum.h
 // NOTE: always must be equal to largest flag, check this when adding new flag
-HANDLE_DI_FLAG((1 << 29), Largest)
+HANDLE_DI_FLAG((1 << 30), Largest)
 #undef DI_FLAG_LARGEST_NEEDED
 #endif
 
 #undef HANDLE_DI_FLAG

include/llvm/IR/DebugInfoMetadata.h

public:
   bool isLValueReference() const { return getFlags() & FlagLValueReference; }
   bool isRValueReference() const { return getFlags() & FlagRValueReference; }
   bool isTypePassByValue() const { return getFlags() & FlagTypePassByValue; }
   bool isTypePassByReference() const {
     return getFlags() & FlagTypePassByReference;
   }
   bool isBigEndian() const { return getFlags() & FlagBigEndian; }
   bool isLittleEndian() const { return getFlags() & FlagLittleEndian; }
+  bool isBinaryScale() const { return getFlags() & FlagBinaryScale; }
 
   static bool classof(const Metadata *MD) {
     switch (MD->getMetadataID()) {
     default:
       return false;
     case DIBasicTypeKind:
     case DIDerivedTypeKind:
     case DICompositeTypeKind:
     case DISubroutineTypeKind:
       return true;
     }
   }
 };
 
 /// Basic type, like 'int' or 'float'.
 ///
 /// TODO: Split out DW_TAG_unspecified_type.
 /// TODO: Drop unused accessors.
 class DIBasicType : public DIType {
   friend class LLVMContextImpl;
   friend class MDNode;
 
+public:
+  /// Basic Type decimal info, used to record optional dwarf decimal attributes
+  /// such as picture_string, digit_counts, decimal_sign, decimal_scale all or
+  /// some can be absent and optional depending on encoding type.
+  struct DecimalInfo {
+    Optional<uint16_t> DigitCount;
+    Optional<uint16_t> DecimalSign;
+    Optional<int16_t> Scale;
+
+    bool operator==(const DecimalInfo &RHS) const {
+      return DigitCount == RHS.DigitCount && DecimalSign == RHS.DecimalSign &&
+             Scale == RHS.Scale;
+    }
+  };
+
+private:
   unsigned Encoding;
+  Optional<DecimalInfo> DecimalAttrInfo;
 
   DIBasicType(LLVMContext &C, StorageType Storage, unsigned Tag,
               uint64_t SizeInBits, uint32_t AlignInBits, unsigned Encoding,
-              DIFlags Flags, ArrayRef<Metadata *> Ops)
+              DIFlags Flags, Optional<DecimalInfo> DecimalAttrInfo,
+              ArrayRef<Metadata *> Ops)
       : DIType(C, DIBasicTypeKind, Storage, Tag, 0, SizeInBits, AlignInBits, 0,
                Flags, Ops),
-        Encoding(Encoding) {}
+        Encoding(Encoding), DecimalAttrInfo(DecimalAttrInfo) {}
   ~DIBasicType() = default;
 
   static DIBasicType *getImpl(LLVMContext &Context, unsigned Tag,
                               StringRef Name, uint64_t SizeInBits,
                               uint32_t AlignInBits, unsigned Encoding,
                               DIFlags Flags, StorageType Storage,
                               bool ShouldCreate = true) {
-    return getImpl(Context, Tag, getCanonicalMDString(Context, Name),
-                   SizeInBits, AlignInBits, Encoding, Flags, Storage,
+    return getImpl(Context, Tag, getCanonicalMDString(Context, Name), nullptr,
+                   SizeInBits, AlignInBits, Encoding, Flags, None, Storage,
                    ShouldCreate);
   }
   static DIBasicType *getImpl(LLVMContext &Context, unsigned Tag,
                               MDString *Name, uint64_t SizeInBits,
                               uint32_t AlignInBits, unsigned Encoding,
-                              DIFlags Flags, StorageType Storage,
-                              bool ShouldCreate = true);
+                              DIFlags Flags,
+                              Optional<DecimalInfo> DecimalAttrInfo,
+                              StorageType Storage, bool ShouldCreate = true) {
+    return getImpl(Context, Tag, Name, nullptr, SizeInBits, AlignInBits,
+                   Encoding, Flags, DecimalAttrInfo, Storage, ShouldCreate);
+  }
+
+  static DIBasicType *getImpl(LLVMContext &Context, unsigned Tag,
+                              StringRef Name, MDString *PictureString,
+                              uint64_t SizeInBits, uint32_t AlignInBits,
+                              unsigned Encoding, DIFlags Flags,
+                              Optional<DecimalInfo> DecimalAttrInfo,
+                              StorageType Storage, bool ShouldCreate = true) {
+    return getImpl(Context, Tag, getCanonicalMDString(Context, Name),
+                   PictureString, SizeInBits, AlignInBits, Encoding, Flags,
+                   DecimalAttrInfo, Storage, ShouldCreate);
+  }
+
+  static DIBasicType *getImpl(LLVMContext &Context, unsigned Tag,
+                              MDString *Name, MDString *PictureString,
+                              uint64_t SizeInBits, uint32_t AlignInBits,
+                              unsigned Encoding, DIFlags Flags,
+                              Optional<DecimalInfo> DecimalAttrInfo,
+                              StorageType Storage, bool ShouldCreate = true);
 
   TempDIBasicType cloneImpl() const {
-    return getTemporary(getContext(), getTag(), getName(), getSizeInBits(),
-                        getAlignInBits(), getEncoding(), getFlags());
+    return getTemporary(getContext(), getTag(), getName(),
+                        getRawPictureString(), getSizeInBits(),
+                        getAlignInBits(), getEncoding(), getFlags(),
+                        getDecimalInfo());
   }
 
 public:
   DEFINE_MDNODE_GET(DIBasicType, (unsigned Tag, StringRef Name),
                     (Tag, Name, 0, 0, 0, FlagZero))
   DEFINE_MDNODE_GET(DIBasicType,
                     (unsigned Tag, StringRef Name, uint64_t SizeInBits,
                      uint32_t AlignInBits, unsigned Encoding, DIFlags Flags),
                     (Tag, Name, SizeInBits, AlignInBits, Encoding, Flags))
   DEFINE_MDNODE_GET(DIBasicType,
                     (unsigned Tag, MDString *Name, uint64_t SizeInBits,
                      uint32_t AlignInBits, unsigned Encoding, DIFlags Flags),
-                    (Tag, Name, SizeInBits, AlignInBits, Encoding, Flags))
+                    (Tag, Name, SizeInBits, AlignInBits, Encoding, Flags, None))
+  DEFINE_MDNODE_GET(DIBasicType,
+                    (unsigned Tag, StringRef Name, MDString *PictureString,
+                     uint64_t SizeInBits, uint32_t AlignInBits,
+                     unsigned Encoding, DIFlags Flags,
+                     Optional<DecimalInfo> ExtInfo),
+                    (Tag, Name, PictureString, SizeInBits, AlignInBits,
+                     Encoding, Flags, ExtInfo))
+  DEFINE_MDNODE_GET(DIBasicType,
+                    (unsigned Tag, MDString *Name, MDString *PictureString,
+                     uint64_t SizeInBits, uint32_t AlignInBits,
+                     unsigned Encoding, DIFlags Flags,
+                     Optional<DecimalInfo> ExtInfo),
+                    (Tag, Name, PictureString, SizeInBits, AlignInBits,
+                     Encoding, Flags, ExtInfo))
 
   TempDIBasicType clone() const { return cloneImpl(); }
 
   unsigned getEncoding() const { return Encoding; }
 
   enum class Signedness { Signed, Unsigned };
 
   /// Return the signedness of this type, or None if this type is neither
   /// signed nor unsigned.
   Optional<Signedness> getSignedness() const;
 
+  bool hasDecimalInfo() const { return DecimalAttrInfo.hasValue(); }
+  Optional<DecimalInfo> getDecimalInfo() const { return DecimalAttrInfo; }
+  StringRef getPictureString() const { return getStringOperand(3); }
+  MDString *getRawPictureString() const { return getOperandAs<MDString>(3); }
+
+  Optional<uint16_t> getDigitCount() const {
+    return DecimalAttrInfo.getValue().DigitCount;
+  }
+
+  Optional<uint16_t> getDecimalSign() const {
+    return DecimalAttrInfo.getValue().DecimalSign;
+  }
+
+  Optional<int16_t> getScale() const {
+    return DecimalAttrInfo.getValue().Scale;
+  }
+
   static bool classof(const Metadata *MD) {
     return MD->getMetadataID() == DIBasicTypeKind;
   }
 };
 
 /// Derived types.
 ///
 /// This includes qualified types, pointers, references, friends, typedefs, and

lib/AsmParser/LLLexer.cpp

#define KEYWORD(STR)                                                           \
   KEYWORD(resByArg);
   KEYWORD(byArg);
   KEYWORD(uniformRetVal);
   KEYWORD(uniqueRetVal);
   KEYWORD(virtualConstProp);
   KEYWORD(info);
   KEYWORD(byte);
   KEYWORD(bit);
+  KEYWORD(pic);
+  KEYWORD(digits);
+  KEYWORD(scale);
+  KEYWORD(sign);
 
 #undef KEYWORD
 
   // Keywords for types.
 #define TYPEKEYWORD(STR, LLVMTY)                                               \
   do {                                                                         \
     if (Keyword == STR) {                                                      \
       TyVal = LLVMTY;                                                          \
#define DWKEYWORD(TYPE, TOKEN)                                                 \
 
   DWKEYWORD(TAG, DwarfTag);
   DWKEYWORD(ATE, DwarfAttEncoding);
   DWKEYWORD(VIRTUALITY, DwarfVirtuality);
   DWKEYWORD(LANG, DwarfLang);
   DWKEYWORD(CC, DwarfCC);
   DWKEYWORD(OP, DwarfOp);
   DWKEYWORD(MACINFO, DwarfMacinfo);
+  DWKEYWORD(DS, DwarfDecimalSign);
 
 #undef DWKEYWORD
 
   if (Keyword.startswith("DIFlag")) {
     StrVal.assign(Keyword.begin(), Keyword.end());
     return lltok::DIFlag;
   }
 

lib/AsmParser/LLParser.cpp

 };
 
 struct DwarfTagField : public MDUnsignedField {
   DwarfTagField() : MDUnsignedField(0, dwarf::DW_TAG_hi_user) {}
   DwarfTagField(dwarf::Tag DefaultTag)
       : MDUnsignedField(DefaultTag, dwarf::DW_TAG_hi_user) {}
 };
 
+struct DwarfDecimalSignField : public MDUnsignedField {
+  DwarfDecimalSignField() : MDUnsignedField(dwarf::DW_DS_Invalid) {}
+  DwarfDecimalSignField(dwarf::DecimalSignEncoding DS) : MDUnsignedField(DS) {}
+};
+
 struct DwarfMacinfoTypeField : public MDUnsignedField {
   DwarfMacinfoTypeField() : MDUnsignedField(0, dwarf::DW_MACINFO_vendor_ext) {}
   DwarfMacinfoTypeField(dwarf::MacinfoRecordType DefaultType)
     : MDUnsignedField(DefaultType, dwarf::DW_MACINFO_vendor_ext) {}
 };
 
 struct DwarfAttEncodingField : public MDUnsignedField {
   DwarfAttEncodingField() : MDUnsignedField(0, dwarf::DW_ATE_hi_user) {}
bool LLParser::ParseMDField(LocTy Loc, StringRef Name, DwarfTagField &Result) {
 
   Result.assign(Tag);
   Lex.Lex();
   return false;
 }
 
 template <>
 bool LLParser::ParseMDField(LocTy Loc, StringRef Name,
+                            DwarfDecimalSignField &Result) {
+  if (Lex.getKind() == lltok::APSInt)
+    return ParseMDField(Loc, Name, static_cast<MDUnsignedField &>(Result));
+
+  if (Lex.getKind() != lltok::DwarfDecimalSign)
+    return TokError("expected DWARF Decimal sign");
+
+  unsigned DS = dwarf::getDecimalSign(Lex.getStrVal());
+  if (DS == dwarf::DW_DS_Invalid)
+    return TokError("invalid DWARF decimal sign" + Twine(" '") +
+                    Lex.getStrVal() + "'");
+  assert(DS <= Result.Max && "Expected valid DWARF decimal sign");
+
+  Result.assign(DS);
+  Lex.Lex();
+  return false;
+}
+
+template <>
+bool LLParser::ParseMDField(LocTy Loc, StringRef Name,
                             DwarfMacinfoTypeField &Result) {
   if (Lex.getKind() == lltok::APSInt)
     return ParseMDField(Loc, Name, static_cast<MDUnsignedField &>(Result));
 
   if (Lex.getKind() != lltok::DwarfMacinfo)
     return TokError("expected DWARF macinfo type");
 
   unsigned Macinfo = dwarf::getMacinfo(Lex.getStrVal());
int64_t Value = value.isMDSignedField()
                       : static_cast<int64_t>(value.getMDUnsignedValue());
   Result =
       GET_OR_DISTINCT(DIEnumerator, (Context, Value, isUnsigned.Val, name.Val));
 
   return false;
 }
 
 /// ParseDIBasicType:
-///   ::= !DIBasicType(tag: DW_TAG_base_type, name: "int", size: 32, align: 32,
-///                    encoding: DW_ATE_encoding, flags: 0)
+/// ::= !DIBasicType(tag: DW_TAG_base_type, name: "int", size: 32, align: 1,
+///                  encoding: DW_ATE_encoding, pic: "picture_string",
+///                  digits: digit_count, sign: decimal_sign,
+///                  scale: decimal/binary scale, flags: 0)
 bool LLParser::ParseDIBasicType(MDNode *&Result, bool IsDistinct) {
 #define VISIT_MD_FIELDS(OPTIONAL, REQUIRED)                                    \
   OPTIONAL(tag, DwarfTagField, (dwarf::DW_TAG_base_type));                     \
   OPTIONAL(name, MDStringField, );                                             \
   OPTIONAL(size, MDUnsignedField, (0, UINT64_MAX));                            \
   OPTIONAL(align, MDUnsignedField, (0, UINT32_MAX));                           \
   OPTIONAL(encoding, DwarfAttEncodingField, );                                 \
+  OPTIONAL(pic, MDStringField, );                                              \
+  OPTIONAL(digits, MDUnsignedField, );                                         \
+  OPTIONAL(sign, DwarfDecimalSignField, (dwarf::DW_DS_Invalid));               \
+  OPTIONAL(scale, MDSignedField, );                                            \
   OPTIONAL(flags, DIFlagField, );
   PARSE_MD_FIELDS();
 #undef VISIT_MD_FIELDS
 
+  if (pic.Seen || digits.Seen || sign.Seen || scale.Seen) {
+    DIBasicType::DecimalInfo DAInfo;
+    if (digits.Seen)
+      DAInfo.DigitCount = digits.Val;
+    if (sign.Seen)
+      DAInfo.DecimalSign = sign.Val;
+    if (scale.Seen)
+      DAInfo.Scale = scale.Val;
+
+    Result = GET_OR_DISTINCT(DIBasicType,
+                             (Context, tag.Val, name.Val, pic.Val, size.Val,
+                              align.Val, encoding.Val, flags.Val, DAInfo));
+  } else {
     Result = GET_OR_DISTINCT(DIBasicType, (Context, tag.Val, name.Val, size.Val,
                                            align.Val, encoding.Val, flags.Val));
+  }
   return false;
 }
 
 /// ParseDIDerivedType:
 ///   ::= !DIDerivedType(tag: DW_TAG_pointer_type, name: "int", file: !0,
 ///                      line: 7, scope: !1, baseType: !2, size: 32,
 ///                      align: 32, offset: 0, flags: 0, extraData: !3,
 ///                      dwarfAddressSpace: 3)

lib/AsmParser/LLToken.h

enum Kind {
   kw_resByArg,
   kw_byArg,
   kw_uniformRetVal,
   kw_uniqueRetVal,
   kw_virtualConstProp,
   kw_info,
   kw_byte,
   kw_bit,
+  kw_pic,
+  kw_digits,
+  kw_scale,
+  kw_sign,
 
   // Unsigned Valued tokens (UIntVal).
   GlobalID,   // @42
   LocalVarID, // %42
   AttrGrpID,  // #42
   SummaryID,  // ^42
 
   // String valued tokens (StrVal).
enum Kind {
   DwarfLang,        // DW_LANG_foo
   DwarfCC,          // DW_CC_foo
   EmissionKind,     // lineTablesOnly
   NameTableKind,    // GNU
   DwarfOp,          // DW_OP_foo
   DIFlag,           // DIFlagFoo
   DwarfMacinfo,     // DW_MACINFO_foo
   ChecksumKind,     // CSK_foo
+  DwarfDecimalSign, // DW_DS_foo
 
   // Type valued tokens (TyVal).
   Type,
 
   APFloat, // APFloatVal
   APSInt   // APSInt
 };
 } // end namespace lltok
 } // end namespace llvm
 
 #endif

lib/BinaryFormat/Dwarf.cpp

 unsigned llvm::dwarf::getTag(StringRef TagString) {
   return StringSwitch<unsigned>(TagString)
 #define HANDLE_DW_TAG(ID, NAME, VERSION, VENDOR)                               \
   .Case("DW_TAG_" #NAME, DW_TAG_##NAME)
 #include "llvm/BinaryFormat/Dwarf.def"
       .Default(DW_TAG_invalid);
 }
 
+unsigned llvm::dwarf::getDecimalSign(StringRef DSString) {
+  return StringSwitch<unsigned>(DSString)
+#define HANDLE_DW_DS(ID, NAME) .Case("DW_DS_" #NAME, DW_DS_##NAME)
+#include "llvm/BinaryFormat/Dwarf.def"
+      .Default(DW_DS_Invalid);
+}
+
 unsigned llvm::dwarf::TagVersion(dwarf::Tag Tag) {
   switch (Tag) {
   default:
     return 0;
 #define HANDLE_DW_TAG(ID, NAME, VERSION, VENDOR)                               \
   case DW_TAG_##NAME:                                                          \
     return VERSION;
 #include "llvm/BinaryFormat/Dwarf.def"

lib/Bitcode/Reader/MetadataLoader.cpp

case bitc::METADATA_ENUMERATOR: {
     MetadataList.assignValue(
         GET_OR_DISTINCT(DIEnumerator, (Context, unrotateSign(Record[1]),
                                        IsUnsigned, getMDString(Record[2]))),
         NextMetadataNo);
     NextMetadataNo++;
     break;
   }
   case bitc::METADATA_BASIC_TYPE: {
-    if (Record.size() < 6 || Record.size() > 7)
-      return error("Invalid record");
 
+    if (Record.size() < 6 || Record.size() > 12)
+      return error("Invalid record");
     IsDistinct = Record[0];
-    DINode::DIFlags Flags = (Record.size() > 6) ?
-                    static_cast<DINode::DIFlags>(Record[6]) : DINode::FlagZero;
+
+    DINode::DIFlags Flags = (Record.size() > 6)
+                                ? static_cast<DINode::DIFlags>(Record[6])
+                                : DINode::FlagZero;
+
+    if (Record.size() > 7) {
+      DIBasicType::DecimalInfo DAInfo;
+      if (Record[8])
+        DAInfo.DigitCount = Record[8];
+      if (Record[9])
+        DAInfo.DecimalSign = Record[9];
+      if (Record[10])
+        DAInfo.Scale = Record[11];
 
       MetadataList.assignValue(
           GET_OR_DISTINCT(DIBasicType,
-                        (Context, Record[1], getMDString(Record[2]), Record[3],
-                         Record[4], Record[5], Flags)),
+                          (Context, Record[1], getMDString(Record[2]),
+                           Record[7] ? getMDString(Record[7]) : nullptr,
+                           Record[3], Record[4], Record[5], Flags, DAInfo)),
           NextMetadataNo);
+    } else {
+      MetadataList.assignValue(
+          GET_OR_DISTINCT(DIBasicType,
+                          (Context, Record[1], getMDString(Record[2]),
+                           Record[3], Record[4], Record[5], Flags)),
+          NextMetadataNo);
+    }
+
     NextMetadataNo++;
     break;
   }
   case bitc::METADATA_DERIVED_TYPE: {
     if (Record.size() < 12 || Record.size() > 13)
       return error("Invalid record");
 
     // DWARF address space is encoded as N->getDWARFAddressSpace() + 1. 0 means

lib/Bitcode/Writer/BitcodeWriter.cpp

void ModuleBitcodeWriter::writeDIBasicType(const DIBasicType *N,
   Record.push_back(N->isDistinct());
   Record.push_back(N->getTag());
   Record.push_back(VE.getMetadataOrNullID(N->getRawName()));
   Record.push_back(N->getSizeInBits());
   Record.push_back(N->getAlignInBits());
   Record.push_back(N->getEncoding());
   Record.push_back(N->getFlags());
 
+  // Below are the optional decimal attributes in case base type is decimal type
+  // and one or more attributes are not needed, we encode 0 to mark the missing
+  // place except the `scale` attribute which is integer and may have valid zero
+  // value, to mark its validity we add one more non-zero record before it.
+  if (N->hasDecimalInfo()) {
+    Record.push_back(VE.getMetadataOrNullID(N->getRawPictureString()));
+
+    if (const auto &digits = N->getDigitCount())
+      Record.push_back(*digits);
+    else
+      Record.push_back(0);
+
+    if (const auto &sign = N->getDecimalSign())
+      Record.push_back(*sign);
+    else
+      Record.push_back(0);
+
+    if (const auto &scale = N->getScale()) {
+      Record.push_back(1);
+      Record.push_back(*scale);
+    } else {
+      Record.push_back(0);
+      Record.push_back(0);
+    }
+  }
+
   Stream.EmitRecord(bitc::METADATA_BASIC_TYPE, Record, Abbrev);
   Record.clear();
 }
 
 void ModuleBitcodeWriter::writeDIDerivedType(const DIDerivedType *N,
                                              SmallVectorImpl<uint64_t> &Record,
                                              unsigned Abbrev) {
   Record.push_back(N->isDistinct());

lib/CodeGen/AsmPrinter/DwarfUnit.cpp

void DwarfUnit::constructTypeDIE(DIE &Buffer, const DIBasicType *BTy) {
 
   uint64_t Size = BTy->getSizeInBits() >> 3;
   addUInt(Buffer, dwarf::DW_AT_byte_size, None, Size);
 
   if (BTy->isBigEndian())
     addUInt(Buffer, dwarf::DW_AT_endianity, None, dwarf::DW_END_big);
   else if (BTy->isLittleEndian())
     addUInt(Buffer, dwarf::DW_AT_endianity, None, dwarf::DW_END_little);
+
+  if (BTy->hasDecimalInfo()) {
+    StringRef PictureString = BTy->getPictureString();
+    if (!PictureString.empty())
+      addString(Buffer, dwarf::DW_AT_picture_string, PictureString);
+
+    if (const auto &digits = BTy->getDigitCount())
+      addUInt(Buffer, dwarf::DW_AT_digit_count, None, *digits);
+
+    if (const auto &sign = BTy->getDecimalSign())
+      addUInt(Buffer, dwarf::DW_AT_decimal_sign, None, *sign);
+
+    if (const auto &scale = BTy->getScale())
+      if (BTy->isBinaryScale())
+        addSInt(Buffer, dwarf::DW_AT_binary_scale, None, *scale);
+      else
+        addSInt(Buffer, dwarf::DW_AT_decimal_scale, None, *scale);
+  }
 }
 
 void DwarfUnit::constructTypeDIE(DIE &Buffer, const DIDerivedType *DTy) {
   // Get core information.
   StringRef Name = DTy->getName();
   uint64_t Size = DTy->getSizeInBits() >> 3;
   uint16_t Tag = Buffer.getTag();
 

lib/IR/AsmWriter.cpp

static void writeDIBasicType(raw_ostream &Out, const DIBasicType *N,
   MDFieldPrinter Printer(Out);
   if (N->getTag() != dwarf::DW_TAG_base_type)
     Printer.printTag(N);
   Printer.printString("name", N->getName());
   Printer.printInt("size", N->getSizeInBits());
   Printer.printInt("align", N->getAlignInBits());
   Printer.printDwarfEnum("encoding", N->getEncoding(),
                          dwarf::AttributeEncodingString);
+
+  if (N->hasDecimalInfo()) {
+    Printer.printString("pic", N->getPictureString());
+    if (const auto &digits = N->getDigitCount())
+      Printer.printInt("digits", *digits);
+
+    if (const auto &sign = N->getDecimalSign())
+      Printer.printDwarfEnum("sign", *sign, dwarf::DecimalSignString);
+
+    if (const auto &scale = N->getScale())
+      Printer.printInt("scale", *scale, /*ShouldSkipZero*/ false);
+  }
+
   Printer.printDIFlags("flags", N->getFlags());
   Out << ")";
 }
 
 static void writeDIDerivedType(raw_ostream &Out, const DIDerivedType *N,
                                TypePrinting *TypePrinter, SlotTracker *Machine,
                                const Module *Context) {
   Out << "!DIDerivedType(";

lib/IR/DIBuilder.cpp

 DIBasicType *DIBuilder::createBasicType(StringRef Name, uint64_t SizeInBits,
                                         unsigned Encoding,
                                         DINode::DIFlags Flags) {
   assert(!Name.empty() && "Unable to create type without name");
   return DIBasicType::get(VMContext, dwarf::DW_TAG_base_type, Name, SizeInBits,
                           0, Encoding, Flags);
 }
 
+DIBasicType *DIBuilder::createBasicType(StringRef Name, StringRef Pic,
+                                        uint64_t SizeInBits, unsigned Encoding,
+                                        Optional<uint16_t> DigitCount,
+                                        Optional<uint16_t> DecimalSign,
+                                        Optional<int16_t> Scale,
+                                        DINode::DIFlags Flags) {
+  assert(!Name.empty() && "Unable to create type without name");
+  assert((!Pic.empty() || DigitCount != None || DecimalSign != None ||
+          Scale != None) &&
+         "Unable to create decimal info with empty attributes");
+
+  MDString *PicString = nullptr;
+  if (!Pic.empty())
+    PicString = MDString::get(VMContext, Pic);
+
+  return DIBasicType::get(
+      VMContext, dwarf::DW_TAG_base_type, Name, PicString, SizeInBits, 0,
+      Encoding, Flags,
+      DIBasicType::DecimalInfo{ DigitCount, DecimalSign, Scale });
+}
+
 DIDerivedType *DIBuilder::createQualifiedType(unsigned Tag, DIType *FromTy) {
   return DIDerivedType::get(VMContext, Tag, "", nullptr, 0, nullptr, FromTy, 0,
                             0, 0, None, DINode::FlagZero);
 }
 
 DIDerivedType *DIBuilder::createPointerType(
     DIType *PointeeTy,
     uint64_t SizeInBits,

lib/IR/DebugInfoMetadata.cpp

DIEnumerator *DIEnumerator::getImpl(LLVMContext &Context, int64_t Value,
                                     StorageType Storage, bool ShouldCreate) {
   assert(isCanonical(Name) && "Expected canonical MDString");
   DEFINE_GETIMPL_LOOKUP(DIEnumerator, (Value, IsUnsigned, Name));
   Metadata *Ops[] = {Name};
   DEFINE_GETIMPL_STORE(DIEnumerator, (Value, IsUnsigned), Ops);
 }
 
 DIBasicType *DIBasicType::getImpl(LLVMContext &Context, unsigned Tag,
-                                  MDString *Name, uint64_t SizeInBits,
-                                  uint32_t AlignInBits, unsigned Encoding,
-                                  DIFlags Flags, StorageType Storage,
-                                  bool ShouldCreate) {
+                                  MDString *Name, MDString *PictureString,
+                                  uint64_t SizeInBits, uint32_t AlignInBits,
+                                  unsigned Encoding, DIFlags Flags,
+                                  Optional<DIBasicType::DecimalInfo> DAInfo,
+                                  StorageType Storage, bool ShouldCreate) {
   assert(isCanonical(Name) && "Expected canonical MDString");
-  DEFINE_GETIMPL_LOOKUP(DIBasicType,
-                        (Tag, Name, SizeInBits, AlignInBits, Encoding, Flags));
-  Metadata *Ops[] = {nullptr, nullptr, Name};
-  DEFINE_GETIMPL_STORE(DIBasicType, (Tag, SizeInBits, AlignInBits, Encoding,
-                      Flags), Ops);
+  DEFINE_GETIMPL_LOOKUP(DIBasicType, (Tag, Name, PictureString, SizeInBits,
+                                      AlignInBits, Encoding, Flags, DAInfo));
+  Metadata *Ops[] = { nullptr, nullptr, Name, PictureString };
+  DEFINE_GETIMPL_STORE(DIBasicType,
+                       (Tag, SizeInBits, AlignInBits, Encoding, Flags, DAInfo),
+                       Ops);
 }
 
 Optional<DIBasicType::Signedness> DIBasicType::getSignedness() const {
   switch (getEncoding()) {
   case dwarf::DW_ATE_signed:
   case dwarf::DW_ATE_signed_char:
     return Signedness::Signed;
   case dwarf::DW_ATE_unsigned:

lib/IR/LLVMContextImpl.h

template <> struct MDNodeKeyImpl<DIEnumerator> {
   }
 
   unsigned getHashValue() const { return hash_combine(Value, Name); }
 };
 
 template <> struct MDNodeKeyImpl<DIBasicType> {
   unsigned Tag;
   MDString *Name;
+  MDString *PictureString;
   uint64_t SizeInBits;
   uint32_t AlignInBits;
   unsigned Encoding;
   unsigned Flags;
+  Optional<DIBasicType::DecimalInfo> DecimalAttrInfo;
 
-  MDNodeKeyImpl(unsigned Tag, MDString *Name, uint64_t SizeInBits,
-                uint32_t AlignInBits, unsigned Encoding, unsigned Flags)
-      : Tag(Tag), Name(Name), SizeInBits(SizeInBits), AlignInBits(AlignInBits),
-        Encoding(Encoding), Flags(Flags) {}
+  MDNodeKeyImpl(unsigned Tag, MDString *Name, MDString *PictureString,
+                uint64_t SizeInBits, uint32_t AlignInBits, unsigned Encoding,
+                unsigned Flags,
+                Optional<DIBasicType::DecimalInfo> DecimalAttrInfo)
+      : Tag(Tag), Name(Name), PictureString(PictureString),
+        SizeInBits(SizeInBits), AlignInBits(AlignInBits), Encoding(Encoding),
+        Flags(Flags), DecimalAttrInfo(DecimalAttrInfo) {}
   MDNodeKeyImpl(const DIBasicType *N)
-      : Tag(N->getTag()), Name(N->getRawName()), SizeInBits(N->getSizeInBits()),
-        AlignInBits(N->getAlignInBits()), Encoding(N->getEncoding()), Flags(N->getFlags()) {}
+      : Tag(N->getTag()), Name(N->getRawName()),
+        PictureString(N->getRawPictureString()), SizeInBits(N->getSizeInBits()),
+        AlignInBits(N->getAlignInBits()), Encoding(N->getEncoding()),
+        Flags(N->getFlags()), DecimalAttrInfo(N->getDecimalInfo()) {}
 
   bool isKeyOf(const DIBasicType *RHS) const {
     return Tag == RHS->getTag() && Name == RHS->getRawName() &&
+           PictureString == RHS->getRawPictureString() &&
            SizeInBits == RHS->getSizeInBits() &&
            AlignInBits == RHS->getAlignInBits() &&
-           Encoding == RHS->getEncoding() &&
-           Flags == RHS->getFlags();
+           Encoding == RHS->getEncoding() && Flags == RHS->getFlags() &&
+           DecimalAttrInfo == RHS->getDecimalInfo();
   }
 
   unsigned getHashValue() const {
     return hash_combine(Tag, Name, SizeInBits, AlignInBits, Encoding);
   }
 };
 
 template <> struct MDNodeKeyImpl<DIDerivedType> {

lib/IR/Verifier.cpp

 }
 
 void Verifier::visitDIBasicType(const DIBasicType &N) {
   AssertDI(N.getTag() == dwarf::DW_TAG_base_type ||
                N.getTag() == dwarf::DW_TAG_unspecified_type,
            "invalid tag", &N);
   AssertDI(!(N.isBigEndian() && N.isLittleEndian()) ,
             "has conflicting flags", &N);
+  if (N.hasDecimalInfo())
+    AssertDI(N.getEncoding() == dwarf::DW_ATE_packed_decimal ||
+             N.getEncoding() == dwarf::DW_ATE_numeric_string ||
+             N.getEncoding() == dwarf::DW_ATE_edited ||
+             N.getEncoding() == dwarf::DW_ATE_signed_fixed ||
+             N.getEncoding() == dwarf::DW_ATE_unsigned_fixed,
+             "Invalid encoding for extended base type", &N);
 }
 
 void Verifier::visitDIDerivedType(const DIDerivedType &N) {
   // Common scope checks.
   visitDIScope(N);
 
   AssertDI(N.getTag() == dwarf::DW_TAG_typedef ||
                N.getTag() == dwarf::DW_TAG_pointer_type ||

test/Assembler/debug-info.ll

 ; RUN: llvm-as < %s | llvm-dis | llvm-as | llvm-dis | FileCheck %s
 ; RUN: verify-uselistorder %s
 
-; CHECK: !named = !{!0, !0, !1, !2, !3, !4, !5, !6, !7, !8, !8, !9, !10, !11, !12, !13, !14, !15, !16, !17, !18, !19, !20, !21, !22, !23, !24, !25, !26, !27, !27, !28, !29, !30, !31, !32, !33, !34, !35, !36, !37, !38, !39}
-!named = !{!0, !1, !2, !3, !4, !5, !6, !7, !8, !9, !10, !11, !12, !13, !14, !15, !16, !17, !18, !19, !20, !21, !22, !23, !24, !25, !26, !27, !28, !29, !30, !31, !32, !33, !34, !35, !36, !37, !38, !39, !40, !41, !42}
+; CHECK: !named = !{!0, !0, !1, !2, !3, !4, !5, !6, !7, !8, !8, !9, !10, !11, !12, !13, !14, !15, !16, !17, !18, !19, !20, !21, !22, !23, !24, !25, !26, !27, !27, !28, !29, !30, !31, !32, !33, !34, !35, !36, !37, !38, !39, !40, !41, !42, !43, !44, !45, !46}
+!named = !{!0, !1, !2, !3, !4, !5, !6, !7, !8, !9, !10, !11, !12, !13, !14, !15, !16, !17, !18, !19, !20, !21, !22, !23, !24, !25, !26, !27, !28, !29, !30, !31, !32, !33, !34, !35, !36, !37, !38, !39, !40, !41, !42, !43, !44, !45, !46, !47, !48, !49}
 
 ; CHECK:      !0 = !DISubrange(count: 3)
 ; CHECK-NEXT: !1 = !DISubrange(count: 3, lowerBound: 4)
 ; CHECK-NEXT: !2 = !DISubrange(count: 3, lowerBound: -5)
 !0 = !DISubrange(count: 3)
 !1 = !DISubrange(count: 3, lowerBound: 0)
 
 !2 = !DISubrange(count: 3, lowerBound: 4)

 ; CHECK-NEXT: !37 = !DIFile(filename: "file", directory: "dir", checksumkind: CSK_MD5, checksum: "3a420e2646916a475e68de8d48f779f5", source: "int source() { }\0A")
 !39 = !DIFile(filename: "file", directory: "dir", source: "int source() { }\0A")
 !40 = !DIFile(filename: "file", directory: "dir", checksumkind: CSK_MD5, checksum: "3a420e2646916a475e68de8d48f779f5", source: "int source() { }\0A")
 
 ; CHECK-NEXT: !38 = !DIBasicType(name: "u64.be", size: 64, align: 1, encoding: DW_ATE_unsigned, flags: DIFlagBigEndian)
 ; CHECK-NEXT: !39 = !DIBasicType(name: "u64.le", size: 64, align: 1, encoding: DW_ATE_unsigned, flags: DIFlagLittleEndian)
 !41 = !DIBasicType(name: "u64.be", size: 64, align: 1, encoding: DW_ATE_unsigned, flags: DIFlagBigEndian)
 !42 = !DIBasicType(name: "u64.le", size: 64, align: 1, encoding: DW_ATE_unsigned, flags: DIFlagLittleEndian)
+
+; CHECK-NEXT !40 = !DIBasicType(name: "ext1", size: 48, align: 1, encoding: DW_ATE_numeric_string, pic: "S999V999", digits: 6, sign: DW_DS_trailing_overpunch, scale: -3)
+; CHECK-NEXT !41 = !DIBasicType(name: "ext2", size: 16, align: 1, encoding: DW_ATE_packed_decimal, pic: "999PP", digits: 3, sign: DW_DS_unsigned, scale: 2)
+; CHECK-NEXT !42 = !DIBasicType(name: "ext3", size: 72, align: 1, encoding: DW_ATE_edited, pic: "+z,zz9.99", digits: 6, scale: -2)
+; CHECK-NEXT !43 = !DIBasicType(name: "ext4", size: 64, align: 1, encoding: DW_ATE_edited, pic: "ABBA(5)")
+; CHECK-NEXT !44 = !DIBasicType(name: "ext5", size: 32, align: 1, encoding: DW_ATE_signed_fixed, pic: "S999V999", digits: 5, scale: -2)
+; CHECK-NEXT !45 = !DIBasicType(name: "ext6", size: 40, align: 1, encoding: DW_ATE_packed_decimal, pic: "S9(3)V99", digits: 5, scale: -2)
+; CHECK-NEXT !46 = !DIBasicType(name: "ext7", size: 40, align: 1, encoding: DW_ATE_packed_decimal, pic: "S9(3)V99", digits: 5, scale: -2, flags: DIFlagBinaryScale)
+!43 = !DIBasicType(name: "ext1", size: 48, align: 1, encoding: DW_ATE_numeric_string, pic: "S999V999", digits: 6, sign: DW_DS_trailing_overpunch, scale: -3)
+!44 = !DIBasicType(name: "ext2", size: 16, align: 1, encoding: DW_ATE_packed_decimal, pic: "999PP", digits: 3, sign: DW_DS_unsigned, scale: 2)
+!45 = !DIBasicType(name: "ext3", size: 72, align: 1, encoding: DW_ATE_edited, pic: "+z,zz9.99", digits: 6, scale: -2)
+!46 = !DIBasicType(name: "ext4", size: 64, align: 1, encoding: DW_ATE_edited, pic: "ABBA(5)")
+!47 = !DIBasicType(name: "ext5", size: 32, align: 1, encoding: DW_ATE_signed_fixed, pic: "S999V999", digits: 5, scale: -2)
+!48 = !DIBasicType(name: "ext6", size: 40, align: 1, encoding: DW_ATE_packed_decimal, pic: "S9(3)V99", digits: 5, scale: -2)
+!49 = !DIBasicType(name: "ext7", size: 40, align: 1, encoding: DW_ATE_packed_decimal, pic: "S9(3)V99", digits: 5, scale: -2, flags: DIFlagBinaryScale)

unittests/IR/MetadataTest.cpp

TEST_F(DIBasicTypeTest, getUnspecified) {
   EXPECT_EQ("unspecified", N->getName());
   EXPECT_EQ(0u, N->getSizeInBits());
   EXPECT_EQ(0u, N->getAlignInBits());
   EXPECT_EQ(0u, N->getEncoding());
   EXPECT_EQ(0u, N->getLine());
   EXPECT_EQ(DINode::FlagZero, N->getFlags());
 }
 
+TEST_F(DIBasicTypeTest, getOptionalDecimalInfo) {
+  auto *N = DIBasicType::get(
+      Context, dwarf::DW_TAG_base_type, "ext1",
+      MDString::get(Context, "S999V99"), 40, 1, dwarf::DW_ATE_numeric_string,
+      DINode::FlagZero,
+      DIBasicType::DecimalInfo{ 5, dwarf::DW_DS_trailing_overpunch, -2 });
+
+  EXPECT_EQ(dwarf::DW_TAG_base_type, N->getTag());
+  EXPECT_EQ("ext1", N->getName());
+  EXPECT_EQ(40u, N->getSizeInBits());
+  EXPECT_EQ(1u, N->getAlignInBits());
+  EXPECT_EQ(dwarf::DW_ATE_numeric_string, N->getEncoding());
+  EXPECT_EQ(DINode::FlagZero, N->getFlags());
+  EXPECT_EQ("S999V99", N->getPictureString());
+  EXPECT_EQ(dwarf::DW_DS_trailing_overpunch, N->getDecimalSign().getValue());
+  EXPECT_EQ(-2, N->getScale().getValue());
+  EXPECT_EQ(5, N->getDigitCount().getValue());
+
+  EXPECT_EQ(N, DIBasicType::get(
+                   Context, dwarf::DW_TAG_base_type, "ext1",
+                   MDString::get(Context, "S999V99"), 40, 1,
+                   dwarf::DW_ATE_numeric_string, DINode::FlagZero,
+                   DIBasicType::DecimalInfo{ 5, dwarf::DW_DS_trailing_overpunch,
+                                             -2 }));
+
+  /// Generally this fails verifier as we are trying to create extended encoding
+  /// without any extended info.
+  EXPECT_NE(N, DIBasicType::get(
+                   Context, dwarf::DW_TAG_base_type, "ext1",
+                   MDString::get(Context, "S999999"), 40, 1,
+                   dwarf::DW_ATE_numeric_string, DINode::FlagZero,
+                   DIBasicType::DecimalInfo{ 5, dwarf::DW_DS_trailing_overpunch,
+                                             -2 }));
+  EXPECT_NE(N, DIBasicType::get(
+                   Context, dwarf::DW_TAG_base_type, "ext1",
+                   MDString::get(Context, "S999V99"), 40, 1,
+                   dwarf::DW_ATE_numeric_string, DINode::FlagZero,
+                   DIBasicType::DecimalInfo{ 4, dwarf::DW_DS_trailing_overpunch,
+                                             -2 }));
+  EXPECT_NE(N, DIBasicType::get(
+                   Context, dwarf::DW_TAG_base_type, "ext1",
+                   MDString::get(Context, "S999V99"), 40, 1,
+                   dwarf::DW_ATE_numeric_string, DINode::FlagZero,
+                   DIBasicType::DecimalInfo{ 5, dwarf::DW_DS_leading_overpunch,
+                                             -2 }));
+  EXPECT_NE(N, DIBasicType::get(
+                   Context, dwarf::DW_TAG_base_type, "ext1",
+                   MDString::get(Context, "S999V99"), 40, 1,
+                   dwarf::DW_ATE_numeric_string, DINode::FlagZero,
+                   DIBasicType::DecimalInfo{ 5, dwarf::DW_DS_trailing_overpunch,
+                                             -1 }));
+
+  TempDIBasicType Temp = N->clone();
+  EXPECT_EQ(N, MDNode::replaceWithUniqued(std::move(Temp)));
+}
+
 typedef MetadataTest DITypeTest;
 
 TEST_F(DITypeTest, clone) {
   // Check that DIType has a specialized clone that returns TempDIType.
   DIType *N = DIBasicType::get(Context, dwarf::DW_TAG_base_type, "int", 32, 32,
                                dwarf::DW_ATE_signed, DINode::FlagZero);
 
   TempDIType Temp = N->clone();