* [PATCH] gdb: LoongArch: Fix code style issues
@ 2022-07-16 11:55 Tiezhu Yang
2022-07-18 14:04 ` Andrew Burgess
0 siblings, 1 reply; 2+ messages in thread
From: Tiezhu Yang @ 2022-07-16 11:55 UTC (permalink / raw)
To: gdb-patches; +Cc: Tom Tromey
Fix some code style issues suggested by Tom Tromey, thank you.
(1) Put an introductory comment to explain the purpose for some functions.
(2) Modify the the attribute code to make it portable.
(3) Remove globals and pass pointers to locals.
(4) Remove "*" in the subsequent comment lines.
Signed-off-by: Tiezhu Yang <yangtiezhu@loongson.cn>
---
gdb/loongarch-tdep.c | 313 +++++++++++++++++++++++++++------------------------
1 file changed, 165 insertions(+), 148 deletions(-)
diff --git a/gdb/loongarch-tdep.c b/gdb/loongarch-tdep.c
index 41422f0..9fc426e 100644
--- a/gdb/loongarch-tdep.c
+++ b/gdb/loongarch-tdep.c
@@ -452,6 +452,9 @@ static const struct frame_unwind loongarch_frame_unwind = {
/*.prev_arch =*/nullptr,
};
+/* Pass a value in a sequence of consecutive general-purpose argument registers.
+ The caller is responsible for ensuring sufficient registers are available. */
+
static void
pass_in_gar (struct regcache *regcache, unsigned int gar, const gdb_byte *val)
{
@@ -459,6 +462,9 @@ pass_in_gar (struct regcache *regcache, unsigned int gar, const gdb_byte *val)
regcache->cooked_write (regnum, val);
}
+/* Pass a value in a sequence of consecutive floating-point argument registers.
+ The caller is responsible for ensuring sufficient registers are available. */
+
static void
pass_in_far (struct regcache *regcache, unsigned int far, const gdb_byte *val)
{
@@ -466,29 +472,30 @@ pass_in_far (struct regcache *regcache, unsigned int far, const gdb_byte *val)
regcache->cooked_write (regnum, val);
}
-static __attribute__((aligned(16))) gdb_byte buf[1024] = { 0 };
-static gdb_byte *addr = buf;
+/* Pass a value on the stack. */
static void
-pass_on_stack (struct regcache *regcache, const gdb_byte *val, size_t len, int align)
+pass_on_stack (struct regcache *regcache, const gdb_byte *val,
+ size_t len, int align, gdb_byte **addr)
{
align = align_up (align, 8);
if (align > 16)
align = 16;
- CORE_ADDR align_addr = (CORE_ADDR) addr;
+ CORE_ADDR align_addr = (CORE_ADDR) (*addr);
align_addr = align_up (align_addr, align);
- addr = (gdb_byte *) align_addr;
- memcpy (addr, val, len);
- addr += len;
+ *addr = (gdb_byte *) align_addr;
+ memcpy (*addr, val, len);
+ *addr += len;
}
-static unsigned int fixed_point_members = 0;
-static unsigned int floating_point_members = 0;
-static bool first_member_is_fixed_point = false;
+/* Compute the numbers of struct member */
static void
-compute_struct_member (struct type *type)
+compute_struct_member (struct type *type,
+ unsigned int *fixed_point_members,
+ unsigned int *floating_point_members,
+ bool *first_member_is_fixed_point)
{
for (int i = 0; i < type->num_fields (); i++)
{
@@ -501,17 +508,20 @@ compute_struct_member (struct type *type)
|| field_type->code () == TYPE_CODE_ENUM
|| field_type->code () == TYPE_CODE_PTR)
{
- fixed_point_members++;
+ (*fixed_point_members)++;
- if (floating_point_members == 0)
- first_member_is_fixed_point = true;
+ if (*floating_point_members == 0)
+ *first_member_is_fixed_point = true;
}
else if (field_type->code () == TYPE_CODE_FLT)
- floating_point_members++;
+ (*floating_point_members)++;
else if (field_type->code () == TYPE_CODE_STRUCT)
- compute_struct_member (field_type);
+ compute_struct_member (field_type,
+ fixed_point_members,
+ floating_point_members,
+ first_member_is_fixed_point);
else if (field_type->code () == TYPE_CODE_COMPLEX)
- floating_point_members += 2;
+ (*floating_point_members) += 2;
}
}
@@ -531,11 +541,15 @@ loongarch_push_dummy_call (struct gdbarch *gdbarch,
int regsize = register_size (gdbarch, 0);
unsigned int gar = LOONGARCH_ARG_REGNUM;
unsigned int far = LOONGARCH_ARG_REGNUM;
+ unsigned int fixed_point_members;
+ unsigned int floating_point_members;
+ bool first_member_is_fixed_point;
+ gdb_byte buf[1024] = { 0 };
+ gdb_byte *addr = buf;
if (return_method != return_method_normal)
pass_in_gar (regcache, gar--, (gdb_byte *) &struct_addr);
- addr = buf;
for (int i = 0; i < nargs; i++)
{
struct value *arg = args[i];
@@ -555,17 +569,17 @@ loongarch_push_dummy_call (struct gdbarch *gdbarch,
case TYPE_CODE_PTR:
{
/* integer or pointer type is passed in GAR.
- * If no GAR is available, it's passed on the stack.
- * When passed in registers or on the stack,
- * the unsigned integer scalars are zero-extended to GRLEN bits,
- * and the signed integer scalars are sign-extended. */
+ If no GAR is available, it's passed on the stack.
+ When passed in registers or on the stack,
+ the unsigned integer scalars are zero-extended to GRLEN bits,
+ and the signed integer scalars are sign-extended. */
if (type->is_unsigned ())
{
ULONGEST data = extract_unsigned_integer (val, len, BFD_ENDIAN_LITTLE);
if (gar > 0)
pass_in_gar (regcache, gar--, (gdb_byte *) &data);
else
- pass_on_stack (regcache, (gdb_byte *) &data, len, align);
+ pass_on_stack (regcache, (gdb_byte *) &data, len, align, &addr);
}
else
{
@@ -573,7 +587,7 @@ loongarch_push_dummy_call (struct gdbarch *gdbarch,
if (gar > 0)
pass_in_gar (regcache, gar--, (gdb_byte *) &data);
else
- pass_on_stack (regcache, (gdb_byte *) &data, len, align);
+ pass_on_stack (regcache, (gdb_byte *) &data, len, align, &addr);
}
}
break;
@@ -581,12 +595,12 @@ loongarch_push_dummy_call (struct gdbarch *gdbarch,
if (len == 2 * regsize)
{
/* long double type is passed in a pair of GAR,
- * with the low-order GRLEN bits in the lower-numbered register
- * and the high-order GRLEN bits in the higher-numbered register.
- * If exactly one register is available,
- * the low-order GRLEN bits are passed in the register
- * and the high-order GRLEN bits are passed on the stack.
- * If no GAR is available, it's passed on the stack. */
+ with the low-order GRLEN bits in the lower-numbered register
+ and the high-order GRLEN bits in the higher-numbered register.
+ If exactly one register is available,
+ the low-order GRLEN bits are passed in the register
+ and the high-order GRLEN bits are passed on the stack.
+ If no GAR is available, it's passed on the stack. */
if (gar >= 2)
{
pass_in_gar (regcache, gar--, val);
@@ -595,24 +609,24 @@ loongarch_push_dummy_call (struct gdbarch *gdbarch,
else if (gar == 1)
{
pass_in_gar (regcache, gar--, val);
- pass_on_stack (regcache, val + regsize, len - regsize, align);
+ pass_on_stack (regcache, val + regsize, len - regsize, align, &addr);
}
else
{
- pass_on_stack (regcache, val, len, align);
+ pass_on_stack (regcache, val, len, align, &addr);
}
}
else
{
/* The other floating-point type is passed in FAR.
- * If no FAR is available, it's passed in GAR.
- * If no GAR is available, it's passed on the stack. */
+ If no FAR is available, it's passed in GAR.
+ If no GAR is available, it's passed on the stack. */
if (far > 0)
pass_in_far (regcache, far--, val);
else if (gar > 0)
pass_in_gar (regcache, gar--, val);
else
- pass_on_stack (regcache, val, len, align);
+ pass_on_stack (regcache, val, len, align, &addr);
}
break;
case TYPE_CODE_STRUCT:
@@ -620,7 +634,10 @@ loongarch_push_dummy_call (struct gdbarch *gdbarch,
fixed_point_members = 0;
floating_point_members = 0;
first_member_is_fixed_point = false;
- compute_struct_member (type);
+ compute_struct_member (type,
+ &fixed_point_members,
+ &floating_point_members,
+ &first_member_is_fixed_point);
if (len > 0 && len <= regsize)
{
@@ -628,20 +645,20 @@ loongarch_push_dummy_call (struct gdbarch *gdbarch,
if (fixed_point_members > 0 && floating_point_members == 0)
{
/* If there is an available GAR,
- * the structure is passed through the GAR by value passing;
- * If no GAR is available, it's passed on the stack. */
+ the structure is passed through the GAR by value passing;
+ If no GAR is available, it's passed on the stack. */
if (gar > 0)
pass_in_gar (regcache, gar--, val);
else
- pass_on_stack (regcache, val, len, align);
+ pass_on_stack (regcache, val, len, align, &addr);
}
/* The structure has only floating-point members. */
else if (fixed_point_members == 0 && floating_point_members > 0)
{
/* One floating-point member.
- * The argument is passed in a FAR.
- * If no FAR is available, the value is passed in a GAR.
- * if no GAR is available, the value is passed on the stack. */
+ The argument is passed in a FAR.
+ If no FAR is available, the value is passed in a GAR.
+ if no GAR is available, the value is passed on the stack. */
if (floating_point_members == 1)
{
if (far > 0)
@@ -649,14 +666,14 @@ loongarch_push_dummy_call (struct gdbarch *gdbarch,
else if (gar > 0)
pass_in_gar (regcache, gar--, val);
else
- pass_on_stack (regcache, val, len, align);
+ pass_on_stack (regcache, val, len, align, &addr);
}
/* Two floating-point members.
- * The argument is passed in a pair of available FAR,
- * with the low-order float member bits in the lower-numbered FAR
- * and the high-order float member bits in the higher-numbered FAR.
- * If the number of available FAR is less than 2, it's passed in a GAR,
- * and passed on the stack if no GAR is available. */
+ The argument is passed in a pair of available FAR,
+ with the low-order float member bits in the lower-numbered FAR
+ and the high-order float member bits in the higher-numbered FAR.
+ If the number of available FAR is less than 2, it's passed in a GAR,
+ and passed on the stack if no GAR is available. */
else if (floating_point_members == 2)
{
if (far >= 2)
@@ -670,7 +687,7 @@ loongarch_push_dummy_call (struct gdbarch *gdbarch,
}
else
{
- pass_on_stack (regcache, val, len, align);
+ pass_on_stack (regcache, val, len, align, &addr);
}
}
}
@@ -678,21 +695,21 @@ loongarch_push_dummy_call (struct gdbarch *gdbarch,
else if (fixed_point_members > 0 && floating_point_members > 0)
{
/* One float member and multiple fixed-point members.
- * If there are available GAR, the structure is passed in a GAR,
- * and passed on the stack if no GAR is available. */
+ If there are available GAR, the structure is passed in a GAR,
+ and passed on the stack if no GAR is available. */
if (floating_point_members == 1 && fixed_point_members > 1)
{
if (gar > 0)
pass_in_gar (regcache, gar--, val);
else
- pass_on_stack (regcache, val, len, align);
+ pass_on_stack (regcache, val, len, align, &addr);
}
/* One float member and only one fixed-point member.
- * If one FAR and one GAR are available,
- * the floating-point member of the structure is passed in the FAR,
- * and the fixed-point member of the structure is passed in the GAR.
- * If no floating-point register but one GAR is available, it's passed in GAR;
- * If no GAR is available, it's passed on the stack. */
+ If one FAR and one GAR are available,
+ the floating-point member of the structure is passed in the FAR,
+ and the fixed-point member of the structure is passed in the GAR.
+ If no floating-point register but one GAR is available, it's passed in GAR;
+ If no GAR is available, it's passed on the stack. */
else if (floating_point_members == 1 && fixed_point_members == 1)
{
if (far > 0 && gar > 0)
@@ -713,7 +730,7 @@ loongarch_push_dummy_call (struct gdbarch *gdbarch,
if (gar > 0)
pass_in_gar (regcache, gar--, val);
else
- pass_on_stack (regcache, val, len, align);
+ pass_on_stack (regcache, val, len, align, &addr);
}
}
}
@@ -724,12 +741,12 @@ loongarch_push_dummy_call (struct gdbarch *gdbarch,
if (fixed_point_members > 0 && floating_point_members == 0)
{
/* The argument is passed in a pair of available GAR,
- * with the low-order bits in the lower-numbered GAR
- * and the high-order bits in the higher-numbered GAR.
- * If only one GAR is available,
- * the low-order bits are in the GAR
- * and the high-order bits are on the stack,
- * and passed on the stack if no GAR is available. */
+ with the low-order bits in the lower-numbered GAR
+ and the high-order bits in the higher-numbered GAR.
+ If only one GAR is available,
+ the low-order bits are in the GAR
+ and the high-order bits are on the stack,
+ and passed on the stack if no GAR is available. */
if (gar >= 2)
{
pass_in_gar (regcache, gar--, val);
@@ -738,26 +755,26 @@ loongarch_push_dummy_call (struct gdbarch *gdbarch,
else if (gar == 1)
{
pass_in_gar (regcache, gar--, val);
- pass_on_stack (regcache, val + regsize, len - regsize, align);
+ pass_on_stack (regcache, val + regsize, len - regsize, align, &addr);
}
else
{
- pass_on_stack (regcache, val, len, align);
+ pass_on_stack (regcache, val, len, align, &addr);
}
}
/* Only floating-point members. */
else if (fixed_point_members == 0 && floating_point_members > 0)
{
/* The structure has one long double member
- * or one double member and two adjacent float members
- * or 3-4 float members.
- * The argument is passed in a pair of available GAR,
- * with the low-order bits in the lower-numbered GAR
- * and the high-order bits in the higher-numbered GAR.
- * If only one GAR is available,
- * the low-order bits are in the GAR
- * and the high-order bits are on the stack,
- * and passed on the stack if no GAR is available. */
+ or one double member and two adjacent float members
+ or 3-4 float members.
+ The argument is passed in a pair of available GAR,
+ with the low-order bits in the lower-numbered GAR
+ and the high-order bits in the higher-numbered GAR.
+ If only one GAR is available,
+ the low-order bits are in the GAR
+ and the high-order bits are on the stack,
+ and passed on the stack if no GAR is available. */
if ((len == 16 && floating_point_members == 1)
|| (len == 16 && floating_point_members == 3)
|| (len == 12 && floating_point_members == 3)
@@ -771,26 +788,26 @@ loongarch_push_dummy_call (struct gdbarch *gdbarch,
else if (gar == 1)
{
pass_in_gar (regcache, gar--, val);
- pass_on_stack (regcache, val + regsize, len - regsize, align);
+ pass_on_stack (regcache, val + regsize, len - regsize, align, &addr);
}
else
{
- pass_on_stack (regcache, val, len, align);
+ pass_on_stack (regcache, val, len, align, &addr);
}
}
/* The structure with two double members
- * is passed in a pair of available FAR,
- * with the low-order bits in the lower-numbered FAR
- * and the high-order bits in the higher-numbered FAR.
- * If no a pair of available FAR,
- * it's passed in a pair of available GAR,
- * with the low-order bits in the lower-numbered GAR
- * and the high-order bits in the higher-numbered GAR.
- * If only one GAR is available,
- * the low-order bits are in the GAR
- * and the high-order bits are on stack,
- * and passed on the stack if no GAR is available.
- * A structure with one double member and one float member is same. */
+ is passed in a pair of available FAR,
+ with the low-order bits in the lower-numbered FAR
+ and the high-order bits in the higher-numbered FAR.
+ If no a pair of available FAR,
+ it's passed in a pair of available GAR,
+ with the low-order bits in the lower-numbered GAR
+ and the high-order bits in the higher-numbered GAR.
+ If only one GAR is available,
+ the low-order bits are in the GAR
+ and the high-order bits are on stack,
+ and passed on the stack if no GAR is available.
+ A structure with one double member and one float member is same. */
else if ((len == 16 && floating_point_members == 2)
|| (len == 12 && floating_point_members == 2))
{
@@ -807,11 +824,11 @@ loongarch_push_dummy_call (struct gdbarch *gdbarch,
else if (gar == 1)
{
pass_in_gar (regcache, gar--, val);
- pass_on_stack (regcache, val + regsize, len - regsize, align);
+ pass_on_stack (regcache, val + regsize, len - regsize, align, &addr);
}
else
{
- pass_on_stack (regcache, val, len, align);
+ pass_on_stack (regcache, val, len, align, &addr);
}
}
}
@@ -822,14 +839,14 @@ loongarch_push_dummy_call (struct gdbarch *gdbarch,
if (floating_point_members == 1 && fixed_point_members == 1)
{
/* If one FAR and one GAR are available,
- * the floating-point member of the structure is passed in the FAR,
- * and the fixed-point member of the structure is passed in the GAR;
- * If no floating-point registers but two GARs are available,
- * it's passed in the two GARs;
- * If only one GAR is available,
- * the low-order bits are in the GAR
- * and the high-order bits are on the stack;
- * And it's passed on the stack if no GAR is available. */
+ the floating-point member of the structure is passed in the FAR,
+ and the fixed-point member of the structure is passed in the GAR;
+ If no floating-point registers but two GARs are available,
+ it's passed in the two GARs;
+ If only one GAR is available,
+ the low-order bits are in the GAR
+ and the high-order bits are on the stack;
+ And it's passed on the stack if no GAR is available. */
if (far > 0 && gar > 0)
{
if (first_member_is_fixed_point == false)
@@ -851,22 +868,22 @@ loongarch_push_dummy_call (struct gdbarch *gdbarch,
else if (far == 0 && gar == 1)
{
pass_in_gar (regcache, gar--, val);
- pass_on_stack (regcache, val + regsize, len - regsize, align);
+ pass_on_stack (regcache, val + regsize, len - regsize, align, &addr);
}
else if (far == 0 && gar == 0)
{
- pass_on_stack (regcache, val, len, align);
+ pass_on_stack (regcache, val, len, align, &addr);
}
}
else
{
/* The argument is passed in a pair of available GAR,
- * with the low-order bits in the lower-numbered GAR
- * and the high-order bits in the higher-numbered GAR.
- * If only one GAR is available,
- * the low-order bits are in the GAR
- * and the high-order bits are on the stack,
- * and passed on the stack if no GAR is available. */
+ with the low-order bits in the lower-numbered GAR
+ and the high-order bits in the higher-numbered GAR.
+ If only one GAR is available,
+ the low-order bits are in the GAR
+ and the high-order bits are on the stack,
+ and passed on the stack if no GAR is available. */
if (gar >= 2)
{
pass_in_gar (regcache, gar--, val);
@@ -875,11 +892,11 @@ loongarch_push_dummy_call (struct gdbarch *gdbarch,
else if (gar == 1)
{
pass_in_gar (regcache, gar--, val);
- pass_on_stack (regcache, val + regsize, len - regsize, align);
+ pass_on_stack (regcache, val + regsize, len - regsize, align, &addr);
}
else
{
- pass_on_stack (regcache, val, len, align);
+ pass_on_stack (regcache, val, len, align, &addr);
}
}
}
@@ -887,15 +904,15 @@ loongarch_push_dummy_call (struct gdbarch *gdbarch,
else if (len > 2 * regsize)
{
/* It's passed by reference and are replaced in the argument list with the address.
- * If there is an available GAR, the reference is passed in the GAR,
- * and passed on the stack if no GAR is available. */
+ If there is an available GAR, the reference is passed in the GAR,
+ and passed on the stack if no GAR is available. */
sp = align_down (sp - len, 16);
write_memory (sp, val, len);
if (gar > 0)
pass_in_gar (regcache, gar--, (const gdb_byte *) &sp);
else
- pass_on_stack (regcache, (const gdb_byte*) &sp, len, regsize);
+ pass_on_stack (regcache, (const gdb_byte*) &sp, len, regsize, &addr);
}
}
break;
@@ -904,21 +921,21 @@ loongarch_push_dummy_call (struct gdbarch *gdbarch,
if (len > 0 && len <= regsize)
{
/* The argument is passed in a GAR,
- * or on the stack by value if no GAR is available. */
+ or on the stack by value if no GAR is available. */
if (gar > 0)
pass_in_gar (regcache, gar--, val);
else
- pass_on_stack (regcache, val, len, align);
+ pass_on_stack (regcache, val, len, align, &addr);
}
else if (len > regsize && len <= 2 * regsize)
{
/* The argument is passed in a pair of available GAR,
- * with the low-order bits in the lower-numbered GAR
- * and the high-order bits in the higher-numbered GAR.
- * If only one GAR is available,
- * the low-order bits are in the GAR
- * and the high-order bits are on the stack.
- * The arguments are passed on the stack when no GAR is available. */
+ with the low-order bits in the lower-numbered GAR
+ and the high-order bits in the higher-numbered GAR.
+ If only one GAR is available,
+ the low-order bits are in the GAR
+ and the high-order bits are on the stack.
+ The arguments are passed on the stack when no GAR is available. */
if (gar >= 2)
{
pass_in_gar (regcache, gar--, val);
@@ -927,25 +944,25 @@ loongarch_push_dummy_call (struct gdbarch *gdbarch,
else if (gar == 1)
{
pass_in_gar (regcache, gar--, val);
- pass_on_stack (regcache, val + regsize, len - regsize, align);
+ pass_on_stack (regcache, val + regsize, len - regsize, align, &addr);
}
else
{
- pass_on_stack (regcache, val, len, align);
+ pass_on_stack (regcache, val, len, align, &addr);
}
}
else if (len > 2 * regsize)
{
/* It's passed by reference and are replaced in the argument list with the address.
- * If there is an available GAR, the reference is passed in the GAR,
- * and passed on the stack if no GAR is available. */
+ If there is an available GAR, the reference is passed in the GAR,
+ and passed on the stack if no GAR is available. */
sp = align_down (sp - len, 16);
write_memory (sp, val, len);
if (gar > 0)
pass_in_gar (regcache, gar--, (const gdb_byte *) &sp);
else
- pass_on_stack (regcache, (const gdb_byte*) &sp, len, regsize);
+ pass_on_stack (regcache, (const gdb_byte*) &sp, len, regsize, &addr);
}
break;
case TYPE_CODE_COMPLEX:
@@ -956,11 +973,11 @@ loongarch_push_dummy_call (struct gdbarch *gdbarch,
if (target_len < regsize)
{
/* The complex with two float members
- * is passed in a pair of available FAR,
- * with the low-order float member bits in the lower-numbered FAR
- * and the high-order float member bits in the higher-numbered FAR.
- * If the number of available FAR is less than 2, it's passed in a GAR,
- * and passed on the stack if no GAR is available. */
+ is passed in a pair of available FAR,
+ with the low-order float member bits in the lower-numbered FAR
+ and the high-order float member bits in the higher-numbered FAR.
+ If the number of available FAR is less than 2, it's passed in a GAR,
+ and passed on the stack if no GAR is available. */
if (far >= 2)
{
pass_in_far (regcache, far--, val);
@@ -972,23 +989,23 @@ loongarch_push_dummy_call (struct gdbarch *gdbarch,
}
else
{
- pass_on_stack (regcache, val, len, align);
+ pass_on_stack (regcache, val, len, align, &addr);
}
}
else if (target_len == regsize)
{
/* The complex with two double members
- * is passed in a pair of available FAR,
- * with the low-order bits in the lower-numbered FAR
- * and the high-order bits in the higher-numbered FAR.
- * If no a pair of available FAR,
- * it's passed in a pair of available GAR,
- * with the low-order bits in the lower-numbered GAR
- * and the high-order bits in the higher-numbered GAR.
- * If only one GAR is available,
- * the low-order bits are in the GAR
- * and the high-order bits are on stack,
- * and passed on the stack if no GAR is available. */
+ is passed in a pair of available FAR,
+ with the low-order bits in the lower-numbered FAR
+ and the high-order bits in the higher-numbered FAR.
+ If no a pair of available FAR,
+ it's passed in a pair of available GAR,
+ with the low-order bits in the lower-numbered GAR
+ and the high-order bits in the higher-numbered GAR.
+ If only one GAR is available,
+ the low-order bits are in the GAR
+ and the high-order bits are on stack,
+ and passed on the stack if no GAR is available. */
{
if (far >= 2)
{
@@ -1003,27 +1020,27 @@ loongarch_push_dummy_call (struct gdbarch *gdbarch,
else if (gar == 1)
{
pass_in_gar (regcache, gar--, val);
- pass_on_stack (regcache, val + align, len - align, align);
+ pass_on_stack (regcache, val + align, len - align, align, &addr);
}
else
{
- pass_on_stack (regcache, val, len, align);
+ pass_on_stack (regcache, val, len, align, &addr);
}
}
}
else if (target_len == 2 * regsize)
{
/* The complex with two long double members
- * is passed by reference and are replaced in the argument list with the address.
- * If there is an available GAR, the reference is passed in the GAR,
- * and passed on the stack if no GAR is available. */
+ is passed by reference and are replaced in the argument list with the address.
+ If there is an available GAR, the reference is passed in the GAR,
+ and passed on the stack if no GAR is available. */
sp = align_down (sp - len, 16);
write_memory (sp, val, len);
if (gar > 0)
pass_in_gar (regcache, gar--, (const gdb_byte *) &sp);
else
- pass_on_stack (regcache, (const gdb_byte*) &sp, regsize, regsize);
+ pass_on_stack (regcache, (const gdb_byte*) &sp, regsize, regsize, &addr);
}
}
break;
--
2.1.0
^ permalink raw reply [flat|nested] 2+ messages in thread
* Re: [PATCH] gdb: LoongArch: Fix code style issues
2022-07-16 11:55 [PATCH] gdb: LoongArch: Fix code style issues Tiezhu Yang
@ 2022-07-18 14:04 ` Andrew Burgess
0 siblings, 0 replies; 2+ messages in thread
From: Andrew Burgess @ 2022-07-18 14:04 UTC (permalink / raw)
To: Tiezhu Yang, gdb-patches; +Cc: Tom Tromey
Tiezhu Yang <yangtiezhu@loongson.cn> writes:
> Fix some code style issues suggested by Tom Tromey, thank you.
>
> (1) Put an introductory comment to explain the purpose for some functions.
>
> (2) Modify the the attribute code to make it portable.
>
> (3) Remove globals and pass pointers to locals.
>
> (4) Remove "*" in the subsequent comment lines.
>
> Signed-off-by: Tiezhu Yang <yangtiezhu@loongson.cn>
> ---
> gdb/loongarch-tdep.c | 313 +++++++++++++++++++++++++++------------------------
> 1 file changed, 165 insertions(+), 148 deletions(-)
>
> diff --git a/gdb/loongarch-tdep.c b/gdb/loongarch-tdep.c
> index 41422f0..9fc426e 100644
> --- a/gdb/loongarch-tdep.c
> +++ b/gdb/loongarch-tdep.c
> @@ -452,6 +452,9 @@ static const struct frame_unwind loongarch_frame_unwind = {
> /*.prev_arch =*/nullptr,
> };
>
> +/* Pass a value in a sequence of consecutive general-purpose argument registers.
> + The caller is responsible for ensuring sufficient registers are available. */
> +
Is the "... a sequence of ..." part correct? I know there are some
parts of GDB that allow values to flow from one register to the next,
but I thought at the regcache level we dealt with individual registers,
and the code in this function doesn't seem to do any "... a sequence of
...." behaviour.
Also, the comments are an opportunity to explain the arguments,
especially anything that might not be immediately obvious. In this case
there is (what I would consider) a non-obvious mapping between GAR and
which register is written to. Your comment can explain this:
/* Write the contents of buffer VAL into the general purpose argument
register defined by GAR in REGCACHE.
GAR should be a value in the range 0 to LOONGARCH_ARG_REGNUM, which
correspond to registers A7 and A0 respectively. */
Please feel free to improve the wording.
I think most of the new function comments added in this commit would
benefit from a similar rewrite.
Thanks,
Andrew
> static void
> pass_in_gar (struct regcache *regcache, unsigned int gar, const gdb_byte *val)
> {
> @@ -459,6 +462,9 @@ pass_in_gar (struct regcache *regcache, unsigned int gar, const gdb_byte *val)
> regcache->cooked_write (regnum, val);
> }
>
> +/* Pass a value in a sequence of consecutive floating-point argument registers.
> + The caller is responsible for ensuring sufficient registers are available. */
> +
> static void
> pass_in_far (struct regcache *regcache, unsigned int far, const gdb_byte *val)
> {
> @@ -466,29 +472,30 @@ pass_in_far (struct regcache *regcache, unsigned int far, const gdb_byte *val)
> regcache->cooked_write (regnum, val);
> }
>
> -static __attribute__((aligned(16))) gdb_byte buf[1024] = { 0 };
> -static gdb_byte *addr = buf;
> +/* Pass a value on the stack. */
>
> static void
> -pass_on_stack (struct regcache *regcache, const gdb_byte *val, size_t len, int align)
> +pass_on_stack (struct regcache *regcache, const gdb_byte *val,
> + size_t len, int align, gdb_byte **addr)
> {
> align = align_up (align, 8);
> if (align > 16)
> align = 16;
>
> - CORE_ADDR align_addr = (CORE_ADDR) addr;
> + CORE_ADDR align_addr = (CORE_ADDR) (*addr);
> align_addr = align_up (align_addr, align);
> - addr = (gdb_byte *) align_addr;
> - memcpy (addr, val, len);
> - addr += len;
> + *addr = (gdb_byte *) align_addr;
> + memcpy (*addr, val, len);
> + *addr += len;
> }
>
> -static unsigned int fixed_point_members = 0;
> -static unsigned int floating_point_members = 0;
> -static bool first_member_is_fixed_point = false;
> +/* Compute the numbers of struct member */
>
> static void
> -compute_struct_member (struct type *type)
> +compute_struct_member (struct type *type,
> + unsigned int *fixed_point_members,
> + unsigned int *floating_point_members,
> + bool *first_member_is_fixed_point)
> {
> for (int i = 0; i < type->num_fields (); i++)
> {
> @@ -501,17 +508,20 @@ compute_struct_member (struct type *type)
> || field_type->code () == TYPE_CODE_ENUM
> || field_type->code () == TYPE_CODE_PTR)
> {
> - fixed_point_members++;
> + (*fixed_point_members)++;
>
> - if (floating_point_members == 0)
> - first_member_is_fixed_point = true;
> + if (*floating_point_members == 0)
> + *first_member_is_fixed_point = true;
> }
> else if (field_type->code () == TYPE_CODE_FLT)
> - floating_point_members++;
> + (*floating_point_members)++;
> else if (field_type->code () == TYPE_CODE_STRUCT)
> - compute_struct_member (field_type);
> + compute_struct_member (field_type,
> + fixed_point_members,
> + floating_point_members,
> + first_member_is_fixed_point);
> else if (field_type->code () == TYPE_CODE_COMPLEX)
> - floating_point_members += 2;
> + (*floating_point_members) += 2;
> }
> }
>
> @@ -531,11 +541,15 @@ loongarch_push_dummy_call (struct gdbarch *gdbarch,
> int regsize = register_size (gdbarch, 0);
> unsigned int gar = LOONGARCH_ARG_REGNUM;
> unsigned int far = LOONGARCH_ARG_REGNUM;
> + unsigned int fixed_point_members;
> + unsigned int floating_point_members;
> + bool first_member_is_fixed_point;
> + gdb_byte buf[1024] = { 0 };
> + gdb_byte *addr = buf;
>
> if (return_method != return_method_normal)
> pass_in_gar (regcache, gar--, (gdb_byte *) &struct_addr);
>
> - addr = buf;
> for (int i = 0; i < nargs; i++)
> {
> struct value *arg = args[i];
> @@ -555,17 +569,17 @@ loongarch_push_dummy_call (struct gdbarch *gdbarch,
> case TYPE_CODE_PTR:
> {
> /* integer or pointer type is passed in GAR.
> - * If no GAR is available, it's passed on the stack.
> - * When passed in registers or on the stack,
> - * the unsigned integer scalars are zero-extended to GRLEN bits,
> - * and the signed integer scalars are sign-extended. */
> + If no GAR is available, it's passed on the stack.
> + When passed in registers or on the stack,
> + the unsigned integer scalars are zero-extended to GRLEN bits,
> + and the signed integer scalars are sign-extended. */
> if (type->is_unsigned ())
> {
> ULONGEST data = extract_unsigned_integer (val, len, BFD_ENDIAN_LITTLE);
> if (gar > 0)
> pass_in_gar (regcache, gar--, (gdb_byte *) &data);
> else
> - pass_on_stack (regcache, (gdb_byte *) &data, len, align);
> + pass_on_stack (regcache, (gdb_byte *) &data, len, align, &addr);
> }
> else
> {
> @@ -573,7 +587,7 @@ loongarch_push_dummy_call (struct gdbarch *gdbarch,
> if (gar > 0)
> pass_in_gar (regcache, gar--, (gdb_byte *) &data);
> else
> - pass_on_stack (regcache, (gdb_byte *) &data, len, align);
> + pass_on_stack (regcache, (gdb_byte *) &data, len, align, &addr);
> }
> }
> break;
> @@ -581,12 +595,12 @@ loongarch_push_dummy_call (struct gdbarch *gdbarch,
> if (len == 2 * regsize)
> {
> /* long double type is passed in a pair of GAR,
> - * with the low-order GRLEN bits in the lower-numbered register
> - * and the high-order GRLEN bits in the higher-numbered register.
> - * If exactly one register is available,
> - * the low-order GRLEN bits are passed in the register
> - * and the high-order GRLEN bits are passed on the stack.
> - * If no GAR is available, it's passed on the stack. */
> + with the low-order GRLEN bits in the lower-numbered register
> + and the high-order GRLEN bits in the higher-numbered register.
> + If exactly one register is available,
> + the low-order GRLEN bits are passed in the register
> + and the high-order GRLEN bits are passed on the stack.
> + If no GAR is available, it's passed on the stack. */
> if (gar >= 2)
> {
> pass_in_gar (regcache, gar--, val);
> @@ -595,24 +609,24 @@ loongarch_push_dummy_call (struct gdbarch *gdbarch,
> else if (gar == 1)
> {
> pass_in_gar (regcache, gar--, val);
> - pass_on_stack (regcache, val + regsize, len - regsize, align);
> + pass_on_stack (regcache, val + regsize, len - regsize, align, &addr);
> }
> else
> {
> - pass_on_stack (regcache, val, len, align);
> + pass_on_stack (regcache, val, len, align, &addr);
> }
> }
> else
> {
> /* The other floating-point type is passed in FAR.
> - * If no FAR is available, it's passed in GAR.
> - * If no GAR is available, it's passed on the stack. */
> + If no FAR is available, it's passed in GAR.
> + If no GAR is available, it's passed on the stack. */
> if (far > 0)
> pass_in_far (regcache, far--, val);
> else if (gar > 0)
> pass_in_gar (regcache, gar--, val);
> else
> - pass_on_stack (regcache, val, len, align);
> + pass_on_stack (regcache, val, len, align, &addr);
> }
> break;
> case TYPE_CODE_STRUCT:
> @@ -620,7 +634,10 @@ loongarch_push_dummy_call (struct gdbarch *gdbarch,
> fixed_point_members = 0;
> floating_point_members = 0;
> first_member_is_fixed_point = false;
> - compute_struct_member (type);
> + compute_struct_member (type,
> + &fixed_point_members,
> + &floating_point_members,
> + &first_member_is_fixed_point);
>
> if (len > 0 && len <= regsize)
> {
> @@ -628,20 +645,20 @@ loongarch_push_dummy_call (struct gdbarch *gdbarch,
> if (fixed_point_members > 0 && floating_point_members == 0)
> {
> /* If there is an available GAR,
> - * the structure is passed through the GAR by value passing;
> - * If no GAR is available, it's passed on the stack. */
> + the structure is passed through the GAR by value passing;
> + If no GAR is available, it's passed on the stack. */
> if (gar > 0)
> pass_in_gar (regcache, gar--, val);
> else
> - pass_on_stack (regcache, val, len, align);
> + pass_on_stack (regcache, val, len, align, &addr);
> }
> /* The structure has only floating-point members. */
> else if (fixed_point_members == 0 && floating_point_members > 0)
> {
> /* One floating-point member.
> - * The argument is passed in a FAR.
> - * If no FAR is available, the value is passed in a GAR.
> - * if no GAR is available, the value is passed on the stack. */
> + The argument is passed in a FAR.
> + If no FAR is available, the value is passed in a GAR.
> + if no GAR is available, the value is passed on the stack. */
> if (floating_point_members == 1)
> {
> if (far > 0)
> @@ -649,14 +666,14 @@ loongarch_push_dummy_call (struct gdbarch *gdbarch,
> else if (gar > 0)
> pass_in_gar (regcache, gar--, val);
> else
> - pass_on_stack (regcache, val, len, align);
> + pass_on_stack (regcache, val, len, align, &addr);
> }
> /* Two floating-point members.
> - * The argument is passed in a pair of available FAR,
> - * with the low-order float member bits in the lower-numbered FAR
> - * and the high-order float member bits in the higher-numbered FAR.
> - * If the number of available FAR is less than 2, it's passed in a GAR,
> - * and passed on the stack if no GAR is available. */
> + The argument is passed in a pair of available FAR,
> + with the low-order float member bits in the lower-numbered FAR
> + and the high-order float member bits in the higher-numbered FAR.
> + If the number of available FAR is less than 2, it's passed in a GAR,
> + and passed on the stack if no GAR is available. */
> else if (floating_point_members == 2)
> {
> if (far >= 2)
> @@ -670,7 +687,7 @@ loongarch_push_dummy_call (struct gdbarch *gdbarch,
> }
> else
> {
> - pass_on_stack (regcache, val, len, align);
> + pass_on_stack (regcache, val, len, align, &addr);
> }
> }
> }
> @@ -678,21 +695,21 @@ loongarch_push_dummy_call (struct gdbarch *gdbarch,
> else if (fixed_point_members > 0 && floating_point_members > 0)
> {
> /* One float member and multiple fixed-point members.
> - * If there are available GAR, the structure is passed in a GAR,
> - * and passed on the stack if no GAR is available. */
> + If there are available GAR, the structure is passed in a GAR,
> + and passed on the stack if no GAR is available. */
> if (floating_point_members == 1 && fixed_point_members > 1)
> {
> if (gar > 0)
> pass_in_gar (regcache, gar--, val);
> else
> - pass_on_stack (regcache, val, len, align);
> + pass_on_stack (regcache, val, len, align, &addr);
> }
> /* One float member and only one fixed-point member.
> - * If one FAR and one GAR are available,
> - * the floating-point member of the structure is passed in the FAR,
> - * and the fixed-point member of the structure is passed in the GAR.
> - * If no floating-point register but one GAR is available, it's passed in GAR;
> - * If no GAR is available, it's passed on the stack. */
> + If one FAR and one GAR are available,
> + the floating-point member of the structure is passed in the FAR,
> + and the fixed-point member of the structure is passed in the GAR.
> + If no floating-point register but one GAR is available, it's passed in GAR;
> + If no GAR is available, it's passed on the stack. */
> else if (floating_point_members == 1 && fixed_point_members == 1)
> {
> if (far > 0 && gar > 0)
> @@ -713,7 +730,7 @@ loongarch_push_dummy_call (struct gdbarch *gdbarch,
> if (gar > 0)
> pass_in_gar (regcache, gar--, val);
> else
> - pass_on_stack (regcache, val, len, align);
> + pass_on_stack (regcache, val, len, align, &addr);
> }
> }
> }
> @@ -724,12 +741,12 @@ loongarch_push_dummy_call (struct gdbarch *gdbarch,
> if (fixed_point_members > 0 && floating_point_members == 0)
> {
> /* The argument is passed in a pair of available GAR,
> - * with the low-order bits in the lower-numbered GAR
> - * and the high-order bits in the higher-numbered GAR.
> - * If only one GAR is available,
> - * the low-order bits are in the GAR
> - * and the high-order bits are on the stack,
> - * and passed on the stack if no GAR is available. */
> + with the low-order bits in the lower-numbered GAR
> + and the high-order bits in the higher-numbered GAR.
> + If only one GAR is available,
> + the low-order bits are in the GAR
> + and the high-order bits are on the stack,
> + and passed on the stack if no GAR is available. */
> if (gar >= 2)
> {
> pass_in_gar (regcache, gar--, val);
> @@ -738,26 +755,26 @@ loongarch_push_dummy_call (struct gdbarch *gdbarch,
> else if (gar == 1)
> {
> pass_in_gar (regcache, gar--, val);
> - pass_on_stack (regcache, val + regsize, len - regsize, align);
> + pass_on_stack (regcache, val + regsize, len - regsize, align, &addr);
> }
> else
> {
> - pass_on_stack (regcache, val, len, align);
> + pass_on_stack (regcache, val, len, align, &addr);
> }
> }
> /* Only floating-point members. */
> else if (fixed_point_members == 0 && floating_point_members > 0)
> {
> /* The structure has one long double member
> - * or one double member and two adjacent float members
> - * or 3-4 float members.
> - * The argument is passed in a pair of available GAR,
> - * with the low-order bits in the lower-numbered GAR
> - * and the high-order bits in the higher-numbered GAR.
> - * If only one GAR is available,
> - * the low-order bits are in the GAR
> - * and the high-order bits are on the stack,
> - * and passed on the stack if no GAR is available. */
> + or one double member and two adjacent float members
> + or 3-4 float members.
> + The argument is passed in a pair of available GAR,
> + with the low-order bits in the lower-numbered GAR
> + and the high-order bits in the higher-numbered GAR.
> + If only one GAR is available,
> + the low-order bits are in the GAR
> + and the high-order bits are on the stack,
> + and passed on the stack if no GAR is available. */
> if ((len == 16 && floating_point_members == 1)
> || (len == 16 && floating_point_members == 3)
> || (len == 12 && floating_point_members == 3)
> @@ -771,26 +788,26 @@ loongarch_push_dummy_call (struct gdbarch *gdbarch,
> else if (gar == 1)
> {
> pass_in_gar (regcache, gar--, val);
> - pass_on_stack (regcache, val + regsize, len - regsize, align);
> + pass_on_stack (regcache, val + regsize, len - regsize, align, &addr);
> }
> else
> {
> - pass_on_stack (regcache, val, len, align);
> + pass_on_stack (regcache, val, len, align, &addr);
> }
> }
> /* The structure with two double members
> - * is passed in a pair of available FAR,
> - * with the low-order bits in the lower-numbered FAR
> - * and the high-order bits in the higher-numbered FAR.
> - * If no a pair of available FAR,
> - * it's passed in a pair of available GAR,
> - * with the low-order bits in the lower-numbered GAR
> - * and the high-order bits in the higher-numbered GAR.
> - * If only one GAR is available,
> - * the low-order bits are in the GAR
> - * and the high-order bits are on stack,
> - * and passed on the stack if no GAR is available.
> - * A structure with one double member and one float member is same. */
> + is passed in a pair of available FAR,
> + with the low-order bits in the lower-numbered FAR
> + and the high-order bits in the higher-numbered FAR.
> + If no a pair of available FAR,
> + it's passed in a pair of available GAR,
> + with the low-order bits in the lower-numbered GAR
> + and the high-order bits in the higher-numbered GAR.
> + If only one GAR is available,
> + the low-order bits are in the GAR
> + and the high-order bits are on stack,
> + and passed on the stack if no GAR is available.
> + A structure with one double member and one float member is same. */
> else if ((len == 16 && floating_point_members == 2)
> || (len == 12 && floating_point_members == 2))
> {
> @@ -807,11 +824,11 @@ loongarch_push_dummy_call (struct gdbarch *gdbarch,
> else if (gar == 1)
> {
> pass_in_gar (regcache, gar--, val);
> - pass_on_stack (regcache, val + regsize, len - regsize, align);
> + pass_on_stack (regcache, val + regsize, len - regsize, align, &addr);
> }
> else
> {
> - pass_on_stack (regcache, val, len, align);
> + pass_on_stack (regcache, val, len, align, &addr);
> }
> }
> }
> @@ -822,14 +839,14 @@ loongarch_push_dummy_call (struct gdbarch *gdbarch,
> if (floating_point_members == 1 && fixed_point_members == 1)
> {
> /* If one FAR and one GAR are available,
> - * the floating-point member of the structure is passed in the FAR,
> - * and the fixed-point member of the structure is passed in the GAR;
> - * If no floating-point registers but two GARs are available,
> - * it's passed in the two GARs;
> - * If only one GAR is available,
> - * the low-order bits are in the GAR
> - * and the high-order bits are on the stack;
> - * And it's passed on the stack if no GAR is available. */
> + the floating-point member of the structure is passed in the FAR,
> + and the fixed-point member of the structure is passed in the GAR;
> + If no floating-point registers but two GARs are available,
> + it's passed in the two GARs;
> + If only one GAR is available,
> + the low-order bits are in the GAR
> + and the high-order bits are on the stack;
> + And it's passed on the stack if no GAR is available. */
> if (far > 0 && gar > 0)
> {
> if (first_member_is_fixed_point == false)
> @@ -851,22 +868,22 @@ loongarch_push_dummy_call (struct gdbarch *gdbarch,
> else if (far == 0 && gar == 1)
> {
> pass_in_gar (regcache, gar--, val);
> - pass_on_stack (regcache, val + regsize, len - regsize, align);
> + pass_on_stack (regcache, val + regsize, len - regsize, align, &addr);
> }
> else if (far == 0 && gar == 0)
> {
> - pass_on_stack (regcache, val, len, align);
> + pass_on_stack (regcache, val, len, align, &addr);
> }
> }
> else
> {
> /* The argument is passed in a pair of available GAR,
> - * with the low-order bits in the lower-numbered GAR
> - * and the high-order bits in the higher-numbered GAR.
> - * If only one GAR is available,
> - * the low-order bits are in the GAR
> - * and the high-order bits are on the stack,
> - * and passed on the stack if no GAR is available. */
> + with the low-order bits in the lower-numbered GAR
> + and the high-order bits in the higher-numbered GAR.
> + If only one GAR is available,
> + the low-order bits are in the GAR
> + and the high-order bits are on the stack,
> + and passed on the stack if no GAR is available. */
> if (gar >= 2)
> {
> pass_in_gar (regcache, gar--, val);
> @@ -875,11 +892,11 @@ loongarch_push_dummy_call (struct gdbarch *gdbarch,
> else if (gar == 1)
> {
> pass_in_gar (regcache, gar--, val);
> - pass_on_stack (regcache, val + regsize, len - regsize, align);
> + pass_on_stack (regcache, val + regsize, len - regsize, align, &addr);
> }
> else
> {
> - pass_on_stack (regcache, val, len, align);
> + pass_on_stack (regcache, val, len, align, &addr);
> }
> }
> }
> @@ -887,15 +904,15 @@ loongarch_push_dummy_call (struct gdbarch *gdbarch,
> else if (len > 2 * regsize)
> {
> /* It's passed by reference and are replaced in the argument list with the address.
> - * If there is an available GAR, the reference is passed in the GAR,
> - * and passed on the stack if no GAR is available. */
> + If there is an available GAR, the reference is passed in the GAR,
> + and passed on the stack if no GAR is available. */
> sp = align_down (sp - len, 16);
> write_memory (sp, val, len);
>
> if (gar > 0)
> pass_in_gar (regcache, gar--, (const gdb_byte *) &sp);
> else
> - pass_on_stack (regcache, (const gdb_byte*) &sp, len, regsize);
> + pass_on_stack (regcache, (const gdb_byte*) &sp, len, regsize, &addr);
> }
> }
> break;
> @@ -904,21 +921,21 @@ loongarch_push_dummy_call (struct gdbarch *gdbarch,
> if (len > 0 && len <= regsize)
> {
> /* The argument is passed in a GAR,
> - * or on the stack by value if no GAR is available. */
> + or on the stack by value if no GAR is available. */
> if (gar > 0)
> pass_in_gar (regcache, gar--, val);
> else
> - pass_on_stack (regcache, val, len, align);
> + pass_on_stack (regcache, val, len, align, &addr);
> }
> else if (len > regsize && len <= 2 * regsize)
> {
> /* The argument is passed in a pair of available GAR,
> - * with the low-order bits in the lower-numbered GAR
> - * and the high-order bits in the higher-numbered GAR.
> - * If only one GAR is available,
> - * the low-order bits are in the GAR
> - * and the high-order bits are on the stack.
> - * The arguments are passed on the stack when no GAR is available. */
> + with the low-order bits in the lower-numbered GAR
> + and the high-order bits in the higher-numbered GAR.
> + If only one GAR is available,
> + the low-order bits are in the GAR
> + and the high-order bits are on the stack.
> + The arguments are passed on the stack when no GAR is available. */
> if (gar >= 2)
> {
> pass_in_gar (regcache, gar--, val);
> @@ -927,25 +944,25 @@ loongarch_push_dummy_call (struct gdbarch *gdbarch,
> else if (gar == 1)
> {
> pass_in_gar (regcache, gar--, val);
> - pass_on_stack (regcache, val + regsize, len - regsize, align);
> + pass_on_stack (regcache, val + regsize, len - regsize, align, &addr);
> }
> else
> {
> - pass_on_stack (regcache, val, len, align);
> + pass_on_stack (regcache, val, len, align, &addr);
> }
> }
> else if (len > 2 * regsize)
> {
> /* It's passed by reference and are replaced in the argument list with the address.
> - * If there is an available GAR, the reference is passed in the GAR,
> - * and passed on the stack if no GAR is available. */
> + If there is an available GAR, the reference is passed in the GAR,
> + and passed on the stack if no GAR is available. */
> sp = align_down (sp - len, 16);
> write_memory (sp, val, len);
>
> if (gar > 0)
> pass_in_gar (regcache, gar--, (const gdb_byte *) &sp);
> else
> - pass_on_stack (regcache, (const gdb_byte*) &sp, len, regsize);
> + pass_on_stack (regcache, (const gdb_byte*) &sp, len, regsize, &addr);
> }
> break;
> case TYPE_CODE_COMPLEX:
> @@ -956,11 +973,11 @@ loongarch_push_dummy_call (struct gdbarch *gdbarch,
> if (target_len < regsize)
> {
> /* The complex with two float members
> - * is passed in a pair of available FAR,
> - * with the low-order float member bits in the lower-numbered FAR
> - * and the high-order float member bits in the higher-numbered FAR.
> - * If the number of available FAR is less than 2, it's passed in a GAR,
> - * and passed on the stack if no GAR is available. */
> + is passed in a pair of available FAR,
> + with the low-order float member bits in the lower-numbered FAR
> + and the high-order float member bits in the higher-numbered FAR.
> + If the number of available FAR is less than 2, it's passed in a GAR,
> + and passed on the stack if no GAR is available. */
> if (far >= 2)
> {
> pass_in_far (regcache, far--, val);
> @@ -972,23 +989,23 @@ loongarch_push_dummy_call (struct gdbarch *gdbarch,
> }
> else
> {
> - pass_on_stack (regcache, val, len, align);
> + pass_on_stack (regcache, val, len, align, &addr);
> }
> }
> else if (target_len == regsize)
> {
> /* The complex with two double members
> - * is passed in a pair of available FAR,
> - * with the low-order bits in the lower-numbered FAR
> - * and the high-order bits in the higher-numbered FAR.
> - * If no a pair of available FAR,
> - * it's passed in a pair of available GAR,
> - * with the low-order bits in the lower-numbered GAR
> - * and the high-order bits in the higher-numbered GAR.
> - * If only one GAR is available,
> - * the low-order bits are in the GAR
> - * and the high-order bits are on stack,
> - * and passed on the stack if no GAR is available. */
> + is passed in a pair of available FAR,
> + with the low-order bits in the lower-numbered FAR
> + and the high-order bits in the higher-numbered FAR.
> + If no a pair of available FAR,
> + it's passed in a pair of available GAR,
> + with the low-order bits in the lower-numbered GAR
> + and the high-order bits in the higher-numbered GAR.
> + If only one GAR is available,
> + the low-order bits are in the GAR
> + and the high-order bits are on stack,
> + and passed on the stack if no GAR is available. */
> {
> if (far >= 2)
> {
> @@ -1003,27 +1020,27 @@ loongarch_push_dummy_call (struct gdbarch *gdbarch,
> else if (gar == 1)
> {
> pass_in_gar (regcache, gar--, val);
> - pass_on_stack (regcache, val + align, len - align, align);
> + pass_on_stack (regcache, val + align, len - align, align, &addr);
> }
> else
> {
> - pass_on_stack (regcache, val, len, align);
> + pass_on_stack (regcache, val, len, align, &addr);
> }
> }
> }
> else if (target_len == 2 * regsize)
> {
> /* The complex with two long double members
> - * is passed by reference and are replaced in the argument list with the address.
> - * If there is an available GAR, the reference is passed in the GAR,
> - * and passed on the stack if no GAR is available. */
> + is passed by reference and are replaced in the argument list with the address.
> + If there is an available GAR, the reference is passed in the GAR,
> + and passed on the stack if no GAR is available. */
> sp = align_down (sp - len, 16);
> write_memory (sp, val, len);
>
> if (gar > 0)
> pass_in_gar (regcache, gar--, (const gdb_byte *) &sp);
> else
> - pass_on_stack (regcache, (const gdb_byte*) &sp, regsize, regsize);
> + pass_on_stack (regcache, (const gdb_byte*) &sp, regsize, regsize, &addr);
> }
> }
> break;
> --
> 2.1.0
^ permalink raw reply [flat|nested] 2+ messages in thread
end of thread, other threads:[~2022-07-18 14:05 UTC | newest]
Thread overview: 2+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2022-07-16 11:55 [PATCH] gdb: LoongArch: Fix code style issues Tiezhu Yang
2022-07-18 14:04 ` Andrew Burgess
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for read-only IMAP folder(s) and NNTP newsgroup(s).