Seperated DIBasicType DIFlags to DIBTFlags.

[Chirag]

Summary

Currently DIBasicType uses two flags DIFlagBigEndian and DIFlagLittleEndian, this patch separates it to DIBTFlags.
DIBTFlags have two flags in this patch, DIBTFlagBigEndian and DIFlagLittleEndian.

This patch is in response for review https://reviews.llvm.org/D73861
After this patch, two more flags will be added in DIBTFlags.

The bitcode test is not present for DIBasicType with BigEndian/LittleEndian flags. this patch adds it.

[djtodoro]

Does this support the old metadata? We should have a test for the old metadata as well (e.g. flags: DIFlagBigEndian).

As we discussed on D73261, we might have to move a few flags from DIFlags into DISPFlags.

[djtodoro]

Please make a stack of this patch and the D73861.

[Chirag]

• Updated bitcode test to check type with proper variable.

[Chirag]

In D74470#1871645, @djtodoro wrote:

Does this support the old metadata? We should have a test for the old metadata as well (e.g. flags: DIFlagBigEndian).

As we discussed on D73261, we might have to move a few flags from DIFlags into DISPFlags.

There is no bitcode testcase available for DIFlagBigEndian in llvm test suite, the current patch adds one bitcode test using DIBTFlagBigEndian/DIBTFlagLittleEndian.
The old metadata related bc files needs to be updated(if it uses DIFlagBigEndian) by DIBTFlag

Also for backward compatibility, the values of the flags can be kept the same.
<- HANDLE_DI_FLAG((1 << 27), BigEndian)
<- HANDLE_DI_FLAG((1 << 28), LittleEndian)

+ HANDLE_DIBT_FLAG((1 << 27), BigEndian) instead of 1
+ HANDLE_DIBT_FLAG((1 << 28), LittleEndian) instead of 2

This will keep the old bitcode format compatible, does this something you think might be usefull?

[djtodoro]

We can use one, currently unused, flag indicating the flags are moved. But, I would move more flags in that case (such as function-related flags that should go into the DISPFlags), not just the two.

We should handle old and new metadata within MetadataLoader, please take a look how that was done here: D59288.

[Chirag]

• Bitcode backward compatibility, added flag with distinct to mark BTFlags' presence.

[probinson]

D73261 would also benefit from moving more flags into the subprogram flags field. The refactoring really should move out as many flags as possible all in one go. I understand this is more than you anticipated but it will be the right thing to do for the project as a whole.

[aprantl]

Thanks! This looks quite good already, I just have a few inline comments.

llvm/include/llvm/IR/DebugInfoMetadata.h

692

Basic

llvm/lib/AsmParser/LLParser.cpp

4171

Could the bulk of the implementation of this function be shared with the function that parses DIFlag and DISPFlag?

llvm/lib/Bitcode/Reader/MetadataLoader.cpp

1300

// BasicType-specific flags in DIFlag were moved to DIBTFlags.

1302

Thanks!

llvm/test/Bitcode/DIBasicType.ll

28

Assuming that the IR in this file is the input for DIBasicType.ll.bc, I would have expected this to use the *old* format to test that the old format can be upgraded to the new format. The assembler roundtrip test debug-info.ll is already testing that the new format works.

[djtodoro]

Anyhow, moving other flags should be a different revision (should not be part of this one), so with the comments addressed, this looks good to me. :)

llvm/include/llvm/IR/DebugInfoFlags.def

105

. at the end of the comment

llvm/test/Bitcode/DIBasicType.ll

28

+1

[Chirag]

• some typos cleanup.
• updated bitcode test(both .bc and .ll files) to use old flags and checked against new btflags.

[Chirag]

In D74470#1872492, @probinson wrote:

D73261 would also benefit from moving more flags into the subprogram flags field. The refactoring really should move out as many flags as possible all in one go. I understand this is more than you anticipated but it will be the right thing to do for the project as a whole.

I can create a separate small patches for other flags DIVarFlags/Mod DISPFlag it will be easier to track if something gets broken. (i am not fully aware of all the flags' complete use cases)

[djtodoro]

In D74470#1873714, @Chirag wrote:

In D74470#1872492, @probinson wrote:

D73261 would also benefit from moving more flags into the subprogram flags field. The refactoring really should move out as many flags as possible all in one go. I understand this is more than you anticipated but it will be the right thing to do for the project as a whole.

I can create a separate small patches for other flags DIVarFlags/Mod DISPFlag it will be easier to track if something gets broken. (i am not fully aware of all the flags' complete use cases)

That would be awesome! :)

[Chirag]

llvm/lib/AsmParser/LLParser.cpp

4171

Does using macro to generate flag LLParser seems like a good idea? it can be reused for other flags as well.

[Chirag]

llvm/lib/AsmParser/LLParser.cpp

4171

something like,

#define FLAG_FIELDS(MDNODE, FLAG_NAME) \
struct DIFLAG_NAMEField : public MDFieldImpl<MDNODE::DIFLAG_NAMEs> { \

DI##FLAG_NAME##Field() : MDFieldImpl(MDNODE::FLAG_NAME##Zero) {}            \

};

FLAG_FIELDS(DINode, Flag)
FLAG_FIELDS(DIBasicType, BTFlag)
FLAG_FIELDS(DISubprogram, SPFlag)

#define FLAG_FIELDS_PARSER(MDNODE, FLAG_NAME) \
template <> \
bool LLParser::ParseMDField(LocTy Loc, StringRef Name, \

                          DI##FLAG_NAME##Field &Result) {                   \
                                                                            \
auto parseFlag = [&](MDNODE::DI##FLAG_NAME##s &Val) {                       \
  if (Lex.getKind() == lltok::APSInt && !Lex.getAPSIntVal().isSigned()) {   \
    uint32_t TempVal = static_cast<uint32_t>(Val);                          \
    bool Res = ParseUInt32(TempVal);                                        \
    Val = static_cast<MDNODE::DI##FLAG_NAME##s>(TempVal);                   \
    return Res;                                                             \
  }                                                                         \
                                                                            \
  if (Lex.getKind() != lltok::DI##FLAG_NAME)                                \
    return TokError("expected debug info flag");                            \
                                                                            \
  Val = MDNODE::getFlag(Lex.getStrVal());                                   \
  if (!Val)                                                                 \
    return TokError(Twine("invalid basicType debug info flag '") +          \
                    Lex.getStrVal() + "'");                                 \
  Lex.Lex();                                                                \
  return false;                                                             \
};                                                                          \
                                                                            \
MDNODE::DI##FLAG_NAME##s Combined = MDNODE::FLAG_NAME##Zero;                \
do {                                                                        \
  MDNODE::DI##FLAG_NAME##s Val;                                             \
  if (parseFlag(Val))                                                       \
    return true;                                                            \
  Combined |= Val;                                                          \
} while (EatIfPresent(lltok::bar));                                         \
                                                                            \
Result.assign(Combined);                                                    \
return false;                                                               \

}

FLAG_FIELDS_PARSER(DINode, Flag)
FLAG_FIELDS_PARSER(DIBasicType, BTFlag)
FLAG_FIELDS_PARSER(DISubprogram, SPFlag)

[Chirag]

llvm/lib/AsmParser/LLParser.cpp

4171

i will create a reusable function for flag parsing.

[aprantl]

In D74470#1873714, @Chirag wrote:

In D74470#1872492, @probinson wrote:

D73261 would also benefit from moving more flags into the subprogram flags field. The refactoring really should move out as many flags as possible all in one go. I understand this is more than you anticipated but it will be the right thing to do for the project as a whole.

I can create a separate small patches for other flags DIVarFlags/Mod DISPFlag it will be easier to track if something gets broken. (i am not fully aware of all the flags' complete use cases)

While we usually always prefer the smallest possible patches for reviews, for moving attributes from one field to another in a bitcode-incompatible way, it would be better to move them in bulk, indicated by a single "version" bit in the bitcode encoding.

[Chirag]

Moved five of the DIFlags to DISPFlags. (updated few clang testcases)
DIFlagExplicit -> DISPFlagExplicit
DIFlagPrototyped -> DISPFlagPrototyped
DIFlagNoReturn -> DISPFlagNoReturn
DIFlagThunk -> DISPFlagThunk
DIFlagAllCallsDescribed -> DISPFlagAllCallsDescribed

Note: currently llvm ir parser still needs the DIFlags, once the llvm ir format gets updated(with all the relevant testcases) the entries from DebugInfoFlags.def will be removed and moveDItoSP should only be used for bitcode read and C-API.

[aprantl]

Thank you this looks very good! Just a few questions inline.

llvm/lib/AsmParser/LLParser.cpp

4171

Sharing the parsing code was not feasible?

llvm/lib/Bitcode/Reader/MetadataLoader.cpp

1516

I believe this should only be called conditionally? Or specifically: What will happen when we reuse flag bits that are in the range of the old now freed-up DIFlags?

llvm/lib/IR/AsmWriter.cpp

1719

Again, can this function share code with the printDISPFlags function?

llvm/lib/IR/DebugInfoMetadata.cpp

366

Which warning is being appeased here?

llvm/include/llvm/IR/DIBuilder.h

public:
     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       Optional DWARF attributes, e.g., DW_AT_endianity.
-    DIBasicType *createBasicType(StringRef Name, uint64_t SizeInBits,
-                                 unsigned Encoding,
-                                 DINode::DIFlags Flags = DINode::FlagZero);
+    DIBasicType *
+    createBasicType(StringRef Name, uint64_t SizeInBits, unsigned Encoding,
+                    DIBasicType::DIBTFlags Flags = DIBasicType::BTFlagZero);
 
     /// 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.

llvm/include/llvm/IR/DebugInfoFlags.def

 //===- llvm/IR/DebugInfoFlags.def - Debug info flag definitions -*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // Macros for running through debug info flags.
 //
 //===----------------------------------------------------------------------===//
 
-#if !(defined HANDLE_DI_FLAG || defined HANDLE_DISP_FLAG)
+#if !(defined HANDLE_DI_FLAG || defined HANDLE_DISP_FLAG ||                    \
+      defined HANDLE_DIBT_FLAG)
 #error "Missing macro definition of HANDLE_DI*"
 #endif
 
 #ifndef HANDLE_DI_FLAG
 #define HANDLE_DI_FLAG(ID, NAME)
 #endif
 
 #ifndef HANDLE_DISP_FLAG
 #define HANDLE_DISP_FLAG(ID, NAME)
 #endif
 
+#ifndef HANDLE_DIBT_FLAG
+#define HANDLE_DIBT_FLAG(ID, NAME)
+#endif
+
 // General flags kept in DINode.
 
 HANDLE_DI_FLAG(0, Zero) // Use it as zero value.
                         // For example: void foo(DIFlags Flags = FlagZero).
 HANDLE_DI_FLAG(1, Private)
 HANDLE_DI_FLAG(2, Protected)
 HANDLE_DI_FLAG(3, Public)
 HANDLE_DI_FLAG((1 << 2), FwdDecl)

 HANDLE_DI_FLAG((1 << 18), IntroducedVirtual)
 HANDLE_DI_FLAG((1 << 19), BitField)
 HANDLE_DI_FLAG((1 << 20), NoReturn)
 HANDLE_DI_FLAG((1 << 22), TypePassByValue)
 HANDLE_DI_FLAG((1 << 23), TypePassByReference)
 HANDLE_DI_FLAG((1 << 24), EnumClass)
 HANDLE_DI_FLAG((1 << 25), Thunk)
 HANDLE_DI_FLAG((1 << 26), NonTrivial)
-HANDLE_DI_FLAG((1 << 27), BigEndian)
-HANDLE_DI_FLAG((1 << 28), LittleEndian)
 HANDLE_DI_FLAG((1 << 29), AllCallsDescribed)
 
 // 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

 
 #ifdef DISP_FLAG_LARGEST_NEEDED
 // Intended to be used with ADT/BitmaskEnum.h.
 // NOTE: Always must be equal to largest flag, check this when adding new flags.
 HANDLE_DISP_FLAG((1 << 11), Largest)
 #undef DISP_FLAG_LARGEST_NEEDED
 #endif
 
+// BasicType flags kept in DIBasicType.
+
+// Use this as a zero/initialization value.
+// For example: void foo(DIBTFlags Flags = BTFlagZero).
+HANDLE_DIBT_FLAG(0, Zero)
+HANDLE_DIBT_FLAG(1u, LittleEndian)
+HANDLE_DIBT_FLAG(2u, BigEndian)
+
+#ifdef DIBT_FLAG_LARGEST_NEEDED
+// Intended to be used with ADT/BitmaskEnum.h.
+// NOTE: Always must be equal to largest flag, check this when adding new flags.
+HANDLE_DIBT_FLAG(2u, Largest)
+#undef DIBT_FLAG_LARGEST_NEEDED
+#endif
+
 #undef HANDLE_DI_FLAG
 #undef HANDLE_DISP_FLAG
+#undef HANDLE_DIBT_FLAG

llvm/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; }
   bool getExportSymbols() const { return getFlags() & FlagExportSymbols; }
 
   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:
+  /// Debug BasicType flags.
+  enum DIBTFlags : uint32_t {
+#define HANDLE_DIBT_FLAG(ID, NAME) BTFlag##NAME = ID,
+#define DIBT_FLAG_LARGEST_NEEDED
+#include "llvm/IR/DebugInfoFlags.def"
+    LLVM_MARK_AS_BITMASK_ENUM(BTFlagLargest)
+  };
+
+  static DIBTFlags getFlag(StringRef Flag);
+  static StringRef getFlagString(DIBTFlags Flag);
+
+  /// Split up a flags bitfield for easier printing.
+  ///
+  /// Split \c Flags into \c SplitFlags, a vector of its components.  Returns
+  /// any remaining (unrecognized) bits.
+  static DIBTFlags splitFlags(DIBTFlags Flags,
+                              SmallVectorImpl<DIBTFlags> &SplitFlags);
+
+  // Helper for converting old bitfields to new flags word.
+  static DIBTFlags toBTFlags(bool IsBigEndian, bool IsLittleEndian) {
+    return static_cast<DIBTFlags>(
+        (IsBigEndian ? BTFlagBigEndian : BTFlagZero) |
+        (IsLittleEndian ? BTFlagLittleEndian : BTFlagZero));
+  }
+
+private:
+  DIBTFlags BTFlags;
   unsigned Encoding;
 
   DIBasicType(LLVMContext &C, StorageType Storage, unsigned Tag,
               uint64_t SizeInBits, uint32_t AlignInBits, unsigned Encoding,
-              DIFlags Flags, ArrayRef<Metadata *> Ops)
+              DIBTFlags BTFlags, ArrayRef<Metadata *> Ops)
       : DIType(C, DIBasicTypeKind, Storage, Tag, 0, SizeInBits, AlignInBits, 0,
-               Flags, Ops),
-        Encoding(Encoding) {}
+               FlagZero, Ops),
+        BTFlags(BTFlags), Encoding(Encoding) {}
   ~DIBasicType() = default;
 
   static DIBasicType *getImpl(LLVMContext &Context, unsigned Tag,
                               StringRef Name, uint64_t SizeInBits,
                               uint32_t AlignInBits, unsigned Encoding,
-                              DIFlags Flags, StorageType Storage,
+                              DIBTFlags BTFlags, StorageType Storage,
                               bool ShouldCreate = true) {
     return getImpl(Context, Tag, getCanonicalMDString(Context, Name),
-                   SizeInBits, AlignInBits, Encoding, Flags, Storage,
+                   SizeInBits, AlignInBits, Encoding, BTFlags, Storage,
                    ShouldCreate);
   }
+
   static DIBasicType *getImpl(LLVMContext &Context, unsigned Tag,
                               MDString *Name, uint64_t SizeInBits,
                               uint32_t AlignInBits, unsigned Encoding,
-                              DIFlags Flags, StorageType Storage,
+                              DIBTFlags BTFlags, StorageType Storage,
                               bool ShouldCreate = true);
 
   TempDIBasicType cloneImpl() const {
     return getTemporary(getContext(), getTag(), getName(), getSizeInBits(),
-                        getAlignInBits(), getEncoding(), getFlags());
+                        getAlignInBits(), getEncoding(), getBTFlags());
   }
 
 public:
   DEFINE_MDNODE_GET(DIBasicType, (unsigned Tag, StringRef Name),
-                    (Tag, Name, 0, 0, 0, FlagZero))
+                    (Tag, Name, 0, 0, 0, BTFlagZero))
   DEFINE_MDNODE_GET(DIBasicType,
                     (unsigned Tag, StringRef Name, uint64_t SizeInBits,
-                     uint32_t AlignInBits, unsigned Encoding, DIFlags Flags),
+                     uint32_t AlignInBits, unsigned Encoding, DIBTFlags 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),
+                     uint32_t AlignInBits, unsigned Encoding, DIBTFlags Flags),
                     (Tag, Name, SizeInBits, AlignInBits, Encoding, Flags))
 
   TempDIBasicType clone() const { return cloneImpl(); }
-
+  DIBTFlags getBTFlags() const { return BTFlags; }
   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 isBigEndian() const { return getBTFlags() & BTFlagBigEndian; }
+  bool isLittleEndian() const { return getBTFlags() & BTFlagLittleEndian; }
 
   static bool classof(const Metadata *MD) {
     return MD->getMetadataID() == DIBasicTypeKind;
   }
 };
 
 /// Derived types.
 ///

llvm/lib/AsmParser/LLLexer.cpp

if (Keyword.startswith("DIFlag")) {
     return lltok::DIFlag;
   }
 
   if (Keyword.startswith("DISPFlag")) {
     StrVal.assign(Keyword.begin(), Keyword.end());
     return lltok::DISPFlag;
   }
 
+  if (Keyword.startswith("DIBTFlag")) {
+    StrVal.assign(Keyword.begin(), Keyword.end());
+    return lltok::DIBTFlag;
+  }
+
   if (Keyword.startswith("CSK_")) {
     StrVal.assign(Keyword.begin(), Keyword.end());
     return lltok::ChecksumKind;
   }
 
   if (Keyword == "NoDebug" || Keyword == "FullDebug" ||
       Keyword == "LineTablesOnly" || Keyword == "DebugDirectivesOnly") {
     StrVal.assign(Keyword.begin(), Keyword.end());

llvm/lib/AsmParser/LLParser.cpp

 struct DIFlagField : public MDFieldImpl<DINode::DIFlags> {
   DIFlagField() : MDFieldImpl(DINode::FlagZero) {}
 };
 
 struct DISPFlagField : public MDFieldImpl<DISubprogram::DISPFlags> {
   DISPFlagField() : MDFieldImpl(DISubprogram::SPFlagZero) {}
 };
 
+struct DIBTFlagField : public MDFieldImpl<DIBasicType::DIBTFlags> {
+  DIBTFlagField() : MDFieldImpl(DIBasicType::BTFlagZero) {}
+};
+
 struct MDSignedField : public MDFieldImpl<int64_t> {
   int64_t Min;
   int64_t Max;
 
   MDSignedField(int64_t Default = 0)
       : ImplTy(Default), Min(INT64_MIN), Max(INT64_MAX) {}
   MDSignedField(int64_t Default, int64_t Min, int64_t Max)
       : ImplTy(Default), Min(Min), Max(Max) {}
if (parseFlag(Val))
       return true;
     Combined |= Val;
   } while (EatIfPresent(lltok::bar));
 
   Result.assign(Combined);
   return false;
 }
 
+/// DIBTFlagField
+///  ::= uint32
+///  ::= DIBTFlagBigEndian
+///  ::= DIBTFlagBigEndian '|' DIBTFlag* '|' uint32
+template <>
+bool LLParser::ParseMDField(LocTy Loc, StringRef Name, DIBTFlagField &Result) {
+
+  // Parser for a single flag.
+  auto parseFlag = [&](DIBasicType::DIBTFlags &Val) {
+    if (Lex.getKind() == lltok::APSInt && !Lex.getAPSIntVal().isSigned()) {
+      uint32_t TempVal = static_cast<uint32_t>(Val);
+      bool Res = ParseUInt32(TempVal);
+      Val = static_cast<DIBasicType::DIBTFlags>(TempVal);
+      return Res;
+    }
+
+    if (Lex.getKind() != lltok::DIBTFlag)
+      return TokError("expected debug info flag");
+
+    Val = DIBasicType::getFlag(Lex.getStrVal());
+    if (!Val)
+      return TokError(Twine("invalid basicType debug info flag '") +
+                      Lex.getStrVal() + "'");
+    Lex.Lex();
+    return false;
+  };
+
+  // Parse the flags and combine them together.
+  DIBasicType::DIBTFlags Combined = DIBasicType::BTFlagZero;
+  do {
+    DIBasicType::DIBTFlags Val;
+    if (parseFlag(Val))
+      return true;
+    Combined |= Val;
+  } while (EatIfPresent(lltok::bar));
+
+  Result.assign(Combined);
+  return false;
+}
+
 /// DISPFlagField
 ///  ::= uint32
 ///  ::= DISPFlagVector
 ///  ::= DISPFlagVector '|' DISPFlag* '|' uint32
 template <>
 bool LLParser::ParseMDField(LocTy Loc, StringRef Name, DISPFlagField &Result) {
 
   // Parser for a single flag.
int64_t Value = value.isMDSignedField()
                       ? value.getMDSignedValue()
                       : 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)
+///                    encoding: DW_ATE_encoding, btFlags: DIBTFlagBigEndian)
 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(flags, DIFlagField, );
+  OPTIONAL(btFlags, DIBTFlagField, );
   PARSE_MD_FIELDS();
 #undef VISIT_MD_FIELDS
-
   Result = GET_OR_DISTINCT(DIBasicType, (Context, tag.Val, name.Val, size.Val,
-                                         align.Val, encoding.Val, flags.Val));
+                                         align.Val, encoding.Val, btFlags.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)

llvm/lib/AsmParser/LLToken.h

enum Kind {
   DwarfVirtuality,  // DW_VIRTUALITY_foo
   DwarfLang,        // DW_LANG_foo
   DwarfCC,          // DW_CC_foo
   EmissionKind,     // lineTablesOnly
   NameTableKind,    // GNU
   DwarfOp,          // DW_OP_foo
   DIFlag,           // DIFlagFoo
   DISPFlag,         // DISPFlagFoo
+  DIBTFlag,         // DIBTFlagFoo
   DwarfMacinfo,     // DW_MACINFO_foo
   ChecksumKind,     // CSK_foo
 
   // Type valued tokens (TyVal).
   Type,
 
   APFloat, // APFloatVal
   APSInt   // APSInt
 };
 } // end namespace lltok
 } // end namespace llvm
 
 #endif

llvm/lib/Bitcode/Reader/MetadataLoader.cpp

MetadataList.assignValue(
         NextMetadataNo);
     NextMetadataNo++;
     break;
   }
   case bitc::METADATA_BASIC_TYPE: {
     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;
+    IsDistinct = Record[0] & 1;
+    bool HasBTFlags = Record[0] & 2;
+    DIBasicType::DIBTFlags BTFlags = DIBasicType::BTFlagZero;
+
+    // BasicType-specific flags in DIFlag were moved to DIBTFlags.
+    const unsigned DIFlagBigEndian = (1 << 27);
+    const unsigned DIFlagLittleEndian = (1 << 28);
+    if (Record.size() > 6) {
+      if (HasBTFlags)
+        BTFlags = static_cast<DIBasicType::DIBTFlags>(Record[6]);
+      else {
+        DINode::DIFlags Flags = static_cast<DINode::DIFlags>(Record[6]);
+        BTFlags = DIBasicType::toBTFlags(Flags & DIFlagBigEndian,
+                                         Flags & DIFlagLittleEndian);
+      }
+    }
 
     MetadataList.assignValue(
         GET_OR_DISTINCT(DIBasicType,
                         (Context, Record[1], getMDString(Record[2]), Record[3],
-                         Record[4], Record[5], Flags)),
+                         Record[4], Record[5], BTFlags)),
         NextMetadataNo);
     NextMetadataNo++;
     break;
   }
   case bitc::METADATA_DERIVED_TYPE: {
     if (Record.size() < 12 || Record.size() > 13)
       return error("Invalid record");
 
case bitc::METADATA_SUBPROGRAM: {
     if (!HasSPFlags)
       Flags = static_cast<DINode::DIFlags>(Record[11 + 2]);
     else {
       Flags = static_cast<DINode::DIFlags>(Record[11]);
       SPFlags = static_cast<DISubprogram::DISPFlags>(Record[9]);
     }
 
     // Support for old metadata when
     // subprogram specific flags are placed in DIFlags.
     const unsigned DIFlagMainSubprogram = 1 << 21;
     bool HasOldMainSubprogramFlag = Flags & DIFlagMainSubprogram;
     if (HasOldMainSubprogramFlag)
       // Remove old DIFlagMainSubprogram from DIFlags.
       // Note: This assumes that any future use of bit 21 defaults to it
       // being 0.
       Flags &= ~static_cast<DINode::DIFlags>(DIFlagMainSubprogram);
 

llvm/lib/Bitcode/Writer/BitcodeWriter.cpp

void ModuleBitcodeWriter::writeDIEnumerator(const DIEnumerator *N,
 
   Stream.EmitRecord(bitc::METADATA_ENUMERATOR, Record, Abbrev);
   Record.clear();
 }
 
 void ModuleBitcodeWriter::writeDIBasicType(const DIBasicType *N,
                                            SmallVectorImpl<uint64_t> &Record,
                                            unsigned Abbrev) {
-  Record.push_back(N->isDistinct());
+  const uint64_t HasBTFlagsFlag = 1 << 1;
+  Record.push_back(uint64_t(N->isDistinct()) | HasBTFlagsFlag);
   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());
+  Record.push_back(N->getBTFlags());
 
   Stream.EmitRecord(bitc::METADATA_BASIC_TYPE, Record, Abbrev);
   Record.clear();
 }
 
 void ModuleBitcodeWriter::writeDIDerivedType(const DIDerivedType *N,
                                              SmallVectorImpl<uint64_t> &Record,
                                              unsigned Abbrev) {

llvm/lib/IR/AsmWriter.cpp

void printString(StringRef Name, StringRef Value,
                    bool ShouldSkipEmpty = true);
   void printMetadata(StringRef Name, const Metadata *MD,
                      bool ShouldSkipNull = true);
   template <class IntTy>
   void printInt(StringRef Name, IntTy Int, bool ShouldSkipZero = true);
   void printBool(StringRef Name, bool Value, Optional<bool> Default = None);
   void printDIFlags(StringRef Name, DINode::DIFlags Flags);
   void printDISPFlags(StringRef Name, DISubprogram::DISPFlags Flags);
+  void printDIBTFlags(StringRef Name, DIBasicType::DIBTFlags Flags);
   template <class IntTy, class Stringifier>
   void printDwarfEnum(StringRef Name, IntTy Value, Stringifier toString,
                       bool ShouldSkipZero = true);
   void printEmissionKind(StringRef Name, DICompileUnit::DebugEmissionKind EK);
   void printNameTableKind(StringRef Name,
                           DICompileUnit::DebugNameTableKind NTK);
 };
 
for (auto F : SplitFlags) {
     auto StringF = DINode::getFlagString(F);
     assert(!StringF.empty() && "Expected valid flag");
     Out << FlagsFS << StringF;
   }
   if (Extra || SplitFlags.empty())
     Out << FlagsFS << Extra;
 }
 
+void MDFieldPrinter::printDIBTFlags(StringRef Name,
+                                    DIBasicType::DIBTFlags Flags) {
+  if (!Flags) {
+    return;
+  }
+
+  Out << FS << Name << ": ";
+  SmallVector<DIBasicType::DIBTFlags, 8> SplitFlags;
+  auto Extra = DIBasicType::splitFlags(Flags, SplitFlags);
+
+  FieldSeparator FlagsFS(" | ");
+  for (auto F : SplitFlags) {
+    auto StringF = DIBasicType::getFlagString(F);
+    assert(!StringF.empty() && "Expected valid flag");
+    Out << FlagsFS << StringF;
+  }
+  if (Extra || SplitFlags.empty())
+    Out << FlagsFS << Extra;
+}
+
 void MDFieldPrinter::printDISPFlags(StringRef Name,
                                     DISubprogram::DISPFlags Flags) {
   // Always print this field, because no flags in the IR at all will be
   // interpreted as old-style isDefinition: true.
   Out << FS << Name << ": ";
 
   if (!Flags) {
     Out << 0;
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());
+  Printer.printDIBTFlags("btFlags", N->getBTFlags());
   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);

llvm/lib/IR/DIBuilder.cpp

 }
 
 DIBasicType *DIBuilder::createNullPtrType() {
   return createUnspecifiedType("decltype(nullptr)");
 }
 
 DIBasicType *DIBuilder::createBasicType(StringRef Name, uint64_t SizeInBits,
                                         unsigned Encoding,
-                                        DINode::DIFlags Flags) {
+                                        DIBasicType::DIBTFlags Flags) {
   assert(!Name.empty() && "Unable to create type without name");
   return DIBasicType::get(VMContext, dwarf::DW_TAG_base_type, Name, SizeInBits,
                           0, Encoding, Flags);
 }
 
 DIDerivedType *DIBuilder::createQualifiedType(unsigned Tag, DIType *FromTy) {
   return DIDerivedType::get(VMContext, Tag, "", nullptr, 0, nullptr, FromTy, 0,
                             0, 0, None, DINode::FlagZero);

llvm/lib/IR/DebugInfo.cpp

 static DINode::DIFlags map_from_llvmDIFlags(LLVMDIFlags Flags) {
   return static_cast<DINode::DIFlags>(Flags);
 }
 
 static LLVMDIFlags map_to_llvmDIFlags(DINode::DIFlags Flags) {
   return static_cast<LLVMDIFlags>(Flags);
 }
 
+static DIBasicType::DIBTFlags pack_into_DIBTFlags(bool IsBigEndian,
+                                                  bool IsLittleEndian) {
+  return DIBasicType::toBTFlags(IsBigEndian, IsLittleEndian);
+}
+
 static DISubprogram::DISPFlags
 pack_into_DISPFlags(bool IsLocalToUnit, bool IsDefinition, bool IsOptimized) {
   return DISubprogram::toSPFlags(IsLocalToUnit, IsDefinition, IsOptimized);
 }
 
 unsigned LLVMDebugMetadataVersion() {
   return DEBUG_METADATA_VERSION;
 }
return wrap(unwrap(Builder)->createVectorType(Size, AlignInBits,
                                                 unwrapDI<DIType>(Ty), Subs));
 }
 
 LLVMMetadataRef
 LLVMDIBuilderCreateBasicType(LLVMDIBuilderRef Builder, const char *Name,
                              size_t NameLen, uint64_t SizeInBits,
                              LLVMDWARFTypeEncoding Encoding,
                              LLVMDIFlags Flags) {
-  return wrap(unwrap(Builder)->createBasicType({Name, NameLen},
-                                               SizeInBits, Encoding,
-                                               map_from_llvmDIFlags(Flags)));
+  auto BTFlags = pack_into_DIBTFlags(Flags & LLVMDIFlagBigEndian,
+                                     Flags & LLVMDIFlagLittleEndian);
+  return wrap(unwrap(Builder)->createBasicType({Name, NameLen}, SizeInBits,
+                                               Encoding, BTFlags));
 }
 
 LLVMMetadataRef LLVMDIBuilderCreatePointerType(
     LLVMDIBuilderRef Builder, LLVMMetadataRef PointeeTy,
     uint64_t SizeInBits, uint32_t AlignInBits, unsigned AddressSpace,
     const char *Name, size_t NameLen) {
   return wrap(unwrap(Builder)->createPointerType(unwrapDI<DIType>(PointeeTy),
                                          SizeInBits, AlignInBits,

llvm/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,
-                                  DIFlags Flags, StorageType Storage,
+                                  DIBTFlags BTFlags, StorageType Storage,
                                   bool ShouldCreate) {
   assert(isCanonical(Name) && "Expected canonical MDString");
-  DEFINE_GETIMPL_LOOKUP(DIBasicType,
-                        (Tag, Name, SizeInBits, AlignInBits, Encoding, Flags));
+  DEFINE_GETIMPL_LOOKUP(
+      DIBasicType, (Tag, Name, SizeInBits, AlignInBits, Encoding, BTFlags));
   Metadata *Ops[] = {nullptr, nullptr, Name};
-  DEFINE_GETIMPL_STORE(DIBasicType, (Tag, SizeInBits, AlignInBits, Encoding,
-                      Flags), Ops);
+  DEFINE_GETIMPL_STORE(DIBasicType,
+                       (Tag, SizeInBits, AlignInBits, Encoding, BTFlags), Ops);
+}
+
+DIBasicType::DIBTFlags DIBasicType::getFlag(StringRef Flag) {
+  return StringSwitch<DIBTFlags>(Flag)
+#define HANDLE_DIBT_FLAG(ID, NAME) .Case("DIBTFlag" #NAME, BTFlag##NAME)
+#include "llvm/IR/DebugInfoFlags.def"
+      .Default(BTFlagZero);
+}
+
+StringRef DIBasicType::getFlagString(DIBTFlags Flag) {
+  switch (Flag) {
+    // Appease a warning.
+#define HANDLE_DIBT_FLAG(ID, NAME)                                             \
+  case BTFlag##NAME:                                                           \
+    return "DIBTFlag" #NAME;
+#include "llvm/IR/DebugInfoFlags.def"
+  }
+  return "";
+}
+
+DIBasicType::DIBTFlags
+DIBasicType::splitFlags(DIBTFlags Flags,
+                        SmallVectorImpl<DIBTFlags> &SplitFlags) {
+  // Multi-bit fields can require special handling. In our case all its values
+  // happen to be single-bit values.
+#define HANDLE_DIBT_FLAG(ID, NAME)                                             \
+  if (DIBTFlags Bit = Flags & BTFlag##NAME) {                                  \
+    SplitFlags.push_back(Bit);                                                 \
+    Flags &= ~Bit;                                                             \
+  }
+#include "llvm/IR/DebugInfoFlags.def"
+  return Flags;
 }
 
 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:

llvm/lib/IR/LLVMContextImpl.h

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

llvm/test/Assembler/debug-info.ll

 !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)
+; CHECK-NEXT: !38 = !DIBasicType(name: "u64.be", size: 64, align: 1, encoding: DW_ATE_unsigned, btFlags: DIBTFlagBigEndian)
+; CHECK-NEXT: !39 = !DIBasicType(name: "u64.le", size: 64, align: 1, encoding: DW_ATE_unsigned, btFlags: DIBTFlagLittleEndian)
+!41 = !DIBasicType(name: "u64.be", size: 64, align: 1, encoding: DW_ATE_unsigned, btFlags: DIBTFlagBigEndian)
+!42 = !DIBasicType(name: "u64.le", size: 64, align: 1, encoding: DW_ATE_unsigned, btFlags: DIBTFlagLittleEndian)

llvm/test/Bitcode/DIBasicType.ll

+; RUN: llvm-dis -o - %s.bc | FileCheck %s
+; CHECK:  = distinct !DIGlobalVariable(name: "a", scope: !2, file: !3, line: 1, type: ![[#LETYPE:]], isLocal: false, isDefinition: true)
+; CHECK:  = distinct !DIGlobalVariable(name: "b", scope: !2, file: !3, line: 1, type: ![[#BETYPE:]], isLocal: false, isDefinition: true)
+; CHECK: ![[#BETYPE]] = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed, btFlags: DIBTFlagBigEndian)
+; CHECK: ![[#LETYPE]] = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed, btFlags: DIBTFlagLittleEndian)
+
+@a = common dso_local global i32 0, align 4, !dbg !0
+@b = common dso_local global i32 0, align 4, !dbg !6
+
+define dso_local void @main() !dbg !12 {
+entry:
+  ret void, !dbg !15
+}
+
+!llvm.dbg.cu = !{!2}
+!llvm.module.flags = !{!10, !11}
+
+!0 = !DIGlobalVariableExpression(var: !1, expr: !DIExpression())
+!1 = distinct !DIGlobalVariable(name: "a", scope: !2, file: !3, line: 1, type: !9, isLocal: false, isDefinition: true)
+!2 = distinct !DICompileUnit(language: DW_LANG_C99, file: !3, producer: "clang", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug, enums: !4, globals: !5, splitDebugInlining: false, nameTableKind: None)
+!3 = !DIFile(filename: "main.c", directory: "/dir")
+!4 = !{}
+!5 = !{!0, !6}
+!6 = !DIGlobalVariableExpression(var: !7, expr: !DIExpression())
+!7 = distinct !DIGlobalVariable(name: "b", scope: !2, file: !3, line: 1, type: !8, isLocal: false, isDefinition: true)
+!8 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed, flags: DIFlagBigEndian)
+!9 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed, flags: DIFlagLittleEndian)
+!10 = !{i32 7, !"Dwarf Version", i32 4}
+!11 = !{i32 2, !"Debug Info Version", i32 3}
+!12 = distinct !DISubprogram(name: "main", scope: !3, file: !3, line: 2, type: !13, scopeLine: 2, spFlags: DISPFlagDefinition, unit: !2, retainedNodes: !4)
+!13 = !DISubroutineType(types: !14)
+!14 = !{null}
+!15 = !DILocation(line: 2, column: 14, scope: !12)
+

llvm/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,
-                        DINode::FlagZero);
+  auto *N = DIBasicType::get(Context, dwarf::DW_TAG_base_type, "special", 33,
+                             26, 7, DIBasicType::BTFlagZero);
   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, DINode::FlagZero));
+                                26, 7, DIBasicType::BTFlagZero));
 
   EXPECT_NE(N, DIBasicType::get(Context, dwarf::DW_TAG_unspecified_type,
-                                "special", 33, 26, 7, DINode::FlagZero));
-  EXPECT_NE(N,
-            DIBasicType::get(Context, dwarf::DW_TAG_base_type, "s", 33, 26, 7,
-                              DINode::FlagZero));
+                                "special", 33, 26, 7, DIBasicType::BTFlagZero));
+  EXPECT_NE(N, DIBasicType::get(Context, dwarf::DW_TAG_base_type, "s", 33, 26,
+                                7, DIBasicType::BTFlagZero));
   EXPECT_NE(N, DIBasicType::get(Context, dwarf::DW_TAG_base_type, "special", 32,
-                                26, 7, DINode::FlagZero));
+                                26, 7, DIBasicType::BTFlagZero));
   EXPECT_NE(N, DIBasicType::get(Context, dwarf::DW_TAG_base_type, "special", 33,
-                                25, 7, DINode::FlagZero));
+                                25, 7, DIBasicType::BTFlagZero));
   EXPECT_NE(N, DIBasicType::get(Context, dwarf::DW_TAG_base_type, "special", 33,
-                                26, 6, DINode::FlagZero));
+                                26, 6, DIBasicType::BTFlagZero));
   EXPECT_NE(N, DIBasicType::get(Context, dwarf::DW_TAG_base_type, "special", 33,
-                                26, 7, DINode::FlagBigEndian));
+                                26, 7, DIBasicType::BTFlagBigEndian));
   EXPECT_NE(N, DIBasicType::get(Context, dwarf::DW_TAG_base_type, "special", 33,
-                                26, 7, DINode::FlagLittleEndian));
+                                26, 7, DIBasicType::BTFlagLittleEndian));
 
   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, DINode::FlagZero);
+  auto *N =
+      DIBasicType::get(Context, dwarf::DW_TAG_base_type, "special", UINT64_MAX,
+                       UINT32_MAX - 1, 7, DIBasicType::BTFlagZero);
   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());
+  EXPECT_EQ(DIBasicType::BTFlagZero, N->getBTFlags());
 }
 
 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);
+                               dwarf::DW_ATE_signed, DIBasicType::BTFlagZero);
 
   TempDIType Temp = N->clone();
   EXPECT_EQ(N, MDNode::replaceWithUniqued(std::move(Temp)));
 }
 
 TEST_F(DITypeTest, cloneWithFlags) {
   // void (void)
   Metadata *TypesOps[] = {nullptr};