[lldb] "See through" atomic types in ClangASTContext

[labath]

Summary

This enables us to display the contents of atomic structs. Calling the
removal of _Atomic "desugaring" is not fully correct as it does more
than remove sugar, but it is the right thing to do for most of the
things that we care about. We can change this back once we decide to
support atomic types more comprehensively.

[teemperor]

LGTM beside my inline comment about the function name.

lldb/source/Symbol/ClangASTContext.cpp

2484

In this case I would rename it to something like getUnderlyingType, unpackType, removeWrappingTypes or something like that. We shouldn't have our own definition of 'desugar' that differs from Clang's definition.

[labath]

rename to RemoveWrappingTypes

lldb/source/Symbol/ClangASTContext.cpp

 ClangASTContext::GetDeclContextForType(const CompilerType &type) {
   return GetDeclContextForType(ClangUtil::GetQualType(type));
 }
 
 /// Aggressively desugar the provided type, skipping past various kinds of
 /// syntactic sugar and other constructs one typically wants to ignore.
 /// The \p mask argument allows one to skip certain kinds of simplifications,
 /// when one wishes to handle a certain kind of type directly.
-static QualType Desugar(QualType type,
-                        ArrayRef<clang::Type::TypeClass> mask = {}) {
+static QualType
+RemoveWrappingTypes(QualType type, ArrayRef<clang::Type::TypeClass> mask = {}) {
   while (true) {
     if (find(mask, type->getTypeClass()) != mask.end())
       return type;
     switch (type->getTypeClass()) {
+    // This is not fully correct as _Atomic is more than sugar, but it is
+    // sufficient for the purposes we care about.
+    case clang::Type::Atomic:
+      type = cast<clang::AtomicType>(type)->getValueType();
+      break;
     case clang::Type::Auto:
     case clang::Type::Elaborated:
     case clang::Type::Paren:
     case clang::Type::Typedef:
       type = type->getLocallyUnqualifiedSingleStepDesugaredType();
       break;
     default:
       return type;
     }
   }
 }
 
 clang::DeclContext *
 ClangASTContext::GetDeclContextForType(clang::QualType type) {
   if (type.isNull())
     return nullptr;
 
-  clang::QualType qual_type = Desugar(type.getCanonicalType());
+  clang::QualType qual_type = RemoveWrappingTypes(type.getCanonicalType());
   const clang::Type::TypeClass type_class = qual_type->getTypeClass();
   switch (type_class) {
   case clang::Type::ObjCInterface:
     return llvm::cast<clang::ObjCObjectType>(qual_type.getTypePtr())
         ->getInterface();
   case clang::Type::ObjCObjectPointer:
     return GetDeclContextForType(
         llvm::cast<clang::ObjCObjectPointerType>(qual_type.getTypePtr())
             ->getPointeeType());
   case clang::Type::Record:
     return llvm::cast<clang::RecordType>(qual_type)->getDecl();
   case clang::Type::Enum:
     return llvm::cast<clang::EnumType>(qual_type)->getDecl();
   default:
     break;
   }
   // No DeclContext in this type...
   return nullptr;
 }
 
 static bool GetCompleteQualType(clang::ASTContext *ast,
                                 clang::QualType qual_type,
                                 bool allow_completion = true) {
-  qual_type = Desugar(qual_type);
+  qual_type = RemoveWrappingTypes(qual_type);
   const clang::Type::TypeClass type_class = qual_type->getTypeClass();
   switch (type_class) {
   case clang::Type::ConstantArray:
   case clang::Type::IncompleteArray:
   case clang::Type::VariableArray: {
     const clang::ArrayType *array_type =
         llvm::dyn_cast<clang::ArrayType>(qual_type.getTypePtr());
 
case eAccessPackage:
     return clang::ObjCIvarDecl::Package;
   }
   return clang::ObjCIvarDecl::None;
 }
 
 // Tests
 
 bool ClangASTContext::IsAggregateType(lldb::opaque_compiler_type_t type) {
-  clang::QualType qual_type(Desugar(GetCanonicalQualType(type)));
+  clang::QualType qual_type(RemoveWrappingTypes(GetCanonicalQualType(type)));
 
   const clang::Type::TypeClass type_class = qual_type->getTypeClass();
   switch (type_class) {
   case clang::Type::IncompleteArray:
   case clang::Type::VariableArray:
   case clang::Type::ConstantArray:
   case clang::Type::ExtVector:
   case clang::Type::Vector:
   case clang::Type::Record:
   case clang::Type::ObjCObject:
   case clang::Type::ObjCInterface:
     return true;
   default:
     break;
   }
   // The clang type does have a value
   return false;
 }
 
 bool ClangASTContext::IsAnonymousType(lldb::opaque_compiler_type_t type) {
-  clang::QualType qual_type(Desugar(GetCanonicalQualType(type)));
+  clang::QualType qual_type(RemoveWrappingTypes(GetCanonicalQualType(type)));
 
   const clang::Type::TypeClass type_class = qual_type->getTypeClass();
   switch (type_class) {
   case clang::Type::Record: {
     if (const clang::RecordType *record_type =
             llvm::dyn_cast_or_null<clang::RecordType>(
                 qual_type.getTypePtrOrNull())) {
       if (const clang::RecordDecl *record_decl = record_type->getDecl()) {
         return record_decl->isAnonymousStructOrUnion();
       }
     }
     break;
   }
   default:
     break;
   }
   // The clang type does have a value
   return false;
 }
 
 bool ClangASTContext::IsArrayType(lldb::opaque_compiler_type_t type,
                                   CompilerType *element_type_ptr,
                                   uint64_t *size, bool *is_incomplete) {
-  clang::QualType qual_type(Desugar(GetCanonicalQualType(type)));
+  clang::QualType qual_type(RemoveWrappingTypes(GetCanonicalQualType(type)));
 
   const clang::Type::TypeClass type_class = qual_type->getTypeClass();
   switch (type_class) {
   default:
     break;
 
   case clang::Type::ConstantArray:
     if (element_type_ptr)
if (type_flags.AnySet(eTypeIsArray | eTypeIsPointer)) {
     }
   }
   return false;
 }
 
 bool ClangASTContext::IsFunctionType(lldb::opaque_compiler_type_t type,
                                      bool *is_variadic_ptr) {
   if (type) {
-    clang::QualType qual_type = Desugar(GetCanonicalQualType(type));
+    clang::QualType qual_type = RemoveWrappingTypes(GetCanonicalQualType(type));
 
     if (qual_type->isFunctionType()) {
       if (is_variadic_ptr) {
         const clang::FunctionProtoType *function_proto_type =
             llvm::dyn_cast<clang::FunctionProtoType>(qual_type.getTypePtr());
         if (function_proto_type)
           *is_variadic_ptr = function_proto_type->isVariadic();
         else

 
 // Used to detect "Homogeneous Floating-point Aggregates"
 uint32_t
 ClangASTContext::IsHomogeneousAggregate(lldb::opaque_compiler_type_t type,
                                         CompilerType *base_type_ptr) {
   if (!type)
     return 0;
 
-  clang::QualType qual_type(Desugar(GetCanonicalQualType(type)));
+  clang::QualType qual_type(RemoveWrappingTypes(GetCanonicalQualType(type)));
   const clang::Type::TypeClass type_class = qual_type->getTypeClass();
   switch (type_class) {
   case clang::Type::Record:
     if (GetCompleteType(type)) {
       const clang::CXXRecordDecl *cxx_record_decl =
           qual_type->getAsCXXRecordDecl();
       if (cxx_record_decl) {
         if (cxx_record_decl->getNumBases() || cxx_record_decl->isDynamicClass())
if (func) {
         return CompilerType(this, func->getParamType(index).getAsOpaquePtr());
     }
   }
   return CompilerType();
 }
 
 bool ClangASTContext::IsFunctionPointerType(lldb::opaque_compiler_type_t type) {
   if (type) {
-    clang::QualType qual_type = Desugar(GetCanonicalQualType(type));
+    clang::QualType qual_type = RemoveWrappingTypes(GetCanonicalQualType(type));
 
     if (qual_type->isFunctionPointerType())
       return true;
 
     const clang::Type::TypeClass type_class = qual_type->getTypeClass();
     switch (type_class) {
     default:
       break;
bool ClangASTContext::IsFunctionPointerType(lldb::opaque_compiler_type_t type) {
   }
   return false;
 }
 
 bool ClangASTContext::IsBlockPointerType(
     lldb::opaque_compiler_type_t type,
     CompilerType *function_pointer_type_ptr) {
   if (type) {
-    clang::QualType qual_type = Desugar(GetCanonicalQualType(type));
+    clang::QualType qual_type = RemoveWrappingTypes(GetCanonicalQualType(type));
 
     if (qual_type->isBlockPointerType()) {
       if (function_pointer_type_ptr) {
         const clang::BlockPointerType *block_pointer_type =
             qual_type->getAs<clang::BlockPointerType>();
         QualType pointee_type = block_pointer_type->getPointeeType();
         QualType function_pointer_type = m_ast_up->getPointerType(pointee_type);
         *function_pointer_type_ptr =
bool ClangASTContext::IsEnumerationType(lldb::opaque_compiler_type_t type,
   }
 
   return false;
 }
 
 bool ClangASTContext::IsPointerType(lldb::opaque_compiler_type_t type,
                                     CompilerType *pointee_type) {
   if (type) {
-    clang::QualType qual_type = Desugar(GetCanonicalQualType(type));
+    clang::QualType qual_type = RemoveWrappingTypes(GetCanonicalQualType(type));
     const clang::Type::TypeClass type_class = qual_type->getTypeClass();
     switch (type_class) {
     case clang::Type::Builtin:
       switch (llvm::cast<clang::BuiltinType>(qual_type)->getKind()) {
       default:
         break;
       case clang::BuiltinType::ObjCId:
       case clang::BuiltinType::ObjCClass:
bool ClangASTContext::IsPointerType(lldb::opaque_compiler_type_t type,
   if (pointee_type)
     pointee_type->Clear();
   return false;
 }
 
 bool ClangASTContext::IsPointerOrReferenceType(
     lldb::opaque_compiler_type_t type, CompilerType *pointee_type) {
   if (type) {
-    clang::QualType qual_type = Desugar(GetCanonicalQualType(type));
+    clang::QualType qual_type = RemoveWrappingTypes(GetCanonicalQualType(type));
     const clang::Type::TypeClass type_class = qual_type->getTypeClass();
     switch (type_class) {
     case clang::Type::Builtin:
       switch (llvm::cast<clang::BuiltinType>(qual_type)->getKind()) {
       default:
         break;
       case clang::BuiltinType::ObjCId:
       case clang::BuiltinType::ObjCClass:
if (pointee_type)
     pointee_type->Clear();
   return false;
 }
 
 bool ClangASTContext::IsReferenceType(lldb::opaque_compiler_type_t type,
                                       CompilerType *pointee_type,
                                       bool *is_rvalue) {
   if (type) {
-    clang::QualType qual_type = Desugar(GetCanonicalQualType(type));
+    clang::QualType qual_type = RemoveWrappingTypes(GetCanonicalQualType(type));
     const clang::Type::TypeClass type_class = qual_type->getTypeClass();
 
     switch (type_class) {
     case clang::Type::LValueReference:
       if (pointee_type)
         pointee_type->SetCompilerType(
             this, llvm::cast<clang::LValueReferenceType>(qual_type)
                       ->desugar()

 }
 
 bool ClangASTContext::IsPossibleDynamicType(lldb::opaque_compiler_type_t type,
                                             CompilerType *dynamic_pointee_type,
                                             bool check_cplusplus,
                                             bool check_objc) {
   clang::QualType pointee_qual_type;
   if (type) {
-    clang::QualType qual_type = Desugar(GetCanonicalQualType(type));
+    clang::QualType qual_type = RemoveWrappingTypes(GetCanonicalQualType(type));
     bool success = false;
     const clang::Type::TypeClass type_class = qual_type->getTypeClass();
     switch (type_class) {
     case clang::Type::Builtin:
       if (check_objc &&
           llvm::cast<clang::BuiltinType>(qual_type)->getKind() ==
               clang::BuiltinType::ObjCId) {
         if (dynamic_pointee_type)
ClangASTContext::GetTypeInfo(lldb::opaque_compiler_type_t type,
                              CompilerType *pointee_or_element_clang_type) {
   if (!type)
     return 0;
 
   if (pointee_or_element_clang_type)
     pointee_or_element_clang_type->Clear();
 
   clang::QualType qual_type =
-      Desugar(GetQualType(type), {clang::Type::Typedef});
+      RemoveWrappingTypes(GetQualType(type), {clang::Type::Typedef});
 
   const clang::Type::TypeClass type_class = qual_type->getTypeClass();
   switch (type_class) {
   case clang::Type::Attributed:
     return GetTypeInfo(
         qual_type->getAs<clang::AttributedType>()
             ->getModifiedType().getAsOpaquePtr(),
         pointee_or_element_clang_type);
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());

 }
 
 lldb::TypeClass
 ClangASTContext::GetTypeClass(lldb::opaque_compiler_type_t type) {
   if (!type)
     return lldb::eTypeClassInvalid;
 
   clang::QualType qual_type =
-      Desugar(GetQualType(type), {clang::Type::Typedef});
+      RemoveWrappingTypes(GetQualType(type), {clang::Type::Typedef});
 
   switch (qual_type->getTypeClass()) {
+  case clang::Type::Atomic:
   case clang::Type::Auto:
   case clang::Type::Elaborated:
   case clang::Type::Paren:
-    llvm_unreachable("Handled in Desugar!");
+    llvm_unreachable("Handled in RemoveWrappingTypes!");
   case clang::Type::UnaryTransform:
     break;
   case clang::Type::FunctionNoProto:
     return lldb::eTypeClassFunction;
   case clang::Type::FunctionProto:
     return lldb::eTypeClassFunction;
   case clang::Type::IncompleteArray:
     return lldb::eTypeClassArray;
case clang::Type::Decltype:
     return CompilerType(this, llvm::cast<clang::TypeOfType>(qual_type)
                                   ->getUnderlyingType()
                                   .getAsOpaquePtr())
         .GetTypeClass();
   case clang::Type::TemplateSpecialization:
     break;
   case clang::Type::DeducedTemplateSpecialization:
     break;
-  case clang::Type::Atomic:
-    break;
   case clang::Type::Pipe:
     break;
 
   // pointer type decayed from an array or function type.
   case clang::Type::Decayed:
     break;
   case clang::Type::Adjusted:
     break;
ClangASTContext::GetFunctionReturnType(lldb::opaque_compiler_type_t type) {
   }
   return CompilerType();
 }
 
 size_t
 ClangASTContext::GetNumMemberFunctions(lldb::opaque_compiler_type_t type) {
   size_t num_functions = 0;
   if (type) {
-    clang::QualType qual_type = Desugar(GetCanonicalQualType(type));
+    clang::QualType qual_type = RemoveWrappingTypes(GetCanonicalQualType(type));
     switch (qual_type->getTypeClass()) {
     case clang::Type::Record:
       if (GetCompleteQualType(getASTContext(), qual_type)) {
         const clang::RecordType *record_type =
             llvm::cast<clang::RecordType>(qual_type.getTypePtr());
         const clang::RecordDecl *record_decl = record_type->getDecl();
         assert(record_decl);
         const clang::CXXRecordDecl *cxx_record_decl =

 TypeMemberFunctionImpl
 ClangASTContext::GetMemberFunctionAtIndex(lldb::opaque_compiler_type_t type,
                                           size_t idx) {
   std::string name;
   MemberFunctionKind kind(MemberFunctionKind::eMemberFunctionKindUnknown);
   CompilerType clang_type;
   CompilerDecl clang_decl;
   if (type) {
-    clang::QualType qual_type = Desugar(GetCanonicalQualType(type));
+    clang::QualType qual_type = RemoveWrappingTypes(GetCanonicalQualType(type));
     switch (qual_type->getTypeClass()) {
     case clang::Type::Record:
       if (GetCompleteQualType(getASTContext(), qual_type)) {
         const clang::RecordType *record_type =
             llvm::cast<clang::RecordType>(qual_type.getTypePtr());
         const clang::RecordDecl *record_decl = record_type->getDecl();
         assert(record_decl);
         const clang::CXXRecordDecl *cxx_record_decl =

 }
 
 lldb::Encoding ClangASTContext::GetEncoding(lldb::opaque_compiler_type_t type,
                                             uint64_t &count) {
   if (!type)
     return lldb::eEncodingInvalid;
 
   count = 1;
-  clang::QualType qual_type = Desugar(GetCanonicalQualType(type));
+  clang::QualType qual_type = RemoveWrappingTypes(GetCanonicalQualType(type));
 
   switch (qual_type->getTypeClass()) {
+  case clang::Type::Atomic:
   case clang::Type::Auto:
   case clang::Type::Elaborated:
   case clang::Type::Paren:
   case clang::Type::Typedef:
-    llvm_unreachable("Handled in Desugar!");
+    llvm_unreachable("Handled in RemoveWrappingTypes!");
 
   case clang::Type::UnaryTransform:
     break;
 
   case clang::Type::FunctionNoProto:
   case clang::Type::FunctionProto:
     break;
 
lldb::Encoding ClangASTContext::GetEncoding(lldb::opaque_compiler_type_t type,
   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:
     break;
 
   case clang::Type::DependentAddressSpace:
     break;
   case clang::Type::MacroQualified:
     break;
   }
   count = 0;
   return lldb::eEncodingInvalid;
 }
 
 lldb::Format ClangASTContext::GetFormat(lldb::opaque_compiler_type_t type) {
   if (!type)
     return lldb::eFormatDefault;
 
-  clang::QualType qual_type = Desugar(GetCanonicalQualType(type));
+  clang::QualType qual_type = RemoveWrappingTypes(GetCanonicalQualType(type));
 
   switch (qual_type->getTypeClass()) {
+  case clang::Type::Atomic:
   case clang::Type::Auto:
   case clang::Type::Elaborated:
   case clang::Type::Paren:
   case clang::Type::Typedef:
-    llvm_unreachable("Handled in Desugar!");
+    llvm_unreachable("Handled in RemoveWrappingTypes!");
   case clang::Type::UnaryTransform:
     break;
 
   case clang::Type::FunctionNoProto:
   case clang::Type::FunctionProto:
     break;
 
   case clang::Type::IncompleteArray:
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:

 
 uint32_t ClangASTContext::GetNumChildren(lldb::opaque_compiler_type_t type,
                                          bool omit_empty_base_classes,
                                          const ExecutionContext *exe_ctx) {
   if (!type)
     return 0;
 
   uint32_t num_children = 0;
-  clang::QualType qual_type(Desugar(GetQualType(type)));
+  clang::QualType qual_type(RemoveWrappingTypes(GetQualType(type)));
   const clang::Type::TypeClass type_class = qual_type->getTypeClass();
   switch (type_class) {
   case clang::Type::Builtin:
     switch (llvm::cast<clang::BuiltinType>(qual_type)->getKind()) {
     case clang::BuiltinType::ObjCId:    // child is Class
     case clang::BuiltinType::ObjCClass: // child is Class
       num_children = 1;
       break;

 
 #pragma mark Aggregate Types
 
 uint32_t ClangASTContext::GetNumFields(lldb::opaque_compiler_type_t type) {
   if (!type)
     return 0;
 
   uint32_t count = 0;
-  clang::QualType qual_type(Desugar(GetCanonicalQualType(type)));
+  clang::QualType qual_type(RemoveWrappingTypes(GetCanonicalQualType(type)));
   const clang::Type::TypeClass type_class = qual_type->getTypeClass();
   switch (type_class) {
   case clang::Type::Record:
     if (GetCompleteType(type)) {
       const clang::RecordType *record_type =
           llvm::dyn_cast<clang::RecordType>(qual_type.getTypePtr());
       if (record_type) {
         clang::RecordDecl *record_decl = record_type->getDecl();

 CompilerType ClangASTContext::GetFieldAtIndex(lldb::opaque_compiler_type_t type,
                                               size_t idx, std::string &name,
                                               uint64_t *bit_offset_ptr,
                                               uint32_t *bitfield_bit_size_ptr,
                                               bool *is_bitfield_ptr) {
   if (!type)
     return CompilerType();
 
-  clang::QualType qual_type(Desugar(GetCanonicalQualType(type)));
+  clang::QualType qual_type(RemoveWrappingTypes(GetCanonicalQualType(type)));
   const clang::Type::TypeClass type_class = qual_type->getTypeClass();
   switch (type_class) {
   case clang::Type::Record:
     if (GetCompleteType(type)) {
       const clang::RecordType *record_type =
           llvm::cast<clang::RecordType>(qual_type.getTypePtr());
       const clang::RecordDecl *record_decl = record_type->getDecl();
       uint32_t field_idx = 0;
default:
     break;
   }
   return CompilerType();
 }
 
 uint32_t
 ClangASTContext::GetNumDirectBaseClasses(lldb::opaque_compiler_type_t type) {
   uint32_t count = 0;
-  clang::QualType qual_type = Desugar(GetCanonicalQualType(type));
+  clang::QualType qual_type = RemoveWrappingTypes(GetCanonicalQualType(type));
   const clang::Type::TypeClass type_class = qual_type->getTypeClass();
   switch (type_class) {
   case clang::Type::Record:
     if (GetCompleteType(type)) {
       const clang::CXXRecordDecl *cxx_record_decl =
           qual_type->getAsCXXRecordDecl();
       if (cxx_record_decl)
         count = cxx_record_decl->getNumBases();
default:
     break;
   }
   return count;
 }
 
 uint32_t
 ClangASTContext::GetNumVirtualBaseClasses(lldb::opaque_compiler_type_t type) {
   uint32_t count = 0;
-  clang::QualType qual_type = Desugar(GetCanonicalQualType(type));
+  clang::QualType qual_type = RemoveWrappingTypes(GetCanonicalQualType(type));
   const clang::Type::TypeClass type_class = qual_type->getTypeClass();
   switch (type_class) {
   case clang::Type::Record:
     if (GetCompleteType(type)) {
       const clang::CXXRecordDecl *cxx_record_decl =
           qual_type->getAsCXXRecordDecl();
       if (cxx_record_decl)
         count = cxx_record_decl->getNumVBases();
     }
     break;
 
   default:
     break;
   }
   return count;
 }
 
 CompilerType ClangASTContext::GetDirectBaseClassAtIndex(
     lldb::opaque_compiler_type_t type, size_t idx, uint32_t *bit_offset_ptr) {
-  clang::QualType qual_type = Desugar(GetCanonicalQualType(type));
+  clang::QualType qual_type = RemoveWrappingTypes(GetCanonicalQualType(type));
   const clang::Type::TypeClass type_class = qual_type->getTypeClass();
   switch (type_class) {
   case clang::Type::Record:
     if (GetCompleteType(type)) {
       const clang::CXXRecordDecl *cxx_record_decl =
           qual_type->getAsCXXRecordDecl();
       if (cxx_record_decl) {
         uint32_t curr_idx = 0;
CompilerType ClangASTContext::GetDirectBaseClassAtIndex(
   default:
     break;
   }
   return CompilerType();
 }
 
 CompilerType ClangASTContext::GetVirtualBaseClassAtIndex(
     lldb::opaque_compiler_type_t type, size_t idx, uint32_t *bit_offset_ptr) {
-  clang::QualType qual_type = Desugar(GetCanonicalQualType(type));
+  clang::QualType qual_type = RemoveWrappingTypes(GetCanonicalQualType(type));
   const clang::Type::TypeClass type_class = qual_type->getTypeClass();
   switch (type_class) {
   case clang::Type::Record:
     if (GetCompleteType(type)) {
       const clang::CXXRecordDecl *cxx_record_decl =
           qual_type->getAsCXXRecordDecl();
       if (cxx_record_decl) {
         uint32_t curr_idx = 0;

 // children, then we either need to trust it, or override it and return a
 // different result. For example, an "int *" has one child that is an integer,
 // but a function pointer doesn't have any children. Likewise if a Record type
 // claims it has no children, then there really is nothing to show.
 uint32_t ClangASTContext::GetNumPointeeChildren(clang::QualType type) {
   if (type.isNull())
     return 0;
 
-  clang::QualType qual_type = Desugar(type.getCanonicalType());
+  clang::QualType qual_type = RemoveWrappingTypes(type.getCanonicalType());
   const clang::Type::TypeClass type_class = qual_type->getTypeClass();
   switch (type_class) {
   case clang::Type::Builtin:
     switch (llvm::cast<clang::BuiltinType>(qual_type)->getKind()) {
     case clang::BuiltinType::UnknownAny:
     case clang::BuiltinType::Void:
     case clang::BuiltinType::NullPtr:
     case clang::BuiltinType::OCLEvent:
CompilerType ClangASTContext::GetChildCompilerTypeAtIndex(
     ValueObject *valobj, uint64_t &language_flags) {
   if (!type)
     return CompilerType();
 
   auto get_exe_scope = [&exe_ctx]() {
     return exe_ctx ? exe_ctx->GetBestExecutionContextScope() : nullptr;
   };
 
-  clang::QualType parent_qual_type(Desugar(GetCanonicalQualType(type)));
+  clang::QualType parent_qual_type(
+      RemoveWrappingTypes(GetCanonicalQualType(type)));
   const clang::Type::TypeClass parent_type_class =
       parent_qual_type->getTypeClass();
   child_bitfield_bit_size = 0;
   child_bitfield_bit_offset = 0;
   child_is_base_class = false;
   language_flags = 0;
 
   const bool idx_is_valid =

 // with: { 0,  1 } The first index 0 is the child index for "class A" within
 // class C (since class B doesn't have any members it doesn't count) The second
 // index 1 is the child index for "m_b" within class A
 
 size_t ClangASTContext::GetIndexOfChildMemberWithName(
     lldb::opaque_compiler_type_t type, const char *name,
     bool omit_empty_base_classes, std::vector<uint32_t> &child_indexes) {
   if (type && name && name[0]) {
-    clang::QualType qual_type = Desugar(GetCanonicalQualType(type));
+    clang::QualType qual_type = RemoveWrappingTypes(GetCanonicalQualType(type));
     const clang::Type::TypeClass type_class = qual_type->getTypeClass();
     switch (type_class) {
     case clang::Type::Record:
       if (GetCompleteType(type)) {
         const clang::RecordType *record_type =
             llvm::cast<clang::RecordType>(qual_type.getTypePtr());
         const clang::RecordDecl *record_decl = record_type->getDecl();
 

 // doesn't descend into the children, but only looks one level deep and name
 // matches can include base class names.
 
 uint32_t
 ClangASTContext::GetIndexOfChildWithName(lldb::opaque_compiler_type_t type,
                                          const char *name,
                                          bool omit_empty_base_classes) {
   if (type && name && name[0]) {
-    clang::QualType qual_type = Desugar(GetCanonicalQualType(type));
+    clang::QualType qual_type = RemoveWrappingTypes(GetCanonicalQualType(type));
 
     const clang::Type::TypeClass type_class = qual_type->getTypeClass();
 
     switch (type_class) {
     case clang::Type::Record:
       if (GetCompleteType(type)) {
         const clang::RecordType *record_type =
             llvm::cast<clang::RecordType>(qual_type.getTypePtr());
ClangASTContext::GetIndexOfChildWithName(lldb::opaque_compiler_type_t type,
   return UINT32_MAX;
 }
 
 size_t
 ClangASTContext::GetNumTemplateArguments(lldb::opaque_compiler_type_t type) {
   if (!type)
     return 0;
 
-  clang::QualType qual_type = Desugar(GetCanonicalQualType(type));
+  clang::QualType qual_type = RemoveWrappingTypes(GetCanonicalQualType(type));
   const clang::Type::TypeClass type_class = qual_type->getTypeClass();
   switch (type_class) {
   case clang::Type::Record:
     if (GetCompleteType(type)) {
       const clang::CXXRecordDecl *cxx_record_decl =
           qual_type->getAsCXXRecordDecl();
       if (cxx_record_decl) {
         const clang::ClassTemplateSpecializationDecl *template_decl =

 }
 
 const clang::ClassTemplateSpecializationDecl *
 ClangASTContext::GetAsTemplateSpecialization(
     lldb::opaque_compiler_type_t type) {
   if (!type)
     return nullptr;
 
-  clang::QualType qual_type(Desugar(GetCanonicalQualType(type)));
+  clang::QualType qual_type(RemoveWrappingTypes(GetCanonicalQualType(type)));
   const clang::Type::TypeClass type_class = qual_type->getTypeClass();
   switch (type_class) {
   case clang::Type::Record: {
     if (! GetCompleteType(type))
       return nullptr;
     const clang::CXXRecordDecl *cxx_record_decl =
         qual_type->getAsCXXRecordDecl();
     if (!cxx_record_decl)
#endif
   return objc_method_decl;
 }
 
 bool ClangASTContext::SetHasExternalStorage(lldb::opaque_compiler_type_t type,
                                             bool has_extern) {
   if (!type)
     return false;
 
-  clang::QualType qual_type(Desugar(GetCanonicalQualType(type)));
+  clang::QualType qual_type(RemoveWrappingTypes(GetCanonicalQualType(type)));
 
   const clang::Type::TypeClass type_class = qual_type->getTypeClass();
   switch (type_class) {
   case clang::Type::Record: {
     clang::CXXRecordDecl *cxx_record_decl = qual_type->getAsCXXRecordDecl();
     if (cxx_record_decl) {
       cxx_record_decl->setHasExternalLexicalStorage(has_extern);
       cxx_record_decl->setHasExternalVisibleStorage(has_extern);
if (metadata) {
     metadata->Dump(&s);
   }
 }
 
 void ClangASTContext::DumpTypeDescription(lldb::opaque_compiler_type_t type,
                                           Stream *s) {
   if (type) {
     clang::QualType qual_type =
-        Desugar(GetQualType(type), {clang::Type::Typedef});
+        RemoveWrappingTypes(GetQualType(type), {clang::Type::Typedef});
 
     llvm::SmallVector<char, 1024> buf;
     llvm::raw_svector_ostream llvm_ostrm(buf);
 
     const clang::Type::TypeClass type_class = qual_type->getTypeClass();
     switch (type_class) {
     case clang::Type::ObjCObject:
     case clang::Type::ObjCInterface: {

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 = {}
+# CHECK: (_Atomic(struct_type)) structure = (member = 71828)
 
         .data
 integer:
         .long 14159
 structure:
-        .byte 0
+        .long 71828
 
         .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
structure:
         .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   1                       # DW_CHILDREN_yes
         .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   6                       # Abbreviation Code
+        .byte   13                      # DW_TAG_member
+        .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   56                      # DW_AT_data_member_location
+        .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
.Lint:
         .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   4                       # DW_AT_byte_size
+        .byte   6                       # Abbrev [6] DW_TAG_member
+        .asciz  "member"                # DW_AT_name
+        .long   .Lint                   # DW_AT_type
+        .byte   0                       # DW_AT_data_member_location
+        .byte   0                       # End Of Children Mark
         .byte   0                       # End Of Children Mark
 .Ldebug_info_end0: