[DebugInfo] Improvements to representation of enumeration types (PR36168)

[chill]

Summary

This patch is the LLVM part of fixing the issues, described in https://bugs.llvm.org/show_bug.cgi?id=36168

• The representation of enumerator values in the debug info metadata now contains a boolean flag isUnsigned, which determines how the bits of the value are interpreted.
• The DW_TAG_enumeration type DIE now always (for DWARF version >= 3) includes a DW_AT_type attribute, which refers to the underlying integer type, as suggested in DWARFv4 (5.7 Enumeration Type Entries).
• The debug info metadata for enumeration type contains (in flags) indication whether this is a C++11 "fixed enum".
• For C++11 enumeration with a fixed underlying type, the DIE also includes the DW_AT_enum_class attribute (for DWARF version >= 4).
• Encoding of enumerator constants uses DW_FORM_sdata for signed values and DW_FORM_udata for unsigned values, as suggested by DWARFv4 (7.5.4 Attribute Encodings).

The changes should be backwards compatible:

• the isUnsigned attribute is optional and defaults to false.
• if the underlying type for the enumeration is not available, the enumerator values are considered signed.
• the FixedEnum flag defaults to clear.
• the bitcode format for DIEnumerator stores the unsigned flag bit #1 of the first record element, so the format does not change and the zero previously stored there is consistent with the false default for IsUnsigned.

There are corresponding changes to clang (I'll submit them shortly), however this patch in isolation
ought to not break build or introduce regressions.

[chill]

clang counterpart here https://reviews.llvm.org/D42736

[aprantl]

Thanks!

From what I can tell this is missing a bitcode upgrade in MetadataLoader to parse the old format and upgrade it (e.g, by treating everything as signed, similar to how our current implementation works).
Can you add that and a bitcode upgrade test to test/Bitcode that exercises it?

Do you need to add any additional checks to the IR Verifier?

[aprantl]

include/llvm/IR/DebugInfoMetadata.h

399 ↗

(On Diff #132150)

I think you can squeeze this bit into the classdata field as some other DI* types do.

[dblaikie]

test/DebugInfo/Generic/debug-info-enum.ll

29–39 ↗

(On Diff #132150)

Usually we don't mix the CHECK lines in with the IR - though I wouldn't rule it out.

Also usually we provide the C or C++ source (or something like it) in a comment a the top to see at a glance what's being tested)

I actually don't mind this test as-is, but just some ideas.

test/DebugInfo/X86/enum-class.ll

47 ↗

(On Diff #132150)

Probably just drop the abbreviation number from the test

[chill]

Update:

• accept also pre-patch Bitcode form of DIEnumerator's
• add an upgrade test

[aprantl]

lib/Bitcode/Reader/MetadataLoader.cpp

1200 ↗

(On Diff #132225)

An alternative implementation would be to stick the isSigned bit into Record[0] & 0x2. This would make the on-disk-representation smaller. There are lots of examples of other entities in the DIType hierarchy that do this.

[chill]

Changes relative to the previous version:

• Signed/unsigned flag stored inside SubclassData32 member of DIEnumerator.
• Metadata for DIEnumerator is back to 3-element record. The signed/unsigned flag is stored in bit #1 of the first record element. Since it looked a bit weird to store IsSigned value of true as 0, ...
• ... changed everywhere IsSigned to IsUnsigned
• removed the upgrade test, as the bitcode format doesn't actually change now

[aprantl]

Did you perhaps forget to add the upgrade test before uploading?

[aprantl]

There should be a bitcode upgrade test in test/Bitcode with a .bc file that contains an old-style enum, and a round-trip test in test/IR that tests the new enums.

[aprantl]

Otherwise I think this looks good, thanks!

[aprantl]

• removed the upgrade test, as the bitcode format doesn't actually change now

Oh I see. Yes, a round-trip test (llvm-as | llvm-dis | llvm-as | llvm-dis) in lib/IR would be enough now.

[aprantl]

test/IR

[chill]

Changes relative to the prevuious revision:

• added an LLVM IR <-> Bitcode round-trip test for enums

[aprantl]

Looks good with one outstanding change applied. Please wait for @dblaikie to sign off, too, before landing this.

test/Bitcode/enum-round-trip.ll

1 ↗

(On Diff #132566)

Please rename this file to test/Assembler/DIEnumerator.ll

[dblaikie]

Looks good - thanks!

lib/AsmParser/LLParser.cpp

3939–3943 ↗

(On Diff #132609)

Could invert this (& similarly below) to reduce indentation & bracing:

if (ParseMDField(...))
  return true;
Result.assign(Res);
return false;

test/Assembler/DIEnumerator.ll

24–64 ↗

(On Diff #132609)

Probably add some whitespace in here at the beginning of each enum so it's easier to read/visually separate each test case?

test/DebugInfo/Generic/debug-info-enum.ll

24 ↗

(On Diff #132609)

Worth a comment at the start of each enumeration/test case describing what this test covers that the others don't? So it's clear what to focus on? (just a short, english language (rather than metadata/check lines) summary of the important features "test a fixed enum class over signed char" or the like)

[vsapsai]

Hi, Momchil. I suspect this change caused

Assertion failed: (DTy), function constructEnumTypeDIE, file /Users/buildslave/jenkins/workspace/clang-stage1-configure-RA/llvm/lib/CodeGen/AsmPrinter/DwarfUnit.cpp, line 1436.

on the build bot http://green.lab.llvm.org/green/job/clang-stage2-Rthinlto/ For example, see http://green.lab.llvm.org/green/job/clang-stage2-Rthinlto/8694/console

Earlier instead of assert(DTy); we had

if (DTy) {
  addType(Buffer, DTy);
  addFlag(Buffer, dwarf::DW_AT_enum_class);
}

I don't know where the bug is but maybe it makes sense to remove assertion for now and correctly handle nullptr DTy? This will unblock the build bot for others and after that you can work on better fix if required.

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

1435

Talking about this assertion.

[chill]

In D42734#1006877, @vsapsai wrote:

Hi, Momchil. I suspect this change caused

Assertion failed: (DTy), function constructEnumTypeDIE, file /Users/buildslave/jenkins/workspace/clang-stage1-configure-RA/llvm/lib/CodeGen/AsmPrinter/DwarfUnit.cpp, line 1436.

on the build bot http://green.lab.llvm.org/green/job/clang-stage2-Rthinlto/ For example, see http://green.lab.llvm.org/green/job/clang-stage2-Rthinlto/8694/console

Earlier instead of assert(DTy); we had

if (DTy) {
  addType(Buffer, DTy);
  addFlag(Buffer, dwarf::DW_AT_enum_class);
}

I don't know where the bug is but maybe it makes sense to remove assertion for now and correctly handle nullptr DTy? This will unblock the build bot for others and after that you can work on better fix if required.

Hello,

This is quite strange. Having the flag DINode::FlagFixedEnum set means the LLVM IR was generated by this
https://github.com/llvm-mirror/clang/blob/7b1bfe45423fcf2ac09f3b5cb7a7ef20596254ed/lib/CodeGen/CGDebugInfo.cpp#L2513
version of Clang (as the last parameter to createEnumerationType did not exist before and defaults to false).

Perhaps the underlying type was null already in the AST?

For pre-existing .ll files, the flag DINode::FlagFixedEnum should be clear, and the control shouldn't even enter that if body.

[vsapsai]

In D42734#1007215, @chill wrote:

In D42734#1006877, @vsapsai wrote:

Hi, Momchil. I suspect this change caused

Assertion failed: (DTy), function constructEnumTypeDIE, file /Users/buildslave/jenkins/workspace/clang-stage1-configure-RA/llvm/lib/CodeGen/AsmPrinter/DwarfUnit.cpp, line 1436.

on the build bot http://green.lab.llvm.org/green/job/clang-stage2-Rthinlto/ For example, see http://green.lab.llvm.org/green/job/clang-stage2-Rthinlto/8694/console

Earlier instead of assert(DTy); we had

if (DTy) {
  addType(Buffer, DTy);
  addFlag(Buffer, dwarf::DW_AT_enum_class);
}

I don't know where the bug is but maybe it makes sense to remove assertion for now and correctly handle nullptr DTy? This will unblock the build bot for others and after that you can work on better fix if required.

Hello,

This is quite strange. Having the flag DINode::FlagFixedEnum set means the LLVM IR was generated by this
https://github.com/llvm-mirror/clang/blob/7b1bfe45423fcf2ac09f3b5cb7a7ef20596254ed/lib/CodeGen/CGDebugInfo.cpp#L2513
version of Clang (as the last parameter to createEnumerationType did not exist before and defaults to false).

Perhaps the underlying type was null already in the AST?

For pre-existing .ll files, the flag DINode::FlagFixedEnum should be clear, and the control shouldn't even enter that if body.

So, do you plan to fix the regression? And if yes, how much time do you need? If the fix isn't expected soon, I'll revert the change.

llvm/trunk/include/llvm/Bitcode/LLVMBitCodes.h

enum MetadataCodes {
   METADATA_KIND = 6,           // [n x [id, name]]
   METADATA_LOCATION = 7,       // [distinct, line, col, scope, inlined-at?]
   METADATA_OLD_NODE = 8,       // OLD_NODE:      [n x (type num, value num)]
   METADATA_OLD_FN_NODE = 9,    // OLD_FN_NODE:   [n x (type num, value num)]
   METADATA_NAMED_NODE = 10,    // NAMED_NODE:    [n x mdnodes]
   METADATA_ATTACHMENT = 11,    // [m x [value, [n x [id, mdnode]]]
   METADATA_GENERIC_DEBUG = 12, // [distinct, tag, vers, header, n x md num]
   METADATA_SUBRANGE = 13,      // [distinct, count, lo]
-  METADATA_ENUMERATOR = 14,    // [distinct, value, name]
+  METADATA_ENUMERATOR = 14,    // [isUnsigned|distinct, value, name]
   METADATA_BASIC_TYPE = 15,    // [distinct, tag, name, size, align, enc]
   METADATA_FILE = 16, // [distinct, filename, directory, checksumkind, checksum]
   METADATA_DERIVED_TYPE = 17,       // [distinct, ...]
   METADATA_COMPOSITE_TYPE = 18,     // [distinct, ...]
   METADATA_SUBROUTINE_TYPE = 19,    // [distinct, flags, types, cc]
   METADATA_COMPILE_UNIT = 20,       // [distinct, ...]
   METADATA_SUBPROGRAM = 21,         // [distinct, ...]
   METADATA_LEXICAL_BLOCK = 22,      // [distinct, scope, file, line, column]

llvm/trunk/include/llvm/IR/DIBuilder.h

public:
     /// using the \p Parent relationship.
     /// \param Parent     Macro file parent (could be nullptr).
     /// \param Line       Source line number where the macro file is included.
     /// \param File       File descriptor containing the name of the macro file.
     DIMacroFile *createTempMacroFile(DIMacroFile *Parent, unsigned Line,
                                      DIFile *File);
 
     /// Create a single enumerator value.
-    DIEnumerator *createEnumerator(StringRef Name, int64_t Val);
+    DIEnumerator *createEnumerator(StringRef Name, int64_t Val, bool IsUnsigned = false);
 
     /// Create a DWARF unspecified type.
     DIBasicType *createUnspecifiedType(StringRef Name);
 
     /// Create C++11 nullptr type.
     DIBasicType *createNullPtrType();
 
     /// Create debugging information entry for a basic
public:
     /// \param Name           Union name.
     /// \param File           File where this member is defined.
     /// \param LineNumber     Line number.
     /// \param SizeInBits     Member size.
     /// \param AlignInBits    Member alignment.
     /// \param Elements       Enumeration elements.
     /// \param UnderlyingType Underlying type of a C++11/ObjC fixed enum.
     /// \param UniqueIdentifier A unique identifier for the enum.
+    /// \param IsFixed Boolean flag indicate if this is C++11/ObjC fixed enum.
     DICompositeType *createEnumerationType(
         DIScope *Scope, StringRef Name, DIFile *File, unsigned LineNumber,
         uint64_t SizeInBits, uint32_t AlignInBits, DINodeArray Elements,
-        DIType *UnderlyingType, StringRef UniqueIdentifier = "");
+        DIType *UnderlyingType, StringRef UniqueIdentifier = "", bool IsFixed = false);
 
     /// Create subroutine type.
     /// \param ParameterTypes  An array of subroutine parameter types. This
     ///                        includes return type at 0th index.
     /// \param Flags           E.g.: LValueReference.
     ///                        These flags are used to emit dwarf attributes.
     /// \param CC              Calling convention, e.g. dwarf::DW_CC_normal
     DISubroutineType *

llvm/trunk/include/llvm/IR/DebugInfoFlags.def

 HANDLE_DI_FLAG((2 << 16), MultipleInheritance)
 HANDLE_DI_FLAG((3 << 16), VirtualInheritance)
 HANDLE_DI_FLAG((1 << 18), IntroducedVirtual)
 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)
 
 // 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 << 23), Largest)
+HANDLE_DI_FLAG((1 << 24), Largest)
 #undef DI_FLAG_LARGEST_NEEDED
 #endif
 
 #undef HANDLE_DI_FLAG

llvm/trunk/include/llvm/IR/DebugInfoMetadata.h

 ///
 /// TODO: Add a pointer to the context (DW_TAG_enumeration_type) once that no
 /// longer creates a type cycle.
 class DIEnumerator : public DINode {
   friend class LLVMContextImpl;
   friend class MDNode;
 
   int64_t Value;
-
   DIEnumerator(LLVMContext &C, StorageType Storage, int64_t Value,
-               ArrayRef<Metadata *> Ops)
+               bool IsUnsigned, ArrayRef<Metadata *> Ops)
       : DINode(C, DIEnumeratorKind, Storage, dwarf::DW_TAG_enumerator, Ops),
-        Value(Value) {}
+        Value(Value) {
+    SubclassData32 = IsUnsigned;
+  }
   ~DIEnumerator() = default;
 
   static DIEnumerator *getImpl(LLVMContext &Context, int64_t Value,
-                               StringRef Name, StorageType Storage,
-                               bool ShouldCreate = true) {
-    return getImpl(Context, Value, getCanonicalMDString(Context, Name), Storage,
-                   ShouldCreate);
+                               bool IsUnsigned, StringRef Name,
+                               StorageType Storage, bool ShouldCreate = true) {
+    return getImpl(Context, Value, IsUnsigned,
+                   getCanonicalMDString(Context, Name), Storage, ShouldCreate);
   }
   static DIEnumerator *getImpl(LLVMContext &Context, int64_t Value,
-                               MDString *Name, StorageType Storage,
-                               bool ShouldCreate = true);
+                               bool IsUnsigned, MDString *Name,
+                               StorageType Storage, bool ShouldCreate = true);
 
   TempDIEnumerator cloneImpl() const {
-    return getTemporary(getContext(), getValue(), getName());
+    return getTemporary(getContext(), getValue(), isUnsigned(), getName());
   }
 
 public:
-  DEFINE_MDNODE_GET(DIEnumerator, (int64_t Value, StringRef Name),
-                    (Value, Name))
-  DEFINE_MDNODE_GET(DIEnumerator, (int64_t Value, MDString *Name),
-                    (Value, Name))
+  DEFINE_MDNODE_GET(DIEnumerator, (int64_t Value, bool IsUnsigned, StringRef Name),
+                    (Value, IsUnsigned, Name))
+  DEFINE_MDNODE_GET(DIEnumerator, (int64_t Value, bool IsUnsigned, MDString *Name),
+                    (Value, IsUnsigned, Name))
 
   TempDIEnumerator clone() const { return cloneImpl(); }
 
   int64_t getValue() const { return Value; }
+  bool isUnsigned() const { return SubclassData32; }
   StringRef getName() const { return getStringOperand(0); }
 
   MDString *getRawName() const { return getOperandAs<MDString>(0); }
 
   static bool classof(const Metadata *MD) {
     return MD->getMetadataID() == DIEnumeratorKind;
   }
 };

llvm/trunk/lib/AsmParser/LLParser.cpp

int64_t getMDSignedValue() const {
     return A.Val;
   }
   Metadata *getMDFieldValue() const {
     assert(isMDField() && "Wrong field type");
     return B.Val;
   }
 };
 
+struct MDSignedOrUnsignedField
+    : MDEitherFieldImpl<MDSignedField, MDUnsignedField> {
+  MDSignedOrUnsignedField() : ImplTy(MDSignedField(0), MDUnsignedField(0)) {}
+
+  bool isMDSignedField() const { return WhatIs == IsTypeA; }
+  bool isMDUnsignedField() const { return WhatIs == IsTypeB; }
+  int64_t getMDSignedValue() const {
+    assert(isMDSignedField() && "Wrong field type");
+    return A.Val;
+  }
+  uint64_t getMDUnsignedValue() const {
+    assert(isMDUnsignedField() && "Wrong field type");
+    return B.Val;
+  }
+};
+
 } // end anonymous namespace
 
 namespace llvm {
 
 template <>
 bool LLParser::ParseMDField(LocTy Loc, StringRef Name,
                             MDUnsignedField &Result) {
   if (Lex.getKind() != lltok::APSInt || Lex.getAPSIntVal().isSigned())
if (!ParseMDField(Loc, Name, Res)) {
     Result.assign(Res);
     return false;
   }
 
   return true;
 }
 
 template <>
+bool LLParser::ParseMDField(LocTy Loc, StringRef Name,
+                            MDSignedOrUnsignedField &Result) {
+  if (Lex.getKind() != lltok::APSInt)
+    return false;
+
+  if (Lex.getAPSIntVal().isSigned()) {
+    MDSignedField Res = Result.A;
+    if (ParseMDField(Loc, Name, Res))
+      return true;
+    Result.assign(Res);
+    return false;
+  }
+
+  MDUnsignedField Res = Result.B;
+  if (ParseMDField(Loc, Name, Res))
+    return true;
+  Result.assign(Res);
+  return false;
+}
+
+template <>
 bool LLParser::ParseMDField(LocTy Loc, StringRef Name, MDStringField &Result) {
   LocTy ValueLoc = Lex.getLoc();
   std::string S;
   if (ParseStringConstant(S))
     return true;
 
   if (!Result.AllowEmpty && S.empty())
     return Error(ValueLoc, "'" + Name + "' cannot be empty");
Result = GET_OR_DISTINCT(
         DISubrange, (Context, count.getMDFieldValue(), lowerBound.Val));
   else
     return true;
 
   return false;
 }
 
 /// ParseDIEnumerator:
-///   ::= !DIEnumerator(value: 30, name: "SomeKind")
+///   ::= !DIEnumerator(value: 30, isUnsigned: true, name: "SomeKind")
 bool LLParser::ParseDIEnumerator(MDNode *&Result, bool IsDistinct) {
 #define VISIT_MD_FIELDS(OPTIONAL, REQUIRED)                                    \
   REQUIRED(name, MDStringField, );                                             \
-  REQUIRED(value, MDSignedField, );
+  REQUIRED(value, MDSignedOrUnsignedField, );                                  \
+  OPTIONAL(isUnsigned, MDBoolField, (false));
   PARSE_MD_FIELDS();
 #undef VISIT_MD_FIELDS
 
-  Result = GET_OR_DISTINCT(DIEnumerator, (Context, value.Val, name.Val));
+  if (isUnsigned.Val && value.isMDSignedField())
+    return TokError("unsigned enumerator with negative value");
+
+  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)
 bool LLParser::ParseDIBasicType(MDNode *&Result, bool IsDistinct) {
 #define VISIT_MD_FIELDS(OPTIONAL, REQUIRED)                                    \
   OPTIONAL(tag, DwarfTagField, (dwarf::DW_TAG_base_type));                     \

llvm/trunk/lib/Bitcode/Reader/MetadataLoader.cpp

case bitc::METADATA_SUBRANGE: {
     IsDistinct = Record[0] & 1;
     NextMetadataNo++;
     break;
   }
   case bitc::METADATA_ENUMERATOR: {
     if (Record.size() != 3)
       return error("Invalid record");
 
-    IsDistinct = Record[0];
+    IsDistinct = Record[0] & 1;
+    bool IsUnsigned = Record[0] & 2;
     MetadataList.assignValue(
         GET_OR_DISTINCT(DIEnumerator, (Context, unrotateSign(Record[1]),
-                                       getMDString(Record[2]))),
+                                       IsUnsigned, getMDString(Record[2]))),
         NextMetadataNo);
     NextMetadataNo++;
     break;
   }
   case bitc::METADATA_BASIC_TYPE: {
     if (Record.size() != 6)
       return error("Invalid record");
 

llvm/trunk/lib/Bitcode/Writer/BitcodeWriter.cpp

void ModuleBitcodeWriter::writeDISubrange(const DISubrange *N,
 
   Stream.EmitRecord(bitc::METADATA_SUBRANGE, Record, Abbrev);
   Record.clear();
 }
 
 void ModuleBitcodeWriter::writeDIEnumerator(const DIEnumerator *N,
                                             SmallVectorImpl<uint64_t> &Record,
                                             unsigned Abbrev) {
-  Record.push_back(N->isDistinct());
+  Record.push_back((N->isUnsigned() << 1) | N->isDistinct());
   Record.push_back(rotateSign(N->getValue()));
   Record.push_back(VE.getMetadataOrNullID(N->getRawName()));
 
   Stream.EmitRecord(bitc::METADATA_ENUMERATOR, Record, Abbrev);
   Record.clear();
 }
 
 void ModuleBitcodeWriter::writeDIBasicType(const DIBasicType *N,

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

for (unsigned i = 0, N = Elements.size(); i < N; ++i) {
     // FIXME: Should this really be such a loose cast?
     if (auto *Element = dyn_cast_or_null<DINode>(Elements[i]))
       if (Element->getTag() == dwarf::DW_TAG_subrange_type)
         constructSubrangeDIE(Buffer, cast<DISubrange>(Element), IdxTy);
   }
 }
 
 void DwarfUnit::constructEnumTypeDIE(DIE &Buffer, const DICompositeType *CTy) {
+  const DIType *DTy = resolve(CTy->getBaseType());
+  bool IsUnsigned = DTy && isUnsignedDIType(DD, DTy);
+  if (DTy && DD->getDwarfVersion() >= 3)
+    addType(Buffer, DTy);
+  if (DD->getDwarfVersion() >= 4 && (CTy->getFlags() & DINode::FlagFixedEnum)) {
+    assert(DTy);
+    addFlag(Buffer, dwarf::DW_AT_enum_class);
+  }
+
   DINodeArray Elements = CTy->getElements();
 
   // Add enumerators to enumeration type.
   for (unsigned i = 0, N = Elements.size(); i < N; ++i) {
     auto *Enum = dyn_cast_or_null<DIEnumerator>(Elements[i]);
     if (Enum) {
       DIE &Enumerator = createAndAddDIE(dwarf::DW_TAG_enumerator, Buffer);
       StringRef Name = Enum->getName();
       addString(Enumerator, dwarf::DW_AT_name, Name);
-      int64_t Value = Enum->getValue();
-      addSInt(Enumerator, dwarf::DW_AT_const_value, dwarf::DW_FORM_sdata,
-              Value);
+      auto Value = static_cast<uint64_t>(Enum->getValue());
+      addConstantValue(Enumerator, IsUnsigned, Value);
     }
   }
-  const DIType *DTy = resolve(CTy->getBaseType());
-  if (DTy) {
-    addType(Buffer, DTy);
-    addFlag(Buffer, dwarf::DW_AT_enum_class);
-  }
 }
 
 void DwarfUnit::constructContainingTypeDIEs() {
   for (auto CI = ContainingTypeMap.begin(), CE = ContainingTypeMap.end();
        CI != CE; ++CI) {
     DIE &SPDie = *CI->first;
     const DINode *D = CI->second;
     if (!D)

llvm/trunk/lib/IR/AsmWriter.cpp

static void writeDISubrange(raw_ostream &Out, const DISubrange *N,
   Out << ")";
 }
 
 static void writeDIEnumerator(raw_ostream &Out, const DIEnumerator *N,
                               TypePrinting *, SlotTracker *, const Module *) {
   Out << "!DIEnumerator(";
   MDFieldPrinter Printer(Out);
   Printer.printString("name", N->getName(), /* ShouldSkipEmpty */ false);
+  if (N->isUnsigned()) {
+    auto Value = static_cast<uint64_t>(N->getValue());
+    Printer.printInt("value", Value, /* ShouldSkipZero */ false);
+    Printer.printBool("isUnsigned", true);
+  } else {
     Printer.printInt("value", N->getValue(), /* ShouldSkipZero */ false);
+  }
   Out << ")";
 }
 
 static void writeDIBasicType(raw_ostream &Out, const DIBasicType *N,
                              TypePrinting *, SlotTracker *, const Module *) {
   Out << "!DIBasicType(";
   MDFieldPrinter Printer(Out);
   if (N->getTag() != dwarf::DW_TAG_base_type)

llvm/trunk/lib/IR/DIBuilder.cpp

DIMacroFile *DIBuilder::createTempMacroFile(DIMacroFile *Parent,
   AllMacrosPerParent[Parent].insert(MF);
   // Add the new temporary DIMacroFile to the macro per parent map as a parent.
   // This is needed to assure DIMacroFile with no children to have an entry in
   // the map. Otherwise, it will not be resolved in DIBuilder::finalize().
   AllMacrosPerParent.insert({MF, {}});
   return MF;
 }
 
-DIEnumerator *DIBuilder::createEnumerator(StringRef Name, int64_t Val) {
+DIEnumerator *DIBuilder::createEnumerator(StringRef Name, int64_t Val,
+                                          bool IsUnsigned) {
   assert(!Name.empty() && "Unable to create enumerator without name");
-  return DIEnumerator::get(VMContext, Val, Name);
+  return DIEnumerator::get(VMContext, Val, IsUnsigned, Name);
 }
 
 DIBasicType *DIBuilder::createUnspecifiedType(StringRef Name) {
   assert(!Name.empty() && "Unable to create type without name");
   return DIBasicType::get(VMContext, dwarf::DW_TAG_unspecified_type, Name);
 }
 
 DIBasicType *DIBuilder::createNullPtrType() {
DISubroutineType *DIBuilder::createSubroutineType(DITypeRefArray ParameterTypes,
                                                   DINode::DIFlags Flags,
                                                   unsigned CC) {
   return DISubroutineType::get(VMContext, Flags, CC, ParameterTypes);
 }
 
 DICompositeType *DIBuilder::createEnumerationType(
     DIScope *Scope, StringRef Name, DIFile *File, unsigned LineNumber,
     uint64_t SizeInBits, uint32_t AlignInBits, DINodeArray Elements,
-    DIType *UnderlyingType, StringRef UniqueIdentifier) {
+    DIType *UnderlyingType, StringRef UniqueIdentifier, bool IsFixed) {
   auto *CTy = DICompositeType::get(
       VMContext, dwarf::DW_TAG_enumeration_type, Name, File, LineNumber,
       getNonCompileUnitScope(Scope), UnderlyingType, SizeInBits, AlignInBits, 0,
-      DINode::FlagZero, Elements, 0, nullptr, nullptr, UniqueIdentifier);
+      IsFixed ? DINode::FlagFixedEnum : DINode::FlagZero, Elements, 0, nullptr,
+      nullptr, UniqueIdentifier);
   AllEnumTypes.push_back(CTy);
   trackIfUnresolved(CTy);
   return CTy;
 }
 
 DICompositeType *DIBuilder::createArrayType(uint64_t Size,
                                             uint32_t AlignInBits, DIType *Ty,
                                             DINodeArray Subscripts) {

llvm/trunk/lib/IR/DebugInfoMetadata.cpp

DISubrange *DISubrange::getImpl(LLVMContext &Context, Metadata *CountNode,
                                 int64_t Lo, StorageType Storage,
                                 bool ShouldCreate) {
   DEFINE_GETIMPL_LOOKUP(DISubrange, (CountNode, Lo));
   Metadata *Ops[] = { CountNode };
   DEFINE_GETIMPL_STORE(DISubrange, (CountNode, Lo), Ops);
 }
 
 DIEnumerator *DIEnumerator::getImpl(LLVMContext &Context, int64_t Value,
-                                    MDString *Name, StorageType Storage,
-                                    bool ShouldCreate) {
+                                    bool IsUnsigned, MDString *Name,
+                                    StorageType Storage, bool ShouldCreate) {
   assert(isCanonical(Name) && "Expected canonical MDString");
-  DEFINE_GETIMPL_LOOKUP(DIEnumerator, (Value, Name));
+  DEFINE_GETIMPL_LOOKUP(DIEnumerator, (Value, IsUnsigned, Name));
   Metadata *Ops[] = {Name};
-  DEFINE_GETIMPL_STORE(DIEnumerator, (Value), Ops);
+  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) {
   assert(isCanonical(Name) && "Expected canonical MDString");
   DEFINE_GETIMPL_LOOKUP(DIBasicType,

llvm/trunk/lib/IR/LLVMContextImpl.h

if (auto *MD = dyn_cast<ConstantAsMetadata>(CountNode))
                           LowerBound);
     return hash_combine(CountNode, LowerBound);
   }
 };
 
 template <> struct MDNodeKeyImpl<DIEnumerator> {
   int64_t Value;
   MDString *Name;
+  bool IsUnsigned;
 
-  MDNodeKeyImpl(int64_t Value, MDString *Name) : Value(Value), Name(Name) {}
+  MDNodeKeyImpl(int64_t Value, bool IsUnsigned, MDString *Name)
+      : Value(Value), Name(Name), IsUnsigned(IsUnsigned) {}
   MDNodeKeyImpl(const DIEnumerator *N)
-      : Value(N->getValue()), Name(N->getRawName()) {}
+      : Value(N->getValue()), Name(N->getRawName()),
+        IsUnsigned(N->isUnsigned()) {}
 
   bool isKeyOf(const DIEnumerator *RHS) const {
-    return Value == RHS->getValue() && Name == RHS->getRawName();
+    return Value == RHS->getValue() && IsUnsigned == RHS->isUnsigned() &&
+           Name == RHS->getRawName();
   }
 
   unsigned getHashValue() const { return hash_combine(Value, Name); }
 };
 
 template <> struct MDNodeKeyImpl<DIBasicType> {
   unsigned Tag;
   MDString *Name;

llvm/trunk/test/Assembler/DIEnumerator.ll

+; Round-trip test for the following program:
+; ```
+; enum E0 {  A0 = -2147483648, B0 = 2147483647 } x0;
+; enum E1 : signed int { A1 = -2147483648, B1 = 2147483647 } x1;
+; enum E2 : signed long long { A2 = -9223372036854775807LL - 1,
+;                              B2 = 9223372036854775807LL } x2;
+; enum E3 : unsigned long long { A3 = 0x8000000000000000ULL } x3;
+; ```
+; Test FixedEnum flag presence/absence, the underlying integer type and
+; enumerator values (signed and unsigned, and extreme cases) all survive through
+; the round-trip.
+
+; RUN: llvm-as %s -o - | llvm-dis | llvm-as | llvm-dis | FileCheck %s
+
+@x0 = global i32 0, align 4, !dbg !0
+@x1 = global i32 0, align 4, !dbg !24
+@x2 = global i64 0, align 8, !dbg !26
+@x3 = global i64 0, align 8, !dbg !28
+
+!llvm.dbg.cu = !{!2}
+!llvm.module.flags = !{!30, !31, !32}
+!llvm.ident = !{!33}
+
+!0 = !DIGlobalVariableExpression(var: !1, expr: !DIExpression())
+!1 = distinct !DIGlobalVariable(name: "x0", scope: !2, file: !3, line: 1, type: !5, isLocal: false, isDefinition: true)
+!2 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus, file: !3, producer: "clang version 7.0.0 (/data/src/llvm/tools/clang 697b0cb4c2e712a28767c2f7fe50c90bae7255f5) (/data/src/llvm 5ba8dcca7470b5da405bc92b9681b1f36e5d6772)", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug, enums: !4, globals: !23)
+!3 = !DIFile(filename: "e.cc", directory: "/work/build/clang-dev")
+!4 = !{!5, !10, !14, !19}
+
+
+!5 = !DICompositeType(tag: DW_TAG_enumeration_type, name: "E0", file: !3, line: 1, baseType: !6, size: 32, elements: !7, identifier: "_ZTS2E0")
+; CHECK: !DICompositeType(tag: DW_TAG_enumeration_type, name: "E0"{{.*}}, baseType: ![[INT:[0-9]+]]
+; CHECK-NOT: FixedEnum
+!6 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
+; CHECK: ![[INT]] = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
+!7 = !{!8, !9}
+!8 = !DIEnumerator(name: "A0", value: -2147483648)
+!9 = !DIEnumerator(name: "B0", value: 2147483647)
+; CHECK: !DIEnumerator(name: "A0", value: -2147483648)
+; CHECK: !DIEnumerator(name: "B0", value: 2147483647)
+
+
+!10 = !DICompositeType(tag: DW_TAG_enumeration_type, name: "E1", file: !3, line: 3, baseType: !6, size: 32, flags: DIFlagFixedEnum, elements: !11, identifier: "_ZTS2E1")
+; CHECK: !DICompositeType(tag: DW_TAG_enumeration_type, name: "E1"{{.*}}, baseType: ![[INT]]
+; CHECK-SAME: DIFlagFixedEnum
+!11 = !{!12, !13}
+!12 = !DIEnumerator(name: "A1", value: -2147483648)
+!13 = !DIEnumerator(name: "B1", value: 2147483647)
+; CHECK: !DIEnumerator(name: "A1", value: -2147483648)
+; CHECK: !DIEnumerator(name: "B1", value: 2147483647)
+
+
+!14 = !DICompositeType(tag: DW_TAG_enumeration_type, name: "E2", file: !3, line: 5, baseType: !15, size: 64, flags: DIFlagFixedEnum, elements: !16, identifier: "_ZTS2E2")
+; CHECK: !DICompositeType(tag: DW_TAG_enumeration_type, name: "E2"{{.*}}, baseType: ![[LONG:[0-9]+]]
+; CHECK-SAME: DIFlagFixedEnum
+!15 = !DIBasicType(name: "long long int", size: 64, encoding: DW_ATE_signed)
+; CHECK: ![[LONG]] = !DIBasicType(name: "long long int", size: 64, encoding: DW_ATE_signed)
+!16 = !{!17, !18}
+!17 = !DIEnumerator(name: "A2", value: -9223372036854775808)
+!18 = !DIEnumerator(name: "B2", value: 9223372036854775807)
+; CHECK: !DIEnumerator(name: "A2", value: -9223372036854775808)
+; CHECK: !DIEnumerator(name: "B2", value: 9223372036854775807)
+
+
+!19 = !DICompositeType(tag: DW_TAG_enumeration_type, name: "E3", file: !3, line: 7, baseType: !20, size: 64, flags: DIFlagFixedEnum, elements: !21, identifier: "_ZTS2E3")
+; CHECK: !DICompositeType(tag: DW_TAG_enumeration_type, name: "E3"{{.*}}, baseType: ![[ULONG:[0-9]+]]
+; CHECK-SAME: DIFlagFixedEnum
+!20 = !DIBasicType(name: "long long unsigned int", size: 64, encoding: DW_ATE_unsigned)
+; CHECK: ![[ULONG]] = !DIBasicType(name: "long long unsigned int", size: 64, encoding: DW_ATE_unsigned)
+!21 = !{!22}
+!22 = !DIEnumerator(name: "A3", value: 9223372036854775808, isUnsigned: true)
+; CHECK: !DIEnumerator(name: "A3", value: 9223372036854775808, isUnsigned: true)
+
+
+!23 = !{!0, !24, !26, !28}
+!24 = !DIGlobalVariableExpression(var: !25, expr: !DIExpression())
+!25 = distinct !DIGlobalVariable(name: "x1", scope: !2, file: !3, line: 3, type: !10, isLocal: false, isDefinition: true)
+!26 = !DIGlobalVariableExpression(var: !27, expr: !DIExpression())
+!27 = distinct !DIGlobalVariable(name: "x2", scope: !2, file: !3, line: 5, type: !14, isLocal: false, isDefinition: true)
+!28 = !DIGlobalVariableExpression(var: !29, expr: !DIExpression())
+!29 = distinct !DIGlobalVariable(name: "x3", scope: !2, file: !3, line: 7, type: !19, isLocal: false, isDefinition: true)
+!30 = !{i32 2, !"Dwarf Version", i32 4}
+!31 = !{i32 2, !"Debug Info Version", i32 3}
+!32 = !{i32 1, !"wchar_size", i32 4}
+!33 = !{!"clang version 7.0.0 (/data/src/llvm/tools/clang 697b0cb4c2e712a28767c2f7fe50c90bae7255f5) (/data/src/llvm 5ba8dcca7470b5da405bc92b9681b1f36e5d6772)"}

llvm/trunk/test/DebugInfo/Generic/debug-info-enum.ll

+; Test enumeration representation in DWARF debug info:
+; * test value representation for each possible underlying integer type
+; * test the integer type is as expected
+; * test the DW_AT_enum_class attribute is present (resp. absent) as expected.
+
+; RUN: llc -debugger-tune=gdb -dwarf-version=4 -filetype=obj -o %t.o < %s
+; RUN: llvm-dwarfdump -debug-info %t.o | FileCheck %s --check-prefix=CHECK --check-prefix=CHECK-DW4
+; RUN: llc -debugger-tune=gdb -dwarf-version=2 -filetype=obj -o %t.o < %s
+; RUN: llvm-dwarfdump -debug-info %t.o | FileCheck %s --check-prefix=CHECK --check-prefix=CHECK-DW2
+
+@x0 = global i8 0, align 1, !dbg !0
+@x1 = global i8 0, align 1, !dbg !46
+@x2 = global i16 0, align 2, !dbg !48
+@x3 = global i16 0, align 2, !dbg !50
+@x4 = global i32 0, align 4, !dbg !52
+@x5 = global i32 0, align 4, !dbg !54
+@x6 = global i64 0, align 8, !dbg !56
+@x7 = global i64 0, align 8, !dbg !58
+@x8 = global i32 0, align 4, !dbg !60
+
+!llvm.dbg.cu = !{!2}
+!llvm.module.flags = !{!62}
+
+!0 = !DIGlobalVariableExpression(var: !1, expr: !DIExpression())
+!1 = distinct !DIGlobalVariable(name: "x0", scope: !2, file: !3, line: 5, type: !5, isLocal: false, isDefinition: true)
+!2 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus, file: !3, producer: "clang version 7.0.0 (/data/src/llvm/tools/clang 0c08d9830124a75675348b4eeb47256f3da6693d) (/data/src/llvm cf29510f52faa77b98510cd53276f564d1f4f41f)", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug, enums: !4, globals: !45)
+!3 = !DIFile(filename: "/data/src/llvm-dev/tools/clang/test/CodeGen/debug-info-enum.cpp", directory: "/work/build/clang-dev")
+!4 = !{!5, !10, !14, !19, !23, !28, !32, !37, !41}
+
+; Test enumeration with a fixed "signed char" underlying type.
+!5 = !DICompositeType(tag: DW_TAG_enumeration_type, name: "E0", file: !3, line: 2, baseType: !6, size: 8, flags: DIFlagFixedEnum, elements: !7, identifier: "_ZTS2E0")
+!6 = !DIBasicType(name: "signed char", size: 8, encoding: DW_ATE_signed_char)
+!7 = !{!8, !9}
+!8 = !DIEnumerator(name: "A0", value: -128)
+!9 = !DIEnumerator(name: "B0", value: 127)
+; CHECK:         DW_TAG_enumeration_type
+; CHECK-DW2-NOT:   DW_AT_type
+; CHECK-DW4:       DW_AT_type{{.*}}"signed char"
+; CHECK-DW4:       DW_AT_enum_class        (true)
+; CHECK:           DW_AT_name      ("E0")
+; CHECK:         DW_TAG_enumerator
+; CHECK:           DW_AT_name    ("A0")
+; CHECK-NEXT:      DW_AT_const_value     (-128)
+; CHECK:         DW_TAG_enumerator
+; CHECK:           DW_AT_name    ("B0")
+; CHECK-NEXT:      DW_AT_const_value     (127)
+
+; Test enumeration with a fixed "unsigned char" underlying type.
+!10 = !DICompositeType(tag: DW_TAG_enumeration_type, name: "E1", file: !3, line: 12, baseType: !11, size: 8, flags: DIFlagFixedEnum, elements: !12, identifier: "_ZTS2E1")
+!11 = !DIBasicType(name: "unsigned char", size: 8, encoding: DW_ATE_unsigned_char)
+!12 = !{!13}
+!13 = !DIEnumerator(name: "A1", value: 255, isUnsigned: true)
+; CHECK:         DW_TAG_enumeration_type
+; CHECK-DW2-NOT:   DW_AT_type
+; CHECK-DW4:       DW_AT_type{{.*}}"unsigned char"
+; CHECK-DW4:       DW_AT_enum_class        (true)
+; CHECK:           DW_AT_name      ("E1")
+; CHECK:         DW_TAG_enumerator
+; CHECK:           DW_AT_name    ("A1")
+; CHECK-NEXT:      DW_AT_const_value     (255)
+
+; Test enumeration with a fixed "short" underlying type.
+!14 = !DICompositeType(tag: DW_TAG_enumeration_type, name: "E2", file: !3, line: 18, baseType: !15, size: 16, flags: DIFlagFixedEnum, elements: !16, identifier: "_ZTS2E2")
+!15 = !DIBasicType(name: "short", size: 16, encoding: DW_ATE_signed)
+!16 = !{!17, !18}
+!17 = !DIEnumerator(name: "A2", value: -32768)
+!18 = !DIEnumerator(name: "B2", value: 32767)
+; CHECK:         DW_TAG_enumeration_type
+; CHECK-DW2-NOT:   DW_AT_type
+; CHECK-DW4:       DW_AT_type{{.*}} "short"
+; CHECK-DW4:       DW_AT_enum_class        (true)
+; CHECK:           DW_AT_name      ("E2")
+; CHECK:         DW_TAG_enumerator
+; CHECK:           DW_AT_name    ("A2")
+; CHECK-NEXT:      DW_AT_const_value     (-32768)
+; CHECK:         DW_TAG_enumerator
+; CHECK:           DW_AT_name    ("B2")
+; CHECK-NEXT:      DW_AT_const_value     (32767)
+
+; Test enumeration with a fixed "unsigned short" underlying type.
+!19 = !DICompositeType(tag: DW_TAG_enumeration_type, name: "E3", file: !3, line: 28, baseType: !20, size: 16, flags: DIFlagFixedEnum, elements: !21, identifier: "_ZTS2E3")
+!20 = !DIBasicType(name: "unsigned short", size: 16, encoding: DW_ATE_unsigned)
+!21 = !{!22}
+!22 = !DIEnumerator(name: "A3", value: 65535, isUnsigned: true)
+; CHECK:         DW_TAG_enumeration_type
+; CHECK-DW2-NOT:   DW_AT_type
+; CHECK-DW4:       DW_AT_type{{.*}}"unsigned short"
+; CHECK-DW4:       DW_AT_enum_class        (true)
+; CHECK:           DW_AT_name      ("E3")
+; CHECK:         DW_TAG_enumerator
+; CHECK:           DW_AT_name    ("A3")
+; CHECK-NEXT:      DW_AT_const_value     (65535)
+
+; Test enumeration with a fixed "int" underlying type.
+!23 = !DICompositeType(tag: DW_TAG_enumeration_type, name: "E4", file: !3, line: 34, baseType: !24, size: 32, flags: DIFlagFixedEnum, elements: !25, identifier: "_ZTS2E4")
+!24 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
+!25 = !{!26, !27}
+!26 = !DIEnumerator(name: "A4", value: -2147483648)
+!27 = !DIEnumerator(name: "B4", value: 2147483647)
+; CHECK:         DW_TAG_enumeration_type
+; CHECK-DW2-NOT:   DW_AT_type
+; CHECK-DW4:       DW_AT_type{{.*}}"int"
+; CHECK-DW4:       DW_AT_enum_class        (true)
+; CHECK:           DW_AT_name      ("E4")
+; CHECK:         DW_TAG_enumerator
+; CHECK:           DW_AT_name    ("A4")
+; CHECK-NEXT:      DW_AT_const_value     (-2147483648)
+; CHECK:         DW_TAG_enumerator
+; CHECK:           DW_AT_name    ("B4")
+; CHECK-NEXT:      DW_AT_const_value     (2147483647)
+
+; Test enumeration with a fixed "unsigend int" underlying type.
+!28 = !DICompositeType(tag: DW_TAG_enumeration_type, name: "E5", file: !3, line: 41, baseType: !29, size: 32, flags: DIFlagFixedEnum, elements: !30, identifier: "_ZTS2E5")
+!29 = !DIBasicType(name: "unsigned int", size: 32, encoding: DW_ATE_unsigned)
+!30 = !{!31}
+!31 = !DIEnumerator(name: "A5", value: 4294967295, isUnsigned: true)
+; CHECK:         DW_TAG_enumeration_type
+; CHECK-DW2-NOT:   DW_AT_type
+; CHECK-DW4:       DW_AT_type{{.*}}"unsigned int"
+; CHECK-DW4:       DW_AT_enum_class        (true)
+; CHECK:           DW_AT_name      ("E5")
+; CHECK:         DW_TAG_enumerator
+; CHECK:           DW_AT_name    ("A5")
+; CHECK-NEXT:      DW_AT_const_value     (4294967295)
+
+; Test enumeration with a fixed "long long" underlying type.
+!32 = !DICompositeType(tag: DW_TAG_enumeration_type, name: "E6", file: !3, line: 47, baseType: !33, size: 64, flags: DIFlagFixedEnum, elements: !34, identifier: "_ZTS2E6")
+!33 = !DIBasicType(name: "long long int", size: 64, encoding: DW_ATE_signed)
+!34 = !{!35, !36}
+!35 = !DIEnumerator(name: "A6", value: -9223372036854775808)
+!36 = !DIEnumerator(name: "B6", value: 9223372036854775807)
+; CHECK:         DW_TAG_enumeration_type
+; CHECK-DW2-NOT:   DW_AT_type
+; CHECK-DW4:       DW_AT_type{{.*}}"long long int"
+; CHECK-DW4:       DW_AT_enum_class        (true)
+; CHECK:           DW_AT_name      ("E6")
+; CHECK:         DW_TAG_enumerator
+; CHECK:           DW_AT_name    ("A6")
+; CHECK-NEXT:      DW_AT_const_value     (-9223372036854775808)
+; CHECK:         DW_TAG_enumerator
+; CHECK:           DW_AT_name    ("B6")
+; CHECK-NEXT:      DW_AT_const_value     (9223372036854775807)
+
+; Test enumeration with a fixed "unsigned long long" underlying type.
+!37 = !DICompositeType(tag: DW_TAG_enumeration_type, name: "E7", file: !3, line: 57, baseType: !38, size: 64, flags: DIFlagFixedEnum, elements: !39, identifier: "_ZTS2E7")
+!38 = !DIBasicType(name: "long long unsigned int", size: 64, encoding: DW_ATE_unsigned)
+!39 = !{!40}
+!40 = !DIEnumerator(name: "A7", value: 18446744073709551615, isUnsigned: true)
+; CHECK:         DW_TAG_enumeration_type
+; CHECK-DW2-NOT:   DW_AT_type
+; CHECK-DW4:       DW_AT_type{{.*}}"long long unsigned int"
+; CHECK-DW4:       DW_AT_enum_class        (true)
+; CHECK:           DW_AT_name      ("E7")
+; CHECK:         DW_TAG_enumerator
+; CHECK:           DW_AT_name    ("A7")
+; CHECK-NEXT:      DW_AT_const_value     (18446744073709551615)
+
+; Test enumeration without a fixed underlying type. The underlying type should
+; still be present (for DWARF >= 3), but the DW_AT_enum_class attribute should
+; be absent.
+!41 = !DICompositeType(tag: DW_TAG_enumeration_type, name: "E8", file: !3, line: 63, baseType: !24, size: 32, elements: !42, identifier: "_ZTS2E8")
+!42 = !{!43, !44}
+!43 = !DIEnumerator(name: "A8", value: -128)
+!44 = !DIEnumerator(name: "B8", value: 127)
+!45 = !{!0, !46, !48, !50, !52, !54, !56, !58, !60}
+; CHECK:         DW_TAG_enumeration_type
+; CHECK-DW2-NOT:   DW_AT_type
+; CHECK-DW4:       DW_AT_type{{.*}}"int"
+; CHECK-NOT:       DW_AT_enum_class
+; CHECK:           DW_AT_name      ("E8")
+
+!46 = !DIGlobalVariableExpression(var: !47, expr: !DIExpression())
+!47 = distinct !DIGlobalVariable(name: "x1", scope: !2, file: !3, line: 12, type: !10, isLocal: false, isDefinition: true)
+!48 = !DIGlobalVariableExpression(var: !49, expr: !DIExpression())
+!49 = distinct !DIGlobalVariable(name: "x2", scope: !2, file: !3, line: 21, type: !14, isLocal: false, isDefinition: true)
+!50 = !DIGlobalVariableExpression(var: !51, expr: !DIExpression())
+!51 = distinct !DIGlobalVariable(name: "x3", scope: !2, file: !3, line: 28, type: !19, isLocal: false, isDefinition: true)
+!52 = !DIGlobalVariableExpression(var: !53, expr: !DIExpression())
+!53 = distinct !DIGlobalVariable(name: "x4", scope: !2, file: !3, line: 34, type: !23, isLocal: false, isDefinition: true)
+!54 = !DIGlobalVariableExpression(var: !55, expr: !DIExpression())
+!55 = distinct !DIGlobalVariable(name: "x5", scope: !2, file: !3, line: 41, type: !28, isLocal: false, isDefinition: true)
+!56 = !DIGlobalVariableExpression(var: !57, expr: !DIExpression())
+!57 = distinct !DIGlobalVariable(name: "x6", scope: !2, file: !3, line: 50, type: !32, isLocal: false, isDefinition: true)
+!58 = !DIGlobalVariableExpression(var: !59, expr: !DIExpression())
+!59 = distinct !DIGlobalVariable(name: "x7", scope: !2, file: !3, line: 57, type: !37, isLocal: false, isDefinition: true)
+!60 = !DIGlobalVariableExpression(var: !61, expr: !DIExpression())
+!61 = distinct !DIGlobalVariable(name: "x8", scope: !2, file: !3, line: 63, type: !41, isLocal: false, isDefinition: true)
+!62 = !{i32 2, !"Debug Info Version", i32 3}

llvm/trunk/test/DebugInfo/X86/enum-class.ll

 ; RUN: llc -O0 -mtriple=x86_64-apple-darwin %s -o %t -filetype=obj
 ; RUN: llvm-dwarfdump -v -debug-info %t | FileCheck %s
 
 source_filename = "test/DebugInfo/X86/enum-class.ll"
 
 @a = global i32 0, align 4, !dbg !0
 @b = global i64 0, align 8, !dbg !7
 @c = global i32 0, align 4, !dbg !13
 
 !llvm.dbg.cu = !{!18}
 !llvm.module.flags = !{!22}
 
 !0 = !DIGlobalVariableExpression(var: !1, expr: !DIExpression())
 !1 = !DIGlobalVariable(name: "a", scope: null, file: !2, line: 4, type: !3, isLocal: false, isDefinition: true)
 !2 = !DIFile(filename: "foo.cpp", directory: "/Users/echristo/tmp")
-!3 = !DICompositeType(tag: DW_TAG_enumeration_type, name: "A", file: !2, line: 1, baseType: !4, size: 32, align: 32, elements: !5)
+!3 = !DICompositeType(tag: DW_TAG_enumeration_type, name: "A", file: !2, line: 1, baseType: !4, size: 32, flags: DIFlagFixedEnum, align: 32, elements: !5)
 !4 = !DIBasicType(name: "int", size: 32, align: 32, encoding: DW_ATE_signed)
 !5 = !{!6}
 !6 = !DIEnumerator(name: "A1", value: 1)
 !7 = !DIGlobalVariableExpression(var: !8, expr: !DIExpression()) ; [ DW_TAG_enumerator ]
 !8 = !DIGlobalVariable(name: "b", scope: null, file: !2, line: 5, type: !9, isLocal: false, isDefinition: true)
-!9 = !DICompositeType(tag: DW_TAG_enumeration_type, name: "B", file: !2, line: 2, baseType: !10, size: 64, align: 64, elements: !11)
+!9 = !DICompositeType(tag: DW_TAG_enumeration_type, name: "B", file: !2, line: 2, baseType: !10, size: 64, flags: DIFlagFixedEnum, align: 64, elements: !11)
 !10 = !DIBasicType(name: "long unsigned int", size: 64, align: 64, encoding: DW_ATE_unsigned)
 !11 = !{!12}
 !12 = !DIEnumerator(name: "B1", value: 1) ; [ DW_TAG_enumerator ]
 !13 = !DIGlobalVariableExpression(var: !14, expr: !DIExpression())
 !14 = !DIGlobalVariable(name: "c", scope: null, file: !2, line: 6, type: !15, isLocal: false, isDefinition: true)
 !15 = !DICompositeType(tag: DW_TAG_enumeration_type, name: "C", file: !2, line: 3, size: 32, align: 32, elements: !16)
 !16 = !{!17}
 !17 = !DIEnumerator(name: "C1", value: 1) ; [ DW_TAG_enumerator ]
 !18 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus, file: !2, producer: "clang version 3.2 (trunk 157269) (llvm/trunk 157264)", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug, enums: !19, retainedTypes: !20, globals: !21, imports: !20)
 !19 = !{!3, !9, !15}
 !20 = !{}
 !21 = !{!0, !7, !13}
 !22 = !{i32 1, !"Debug Info Version", i32 3}
 
 ; CHECK: DW_TAG_enumeration_type [{{.*}}]
 ; CHECK: DW_AT_type [DW_FORM_ref4]
 ; CHECK: DW_AT_enum_class [DW_FORM_flag_present] (true)
 ; CHECK: DW_AT_name [DW_FORM_strp]      ( .debug_str[{{.*}}] = "A")
 
 ; CHECK: DW_TAG_enumeration_type [{{.*}}] *
 ; CHECK: DW_AT_type [DW_FORM_ref4]
 ; CHECK: DW_AT_enum_class [DW_FORM_flag_present] (true)
 ; CHECK: DW_AT_name [DW_FORM_strp]          ( .debug_str[{{.*}}] = "B")
 
-; CHECK: DW_TAG_enumeration_type [6]
+; CHECK: DW_TAG_enumeration_type
 ; CHECK-NOT: DW_AT_enum_class
 ; CHECK: DW_AT_name [DW_FORM_strp]      ( .debug_str[{{.*}}] = "C")

llvm/trunk/unittests/IR/MetadataTest.cpp

TEST_F(DISubrangeTest, getVariableCount) {
   EXPECT_EQ(0, N->getLowerBound());
   EXPECT_EQ("vla_expr", Count.get<DIVariable*>()->getName());
   EXPECT_EQ(N, DISubrange::get(Context, VlaExpr, 0));
 }
 
 typedef MetadataTest DIEnumeratorTest;
 
 TEST_F(DIEnumeratorTest, get) {
-  auto *N = DIEnumerator::get(Context, 7, "name");
+  auto *N = DIEnumerator::get(Context, 7, false, "name");
   EXPECT_EQ(dwarf::DW_TAG_enumerator, N->getTag());
   EXPECT_EQ(7, N->getValue());
+  EXPECT_EQ(false, N->isUnsigned());
   EXPECT_EQ("name", N->getName());
-  EXPECT_EQ(N, DIEnumerator::get(Context, 7, "name"));
+  EXPECT_EQ(N, DIEnumerator::get(Context, 7, false, "name"));
 
-  EXPECT_NE(N, DIEnumerator::get(Context, 8, "name"));
-  EXPECT_NE(N, DIEnumerator::get(Context, 7, "nam"));
+  EXPECT_NE(N, DIEnumerator::get(Context, 7, true, "name"));
+  EXPECT_NE(N, DIEnumerator::get(Context, 8, false, "name"));
+  EXPECT_NE(N, DIEnumerator::get(Context, 7, false, "nam"));
 
   TempDIEnumerator Temp = N->clone();
   EXPECT_EQ(N, MDNode::replaceWithUniqued(std::move(Temp)));
 }
 
 typedef MetadataTest DIBasicTypeTest;
 
 TEST_F(DIBasicTypeTest, get) {