Add/Improve complex, vector, aggregate types handling for SysV ARM (hard/soft) ABI.

[omjavaid]

Summary

This patch adds code to SysV ARM ABI for handling complex and aggregates containing complex return types.

It also improves support for handling vectors and aggregates containing vector return types for both ARM hard and soft ABIs.

This patch further enables vector value tests for both gcc and clang.

There is some work in progress to add more comprehensive return value tests and will be followed up in couple of days.

[tberghammer]

Looks good (it would be nice if we can split GetReturnValueObjectImpl to multiple function as it starts to become pretty big and hard to read but I don't think we shouldn't do it as part of this CL)

source/Plugins/ABI/SysV-arm/ABISysV_arm.cpp

586–588 ↗

(On Diff #49353)

(nit): It can be an "else if"

599–601 ↗

(On Diff #49353)

(nit); Indentation

lldb/trunk/packages/Python/lldbsuite/test/functionalities/return-value/TestReturnValue.py

def test_with_python(self):
         self.return_and_test_struct_value ("return_one_short_one_double_one_short")
         self.return_and_test_struct_value ("return_one_float_one_int_one_float")
         self.return_and_test_struct_value ("return_two_float")
         # I am leaving out the packed test until we have a way to tell CLANG 
         # about alignment when reading DWARF for packed types.
         #self.return_and_test_struct_value ("return_one_int_one_double_packed")
         self.return_and_test_struct_value ("return_one_int_one_long")
 
-        # icc and gcc don't support this extension.
-        if self.getCompiler().endswith('clang'):
-            self.return_and_test_struct_value ("return_vector_size_float32_8")
-            self.return_and_test_struct_value ("return_vector_size_float32_16")
-            self.return_and_test_struct_value ("return_vector_size_float32_32")
+        # icc and gcc don't support this extension.
+        if self.getCompiler().endswith('clang'):
             self.return_and_test_struct_value ("return_ext_vector_size_float32_2")
             self.return_and_test_struct_value ("return_ext_vector_size_float32_4")
             self.return_and_test_struct_value ("return_ext_vector_size_float32_8")
 
     def return_and_test_struct_value (self, func_name):
         """Pass in the name of the function to return from - takes in value, returns value."""
         
         # Set the breakpoint, run to it, finish out.

lldb/trunk/source/Plugins/ABI/SysV-arm/ABISysV_arm.cpp

ABISysV_arm::GetReturnValueObjectImpl (Thread &thread,
             
     RegisterContext *reg_ctx = thread.GetRegisterContext().get();
     if (!reg_ctx)
         return return_valobj_sp;
         
     bool is_signed;
     bool is_complex;
     uint32_t float_count;
+    bool is_vfp_candidate = false;
+    uint8_t vfp_count = 0;
+    uint8_t vfp_byte_size = 0;
     
     // Get the pointer to the first stack argument so we have a place to start 
     // when reading data
     
     const RegisterInfo *r0_reg_info = reg_ctx->GetRegisterInfo(eRegisterKindGeneric, LLDB_REGNUM_GENERIC_ARG1);
     size_t bit_width = compiler_type.GetBitSize(&thread);
+    size_t byte_size = compiler_type.GetByteSize(&thread);
 
     if (compiler_type.IsIntegerType (is_signed))
     {       
         switch (bit_width)
         {
             default:
                 return return_valobj_sp;
             case 64:
ABISysV_arm::GetReturnValueObjectImpl (Thread &thread,
     }
     else if (compiler_type.IsPointerType ())
     {
         uint32_t ptr = thread.GetRegisterContext()->ReadRegisterAsUnsigned(r0_reg_info, 0) & UINT32_MAX;
         value.GetScalar() = ptr;
     }
     else if (compiler_type.IsVectorType(nullptr, nullptr))
     {
-        size_t byte_size = compiler_type.GetByteSize(&thread);
-        if (byte_size <= 16)
+        if (IsArmHardFloat(thread) && (byte_size == 8 || byte_size == 16))
+        {
+            is_vfp_candidate = true;
+            vfp_byte_size = 8;
+            vfp_count = (byte_size == 8?1:2);
+        }
+        else if (byte_size <= 16)
         {
             DataBufferHeap buffer(16, 0);
             uint32_t* buffer_ptr = (uint32_t*)buffer.GetBytes();
             
             for (uint32_t i = 0; 4*i < byte_size; ++i)
             {
                 const RegisterInfo *reg_info = reg_ctx->GetRegisterInfo(eRegisterKindGeneric, LLDB_REGNUM_GENERIC_ARG1 + i);
                 buffer_ptr[i] = reg_ctx->ReadRegisterAsUnsigned(reg_info, 0) & UINT32_MAX;
else if (compiler_type.IsFloatingPointType(float_count, is_complex))
                         uint32_t raw_value;
                         raw_value = reg_ctx->ReadRegisterAsUnsigned(r0_reg_info, 0) & UINT32_MAX;
                         value.GetScalar() = *reinterpret_cast<float*>(&raw_value);
                     }
                     break;
                 }
             }
         }
-        else
+        else if (is_complex && float_count == 2)
         {
-            // not handled yet
+            if (IsArmHardFloat(thread))
+            {
+                is_vfp_candidate = true;
+                vfp_byte_size = byte_size / 2;
+                vfp_count = 2;
+            }
+            else if (!GetReturnValuePassedInMemory(thread, reg_ctx, bit_width / 8, value))
                 return return_valobj_sp;
         }
+        else
+            // not handled yet
+            return return_valobj_sp;
     }
     else if (compiler_type.IsAggregateType())
     {
-        size_t byte_size = compiler_type.GetByteSize(&thread);
         if (IsArmHardFloat(thread))
         {
             CompilerType base_type;
             const uint32_t homogeneous_count = compiler_type.IsHomogeneousAggregate (&base_type);
 
             if (homogeneous_count > 0 && homogeneous_count <= 4)
             {
-                if (base_type.IsFloatingPointType(float_count, is_complex))
+                if (base_type.IsVectorType(nullptr, nullptr))
+                {
+                    uint64_t base_byte_size = base_type.GetByteSize(nullptr);
+                    if (base_byte_size == 8 || base_byte_size == 16)
+                    {
+                        is_vfp_candidate = true;
+                        vfp_byte_size = 8;
+                        vfp_count = (base_type.GetByteSize(nullptr) == 8 ? homogeneous_count : homogeneous_count * 2);
+                    }
+                }
+                else if (base_type.IsFloatingPointType(float_count, is_complex))
                 {
                     if (float_count == 1 && !is_complex)
                     {
-                        ProcessSP process_sp (thread.GetProcess());
-                        ByteOrder byte_order = process_sp->GetByteOrder();
+                        is_vfp_candidate = true;
+                        vfp_byte_size = base_type.GetByteSize(nullptr);
+                        vfp_count = homogeneous_count;
+                    }
+                }
+            }
+            else if (homogeneous_count == 0)
+            {
+                const uint32_t num_children = compiler_type.GetNumFields ();
+
+                if (num_children > 0 && num_children <=2)
+                {
+                    uint32_t index = 0;
+                    for (index = 0; index < num_children; index++)
+                    {
+                        std::string name;
+                        base_type = compiler_type.GetFieldAtIndex (index, name, NULL, NULL, NULL);
+
+                        if (base_type.IsFloatingPointType(float_count, is_complex))
+                        {
+                            if (float_count == 2 && is_complex)
+                            {
+                                if (index != 0 && vfp_byte_size != base_type.GetByteSize(nullptr))
+                                    break;
+                                else
+                                    vfp_byte_size = base_type.GetByteSize(nullptr);
+                            }
+                            else
+                                break;
+                        }
+                        else
+                            break;
+                    }
+
+                    if (index == num_children)
+                    {
+                        is_vfp_candidate = true;
+                        vfp_byte_size = (vfp_byte_size >> 1);
+                        vfp_count = (num_children << 1);
+                    }
+                }
+            }
+        }
+
+        if (byte_size <= 4)
+        {
+            RegisterValue r0_reg_value;
+            uint32_t raw_value = reg_ctx->ReadRegisterAsUnsigned(r0_reg_info, 0) & UINT32_MAX;
+            value.SetBytes(&raw_value, byte_size);
+        }
+        else if (!is_vfp_candidate)
+        {
+            if (!GetReturnValuePassedInMemory(thread, reg_ctx, byte_size, value))
+                return return_valobj_sp;
+        }
+    }
+    else
+    {
+        // not handled yet
+        return return_valobj_sp;
+    }
+    
+    if (is_vfp_candidate)
+    {
 
-                        DataBufferSP data_sp (new DataBufferHeap(byte_size, 0));
-                        const size_t base_byte_size = base_type.GetByteSize(nullptr);
-                        uint32_t data_offset = 0;
 
-                        for (uint32_t reg_index = 0; reg_index < homogeneous_count; reg_index++)
-                        {
-                            uint32_t regnum = 0;
+        for (uint32_t reg_index = 0; reg_index < vfp_count; reg_index++)
 
-                            if (base_byte_size == 4)
-                                regnum = dwarf_s0 + reg_index;
-                            else if (base_byte_size == 8)
-                                regnum = dwarf_d0 + reg_index;
-                            else
-                                break;
+            if (vfp_byte_size == 4)
+            else if (vfp_byte_size == 8)
 
-                            const RegisterInfo *reg_info = reg_ctx->GetRegisterInfo (eRegisterKindDWARF, regnum);
-                            if (reg_info == nullptr)
-                                break;
+            if (reg_info == NULL)
 
-                            RegisterValue reg_value;
-                            if (!reg_ctx->ReadRegister(reg_info, reg_value))
-                                break;
 
-                            // Make sure we have enough room in "data_sp"
-                            if ((data_offset + base_byte_size) <= data_sp->GetByteSize())
-                            {
-                                Error error;
-                                const size_t bytes_copied = reg_value.GetAsMemoryData (reg_info,
-                                                                                       data_sp->GetBytes() + data_offset,
-                                                                                       base_byte_size,
-                                                                                       byte_order,
-                                                                                       error);
-                                if (bytes_copied != base_byte_size)
-                                    break;
+            if ((data_offset + vfp_byte_size) <= data_sp->GetByteSize())
+                                                                       vfp_byte_size,
+                if (bytes_copied != vfp_byte_size)
 
-                                data_offset += bytes_copied;
-                            }
-                        }
 
-                        if (data_offset == byte_size)
-                        {
-                            DataExtractor data;
-                            data.SetByteOrder(byte_order);
-                            data.SetAddressByteSize(process_sp->GetAddressByteSize());
-                            data.SetData(data_sp);
 
-                            return ValueObjectConstResult::Create (&thread, compiler_type, ConstString(""), data);
-                        }
-                        else
-                        {   // Some error occurred while getting values from registers
-                            return return_valobj_sp;
-                        }
-
-                    }
-                    else
-                    {   // TODO: Add code to handle complex and vector types.
-                        return return_valobj_sp;
-                    }
-                }
-            }
-        }
-
-        if (byte_size <= 4)
-        {
-            RegisterValue r0_reg_value;
-            uint32_t raw_value = reg_ctx->ReadRegisterAsUnsigned(r0_reg_info, 0) & UINT32_MAX;
-            value.SetBytes(&raw_value, byte_size);
-        }
-        else
-        {
-            if (!GetReturnValuePassedInMemory(thread, reg_ctx, byte_size, value))
-                return return_valobj_sp;
-        }
-    }
-    else
-    {
-        // not handled yet
-        return return_valobj_sp;
     }
-    
     // If we get here, we have a valid Value, so make our ValueObject out of it:
     
     return_valobj_sp = ValueObjectConstResult::Create(thread.GetStackFrameAtIndex(0).get(),
                                                       value,
                                                       ConstString(""));
     return return_valobj_sp;
 }