[DebugInfo] Accept enumeration types without underlying inetger type present in debug info metadata

[chill]

Summary

Workaround for not yet explained buildbot issue.

http://green.lab.llvm.org/green/job/clang-stage2-Rthinlto/8694/console

[chill]

I'll add a test tomorrow.

[rogfer01]

lib/CodeGen/AsmPrinter/DwarfUnit.cpp

1433 ↗

(On Diff #134267)

I think if (DTy) suits more the existing coding standard elsewhere in this file.

[vsapsai]

Roger has a good point, I agree that if (DTy) is more consistent with the rest of the code, please change it when commit. Code looks good to me from the standpoint of fixing the build.

[chill]

Minor style change and added a test.

[vsapsai]

Thanks for the fix.

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

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)
+  if (DTy) {
+    if (DD->getDwarfVersion() >= 3)
       addType(Buffer, DTy);
-  if (DD->getDwarfVersion() >= 4 && (CTy->getFlags() & DINode::FlagFixedEnum)) {
-    assert(DTy);
+    if (DD->getDwarfVersion() >= 4 && (CTy->getFlags() & DINode::FlagFixedEnum))
       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) {

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

 
 ; 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")
 
+; Test enumeration without a fixed underlying type, but with the DIFlagFixedEnum
+; set. The DW_AT_enum_class attribute should be absent. This behaviour is
+; intented to keep compatibilty with existing DWARF consumers, which may imply
+; the type is present whenever DW_AT_enum_class is set.
+!63 = !DICompositeType(tag: DW_TAG_enumeration_type, name: "E9", file: !3, line: 63, size: 32, flags: DIFlagFixedEnum,  elements: !64, identifier: "_ZTS2E9")
+!64 = !{!65, !66}
+!65 = !DIEnumerator(name: "A9", value: -128)
+!66 = !DIEnumerator(name: "B9", value: 127)
+; CHECK:     DW_TAG_enumeration_type
+; CHECK-NOT:   DW_AT_type
+; CHECK-NOT:   DW_AT_enum_class
+; CHECK:       DW_AT_name      ("E9")
+
+!45 = !{!0, !46, !48, !50, !52, !54, !56, !58, !60, !67}
 !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)
+!67 = !DIGlobalVariableExpression(var: !68, expr: !DIExpression())
+!68 = distinct !DIGlobalVariable(name: "x9", scope: !2, file: !3, line: 63, type: !63, isLocal: false, isDefinition: true)
 !62 = !{i32 2, !"Debug Info Version", i32 3}