DebugInfo: make DW_TAG_atomic_type valid

[vleschuk]

Summary

DW_TAG_atomic_type was already included in Dwarf.defs and emitted correctly, however Verifier didn't recognize it as valid. Thus we introduce the following changes:

• Make DW_TAG_atomic_type valid tag for IR and DWARF (enabled only with -gdwarf-5)
• Add it to related docs
• Add DebugInfo test

[aprantl]

include/llvm/DebugInfo/CodeView/CodeView.h

285

Can someone familiar with the CodeView code check this?

test/DebugInfo/X86/atomic_c11.ll

12

Please check for the entire type tree: otherwise output like (hypothetical example)

error: unknown token: DW_TAG_atomic_type

would match, too.

17

Could you include a comment with the source this was generated from?

31

This seems unnecessary for the test?

[vleschuk]

test/DebugInfo/X86/atomic_c11.ll

12

WIll do.

17

It's included, see lines 4-7:

; Generated by clang -c -g -std=c11 -S -emit-llvm from the following C11 source
;
; _Atomic const int i;
;

[aprantl]

Should we restrict output of DW_TAG_atomic_type to -gdwarf-5 only?
In contrast to an attribute, a consumer can't really ignore the tag if it doesn't understand it.

[rnk]

lib/CodeGen/AsmPrinter/CodeViewDebug.cpp

1412

Let's ignore _Atomic qualifiers for now. I emailed Dave Bartolomeo about reserving that bit, and eventually getting MS debuggers to print the _Atomic qualifier, but until we hear back, I don't want to start emitting it. Leave a FIXME to follow up on it.

You would also want to update lib/DebugInfo/CodeView/EnumTables.cpp to dump this properly, and add a basic test to test/DebugInfo/COFF/ similar to the one you have.

[vleschuk]

• Reverted CodeView-related changes, replaced with TODO comments instead
• Made DW_TAG_atomic_type available only with DwarfVersion >= 5 (otherwise do not emit it)
• Updated test to match all type tree (also changed dwarf version in test IR to 5)

[aprantl]

Thanks, LGTM with inline feedback addressed.

test/DebugInfo/X86/atomic_c11.ll

35

We now also need a second copy of this testcase with "Dwarf Version"=4 that checks that the we see through the atomic type on older versions.

docs/LangRef.rst

.. code-block:: text
   DW_TAG_reference_type     = 16
   DW_TAG_typedef            = 22
   DW_TAG_inheritance        = 28
   DW_TAG_ptr_to_member_type = 31
   DW_TAG_const_type         = 38
   DW_TAG_friend             = 42
   DW_TAG_volatile_type      = 53
   DW_TAG_restrict_type      = 55
+  DW_TAG_atomic_type        = 71
 
 .. _DIDerivedTypeMember:
 
 ``DW_TAG_member`` is used to define a member of a :ref:`composite type
 <DICompositeType>`. The type of the member is the ``baseType:``. The
 ``offset:`` is the member's bit offset.  If the composite type has an ODR
 ``identifier:`` and does not set ``flags: DIFwdDecl``, then the member is
 uniqued based only on its ``name:`` and ``scope:``.
 
 ``DW_TAG_inheritance`` and ``DW_TAG_friend`` are used in the ``elements:``
 field of :ref:`composite types <DICompositeType>` to describe parents and
 friends.
 
 ``DW_TAG_typedef`` is used to provide a name for the ``baseType:``.
 
 ``DW_TAG_pointer_type``, ``DW_TAG_reference_type``, ``DW_TAG_const_type``,
-``DW_TAG_volatile_type`` and ``DW_TAG_restrict_type`` are used to qualify the
-``baseType:``.
+``DW_TAG_volatile_type``, ``DW_TAG_restrict_type`` and ``DW_TAG_atomic_type``
+are used to qualify the ``baseType:``.
 
 Note that the ``void *`` type is expressed as a type derived from NULL.
 
 .. _DICompositeType:
 
 DICompositeType
 """""""""""""""
 

docs/SourceLevelDebugging.rst

 * DW_TAG_subrange_type
 * DW_TAG_base_type
 * DW_TAG_const_type
 * DW_TAG_file_type
 * DW_TAG_namelist
 * DW_TAG_packed_type
 * DW_TAG_volatile_type
 * DW_TAG_restrict_type
+* DW_TAG_atomic_type
 * DW_TAG_interface_type
 * DW_TAG_unspecified_type
 * DW_TAG_shared_type
 
 Only entries with a ``DW_AT_name`` attribute are included, and the entry must
 not be a forward declaration (``DW_AT_declaration`` attribute with a non-zero
 value).  For example, using the following code:
 

include/llvm/DebugInfo/CodeView/CodeView.h

enum class MethodOptions : uint16_t {
   NoInherit = 0x0040,
   NoConstruct = 0x0080,
   CompilerGenerated = 0x0100,
   Sealed = 0x0200
 };
 CV_DEFINE_ENUM_CLASS_FLAGS_OPERATORS(MethodOptions)
 
 /// Equivalent to CV_modifier_t.
+/// TODO: Add flag for _Atomic modifier
 enum class ModifierOptions : uint16_t {
   None = 0x0000,
   Const = 0x0001,
   Volatile = 0x0002,
   Unaligned = 0x0004
 };
 CV_DEFINE_ENUM_CLASS_FLAGS_OPERATORS(ModifierOptions)
 
 enum class ModuleSubstreamKind : uint32_t {
   None = 0,
   Symbols = 0xf1,
   Lines = 0xf2,
   StringTable = 0xf3,
   FileChecksums = 0xf4,

lib/CodeGen/AsmPrinter/CodeViewDebug.cpp

case dwarf::DW_TAG_pointer_type:
     LLVM_FALLTHROUGH;
   case dwarf::DW_TAG_reference_type:
   case dwarf::DW_TAG_rvalue_reference_type:
     return lowerTypePointer(cast<DIDerivedType>(Ty));
   case dwarf::DW_TAG_ptr_to_member_type:
     return lowerTypeMemberPointer(cast<DIDerivedType>(Ty));
   case dwarf::DW_TAG_const_type:
   case dwarf::DW_TAG_volatile_type:
+  // TODO: add support for DW_TAG_atomic_type here
     return lowerTypeModifier(cast<DIDerivedType>(Ty));
   case dwarf::DW_TAG_subroutine_type:
     if (ClassTy) {
       // The member function type of a member function pointer has no
       // ThisAdjustment.
       return lowerTypeMemberFunction(cast<DISubroutineType>(Ty), ClassTy,
                                      /*ThisAdjustment=*/0);
     }
static CallingConvention dwarfCCToCodeView(unsigned DwarfCC) {
   return CallingConvention::NearC;
 }
 
 TypeIndex CodeViewDebug::lowerTypeModifier(const DIDerivedType *Ty) {
   ModifierOptions Mods = ModifierOptions::None;
   bool IsModifier = true;
   const DIType *BaseTy = Ty;
   while (IsModifier && BaseTy) {
-    // FIXME: Need to add DWARF tag for __unaligned.
+    // FIXME: Need to add DWARF tags for __unaligned and _Atomic
     switch (BaseTy->getTag()) {
     case dwarf::DW_TAG_const_type:
       Mods |= ModifierOptions::Const;
       break;
     case dwarf::DW_TAG_volatile_type:
       Mods |= ModifierOptions::Volatile;
       break;
     default:
       IsModifier = false;
       break;
     }
     if (IsModifier)
       BaseTy = cast<DIDerivedType>(BaseTy)->getBaseType().resolve();
   }
   TypeIndex ModifiedTI = getTypeIndex(BaseTy);
   return TypeTable.writeKnownType(ModifierRecord(ModifiedTI, Mods));
 }

lib/CodeGen/AsmPrinter/DebugHandlerBase.cpp

uint64_t DebugHandlerBase::getBaseTypeSize(const DITypeRef TyRef) {
   DIDerivedType *DDTy = dyn_cast<DIDerivedType>(Ty);
   if (!DDTy)
     return Ty->getSizeInBits();
 
   unsigned Tag = DDTy->getTag();
 
   if (Tag != dwarf::DW_TAG_member && Tag != dwarf::DW_TAG_typedef &&
       Tag != dwarf::DW_TAG_const_type && Tag != dwarf::DW_TAG_volatile_type &&
-      Tag != dwarf::DW_TAG_restrict_type)
+      Tag != dwarf::DW_TAG_restrict_type && Tag != dwarf::DW_TAG_atomic_type)
     return DDTy->getSizeInBits();
 
   DIType *BaseType = DDTy->getBaseType().resolve();
 
   assert(BaseType && "Unexpected invalid base type");
 
   // If this is a derived type, go ahead and get the base type, unless it's a
   // reference then it's just the size of the field. Pointer types have no need

lib/CodeGen/AsmPrinter/DwarfUnit.cpp

if (auto *DTy = dyn_cast<DIDerivedType>(Ty)) {
     // dbg.values.
     if (T == dwarf::DW_TAG_pointer_type ||
         T == dwarf::DW_TAG_ptr_to_member_type ||
         T == dwarf::DW_TAG_reference_type ||
         T == dwarf::DW_TAG_rvalue_reference_type)
       return true;
     assert(T == dwarf::DW_TAG_typedef || T == dwarf::DW_TAG_const_type ||
            T == dwarf::DW_TAG_volatile_type ||
-           T == dwarf::DW_TAG_restrict_type);
+           T == dwarf::DW_TAG_restrict_type || T == dwarf::DW_TAG_atomic_type);
     DITypeRef Deriv = DTy->getBaseType();
     assert(Deriv && "Expected valid base type");
     return isUnsignedDIType(DD, DD->resolve(Deriv));
   }
 
   auto *BTy = cast<DIBasicType>(Ty);
   unsigned Encoding = BTy->getEncoding();
   assert((Encoding == dwarf::DW_ATE_unsigned ||
if (!TyNode)
     return nullptr;
 
   auto *Ty = cast<DIType>(TyNode);
 
   // DW_TAG_restrict_type is not supported in DWARF2
   if (Ty->getTag() == dwarf::DW_TAG_restrict_type && DD->getDwarfVersion() <= 2)
     return getOrCreateTypeDIE(resolve(cast<DIDerivedType>(Ty)->getBaseType()));
 
+  // DW_TAG_atomic_type is not supported in DWARF < 5
+  if (Ty->getTag() == dwarf::DW_TAG_atomic_type && DD->getDwarfVersion() < 5)
+    return getOrCreateTypeDIE(resolve(cast<DIDerivedType>(Ty)->getBaseType()));
+
   // Construct the context before querying for the existence of the DIE in case
   // such construction creates the DIE.
   auto *Context = resolve(Ty->getScope());
   DIE *ContextDIE = getOrCreateContextDIE(Context);
   assert(ContextDIE);
 
   if (DIE *TyDIE = getDIE(Ty))
     return TyDIE;

lib/IR/Verifier.cpp

void Verifier::visitDIDerivedType(const DIDerivedType &N) {
   AssertDI(N.getTag() == dwarf::DW_TAG_typedef ||
                N.getTag() == dwarf::DW_TAG_pointer_type ||
                N.getTag() == dwarf::DW_TAG_ptr_to_member_type ||
                N.getTag() == dwarf::DW_TAG_reference_type ||
                N.getTag() == dwarf::DW_TAG_rvalue_reference_type ||
                N.getTag() == dwarf::DW_TAG_const_type ||
                N.getTag() == dwarf::DW_TAG_volatile_type ||
                N.getTag() == dwarf::DW_TAG_restrict_type ||
+               N.getTag() == dwarf::DW_TAG_atomic_type ||
                N.getTag() == dwarf::DW_TAG_member ||
                N.getTag() == dwarf::DW_TAG_inheritance ||
                N.getTag() == dwarf::DW_TAG_friend,
            "invalid tag", &N);
   if (N.getTag() == dwarf::DW_TAG_ptr_to_member_type) {
     AssertDI(isType(N.getRawExtraData()), "invalid pointer to member type", &N,
              N.getRawExtraData());
   }

test/DebugInfo/X86/atomic_c11.ll

+; RUN: %llc_dwarf -filetype=obj < %s | llvm-dwarfdump -debug-dump=info - | FileCheck %s
+; REQUIRES: object-emission
+
+; Generated by clang -c -g -std=c11 -S -emit-llvm from the following C11 source
+;
+; _Atomic const int i;
+;
+
+; CHECK: DW_TAG_variable
+; CHECK: DW_TAG_const_type
+; CHECK: DW_TAG_atomic_type
+; CHECK-NOT: NULL
+; CHECK: DW_TAG_base_type
+
+; ModuleID = 'atomic.c'
+source_filename = "atomic.c"
+target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
+target triple = "x86_64-unknown-linux-gnu"
+
+@i = common global i32 0, align 4, !dbg !0
+
+!llvm.dbg.cu = !{!1}
+!llvm.module.flags = !{!9, !10}
+!llvm.ident = !{!11}
+
+!0 = distinct !DIGlobalVariable(name: "i", scope: !1, file: !5, line: 1, type: !6, isLocal: false, isDefinition: true)
+!1 = distinct !DICompileUnit(language: DW_LANG_C99, file: !2, producer: "clang version 4.0.0 (http://llvm.org/git/clang.git cd238117e3a8a57271a82d0bb03d6df6ad8f073e) (http://llvm.org/git/llvm.git 9fd063832c1541aad3907cd60ac344d36997905f)", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug, enums: !3, globals: !4)
+!2 = !DIFile(filename: "atomic.c", directory: "/tmp")
+!3 = !{}
+!4 = !{!0}
+!5 = !DIFile(filename: "atomic.c", directory: "/tmp")
+!6 = !DIDerivedType(tag: DW_TAG_const_type, baseType: !7)
+!7 = !DIDerivedType(tag: DW_TAG_atomic_type, baseType: !8)
+!8 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
+!9 = !{i32 2, !"Dwarf Version", i32 5}
+!10 = !{i32 2, !"Debug Info Version", i32 3}
+!11 = !{!"clang version 4.0.0 (http://llvm.org/git/clang.git cd238117e3a8a57271a82d0bb03d6df6ad8f073e) (http://llvm.org/git/llvm.git 9fd063832c1541aad3907cd60ac344d36997905f)"}

tools/dsymutil/DwarfLinker.cpp

static bool isTypeTag(uint16_t Tag) {
   case dwarf::DW_TAG_base_type:
   case dwarf::DW_TAG_const_type:
   case dwarf::DW_TAG_constant:
   case dwarf::DW_TAG_file_type:
   case dwarf::DW_TAG_namelist:
   case dwarf::DW_TAG_packed_type:
   case dwarf::DW_TAG_volatile_type:
   case dwarf::DW_TAG_restrict_type:
+  case dwarf::DW_TAG_atomic_type:
   case dwarf::DW_TAG_interface_type:
   case dwarf::DW_TAG_unspecified_type:
   case dwarf::DW_TAG_shared_type:
     return true;
   default:
     break;
   }
   return false;