Fix test for homogeneity in case of aggregate consisting of containerized vector types

[omjavaid]

Summary

This patch ClangASTContext::IsHomogeneousAggregate test for homogeneity in light of Arm procedure call standard definition of a homogeneous aggregate given below:

A Homogeneous Aggregate is a Composite Type where all of the Fundamental Data Types that compose the type
are the same. The test for homogeneity is applied after data layout is completed and without regard to access
control or other source language restrictions.
An aggregate consisting of containerized vector types is treated as homogeneous if all the members are of the
same size, even if the internal format of the containerized members are different. For example, a structure
containing a vector of 8 bytes and a vector of 4 half-words satisfies the requirements for a homogeneous
aggregate.
A Homogenous Aggregate has a Base Type, which is the Fundamental Data Type of each Element. The overall
size is the size of the Base Type multiplied by the number of Elements; its alignment will be the alignment of the
Base Type.

ClangASTContext::IsHomogeneousAggregate functions is currently only used by ARM ABI and I have not seen a conflicting definition of a Homogenous Aggregate elsewhere so seems safe to use ARM's definition as is.

LGTM?

[omjavaid]

Just to mention this simplifies vector return type handling for ARM. A patch implementing that is following up if this gets approves.

[clayborg]

Looks fine to me.

lldb/trunk/source/Symbol/ClangASTContext.cpp

switch (type_class)
                     if (record_decl)
                     {
                         // We are looking for a structure that contains only floating point types
                         clang::RecordDecl::field_iterator field_pos, field_end = record_decl->field_end();
                         uint32_t num_fields = 0;
                         bool is_hva = false;
                         bool is_hfa = false;
                         clang::QualType base_qual_type;
+                        uint64_t base_bitwidth = 0;
                         for (field_pos = record_decl->field_begin(); field_pos != field_end; ++field_pos)
                         {
                             clang::QualType field_qual_type = field_pos->getType();
+                            uint64_t field_bitwidth = getASTContext()->getTypeSize (qual_type);
                             if (field_qual_type->isFloatingType())
                             {
                                 if (field_qual_type->isComplexType())
                                     return 0;
                                 else
                                 {
                                     if (num_fields == 0)
                                         base_qual_type = field_qual_type;
                                     else
                                     {
                                         if (is_hva)
                                             return 0;
                                         is_hfa = true;
                                         if (field_qual_type.getTypePtr() != base_qual_type.getTypePtr())
                                             return 0;
                                     }
                                 }
                             }
                             else if (field_qual_type->isVectorType() || field_qual_type->isExtVectorType())
                             {
-                                const clang::VectorType *array = field_qual_type.getTypePtr()->getAs<clang::VectorType>();
-                                if (array && array->getNumElements() <= 4)
-                                {
-                                    if (num_fields == 0)
-                                        base_qual_type = array->getElementType();
-                                    else
-                                    {
-                                        if (is_hfa)
-                                            return 0;
-                                        is_hva = true;
-                                        if (field_qual_type.getTypePtr() != base_qual_type.getTypePtr())
-                                            return 0;
-                                    }
-                                }
-                                else
-                                    return 0;
-                            }
-                            else
-                                return 0;
+                                {
+                                    base_qual_type = field_qual_type;
+                                    base_bitwidth = field_bitwidth;
+                                }
+                                    if (base_bitwidth != field_bitwidth)
+                                        return 0;
                             ++num_fields;
                         }
                         if (base_type_ptr)
                             *base_type_ptr = CompilerType (getASTContext(), base_qual_type);
                         return num_fields;
                     }
                 }
             }