Add support for displaying Java array types on Andorid

[tberghammer]

Summary

Add support for displaying Java array types on Andorid

[ovyalov]

LGTM

source/Plugins/Language/Java/JavaLanguage.cpp

103 ↗

(On Diff #55031)

Could you define a constant for "^.*\\[\\]&?$" since it's used twice?

lldb/trunk/include/lldb/Symbol/JavaASTContext.h

public:
 
     CompilerType
     CreateBaseType(const ConstString &name);
 
     CompilerType
     CreateObjectType(const ConstString &name, const ConstString &linkage_name, uint32_t byte_size);
 
     CompilerType
-    CreateArrayType(const CompilerType &element_type, const DWARFExpression &length_expression,
-                    const lldb::addr_t data_offset);
+    CreateArrayType(const ConstString &linkage_name, const CompilerType &element_type,
+                    const DWARFExpression &length_expression, const lldb::addr_t data_offset);
 
     CompilerType
     CreateReferenceType(const CompilerType &pointee_type);
 
     void
     CompleteObjectType(const CompilerType &object_type);
 
     void
     AddBaseClassToObject(const CompilerType &object_type, const CompilerType &member_type, uint32_t member_offset);
 
     void
     AddMemberToObject(const CompilerType &object_type, const ConstString &name, const CompilerType &member_type,
                       uint32_t member_offset);
 
     void
     SetDynamicTypeId(const CompilerType &type, const DWARFExpression &type_id);
 
     static uint64_t
     CalculateDynamicTypeId(ExecutionContext *exe_ctx, const CompilerType &type, ValueObject &in_value);
 
     static ConstString
     GetLinkageName(const CompilerType &type);
 
+    static uint32_t
+    CalculateArraySize(const CompilerType &type, ValueObject &in_value);
+
+    static uint64_t
+    CalculateArrayElementOffset(const CompilerType &type, size_t index);
+
     //------------------------------------------------------------------
     // llvm casting support
     //------------------------------------------------------------------
     static bool
     classof(const TypeSystem *ts)
     {
         return ts->getKind() == TypeSystem::eKindJava;
     }

lldb/trunk/source/Plugins/Language/Java/JavaFormatterFunctions.h

 namespace lldb_private
 {
 namespace formatters
 {
 
 bool
 JavaStringSummaryProvider(ValueObject &valobj, Stream &stream, const TypeSummaryOptions &options);
 
+bool
+JavaArraySummaryProvider(ValueObject &valobj, Stream &stream, const TypeSummaryOptions &options);
+
+SyntheticChildrenFrontEnd*
+JavaArraySyntheticFrontEndCreator (CXXSyntheticChildren*, lldb::ValueObjectSP valobj_sp);
+
 } // namespace formatters
 } // namespace lldb_private
 
 #endif // liblldb_JavaFormatterFunctions_h_

lldb/trunk/source/Plugins/Language/Java/JavaFormatterFunctions.cpp

 //===-- JavaFormatterFunctions.cpp-------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // C Includes
 // C++ Includes
 // Other libraries and framework includes
 // Project includes
 #include "JavaFormatterFunctions.h"
 #include "lldb/DataFormatters/FormattersHelpers.h"
 #include "lldb/DataFormatters/StringPrinter.h"
+#include "lldb/Symbol/JavaASTContext.h"
 
 using namespace lldb;
 using namespace lldb_private;
 using namespace lldb_private::formatters;
 
+namespace
+{
+
+class JavaArraySyntheticFrontEnd : public SyntheticChildrenFrontEnd
+{
+public:
+    JavaArraySyntheticFrontEnd(lldb::ValueObjectSP valobj_sp) :
+        SyntheticChildrenFrontEnd(*valobj_sp)
+    {
+        if (valobj_sp)
+            Update();
+    }
+
+    size_t
+    CalculateNumChildren() override
+    {
+        ValueObjectSP valobj = GetDereferencedValueObject();
+        if (!valobj)
+            return 0;
+
+        CompilerType type = valobj->GetCompilerType();
+        uint32_t size = JavaASTContext::CalculateArraySize(type, *valobj);
+        if (size == UINT32_MAX)
+            return 0;
+        return size;
+    }
+
+    lldb::ValueObjectSP
+    GetChildAtIndex(size_t idx) override
+    {
+        ValueObjectSP valobj = GetDereferencedValueObject();
+        if (!valobj)
+            return nullptr;
+
+        ProcessSP process_sp = valobj->GetProcessSP();
+        if (!process_sp)
+            return nullptr;
+
+        CompilerType type = valobj->GetCompilerType();
+        CompilerType element_type = type.GetArrayElementType();
+        lldb::addr_t address = valobj->GetAddressOf() + JavaASTContext::CalculateArrayElementOffset(type, idx);
+
+        Error error;
+        size_t byte_size = element_type.GetByteSize(nullptr);
+        DataBufferSP buffer_sp(new DataBufferHeap(byte_size, 0));
+        size_t bytes_read = process_sp->ReadMemory(address, buffer_sp->GetBytes(), byte_size, error);
+        if (error.Fail() || byte_size != bytes_read)
+            return nullptr;
+
+        StreamString name;
+        name.Printf("[%" PRIu64 "]", (uint64_t)idx);
+        DataExtractor data(buffer_sp, process_sp->GetByteOrder(), process_sp->GetAddressByteSize());
+        return CreateValueObjectFromData(name.GetData(), data, valobj->GetExecutionContextRef(),
+                                         element_type);
+    }
+
+    bool
+    Update() override
+    {
+        return false;
+    }
+
+    bool
+    MightHaveChildren() override
+    {
+        return true;
+    }
+
+    size_t
+    GetIndexOfChildWithName(const ConstString &name) override
+    {
+        return ExtractIndexFromString(name.GetCString());
+    }
+
+private:
+    ValueObjectSP
+    GetDereferencedValueObject()
+    {
+        if (!m_backend.IsPointerOrReferenceType())
+            m_backend.GetSP();
+
+        Error error;
+        return m_backend.Dereference(error);
+    }
+};
+
+} // end of anonymous namespace
+
 bool
 lldb_private::formatters::JavaStringSummaryProvider(ValueObject &valobj, Stream &stream, const TypeSummaryOptions &opts)
 {
     if (valobj.IsPointerOrReferenceType())
     {
         Error error;
         ValueObjectSP deref = valobj.Dereference(error);
         if (error.Fail())
lldb_private::formatters::JavaStringSummaryProvider(ValueObject &valobj, Stream &stream, const TypeSummaryOptions &opts)
     options.SetLanguage(eLanguageTypeJava);
 
     if (StringPrinter::ReadStringAndDumpToStream<StringPrinter::StringElementType::UTF16>(options))
         return true;
 
     stream.Printf("Summary Unavailable");
     return true;
 }
+
+bool
+lldb_private::formatters::JavaArraySummaryProvider(ValueObject &valobj, Stream &stream, const TypeSummaryOptions &options)
+{
+    if (valobj.IsPointerOrReferenceType())
+    {
+        Error error;
+        ValueObjectSP deref = valobj.Dereference(error);
+        if (error.Fail())
+            return false;
+        return JavaArraySummaryProvider(*deref, stream, options);
+    }
+
+    CompilerType type = valobj.GetCompilerType();
+    uint32_t size = JavaASTContext::CalculateArraySize(type, valobj);
+    if (size == UINT32_MAX)
+        return false;
+    stream.Printf("[%u]{...}", size);
+    return true;
+}
+
+SyntheticChildrenFrontEnd*
+lldb_private::formatters::JavaArraySyntheticFrontEndCreator (CXXSyntheticChildren*, lldb::ValueObjectSP valobj_sp)
+{
+    return valobj_sp ? new JavaArraySyntheticFrontEnd(valobj_sp) : nullptr;
+}

lldb/trunk/source/Plugins/Language/Java/JavaLanguage.cpp

 {
     static std::once_flag g_initialize;
     static TypeCategoryImplSP g_category;
 
     std::call_once(g_initialize, [this]() -> void {
         DataVisualization::Categories::GetCategory(GetPluginName(), g_category);
         if (g_category)
         {
+            const char* array_regexp = "^.*\\[\\]&?$";
+
             lldb::TypeSummaryImplSP string_summary_sp(new CXXFunctionSummaryFormat(
                 TypeSummaryImpl::Flags().SetDontShowChildren(true), lldb_private::formatters::JavaStringSummaryProvider,
                 "java.lang.String summary provider"));
-
             g_category->GetTypeSummariesContainer()->Add(ConstString("java::lang::String"), string_summary_sp);
+
+            lldb::TypeSummaryImplSP array_summary_sp(new CXXFunctionSummaryFormat(
+                TypeSummaryImpl::Flags().SetDontShowChildren(true), lldb_private::formatters::JavaArraySummaryProvider,
+                "Java array summary provider"));
+            g_category->GetRegexTypeSummariesContainer()->Add(RegularExpressionSP(new RegularExpression(array_regexp)),
+                                                              array_summary_sp);
+
+            AddCXXSynthetic(g_category, lldb_private::formatters::JavaArraySyntheticFrontEndCreator,
+                            "Java array synthetic children", ConstString(array_regexp),
+                            SyntheticChildren::Flags().SetCascades(true), true);
         }
     });
     return g_category;
 }

lldb/trunk/source/Plugins/SymbolFile/DWARF/DWARFASTParserJava.cpp

DWARFASTParserJava::ParseArrayTypeFromDIE(const DWARFDIE &die)
 
     DIERef type_die_ref(type_attr_value);
     Type *element_type = dwarf->ResolveTypeUID(type_die_ref);
     if (!element_type)
         return nullptr;
 
     CompilerType element_compiler_type = element_type->GetForwardCompilerType();
     CompilerType array_compiler_type =
-        m_ast.CreateArrayType(element_compiler_type, length_expression, data_offset);
+        m_ast.CreateArrayType(linkage_name, element_compiler_type, length_expression, data_offset);
 
     Declaration decl;
     TypeSP type_sp(new Type(die.GetID(), dwarf, array_compiler_type.GetTypeName(), -1, nullptr,
                             type_die_ref.GetUID(dwarf), Type::eEncodingIsUID, &decl,
                             array_compiler_type, Type::eResolveStateFull));
     type_sp->SetEncodingType(element_type);
     return type_sp;
 }

lldb/trunk/source/Plugins/SymbolFile/DWARF/DWARFCompileUnit.cpp

DWARFCompileUnit::IndexPrivate (DWARFCompileUnit* dwarf_cu,
     for (pos = begin; pos != end; ++pos)
     {
         const DWARFDebugInfoEntry &die = *pos;
         
         const dw_tag_t tag = die.Tag();
     
         switch (tag)
         {
-        case DW_TAG_subprogram:
-        case DW_TAG_inlined_subroutine:
+        case DW_TAG_array_type:
         case DW_TAG_base_type:
         case DW_TAG_class_type:
         case DW_TAG_constant:
         case DW_TAG_enumeration_type:
+        case DW_TAG_inlined_subroutine:
+        case DW_TAG_namespace:
         case DW_TAG_string_type:
-        case DW_TAG_subroutine_type:
         case DW_TAG_structure_type:
-        case DW_TAG_union_type:
+        case DW_TAG_subprogram:
+        case DW_TAG_subroutine_type:
         case DW_TAG_typedef:
-        case DW_TAG_namespace:
-        case DW_TAG_variable:
+        case DW_TAG_union_type:
         case DW_TAG_unspecified_type:
+        case DW_TAG_variable:
             break;
             
         default:
             continue;
         }
 
         DWARFAttributes attributes;
         const char *name = NULL;
//                              }
                             func_fullnames.Insert (demangled, DIERef(cu_offset, die.GetOffset()));
                     }
                 }
                 else
                     func_fullnames.Insert (ConstString(name), DIERef(cu_offset, die.GetOffset()));
             }
             break;
         
+        case DW_TAG_array_type:
         case DW_TAG_base_type:
         case DW_TAG_class_type:
         case DW_TAG_constant:
         case DW_TAG_enumeration_type:
         case DW_TAG_string_type:
-        case DW_TAG_subroutine_type:
         case DW_TAG_structure_type:
-        case DW_TAG_union_type:
+        case DW_TAG_subroutine_type:
         case DW_TAG_typedef:
+        case DW_TAG_union_type:
         case DW_TAG_unspecified_type:
             if (name && !is_declaration)
                 types.Insert (ConstString(name), DIERef(cu_offset, die.GetOffset()));
             if (mangled_cstr && !is_declaration)
                 types.Insert (ConstString(mangled_cstr), DIERef(cu_offset, die.GetOffset()));
             break;
 
         case DW_TAG_namespace:

lldb/trunk/source/Symbol/JavaASTContext.cpp

public:
     {
         return jt->getKind() == JavaType::eKindPrimitive;
     }
 
 private:
     const TypeKind m_type_kind;
 };
 
-class JavaObjectType : public JavaASTContext::JavaType
+class JavaDynamicType : public JavaASTContext::JavaType
+{
+public:
+    JavaDynamicType(LLVMCastKind kind, const ConstString &linkage_name) :
+        JavaType(kind),
+        m_linkage_name(linkage_name),
+        m_dynamic_type_id(nullptr)
+    {
+    }
+
+    ConstString
+    GetLinkageName() const
+    {
+        return m_linkage_name;
+    }
+
+    void
+    SetDynamicTypeId(const DWARFExpression &type_id)
+    {
+        m_dynamic_type_id = type_id;
+    }
+
+    uint64_t
+    CalculateDynamicTypeId(ExecutionContext *exe_ctx, ValueObject &value_obj)
+    {
+        if (!m_dynamic_type_id.IsValid())
+            return UINT64_MAX;
+
+        Value obj_load_address = value_obj.GetValue();
+        obj_load_address.ResolveValue(exe_ctx);
+        obj_load_address.SetValueType(Value::eValueTypeLoadAddress);
+
+        Value result;
+        if (m_dynamic_type_id.Evaluate(exe_ctx->GetBestExecutionContextScope(), nullptr, nullptr, 0, &obj_load_address,
+                                       nullptr, result, nullptr))
+        {
+            Error error;
+
+            lldb::addr_t type_id_addr = result.GetScalar().UInt();
+            lldb::ProcessSP process_sp = exe_ctx->GetProcessSP();
+            if (process_sp)
+                return process_sp->ReadUnsignedIntegerFromMemory(type_id_addr, process_sp->GetAddressByteSize(),
+                                                                 UINT64_MAX, error);
+        }
+
+        return UINT64_MAX;
+    }
+
+public:
+    ConstString m_linkage_name;
+    DWARFExpression m_dynamic_type_id;
+};
+
+class JavaObjectType : public JavaDynamicType
 {
 public:
     struct Field
     {
         ConstString m_name;
         CompilerType m_type;
         uint32_t m_offset;
     };
 
     JavaObjectType(const ConstString &name, const ConstString &linkage_name, uint32_t byte_size)
-        : JavaType(JavaType::eKindObject),
+        : JavaDynamicType(JavaType::eKindObject, linkage_name),
           m_name(name),
-          m_linkage_name(linkage_name),
           m_byte_size(byte_size),
           m_base_class_offset(0),
-          m_is_complete(false),
-          m_dynamic_type_id(nullptr)
+          m_is_complete(false)
     {
     }
 
     ConstString
     GetName() override
     {
         return m_name;
     }
 
-    ConstString
-    GetLinkageName() const
-    {
-        return m_linkage_name;
-    }
-
     uint32_t
     GetByteSize() const
     {
         return m_byte_size;
     }
 
     uint32_t
     GetNumFields()
public:
     }
 
     void
     AddField(const ConstString &name, const CompilerType &type, uint32_t offset)
     {
         m_fields.push_back({name, type, offset});
     }
 
-    void
-    SetDynamicTypeId(const DWARFExpression &type_id)
-    {
-        m_dynamic_type_id = type_id;
-    }
-
-    uint64_t
-    CalculateDynamicTypeId(ExecutionContext *exe_ctx, ValueObject &value_obj)
-    {
-        if (!m_dynamic_type_id.IsValid())
-            return UINT64_MAX;
-
-        Value obj_load_address = value_obj.GetValue();
-        obj_load_address.ResolveValue(exe_ctx);
-        obj_load_address.SetValueType(Value::eValueTypeLoadAddress);
-
-        Value result;
-        if (m_dynamic_type_id.Evaluate(exe_ctx->GetBestExecutionContextScope(), nullptr, nullptr, 0, &obj_load_address,
-                                       nullptr, result, nullptr))
-        {
-            Error error;
-
-            lldb::addr_t type_id_addr = result.GetScalar().UInt();
-            lldb::ProcessSP process_sp = exe_ctx->GetProcessSP();
-            if (process_sp)
-                return process_sp->ReadUnsignedIntegerFromMemory(type_id_addr, process_sp->GetAddressByteSize(),
-                                                                 UINT64_MAX, error);
-        }
-
-        return UINT64_MAX;
-    }
-
     static bool
     classof(const JavaType *jt)
     {
         return jt->getKind() == JavaType::eKindObject;
     }
 
 private:
     ConstString m_name;
-    ConstString m_linkage_name;
     uint32_t m_byte_size;
     CompilerType m_base_class;
     uint32_t m_base_class_offset;
     std::vector<CompilerType> m_interfaces;
     std::vector<Field> m_fields;
     bool m_is_complete;
-    DWARFExpression m_dynamic_type_id;
 };
 
 class JavaReferenceType : public JavaASTContext::JavaType
 {
 public:
     JavaReferenceType(CompilerType pointee_type) : JavaType(JavaType::eKindReference), m_pointee_type(pointee_type) {}
 
     static bool
public:
     {
         return m_pointee_type.IsCompleteType();
     }
 
 private:
     CompilerType m_pointee_type;
 };
 
-class JavaArrayType : public JavaASTContext::JavaType
+class JavaArrayType : public JavaDynamicType
 {
 public:
-    JavaArrayType(CompilerType element_type, const DWARFExpression &length_expression, const lldb::addr_t data_offset)
-        : JavaType(JavaType::eKindArray),
+    JavaArrayType(const ConstString& linkage_name, CompilerType element_type, const DWARFExpression &length_expression,
+                  lldb::addr_t data_offset)
+        : JavaDynamicType(JavaType::eKindArray, linkage_name),
           m_element_type(element_type),
-          m_length_expression(length_expression)
+          m_length_expression(length_expression),
+          m_data_offset(data_offset)
     {
     }
 
     static bool
     classof(const JavaType *jt)
     {
         return jt->getKind() == JavaType::eKindArray;
     }
public:
 
     bool
     IsCompleteType() override
     {
         return m_length_expression.IsValid();
     }
 
     uint32_t
-    GetNumElements(const ValueObject *value_obj)
+    GetNumElements(ValueObject *value_obj)
     {
         if (!m_length_expression.IsValid())
-            return false;
+            return UINT32_MAX;
+
+        Error error;
+        ValueObjectSP address_obj = value_obj->AddressOf(error);
+        if (error.Fail())
+            return UINT32_MAX;
 
-        Value obj_load_address = value_obj->GetValue();
+        Value obj_load_address = address_obj->GetValue();
         obj_load_address.SetValueType(Value::eValueTypeLoadAddress);
 
         Value result;
-        if (m_length_expression.Evaluate(nullptr, nullptr, nullptr, nullptr, 0, nullptr, &obj_load_address, result,
-                                         nullptr))
+        ExecutionContextScope* exec_ctx_scope = value_obj->GetExecutionContextRef().Lock(true).GetBestExecutionContextScope();
+        if (m_length_expression.Evaluate(exec_ctx_scope, nullptr, nullptr, 0, nullptr, &obj_load_address, result, nullptr))
             return result.GetScalar().UInt();
 
-        return 0;
+        return UINT32_MAX;
+    }
+
+    uint64_t
+    GetElementOffset(size_t idx)
+    {
+        return m_data_offset + idx * m_element_type.GetByteSize(nullptr);
     }
 
 private:
     CompilerType m_element_type;
     DWARFExpression m_length_expression;
+    lldb::addr_t m_data_offset;
 };
 
 } // end of anonymous namespace
 
 ConstString
 JavaASTContext::GetPluginNameStatic()
 {
     return ConstString("java");
if (JavaPrimitiveType *ptype = llvm::dyn_cast<JavaPrimitiveType>(static_cast<JavaType *>(type)))
             case JavaPrimitiveType::eTypeChar:
                 return 16;
         }
     }
     else if (llvm::isa<JavaReferenceType>(static_cast<JavaType *>(type)))
     {
         return 32; // References are always 4 byte long in java
     }
+    else if (llvm::isa<JavaArrayType>(static_cast<JavaType *>(type)))
+    {
+        return 64;
+    }
     else if (JavaObjectType *obj = llvm::dyn_cast<JavaObjectType>(static_cast<JavaType *>(type)))
     {
         return obj->GetByteSize() * 8;
     }
     return 0;
 }
 
 lldb::Encoding
JavaASTContext::CreateObjectType(const ConstString &name, const ConstString &linkage_name, uint32_t byte_size)
     {
         std::unique_ptr<JavaType> object_type(new JavaObjectType(name, linkage_name, byte_size));
         it = m_object_type_map.emplace(name, std::move(object_type)).first;
     }
     return CompilerType(this, it->second.get());
 }
 
 CompilerType
-JavaASTContext::CreateArrayType(const CompilerType &element_type, const DWARFExpression &length_expression,
-                                const lldb::addr_t data_offset)
+JavaASTContext::CreateArrayType(const ConstString &linkage_name, const CompilerType &element_type,
+                                const DWARFExpression &length_expression, const lldb::addr_t data_offset)
 {
     ConstString name = element_type.GetTypeName();
     auto it = m_array_type_map.find(name);
     if (it == m_array_type_map.end())
     {
-        std::unique_ptr<JavaType> array_type(new JavaArrayType(element_type, length_expression, data_offset));
+        std::unique_ptr<JavaType> array_type(new JavaArrayType(linkage_name, element_type, length_expression,
+                                                               data_offset));
         it = m_array_type_map.emplace(name, std::move(array_type)).first;
     }
     return CompilerType(this, it->second.get());
 }
 
 CompilerType
 JavaASTContext::CreateReferenceType(const CompilerType &pointee_type)
 {
JavaASTContext::SetDynamicTypeId(const CompilerType &type, const DWARFExpression &type_id)
     obj->SetDynamicTypeId(type_id);
 }
 
 uint64_t
 JavaASTContext::CalculateDynamicTypeId(ExecutionContext *exe_ctx, const CompilerType &type, ValueObject &in_value)
 {
     if (JavaObjectType *obj = llvm::dyn_cast<JavaObjectType>(static_cast<JavaType *>(type.GetOpaqueQualType())))
         return obj->CalculateDynamicTypeId(exe_ctx, in_value);
+    if (JavaArrayType *arr = llvm::dyn_cast<JavaArrayType>(static_cast<JavaType *>(type.GetOpaqueQualType())))
+        return arr->CalculateDynamicTypeId(exe_ctx, in_value);
+    return UINT64_MAX;
+}
+
+uint32_t
+JavaASTContext::CalculateArraySize(const CompilerType &type, ValueObject &in_value)
+{
+    if (JavaArrayType *arr = llvm::dyn_cast<JavaArrayType>(static_cast<JavaType *>(type.GetOpaqueQualType())))
+        return arr->GetNumElements(&in_value);
+    return UINT32_MAX;
+}
+
+uint64_t
+JavaASTContext::CalculateArrayElementOffset(const CompilerType &type, size_t index)
+{
+    if (JavaArrayType *arr = llvm::dyn_cast<JavaArrayType>(static_cast<JavaType *>(type.GetOpaqueQualType())))
+        return arr->GetElementOffset(index);
     return UINT64_MAX;
 }
 
 ConstString
 JavaASTContext::GetLinkageName(const CompilerType &type)
 {
     if (JavaObjectType *obj = llvm::dyn_cast<JavaObjectType>(static_cast<JavaType *>(type.GetOpaqueQualType())))
         return obj->GetLinkageName();
     return ConstString();
 }