[lldb] Support for DWARF-5 atomic types

[teemperor]

Summary

This patch adds support for atomic types (DW_TAG_atomic_type) to LLDB. It's mostly just filling out all the switch-statements that didn't implement Atomic case with the usual boilerplate.

Thanks Pavel for writing the test case.

[labath]

Looks pretty straight-forward. When I wrote this test, I was expecting that an "atomic struct" would be "invalid input". Given that this is actually a thing, it would be nice to add some members to the struct to show that can be displayed too, but I can also do that afterwards...

lldb/test/Shell/SymbolFile/DWARF/dwarf5-atomic.s

25–26

Looks like I didn't remote tabs here. Could you please fix this before submitting?

[teemperor]

• Fix test formatting.

lldb/include/lldb/Symbol/ClangASTContext.h

public:
   CompilerType GetPointerType(lldb::opaque_compiler_type_t type) override;
 
   CompilerType
   GetLValueReferenceType(lldb::opaque_compiler_type_t type) override;
 
   CompilerType
   GetRValueReferenceType(lldb::opaque_compiler_type_t type) override;
 
+  CompilerType GetAtomicType(lldb::opaque_compiler_type_t type) override;
+
   CompilerType AddConstModifier(lldb::opaque_compiler_type_t type) override;
 
   CompilerType AddVolatileModifier(lldb::opaque_compiler_type_t type) override;
 
   CompilerType AddRestrictModifier(lldb::opaque_compiler_type_t type) override;
 
   CompilerType CreateTypedef(lldb::opaque_compiler_type_t type,
                              const char *name,

lldb/include/lldb/Symbol/CompilerType.h

public:
   // invalid type.
   CompilerType AddConstModifier() const;
 
   // Return a new CompilerType adds a volatile modifier to this type if this
   // type is valid and the type system supports volatile modifiers, else return
   // an invalid type.
   CompilerType AddVolatileModifier() const;
 
+  // Return a new CompilerType that is the atomic type of this type. If this
+  // type is not valid or the type system doesn't support atomic types, this
+  // returns an invalid type.
+  CompilerType GetAtomicType() const;
+
   // Return a new CompilerType adds a restrict modifier to this type if this
   // type is valid and the type system supports restrict modifiers, else return
   // an invalid type.
   CompilerType AddRestrictModifier() const;
 
   // Create a typedef to this type using "name" as the name of the typedef this
   // type is valid and the type system supports typedefs, else return an
   // invalid type.

lldb/include/lldb/Symbol/Type.h

eEncodingIsVolatileUID, ///< This type is the type whose UID is
                             /// m_encoding_uid with the volatile qualifier added
     eEncodingIsTypedefUID,  ///< This type is pointer to a type whose UID is
                             /// m_encoding_uid
     eEncodingIsPointerUID,  ///< This type is pointer to a type whose UID is
                             /// m_encoding_uid
     eEncodingIsLValueReferenceUID, ///< This type is L value reference to a type
                                    /// whose UID is m_encoding_uid
     eEncodingIsRValueReferenceUID, ///< This type is R value reference to a type
-                                   /// whose UID is m_encoding_uid
+                                   /// whose UID is m_encoding_uid,
+    eEncodingIsAtomicUID,          ///< This type is the type whose UID is
+                                   /// m_encoding_uid as an atomic type.
     eEncodingIsSyntheticUID
   };
 
   enum class ResolveState : unsigned char {
     Unresolved = 0,
     Forward = 1,
     Layout = 2,
     Full = 3

lldb/include/lldb/Symbol/TypeSystem.h

public:
   virtual CompilerType GetPointerType(lldb::opaque_compiler_type_t type) = 0;
 
   virtual CompilerType
   GetLValueReferenceType(lldb::opaque_compiler_type_t type);
 
   virtual CompilerType
   GetRValueReferenceType(lldb::opaque_compiler_type_t type);
 
+  virtual CompilerType GetAtomicType(lldb::opaque_compiler_type_t type);
+
   virtual CompilerType AddConstModifier(lldb::opaque_compiler_type_t type);
 
   virtual CompilerType AddVolatileModifier(lldb::opaque_compiler_type_t type);
 
   virtual CompilerType AddRestrictModifier(lldb::opaque_compiler_type_t type);
 
   virtual CompilerType CreateTypedef(lldb::opaque_compiler_type_t type,
                                      const char *name,

lldb/source/Plugins/SymbolFile/DWARF/DWARFASTParserClang.cpp

TypeSP DWARFASTParserClang::ParseTypeFromDWARF(const SymbolContext &sc,
   case DW_TAG_typedef:
   case DW_TAG_base_type:
   case DW_TAG_pointer_type:
   case DW_TAG_reference_type:
   case DW_TAG_rvalue_reference_type:
   case DW_TAG_const_type:
   case DW_TAG_restrict_type:
   case DW_TAG_volatile_type:
+  case DW_TAG_atomic_type:
   case DW_TAG_unspecified_type: {
     type_sp = ParseTypeModifier(sc, die, attrs);
     break;
   }
 
   case DW_TAG_structure_type:
   case DW_TAG_union_type:
   case DW_TAG_class_type: {
case DW_TAG_const_type:
     encoding_data_type = Type::eEncodingIsConstUID;
     break;
   case DW_TAG_restrict_type:
     encoding_data_type = Type::eEncodingIsRestrictUID;
     break;
   case DW_TAG_volatile_type:
     encoding_data_type = Type::eEncodingIsVolatileUID;
     break;
+  case DW_TAG_atomic_type:
+    encoding_data_type = Type::eEncodingIsAtomicUID;
+    break;
   }
 
   if (!clang_type && (encoding_data_type == Type::eEncodingIsPointerUID ||
                       encoding_data_type == Type::eEncodingIsTypedefUID)) {
     if (tag == DW_TAG_pointer_type) {
       DWARFDIE target_die = die.GetReferencedDIE(DW_AT_type);
 
       if (target_die.GetAttributeValueAsUnsigned(DW_AT_APPLE_block, 0)) {

lldb/source/Symbol/ClangASTContext.cpp

return CompilerType(this, llvm::cast<clang::TypeOfExprType>(qual_type)
                                   ->getType()
                                   .getAsOpaquePtr())
         .GetTypeInfo(pointee_or_element_clang_type);
   case clang::Type::TypeOf:
     return CompilerType(this, llvm::cast<clang::TypeOfType>(qual_type)
                                   ->getUnderlyingType()
                                   .getAsOpaquePtr())
         .GetTypeInfo(pointee_or_element_clang_type);
+  case clang::Type::Atomic:
+    return CompilerType(this, llvm::cast<clang::AtomicType>(qual_type)
+                                  ->getValueType()
+                                  .getAsOpaquePtr())
+        .GetTypeInfo(pointee_or_element_clang_type);
   case clang::Type::UnresolvedUsing:
     return 0;
 
   case clang::Type::ExtVector:
   case clang::Type::Vector: {
     uint32_t vector_type_flags = eTypeHasChildren | eTypeIsVector;
     const clang::VectorType *vector_type = llvm::dyn_cast<clang::VectorType>(
         qual_type->getCanonicalTypeInternal());
ClangASTContext::GetRValueReferenceType(lldb::opaque_compiler_type_t type) {
   if (type)
     return CompilerType(this, getASTContext()
                                   ->getRValueReferenceType(GetQualType(type))
                                   .getAsOpaquePtr());
   else
     return CompilerType();
 }
 
+CompilerType ClangASTContext::GetAtomicType(lldb::opaque_compiler_type_t type) {
+  if (!type)
+    return CompilerType();
+  return CompilerType(
+      this, getASTContext()->getAtomicType(GetQualType(type)).getAsOpaquePtr());
+}
+
 CompilerType
 ClangASTContext::AddConstModifier(lldb::opaque_compiler_type_t type) {
   if (type) {
     clang::QualType result(GetQualType(type));
     result.addConst();
     return CompilerType(this, result.getAsOpaquePtr());
   }
   return CompilerType();
return CompilerType(this, llvm::cast<clang::TypeOfType>(qual_type)
                                   ->getUnderlyingType()
                                   .getAsOpaquePtr())
         .GetFormat();
   case clang::Type::Decltype:
     return CompilerType(this, llvm::cast<clang::DecltypeType>(qual_type)
                                   ->getUnderlyingType()
                                   .getAsOpaquePtr())
         .GetFormat();
+  case clang::Type::Atomic:
+    return CompilerType(this, llvm::cast<clang::AtomicType>(qual_type)
+                                  ->getValueType()
+                                  .getAsOpaquePtr())
+        .GetFormat();
   case clang::Type::DependentSizedArray:
   case clang::Type::DependentSizedExtVector:
   case clang::Type::UnresolvedUsing:
   case clang::Type::Attributed:
   case clang::Type::TemplateTypeParm:
   case clang::Type::SubstTemplateTypeParm:
   case clang::Type::SubstTemplateTypeParmPack:
   case clang::Type::InjectedClassName:
   case clang::Type::DependentName:
   case clang::Type::DependentTemplateSpecialization:
   case clang::Type::PackExpansion:
   case clang::Type::ObjCObject:
 
   case clang::Type::TemplateSpecialization:
   case clang::Type::DeducedTemplateSpecialization:
-  case clang::Type::Atomic:
   case clang::Type::Adjusted:
   case clang::Type::Pipe:
     break;
 
   // pointer type decayed from an array or function type.
   case clang::Type::Decayed:
     break;
   case clang::Type::ObjCTypeParam:

lldb/source/Symbol/CompilerType.cpp

 
 CompilerType CompilerType::GetRValueReferenceType() const {
   if (IsValid())
     return m_type_system->GetRValueReferenceType(m_type);
   else
     return CompilerType();
 }
 
+CompilerType CompilerType::GetAtomicType() const {
+  if (IsValid())
+    return m_type_system->GetAtomicType(m_type);
+  return CompilerType();
+}
+
 CompilerType CompilerType::AddConstModifier() const {
   if (IsValid())
     return m_type_system->AddConstModifier(m_type);
   else
     return CompilerType();
 }
 
 CompilerType CompilerType::AddVolatileModifier() const {

lldb/source/Symbol/Type.cpp

case eEncodingIsConstUID:
       s->PutCString(" (unresolved const type)");
       break;
     case eEncodingIsRestrictUID:
       s->PutCString(" (unresolved restrict type)");
       break;
     case eEncodingIsVolatileUID:
       s->PutCString(" (unresolved volatile type)");
       break;
+    case eEncodingIsAtomicUID:
+      s->PutCString(" (unresolved atomic type)");
+      break;
     case eEncodingIsTypedefUID:
       s->PutCString(" (unresolved typedef)");
       break;
     case eEncodingIsPointerUID:
       s->PutCString(" (unresolved pointer)");
       break;
     case eEncodingIsLValueReferenceUID:
       s->PutCString(" (unresolved L value reference)");
case eEncodingIsConstUID:
       s->PutCString(" (unresolved const type)");
       break;
     case eEncodingIsRestrictUID:
       s->PutCString(" (unresolved restrict type)");
       break;
     case eEncodingIsVolatileUID:
       s->PutCString(" (unresolved volatile type)");
       break;
+    case eEncodingIsAtomicUID:
+      s->PutCString(" (unresolved atomic type)");
+      break;
     case eEncodingIsTypedefUID:
       s->PutCString(" (unresolved typedef)");
       break;
     case eEncodingIsPointerUID:
       s->PutCString(" (unresolved pointer)");
       break;
     case eEncodingIsLValueReferenceUID:
       s->PutCString(" (unresolved L value reference)");
llvm::Optional<uint64_t> Type::GetByteSize() {
   switch (m_encoding_uid_type) {
   case eEncodingInvalid:
   case eEncodingIsSyntheticUID:
     break;
   case eEncodingIsUID:
   case eEncodingIsConstUID:
   case eEncodingIsRestrictUID:
   case eEncodingIsVolatileUID:
+  case eEncodingIsAtomicUID:
   case eEncodingIsTypedefUID: {
     Type *encoding_type = GetEncodingType();
     if (encoding_type)
       if (llvm::Optional<uint64_t> size = encoding_type->GetByteSize()) {
         m_byte_size = *size;
         m_byte_size_has_value = true;
         return m_byte_size;
       }
if (encoding_type) {
             encoding_type->GetForwardCompilerType().AddRestrictModifier();
         break;
 
       case eEncodingIsVolatileUID:
         m_compiler_type =
             encoding_type->GetForwardCompilerType().AddVolatileModifier();
         break;
 
+      case eEncodingIsAtomicUID:
+        m_compiler_type =
+            encoding_type->GetForwardCompilerType().GetAtomicType();
+        break;
+
       case eEncodingIsTypedefUID:
         m_compiler_type = encoding_type->GetForwardCompilerType().CreateTypedef(
             m_name.AsCString("__lldb_invalid_typedef_name"),
             GetSymbolFile()->GetDeclContextContainingUID(GetID()));
         m_name.Clear();
         break;
 
       case eEncodingIsPointerUID:
if (encoding_type) {
         case eEncodingIsRestrictUID:
           m_compiler_type = void_compiler_type.AddRestrictModifier();
           break;
 
         case eEncodingIsVolatileUID:
           m_compiler_type = void_compiler_type.AddVolatileModifier();
           break;
 
+        case eEncodingIsAtomicUID:
+          m_compiler_type = void_compiler_type.GetAtomicType();
+          break;
+
         case eEncodingIsTypedefUID:
           m_compiler_type = void_compiler_type.CreateTypedef(
               m_name.AsCString("__lldb_invalid_typedef_name"),
               GetSymbolFile()->GetDeclContextContainingUID(GetID()));
           break;
 
         case eEncodingIsPointerUID:
           m_compiler_type = void_compiler_type.GetPointerType();

lldb/source/Symbol/TypeSystem.cpp

TypeSystem::GetLValueReferenceType(lldb::opaque_compiler_type_t type) {
   return CompilerType();
 }
 
 CompilerType
 TypeSystem::GetRValueReferenceType(lldb::opaque_compiler_type_t type) {
   return CompilerType();
 }
 
+CompilerType TypeSystem::GetAtomicType(lldb::opaque_compiler_type_t type) {
+  return CompilerType();
+}
+
 CompilerType TypeSystem::AddConstModifier(lldb::opaque_compiler_type_t type) {
   return CompilerType();
 }
 
 CompilerType
 TypeSystem::AddVolatileModifier(lldb::opaque_compiler_type_t type) {
   return CompilerType();
 }

lldb/test/Shell/SymbolFile/DWARF/dwarf5-atomic.s

+# REQUIRES: x86
+
+# RUN: llvm-mc -triple=x86_64-pc-linux -filetype=obj %s > %t
+# RUN: %lldb %t -o "target variable integer structure" -o exit | FileCheck %s
+
+# CHECK: (_Atomic(int)) integer = 14159
+# CHECK: (_Atomic(struct_type)) structure = {}
+
+        .data
+integer:
+        .long 14159
+structure:
+        .byte 0
+
+        .section        .debug_abbrev,"",@progbits
+        .byte   1                       # Abbreviation Code
+        .byte   17                      # DW_TAG_compile_unit
+        .byte   1                       # DW_CHILDREN_yes
+        .byte   37                      # DW_AT_producer
+        .byte   8                       # DW_FORM_string
+        .byte   19                      # DW_AT_language
+        .byte   5                       # DW_FORM_data2
+        .byte   0                       # EOM(1)
+        .byte   0                       # EOM(2)
+        .byte   2                       # Abbreviation Code
+        .byte   52                      # DW_TAG_variable
+        .byte   0                       # DW_CHILDREN_no
+        .byte   3                       # DW_AT_name
+        .byte   8                       # DW_FORM_string
+        .byte   73                      # DW_AT_type
+        .byte   19                      # DW_FORM_ref4
+        .byte   2                       # DW_AT_location
+        .byte   24                      # DW_FORM_exprloc
+        .byte   0                       # EOM(1)
+        .byte   0                       # EOM(2)
+        .byte   3                       # Abbreviation Code
+        .byte   71                      # DW_TAG_atomic_type
+        .byte   0                       # DW_CHILDREN_no
+        .byte   73                      # DW_AT_type
+        .byte   19                      # DW_FORM_ref4
+        .byte   0                       # EOM(1)
+        .byte   0                       # EOM(2)
+        .byte   4                       # Abbreviation Code
+        .byte   36                      # DW_TAG_base_type
+        .byte   0                       # DW_CHILDREN_no
+        .byte   3                       # DW_AT_name
+        .byte   8                       # DW_FORM_string
+        .byte   62                      # DW_AT_encoding
+        .byte   11                      # DW_FORM_data1
+        .byte   11                      # DW_AT_byte_size
+        .byte   11                      # DW_FORM_data1
+        .byte   0                       # EOM(1)
+        .byte   0                       # EOM(2)
+        .byte   5                       # Abbreviation Code
+        .byte   19                      # DW_TAG_structure_type
+        .byte   0                       # DW_CHILDREN_no
+        .byte   3                       # DW_AT_name
+        .byte   8                       # DW_FORM_string
+        .byte   11                      # DW_AT_byte_size
+        .byte   11                      # DW_FORM_data1
+        .byte   0                       # EOM(1)
+        .byte   0                       # EOM(2)
+        .byte   0                       # EOM(3)
+
+        .section        .debug_info,"",@progbits
+.Lcu_begin0:
+        .long   .Ldebug_info_end0-.Ldebug_info_start0 # Length of Unit
+.Ldebug_info_start0:
+        .short  5                       # DWARF version number
+        .byte   1                       # DWARF Unit Type
+        .byte   8                       # Address Size (in bytes)
+        .long   .debug_abbrev           # Offset Into Abbrev. Section
+        .byte   1                       # Abbrev [1] 0xb:0x50 DW_TAG_compile_unit
+        .asciz  "Hand-written DWARF"    # DW_AT_producer
+        .short  12                      # DW_AT_language
+        .byte   2                       # Abbrev [2] DW_TAG_variable
+        .asciz  "integer"               # DW_AT_name
+        .long   .Latomic_int            # DW_AT_type
+        .byte   9                       # DW_AT_location
+        .byte   3
+        .quad   integer
+        .byte   2                       # Abbrev [2] DW_TAG_variable
+        .asciz  "structure"             # DW_AT_name
+        .long   .Latomic_struct         # DW_AT_type
+        .byte   9                       # DW_AT_location
+        .byte   3
+        .quad   structure
+.Latomic_int:
+        .byte   3                       # Abbrev [3] DW_TAG_atomic_type
+        .long   .Lint                   # DW_AT_type
+.Lint:
+        .byte   4                       # Abbrev [4] 0x53:0x7 DW_TAG_base_type
+        .asciz  "int"                   # DW_AT_name
+        .byte   5                       # DW_AT_encoding
+        .byte   4                       # DW_AT_byte_size
+.Latomic_struct:
+        .byte   3                       # Abbrev [3] DW_TAG_atomic_type
+        .long   .Lstruct                # DW_AT_type
+.Lstruct:
+        .byte   5                       # Abbrev [5] DW_TAG_structure_type
+        .asciz  "struct_type"           # DW_AT_name
+        .byte   0                       # DW_AT_byte_size
+        .byte   0                       # End Of Children Mark
+.Ldebug_info_end0: