Handle aggregate return types in SysV-arm ABI

[tberghammer]

Summary

Handle aggregate return types in SysV-arm ABI

[labath]

lgtm

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

for (uint32_t value_idx = 0; value_idx < num_values; ++value_idx)
             }
         }
     }
     return true;
 }
 
 ValueObjectSP
 ABISysV_arm::GetReturnValueObjectImpl (Thread &thread,
-                                         lldb_private::ClangASTType &clang_type) const
 {
     Value value;
     ValueObjectSP return_valobj_sp;
     
     if (!clang_type)
         return return_valobj_sp;
     
     clang::ASTContext *ast_context = clang_type.GetASTContext();
ABISysV_arm::GetReturnValueObjectImpl (Thread &thread,
     bool is_signed;
     bool is_complex;
     uint32_t float_count;
     
     // 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);
-    if (clang_type.IsIntegerType (is_signed))
-    {
-        size_t bit_width = clang_type.GetBitSize(&thread);
-        
+    if (clang_type.IsIntegerType (is_signed))
+    {       
         switch (bit_width)
         {
             default:
                 return return_valobj_sp;
             case 64:
             {
                 const RegisterInfo *r1_reg_info = reg_ctx->GetRegisterInfo(eRegisterKindGeneric, LLDB_REGNUM_GENERIC_ARG2);
                 uint64_t raw_value;
ABISysV_arm::GetReturnValueObjectImpl (Thread &thread,
     {
         uint32_t ptr = thread.GetRegisterContext()->ReadRegisterAsUnsigned(r0_reg_info, 0) & UINT32_MAX;
         value.GetScalar() = ptr;
     }
     else if (clang_type.IsFloatingPointType(float_count, is_complex))
     {
         if (float_count == 1 && !is_complex)
         {
-            size_t bit_width = clang_type.GetBitSize(&thread);
             switch (bit_width)
             {
                 default:
                     return return_valobj_sp;
                 case 64:
                 {
                     static_assert(sizeof(double) == sizeof(uint64_t), "");
                     const RegisterInfo *r1_reg_info = reg_ctx->GetRegisterInfo(eRegisterKindGeneric, LLDB_REGNUM_GENERIC_ARG2);
else if (clang_type.IsFloatingPointType(float_count, is_complex))
             }
         }
         else
         {
             // not handled yet
             return return_valobj_sp;
         }
     }
+    else if (clang_type.IsAggregateType())
+    {
+        size_t byte_size = clang_type.GetByteSize(&thread);
+        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
+        {
+            RegisterValue r0_reg_value;
+            uint32_t address = reg_ctx->ReadRegisterAsUnsigned(r0_reg_info, 0) & UINT32_MAX;
+
+            Error error;
+            DataBufferHeap buffer(byte_size, 0);
+            thread.GetProcess()->ReadMemory(address, buffer.GetBytes(), buffer.GetByteSize(), error);
+
+            if (error.Success())
+                value.SetBytes(buffer.GetBytes(), buffer.GetByteSize());
+            else
+                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: