[DebugInfoMetadata] Added DIFlags interface in DIBasicType.

[Chirag]

Summary

This change is only initial implementation. will be extended in Asm/Bitcode writer/reader and DIBuilder.
Flags in DIBasicType will be used to pass attributes used in DW_TAG_base_type, such as DW_AT_endianity.

[Chirag]

Testing Done: Compilation and llvm-check.

[aprantl]

May I ask what the context of this is? Do you have a machine where some (but not all) basic types have a different endianity than the one specified by the ABI?

[Chirag]

Hello Adrian,

Thanks for the reply.
Apologies for late answer.

I am currently working on supporting the gcc specific bi-endian syntactic and semantic convention attribute((bigendian)) for source level debugging for structures with basic type.
I searched for the extension and found out that endianity is completely missing from llvm debug info generation.
So i started from basicType.

I am planning to add this to Variable with Unspecified types, and formal parameters etc as described in DWARFv4.

Regards,
Chirag Patel.

[Chirag]

Extended DIFlags to support DW_AT_endianity in basictype as per DWARFv4

[Chirag]

For testing i have ran llvm-check with no regressions.

[aprantl]

Do you need to support endinaness attributes just on basic types or eventually on any type?
This is still missing an assembler round-trip test.

include/llvm/IR/DebugInfoFlags.def

57

Can you add context to the patch? (git diff -u 9999)
What's bit 1 used for normally?

[Chirag]

Do you need to support endinaness attributes just on basic types or eventually on any type?

for the time being the basicType that maps to DW_TAG_base_type, but in future the variables created using that basictype or any other type with DW_TAG_variable and DW_TAG_formal_parameters tags.

This is still missing an assembler round-trip test.

I will test and update it.

Can you add context to the patch? (git diff -u 9999)

I will update it with missing round-trip test.

What's bit 1 used for normally?

Those lower bits are mapped to DW_END_default/big/little enums(that mapping is not used anywhere at the moment but as it was tristate i needed to use it so, ), and bit 0 is mapped to DW_END_default which does not need to be explicitly used if that flag is equal to absence of DW_AT_endianity as it is optional., and also i will remove the unnecessary shifts.

[aprantl]

for the time being the basicType that maps to DW_TAG_base_type, but in future the variables created using that basictype or any other type with DW_TAG_variable and DW_TAG_formal_parameters tags.

Is it a property of the type or a property of the variable? I.e.: Can you have a struct with one LE member and one BE member?

[Chirag]

for the time being the basicType that maps to DW_TAG_base_type, but in future the variables created using that basictype or any other type with DW_TAG_variable and DW_TAG_formal_parameters tags.

Is it a property of the type or a property of the variable? I.e.: Can you have a struct with one LE member and one BE member?

As far as dwarf standard is concerned it is both(type and variable),
case 1: when struct with 10 ints so, to add dwarf info we can create base_type with BE and reuse that type while creating 10 member variables.
case 2: when struct with 10 ints and void*(unspecified or incomplete type), to create for 10 ints use prev methos and for void* create variable with unspecified type and mark "variable" as BE.

i am aware that creating variable with base type and having endianity in both(type and variabel), is redundant, but as far as dwarf standard lists, the DW_AT_endianity attribute is used to mark both type and variables.

Can you have a struct with one LE member and one BE member?

as far as gcc goes no. but dwarf supports it by marking variables instead of type.

[Chirag]

• Included Full context.
• Changed flag values for BigEndian, LittleEndian.
• Included assembler round-trip test for BasicType with BigEndian/LittleEndian testcases.

[aprantl]

include/llvm/IR/DIBuilder.h

195

We should not pass in raw Flags here. They are an implementation detail. Please use an enum { DW_END_default / DW_END_big / DW_END_little } instead. (It also looks like this enum is currently missing in Dwarf.def.)

test/Assembler/debug-info.ll

101

Thanks, this is good.

[aprantl]

include/llvm/IR/DebugInfoFlags.def

57

I like this more. There should also be a Verifier check that ensures that 27 & 28 cannot be set at the same time.

[Chirag]

include/llvm/IR/DIBuilder.h

195

About rawflag, I was planning to use the same implementation as used in "createAutoVariable", which uses DIFlags, so in future the DW_AT_endianity can be extended to the same without much of a changes to mark the TAG_variables.

about DW_END_default/big/little are defined in dwarf.h and not used much anywhere else, so if we can work with rawflags then those need not be moved to dwarf.def for the moment being.

if you want it then i am happy to make those changes.

[aprantl]

include/llvm/IR/DIBuilder.h

195

If there is precedence for passing in raw flags in DIBuilder then that's fine with me, too.

We will need the enum in Dwarf.def for llvm-dwarfdump anyway, so we might as well add it now.

lib/IR/LLVMContextImpl.h

399 ↗

(On Diff #158692)

hashing the flags is going to be a waste of time on the vast majority of platforms. I would just leave this as is.

[aprantl]

The last thing that is missing is a bitcode upgrade test (unless you can show that one of the existing checked in .bc files in the testsuite also covers the upgrade path for the old, shorter DIBasicType).

[Chirag]

• moved endianity enums to dwarf.def
• Added verifier check for DIBasicType for invalid flags.
• removed hashing of flags from DIBasicType

[Chirag]

The last thing that is missing is a bitcode upgrade test (unless you can show that one of the existing checked in .bc files in the testsuite also covers the upgrade path for the old, shorter DIBasicType).

It seems like there is no such dedicated test case for DIBasicType, but some other testcases such as DIVariable, DiExpression uses the DIBasicType.
Please advice, if you want me to create a new test case for bitcode upgrade of DIBasicType or is it okey to modify the existing DiVariable one.

[aprantl]

It would be cleanest to create a new, minimal test that only contains one global variable with a basic type. The resulting bitcode should only be a few bytes and then it would be obvious what the tests tests.

[Chirag]

• Minor changes relating to DIFlags checks.
• Added bitcode upgrade test for DIBasicType with flags endianity.

[aprantl]

lib/IR/Verifier.cpp

886

same for this function name.

900

FlagLittleEndian is not a "reference" flag. Either just say "has conflicting flags" or have two assertions one for reference and one for endianity.

unittests/IR/MetadataTest.cpp

1022

You need to add one extra case:

EXPECT_NE(N, DIBasicType::get(Context, dwarf::DW_TAG_base_type, "special", 33,
                                26, 7, DINode::FlagEndianLittle));

[Chirag]

unittests/IR/MetadataTest.cpp

1022

During one of our last review, we made BasicType node unique without using the flags, (as those are optional),

I have few concerns,
as DINode:FlagEndianLittle (no such flag present) it will fail at compile-time.

and if thats a typo and you mean (DiNode::FlagLittleEndian)
as we made node unique without considering flags (as per dwarf standard which is optional), it will be same as "N" (in our case), which will fail at runtime (we are trying EXPECT_NE),

adding this case does not make any sense.
Please advise more on the comment.

[aprantl]

unittests/IR/MetadataTest.cpp

1022

The idea was to only remove the *hashing* of the flags (for performance reasons in the common case), but not the comparison. If two basic types hash the same, they would still fail the operator= check. So this test should work.

[Chirag]

unittests/IR/MetadataTest.cpp

1022

Apologies in advance if my understanding is wrong,

During creation of basictype we check that if it is unique or not using hashing so, if we exclude flags we will have the same node, so operator= will succed.

[aprantl]

unittests/IR/MetadataTest.cpp

1022

The hash function is just the first stage of the DenseMap lookup, if the hash function is equivalent then the comparison function is invoked. This is necessary because two hashes could conflict.

MDNodeKeyImpl<DIBasicType>::isKeyOf() is still comparing the Flags in the second stage of the lookup. (If it doesn't then we'll need to add this in this patch).

[Chirag]

unittests/IR/MetadataTest.cpp

1022

Thanks for clarification. i will update the patch soon.

[Chirag]

• fixed unique node lookup for basicType
• fixed assert message for conflicting flags.
• added testcases for comparing basictype with flags.

[aprantl]

lib/IR/LLVMContextImpl.h

394 ↗

(On Diff #159870)

thanks!

test/Bitcode/DIBasicType-DIFlags.ll

2

This test is supposed to test that the *old* format (without the new Flags field) can be parsed. There is no need to check in a .bc file with the new format. That case is already covered by the round-trip tests.

28

Please use just one DIBasicType without any flags, as generated by current LLVM trunk.

[Chirag]

test/Bitcode/DIBasicType-DIFlags.ll

2

Oh, my bad,
In that case there are plenty of testcases that checks just same, covering many off the DIBasicType old format,
so i will remove this testcase as it is not required.

few examples:
test/Bitcode/DIExpression-minus-upgrade.ll
test/Bitcode/disubrange.ll
test/Bitcode/disubrange.ll
test/Bitcode/dilocalvariable-3.9.ll
test/Bitcode/dilocalvariable-3.9.ll
test/Bitcode/disubrange-v0.ll
test/Bitcode/disubrange-v0.ll
test/Bitcode/DIExpression-deref.ll
test/Bitcode/DIExpression-aggresult.ll
test/Bitcode/DIGlobalVariableExpression.ll
test/Bitcode/DIGlobalVariableExpression2.ll
test/Bitcode/upgrade-dbg-value.ll
test/Bitcode/diglobalvariable-3.8.ll
test/Bitcode/DIExpression-4.0.ll
test/Bitcode/DINamespace.ll

Thanks.

[Chirag]

• removed wrong testcase.

[aprantl]

Thanks!

[Chirag]

Hello adrian,

Thanks.
Can you kindly push this changes, as i do not have write permissions on repo.

Regards,
Chirag Patel.

include/llvm/BinaryFormat/Dwarf.h

enum DecimalSignEncoding {
   DW_DS_leading_overpunch = 0x02,
   DW_DS_trailing_overpunch = 0x03,
   DW_DS_leading_separate = 0x04,
   DW_DS_trailing_separate = 0x05
 };
 
 enum EndianityEncoding {
   // Endianity attribute values
-  DW_END_default = 0x00,
-  DW_END_big = 0x01,
-  DW_END_little = 0x02,
+#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
 };
 
 enum AccessAttribute {
   // Accessibility codes
   DW_ACCESS_public = 0x01,
   DW_ACCESS_protected = 0x02,

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_DWARF_SECTION || defined HANDLE_DW_IDX ||                   \
+    defined HANDLE_DW_END)
 #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_DWARF_SECTION
 #define HANDLE_DWARF_SECTION(ENUM_NAME, ELF_NAME, CMDLINE_NAME)
 #endif
 
 #ifndef HANDLE_DW_IDX
 #define HANDLE_DW_IDX(ID, NAME)
 #endif
 
+#ifndef HANDLE_DW_END
+#define HANDLE_DW_END(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 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)
 HANDLE_DW_VIRTUALITY(0x02, pure_virtual)
 
 // DWARF v5 Defaulted Member Encodings.
 HANDLE_DW_DEFAULTED(0x00, no)
 HANDLE_DW_DEFAULTED(0x01, in_class)

 #undef HANDLE_DW_LNCT
 #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

include/llvm/IR/DIBuilder.h

public:
     /// Create C++11 nullptr type.
     DIBasicType *createNullPtrType();
 
     /// Create debugging information entry for a basic
     /// type.
     /// \param Name        Type name.
     /// \param SizeInBits  Size of the type.
     /// \param Encoding    DWARF encoding code, e.g. dwarf::DW_ATE_float.
+    /// \param Flags       DWARF optional attributes e.g. dwarf::DW_AT_endianity
     DIBasicType *createBasicType(StringRef Name, uint64_t SizeInBits,
-                                 unsigned Encoding);
+                                 unsigned Encoding,
+                                 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.

include/llvm/IR/DebugInfoFlags.def

 HANDLE_DI_FLAG((1 << 19), BitField)
 HANDLE_DI_FLAG((1 << 20), NoReturn)
 HANDLE_DI_FLAG((1 << 21), MainSubprogram)
 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)
 
 // 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 << 26), Largest)
+HANDLE_DI_FLAG((1 << 28), Largest)
 #undef DI_FLAG_LARGEST_NEEDED
 #endif
 
 #undef HANDLE_DI_FLAG

include/llvm/IR/DebugInfoMetadata.h

public:
   bool isBitField() const { return getFlags() & FlagBitField; }
   bool isStaticMember() const { return getFlags() & FlagStaticMember; }
   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; }
 
   static bool classof(const Metadata *MD) {
     switch (MD->getMetadataID()) {
     default:
       return false;
     case DIBasicTypeKind:
     case DIDerivedTypeKind:
     case DICompositeTypeKind:

 class DIBasicType : public DIType {
   friend class LLVMContextImpl;
   friend class MDNode;
 
   unsigned Encoding;
 
   DIBasicType(LLVMContext &C, StorageType Storage, unsigned Tag,
               uint64_t SizeInBits, uint32_t AlignInBits, unsigned Encoding,
-              ArrayRef<Metadata *> Ops)
+              DIFlags Flags, ArrayRef<Metadata *> Ops)
       : DIType(C, DIBasicTypeKind, Storage, Tag, 0, SizeInBits, AlignInBits, 0,
-               FlagZero, Ops),
+               Flags, Ops),
         Encoding(Encoding) {}
   ~DIBasicType() = default;
 
   static DIBasicType *getImpl(LLVMContext &Context, unsigned Tag,
                               StringRef Name, uint64_t SizeInBits,
                               uint32_t AlignInBits, unsigned Encoding,
-                              StorageType Storage, bool ShouldCreate = true) {
+                              DIFlags Flags, StorageType Storage,
+                              bool ShouldCreate = true) {
     return getImpl(Context, Tag, getCanonicalMDString(Context, Name),
-                   SizeInBits, AlignInBits, Encoding, Storage, ShouldCreate);
+                   SizeInBits, AlignInBits, Encoding, Flags, Storage,
+                   ShouldCreate);
   }
   static DIBasicType *getImpl(LLVMContext &Context, unsigned Tag,
                               MDString *Name, uint64_t SizeInBits,
                               uint32_t AlignInBits, unsigned Encoding,
-                              StorageType Storage, bool ShouldCreate = true);
+                              DIFlags Flags, StorageType Storage,
+                              bool ShouldCreate = true);
 
   TempDIBasicType cloneImpl() const {
     return getTemporary(getContext(), getTag(), getName(), getSizeInBits(),
-                        getAlignInBits(), getEncoding());
+                        getAlignInBits(), getEncoding(), getFlags());
   }
 
 public:
   DEFINE_MDNODE_GET(DIBasicType, (unsigned Tag, StringRef Name),
-                    (Tag, Name, 0, 0, 0))
+                    (Tag, Name, 0, 0, 0, FlagZero))
   DEFINE_MDNODE_GET(DIBasicType,
                     (unsigned Tag, StringRef Name, uint64_t SizeInBits,
-                     uint32_t AlignInBits, unsigned Encoding),
-                    (Tag, Name, SizeInBits, AlignInBits, Encoding))
+                     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),
-                    (Tag, Name, SizeInBits, AlignInBits, Encoding))
+                     uint32_t AlignInBits, unsigned Encoding, DIFlags Flags),
+                    (Tag, Name, SizeInBits, AlignInBits, Encoding, Flags))
 
   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

lib/AsmParser/LLParser.cpp

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)
+///   ::= !DIBasicType(tag: DW_TAG_base_type, name: "int", size: 32, align: 32,
+///                    encoding: DW_ATE_encoding, 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(encoding, DwarfAttEncodingField, );                                 \
+  OPTIONAL(flags, DIFlagField, );
   PARSE_MD_FIELDS();
 #undef VISIT_MD_FIELDS
 
   Result = GET_OR_DISTINCT(DIBasicType, (Context, tag.Val, name.Val, size.Val,
-                                         align.Val, encoding.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/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)
+    if (Record.size() < 6 || Record.size() > 7)
       return error("Invalid record");
 
     IsDistinct = Record[0];
+    DINode::DIFlags Flags = (Record.size() > 6) ?
+                    static_cast<DINode::DIFlags>(Record[6]) : DINode::FlagZero;
+
     MetadataList.assignValue(
         GET_OR_DISTINCT(DIBasicType,
                         (Context, Record[1], getMDString(Record[2]), Record[3],
-                         Record[4], Record[5])),
+                         Record[4], Record[5], Flags)),
         NextMetadataNo);
     NextMetadataNo++;
     break;
   }
   case bitc::METADATA_DERIVED_TYPE: {
     if (Record.size() < 12 || Record.size() > 13)
       return error("Invalid record");
 

lib/Bitcode/Writer/BitcodeWriter.cpp

void ModuleBitcodeWriter::writeDIBasicType(const DIBasicType *N,
                                            SmallVectorImpl<uint64_t> &Record,
                                            unsigned Abbrev) {
   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());
 
   Stream.EmitRecord(bitc::METADATA_BASIC_TYPE, Record, Abbrev);
   Record.clear();
 }
 
 void ModuleBitcodeWriter::writeDIDerivedType(const DIDerivedType *N,
                                              SmallVectorImpl<uint64_t> &Record,
                                              unsigned Abbrev) {

lib/CodeGen/AsmPrinter/DwarfUnit.cpp

void DwarfUnit::constructTypeDIE(DIE &Buffer, const DIBasicType *BTy) {
   if (BTy->getTag() == dwarf::DW_TAG_unspecified_type)
     return;
 
   addUInt(Buffer, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
           BTy->getEncoding());
 
   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);
 }
 
 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);
+  Printer.printDIFlags("flags", N->getFlags());
   Out << ")";
 }
 
 static void writeDIDerivedType(raw_ostream &Out, const DIDerivedType *N,
                                TypePrinting *TypePrinter, SlotTracker *Machine,
                                const Module *Context) {
   Out << "!DIDerivedType(";
   MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);

lib/IR/DebugInfoMetadata.cpp

DIEnumerator *DIEnumerator::getImpl(LLVMContext &Context, int64_t Value,
   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,
-                                  StorageType Storage, bool ShouldCreate) {
+                                  DIFlags Flags, StorageType Storage,
+                                  bool ShouldCreate) {
   assert(isCanonical(Name) && "Expected canonical MDString");
   DEFINE_GETIMPL_LOOKUP(DIBasicType,
                         (Tag, Name, SizeInBits, AlignInBits, Encoding));
   Metadata *Ops[] = {nullptr, nullptr, Name};
-  DEFINE_GETIMPL_STORE(DIBasicType, (Tag, SizeInBits, AlignInBits, Encoding),
-                       Ops);
+  DEFINE_GETIMPL_STORE(DIBasicType, (Tag, SizeInBits, AlignInBits, Encoding,
+                      Flags), 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/Verifier.cpp

AssertDI(!Count.is<ConstantInt*>() ||
                Count.get<ConstantInt*>()->getSExtValue() >= -1,
            "invalid subrange count", &N);
 }
 
 void Verifier::visitDIEnumerator(const DIEnumerator &N) {
   AssertDI(N.getTag() == dwarf::DW_TAG_enumerator, "invalid tag", &N);
 }
 
+/// Detect mutually exclusive flags.
+static bool hasConflictingReferenceFlags(unsigned Flags) {
+  return ((Flags & DINode::FlagLValueReference) &&
+          (Flags & DINode::FlagRValueReference)) ||
+         ((Flags & DINode::FlagTypePassByValue) &&
+          (Flags & DINode::FlagTypePassByReference)) ||
+          ((Flags & DINode::FlagBigEndian) &&
+          (Flags & DINode::FlagLittleEndian));
+}
+
 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(!hasConflictingReferenceFlags(N.getFlags()),
+           "invalid reference flags", &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 ||
void Verifier::visitDIDerivedType(const DIDerivedType &N) {
   if (N.getDWARFAddressSpace()) {
     AssertDI(N.getTag() == dwarf::DW_TAG_pointer_type ||
                  N.getTag() == dwarf::DW_TAG_reference_type,
              "DWARF address space only applies to pointer or reference types",
              &N);
   }
 }
 
-/// Detect mutually exclusive flags.
-static bool hasConflictingReferenceFlags(unsigned Flags) {
-  return ((Flags & DINode::FlagLValueReference) &&
-          (Flags & DINode::FlagRValueReference)) ||
-         ((Flags & DINode::FlagTypePassByValue) &&
-          (Flags & DINode::FlagTypePassByReference));
-}
-
 void Verifier::visitTemplateParams(const MDNode &N, const Metadata &RawParams) {
   auto *Params = dyn_cast<MDTuple>(&RawParams);
   AssertDI(Params, "invalid template params", &N, &RawParams);
   for (Metadata *Op : Params->operands()) {
     AssertDI(Op && isa<DITemplateParameter>(Op), "invalid template parameter",
              &N, Params, Op);
   }
 }

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}
-!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}
+; 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:      !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)

 !36 = !DICompositeType(tag: DW_TAG_variant_part, name: "A", scope: !16, size: 64, discriminator: !37)
 !37 = !DIDerivedType(tag: DW_TAG_member, scope: !36, baseType: !38, size: 64, align: 64, flags: DIFlagArtificial)
 !38 = !DIBasicType(name: "u64", size: 64, encoding: DW_ATE_unsigned)
 
 ; CHECK-NEXT: !36 = !DIFile(filename: "file", directory: "dir", source: "int source() { }\0A")
 ; 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)

test/Bitcode/DIBasicType-DIFlags.ll

+; Test bitcode upgrade of DIBasicType.
+;
+; RUN: llvm-dis < %s.bc -o - | llvm-as | llvm-dis | FileCheck %s
+
+; CHECK: @a = common global i32 0, align 4, !dbg ![[G:[0-9]+]]
+; CHECK: @b = common global i32 0, align 4, !dbg ![[G:[0-9]+]]
+; CHECK-DAG: ![[G]] = !DIGlobalVariableExpression(var: ![[GVAR:[0-9]+]], expr: !DIExpression())
+; CHECK-DAG: ![[GVAR]] = distinct !DIGlobalVariable(name: "{{[a-z"]+}}", scope: !2, file: !6, line: {{[0-9]+}}, type: ![[GTYPES:[0-9]+]], isLocal: false, isDefinition: true)
+; CHECK-DAG: ![[GTYPES]] = !DIBasicType(name: "{{[a-z.]*}}", size: 32, encoding: DW_ATE_signed, flags:{{ DIFlagBigEndian | DIFlagLittleEndian}})
+
+@a = common global i32 0, align 4, !dbg !0
+@b = common global i32 0, align 4, !dbg !11
+
+!llvm.dbg.cu = !{!2}
+!llvm.module.flags = !{!8, !9}
+
+!0 = !DIGlobalVariableExpression(var: !1, expr: !DIExpression())
+!1 = distinct !DIGlobalVariable(name: "a", scope: !2, file: !6, line: 1, type: !7, isLocal: false, isDefinition: true)
+!2 = distinct !DICompileUnit(language: DW_LANG_C99, file: !3, producer: "clang version 4.0.0", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug, enums: !4, globals: !5)
+!3 = !DIFile(filename: "test.c", directory: "/home/chirag/Desktop")
+!4 = !{}
+!5 = !{!0}
+!6 = !DIFile(filename: "dummy_source.c", directory: "/")
+!7 = !DIBasicType(name: "int.be", size: 32, encoding: DW_ATE_signed, flags:DIFlagBigEndian)
+!8 = !{i32 2, !"Dwarf Version", i32 4}
+!9 = !{i32 2, !"Debug Info Version", i32 3}
+!10 = !DIBasicType(name: "int.le", size: 32, encoding: DW_ATE_signed, flags:DIFlagLittleEndian)
+!11 = !DIGlobalVariableExpression(var: !12, expr: !DIExpression())
+!12 = distinct !DIGlobalVariable(name: "b", scope: !2, file: !6, line: 2, type: !10, isLocal: false, isDefinition: true)

unittests/IR/MetadataTest.cpp

TEST_F(DIEnumeratorTest, get) {
   TempDIEnumerator Temp = N->clone();
   EXPECT_EQ(N, MDNode::replaceWithUniqued(std::move(Temp)));
 }
 
 typedef MetadataTest DIBasicTypeTest;
 
 TEST_F(DIBasicTypeTest, get) {
   auto *N =
-      DIBasicType::get(Context, dwarf::DW_TAG_base_type, "special", 33, 26, 7);
+      DIBasicType::get(Context, dwarf::DW_TAG_base_type, "special", 33, 26, 7,
+                        DINode::FlagZero);
   EXPECT_EQ(dwarf::DW_TAG_base_type, N->getTag());
   EXPECT_EQ("special", N->getName());
   EXPECT_EQ(33u, N->getSizeInBits());
   EXPECT_EQ(26u, N->getAlignInBits());
   EXPECT_EQ(7u, N->getEncoding());
   EXPECT_EQ(0u, N->getLine());
+  EXPECT_EQ(DINode::FlagZero, N->getFlags());
   EXPECT_EQ(N, DIBasicType::get(Context, dwarf::DW_TAG_base_type, "special", 33,
-                                26, 7));
+                                26, 7, DINode::FlagZero));
 
   EXPECT_NE(N, DIBasicType::get(Context, dwarf::DW_TAG_unspecified_type,
-                                "special", 33, 26, 7));
+                                "special", 33, 26, 7, DINode::FlagZero));
   EXPECT_NE(N,
-            DIBasicType::get(Context, dwarf::DW_TAG_base_type, "s", 33, 26, 7));
+            DIBasicType::get(Context, dwarf::DW_TAG_base_type, "s", 33, 26, 7,
+                              DINode::FlagZero));
   EXPECT_NE(N, DIBasicType::get(Context, dwarf::DW_TAG_base_type, "special", 32,
-                                26, 7));
+                                26, 7, DINode::FlagZero));
   EXPECT_NE(N, DIBasicType::get(Context, dwarf::DW_TAG_base_type, "special", 33,
-                                25, 7));
+                                25, 7, DINode::FlagZero));
   EXPECT_NE(N, DIBasicType::get(Context, dwarf::DW_TAG_base_type, "special", 33,
-                                26, 6));
+                                26, 6, DINode::FlagZero));
 
   TempDIBasicType Temp = N->clone();
   EXPECT_EQ(N, MDNode::replaceWithUniqued(std::move(Temp)));
 }
 
 TEST_F(DIBasicTypeTest, getWithLargeValues) {
   auto *N = DIBasicType::get(Context, dwarf::DW_TAG_base_type, "special",
-                             UINT64_MAX, UINT32_MAX - 1, 7);
+                             UINT64_MAX, UINT32_MAX - 1, 7, DINode::FlagZero);
   EXPECT_EQ(UINT64_MAX, N->getSizeInBits());
   EXPECT_EQ(UINT32_MAX - 1, N->getAlignInBits());
 }
 
 TEST_F(DIBasicTypeTest, getUnspecified) {
   auto *N =
       DIBasicType::get(Context, dwarf::DW_TAG_unspecified_type, "unspecified");
   EXPECT_EQ(dwarf::DW_TAG_unspecified_type, N->getTag());
   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());
 }
 
 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);
+                               dwarf::DW_ATE_signed, DINode::FlagZero);
 
   TempDIType Temp = N->clone();
   EXPECT_EQ(N, MDNode::replaceWithUniqued(std::move(Temp)));
 }
 
 TEST_F(DITypeTest, cloneWithFlags) {
   // void (void)
   Metadata *TypesOps[] = {nullptr};