[lldb][TypeSystemClang] Add a function IsValidDereferenceType to TypeSystem to allow arrays to be dereferenced in C/C++.

Author: kuilpd

lldb/include/lldb/Symbol/CompilerType.h

@@ -186,6 +186,8 @@ class CompilerType {
   bool IsReferenceType(CompilerType *pointee_type = nullptr,
                        bool *is_rvalue = nullptr) const;
 
+  bool IsValidDereferenceType() const;
+
   bool ShouldTreatScalarValueAsAddress() const;
 
   bool IsScalarType() const;

lldb/include/lldb/Symbol/TypeSystem.h

@@ -486,6 +486,8 @@ class TypeSystem : public PluginInterface,
   virtual bool IsReferenceType(lldb::opaque_compiler_type_t type,
                                CompilerType *pointee_type, bool *is_rvalue) = 0;
 
+  virtual bool IsValidDereferenceType(lldb::opaque_compiler_type_t type) = 0;
+
   virtual bool
   ShouldTreatScalarValueAsAddress(lldb::opaque_compiler_type_t type) {
     return IsPointerOrReferenceType(type, nullptr);

lldb/source/Plugins/TypeSystem/Clang/TypeSystemClang.cpp

@@ -3443,6 +3443,13 @@ bool TypeSystemClang::IsReferenceType(lldb::opaque_compiler_type_t type,
   return false;
 }
 
+bool TypeSystemClang::IsValidDereferenceType(
+    lldb::opaque_compiler_type_t type) {
+  CompilerType compiler_type = GetType(clang::QualType::getFromOpaquePtr(type));
+  return compiler_type.IsPointerOrReferenceType() ||
+         compiler_type.IsArrayType();
+}
+
 bool TypeSystemClang::IsFloatingPointType(lldb::opaque_compiler_type_t type,
                                           uint32_t &count, bool &is_complex) {
   if (type) {
@@ -6565,6 +6572,8 @@ llvm::Expected<CompilerType> TypeSystemClang::GetChildCompilerTypeAtIndex(
             return size_or_err.takeError();
           child_byte_size = *size_or_err;
           child_byte_offset = (int32_t)idx * (int32_t)child_byte_size;
+          if (idx == 0)
+            child_is_deref_of_parent = true;
           return element_type;
         }
       }

lldb/source/Plugins/TypeSystem/Clang/TypeSystemClang.h

@@ -716,6 +716,8 @@ class TypeSystemClang : public TypeSystem {
   bool IsReferenceType(lldb::opaque_compiler_type_t type,
                        CompilerType *pointee_type, bool *is_rvalue) override;
 
+  bool IsValidDereferenceType(lldb::opaque_compiler_type_t type) override;
+
   bool IsScalarType(lldb::opaque_compiler_type_t type) override;
 
   bool IsTypedefType(lldb::opaque_compiler_type_t type) override;

lldb/source/Symbol/CompilerType.cpp

@@ -233,6 +233,13 @@ bool CompilerType::IsReferenceType(CompilerType *pointee_type,
   return false;
 }
 
+bool CompilerType::IsValidDereferenceType() const {
+  if (IsValid())
+    if (auto type_system_sp = GetTypeSystem())
+      return type_system_sp->IsValidDereferenceType(m_type);
+  return false;
+}
+
 bool CompilerType::ShouldTreatScalarValueAsAddress() const {
   if (IsValid())
     if (auto type_system_sp = GetTypeSystem())

lldb/source/ValueObject/ValueObject.cpp

@@ -2850,8 +2850,9 @@ ValueObjectSP ValueObject::Dereference(Status &error) {
   if (m_deref_valobj)
     return m_deref_valobj->GetSP();
 
-  const bool is_pointer_or_reference_type = IsPointerOrReferenceType();
-  if (is_pointer_or_reference_type) {
+  const bool is_valid_dereference_type =
+      GetCompilerType().IsValidDereferenceType();
+  if (is_valid_dereference_type) {
     bool omit_empty_base_classes = true;
     bool ignore_array_bounds = false;
 
@@ -2930,7 +2931,7 @@ ValueObjectSP ValueObject::Dereference(Status &error) {
     StreamString strm;
     GetExpressionPath(strm);
 
-    if (is_pointer_or_reference_type)
+    if (is_valid_dereference_type)
       error = Status::FromErrorStringWithFormat(
           "dereference failed: (%s) %s",
           GetTypeName().AsCString("<invalid type>"), strm.GetData());