From 963e2bb72c415631fb836e137f24c6e0686fd205 Mon Sep 17 00:00:00 2001 From: Andrew Cagney Date: Mon, 10 Nov 2003 22:47:31 +0000 Subject: [PATCH] 2003-11-10 Andrew Cagney * gdbarch.sh (return_value): Replace "inval" and "outval" with "readbuf" and "writebuf". * ppcnbsd-tdep.c (ppcnbsd_return_value): Ditto. * d10v-tdep.c (d10v_return_value): Ditto. * ppc-tdep.h (ppc_sysv_abi_return_value): Ditto. (ppc_sysv_abi_broken_return_value): Ditto. (ppc64_sysv_abi_return_value): Ditto. * ppc-sysv-tdep.c (do_ppc_sysv_return_value): Ditto. (ppc_sysv_abi_return_value): Ditto. (ppc_sysv_abi_broken_return_value): Ditto. (ppc64_sysv_abi_return_value): Ditto. * values.c (register_value_being_returned): Update call. * stack.c (return_command): Update call. * gdbarch.h, gdbarch.c: Re-generate. Index: gdb/doc/ChangeLog 2003-11-10 Andrew Cagney * gdbint.texinfo (Target Architecture Definition): Replace the return_value method's "inval" and "outval" parameters with "readbuf" and "writebuf". --- gdb/ChangeLog | 15 +++++ gdb/d10v-tdep.c | 4 +- gdb/doc/ChangeLog | 6 ++ gdb/doc/gdbint.texinfo | 10 ++-- gdb/gdbarch.c | 4 +- gdb/gdbarch.h | 4 +- gdb/gdbarch.sh | 2 +- gdb/ppc-sysv-tdep.c | 146 +++++++++++++++++++++++++------------------------ gdb/ppc-tdep.h | 12 ++-- gdb/ppcnbsd-tdep.c | 5 +- gdb/stack.c | 5 +- gdb/values.c | 2 +- 12 files changed, 121 insertions(+), 94 deletions(-) diff --git a/gdb/ChangeLog b/gdb/ChangeLog index 04a0bb8..d846537 100644 --- a/gdb/ChangeLog +++ b/gdb/ChangeLog @@ -1,5 +1,20 @@ 2003-11-10 Andrew Cagney + * gdbarch.sh (return_value): Replace "inval" and "outval" with + "readbuf" and "writebuf". + * ppcnbsd-tdep.c (ppcnbsd_return_value): Ditto. + * d10v-tdep.c (d10v_return_value): Ditto. + * ppc-tdep.h (ppc_sysv_abi_return_value): Ditto. + (ppc_sysv_abi_broken_return_value): Ditto. + (ppc64_sysv_abi_return_value): Ditto. + * ppc-sysv-tdep.c (do_ppc_sysv_return_value): Ditto. + (ppc_sysv_abi_return_value): Ditto. + (ppc_sysv_abi_broken_return_value): Ditto. + (ppc64_sysv_abi_return_value): Ditto. + * values.c (register_value_being_returned): Update call. + * stack.c (return_command): Update call. + * gdbarch.h, gdbarch.c: Re-generate. + * target.h (struct target_ops): Order xfer buffer parameters "read write" not "write read". * bfd-target.c (target_bfd_xfer_partial): Update. diff --git a/gdb/d10v-tdep.c b/gdb/d10v-tdep.c index d3c61f9..6ad5ed5 100644 --- a/gdb/d10v-tdep.c +++ b/gdb/d10v-tdep.c @@ -378,8 +378,8 @@ d10v_integer_to_address (struct type *type, void *buf) static enum return_value_convention d10v_return_value (struct gdbarch *gdbarch, struct type *valtype, - struct regcache *regcache, const void *writebuf, - void *readbuf) + struct regcache *regcache, void *readbuf, + const void *writebuf) { if (TYPE_LENGTH (valtype) > 8) /* Anything larger than 8 bytes (4 registers) goes on the stack. */ diff --git a/gdb/doc/ChangeLog b/gdb/doc/ChangeLog index 374d05f..06fb5b2 100644 --- a/gdb/doc/ChangeLog +++ b/gdb/doc/ChangeLog @@ -1,3 +1,9 @@ +2003-11-10 Andrew Cagney + + * gdbint.texinfo (Target Architecture Definition): Replace the + return_value method's "inval" and "outval" parameters with + "readbuf" and "writebuf". + 2003-10-28 Jim Blandy * gdb.texinfo (The F request packet, The F reply packet): Renamed diff --git a/gdb/doc/gdbint.texinfo b/gdb/doc/gdbint.texinfo index 77e2b7e..3170ce2 100644 --- a/gdb/doc/gdbint.texinfo +++ b/gdb/doc/gdbint.texinfo @@ -3828,7 +3828,7 @@ allocated on the stack. @xref{unwind_dummy_id}. Define this to convert sdb register numbers into @value{GDBN} regnums. If not defined, no conversion will be done. -@item enum return_value_convention gdbarch_return_value (struct gdbarch *@var{gdbarch}, struct type *@var{valtype}, struct regcache *@var{regcache}, const void *@var{inval}, void *@var{outval}) +@item enum return_value_convention gdbarch_return_value (struct gdbarch *@var{gdbarch}, struct type *@var{valtype}, struct regcache *@var{regcache}, void *@var{readbuf}, const void *@var{writebuf}) @findex gdbarch_return_value @anchor{gdbarch_return_value} Given a function with a return-value of type @var{rettype}, return which return-value convention that function @@ -3840,13 +3840,13 @@ in registers; and @code{RETURN_VALUE_STRUCT_CONVENTION} where the return value is found in memory and the address of that memory location is passed in as the function's first parameter. -If the register convention is being used, and @var{inval} is -non-@code{NULL}, also copy the return-value in @var{inval} into +If the register convention is being used, and @var{writebuf} is +non-@code{NULL}, also copy the return-value in @var{writebuf} into @var{regcache}. -If the register convention is being used, and @var{outval} is +If the register convention is being used, and @var{readbuf} is non-@code{NULL}, also copy the return value from @var{regcache} into -@var{outval} (@var{regcache} contains a copy of the registers from the +@var{readbuf} (@var{regcache} contains a copy of the registers from the just returned function). @xref{EXTRACT_STRUCT_VALUE_ADDRESS}, for a description of how diff --git a/gdb/gdbarch.c b/gdb/gdbarch.c index 2d7683c..f73a4f6 100644 --- a/gdb/gdbarch.c +++ b/gdb/gdbarch.c @@ -4289,13 +4289,13 @@ gdbarch_return_value_p (struct gdbarch *gdbarch) } enum return_value_convention -gdbarch_return_value (struct gdbarch *gdbarch, struct type *valtype, struct regcache *regcache, const void *inval, void *outval) +gdbarch_return_value (struct gdbarch *gdbarch, struct type *valtype, struct regcache *regcache, void *readbuf, const void *writebuf) { gdb_assert (gdbarch != NULL); gdb_assert (gdbarch->return_value != NULL); if (gdbarch_debug >= 2) fprintf_unfiltered (gdb_stdlog, "gdbarch_return_value called\n"); - return gdbarch->return_value (gdbarch, valtype, regcache, inval, outval); + return gdbarch->return_value (gdbarch, valtype, regcache, readbuf, writebuf); } void diff --git a/gdb/gdbarch.h b/gdb/gdbarch.h index 766c20c..3affac5 100644 --- a/gdb/gdbarch.h +++ b/gdb/gdbarch.h @@ -1451,8 +1451,8 @@ extern void set_gdbarch_deprecated_store_struct_return (struct gdbarch *gdbarch, extern int gdbarch_return_value_p (struct gdbarch *gdbarch); -typedef enum return_value_convention (gdbarch_return_value_ftype) (struct gdbarch *gdbarch, struct type *valtype, struct regcache *regcache, const void *inval, void *outval); -extern enum return_value_convention gdbarch_return_value (struct gdbarch *gdbarch, struct type *valtype, struct regcache *regcache, const void *inval, void *outval); +typedef enum return_value_convention (gdbarch_return_value_ftype) (struct gdbarch *gdbarch, struct type *valtype, struct regcache *regcache, void *readbuf, const void *writebuf); +extern enum return_value_convention gdbarch_return_value (struct gdbarch *gdbarch, struct type *valtype, struct regcache *regcache, void *readbuf, const void *writebuf); extern void set_gdbarch_return_value (struct gdbarch *gdbarch, gdbarch_return_value_ftype *return_value); /* The deprecated methods RETURN_VALUE_ON_STACK, EXTRACT_RETURN_VALUE, diff --git a/gdb/gdbarch.sh b/gdb/gdbarch.sh index bf2f855..95db711 100755 --- a/gdb/gdbarch.sh +++ b/gdb/gdbarch.sh @@ -602,7 +602,7 @@ F:2:DEPRECATED_STORE_STRUCT_RETURN:void:deprecated_store_struct_return:CORE_ADDR # should take the type/value of the function to be called and not the # return type. This is left as an exercise for the reader. -M:::enum return_value_convention:return_value:struct type *valtype, struct regcache *regcache, const void *inval, void *outval:valtype, regcache, inval, outval +M:::enum return_value_convention:return_value:struct type *valtype, struct regcache *regcache, void *readbuf, const void *writebuf:valtype, regcache, readbuf, writebuf # The deprecated methods RETURN_VALUE_ON_STACK, EXTRACT_RETURN_VALUE, # STORE_RETURN_VALUE and USE_STRUCT_CONVENTION have all been folded diff --git a/gdb/ppc-sysv-tdep.c b/gdb/ppc-sysv-tdep.c index a1f5282..01438c1 100644 --- a/gdb/ppc-sysv-tdep.c +++ b/gdb/ppc-sysv-tdep.c @@ -323,8 +323,8 @@ ppc_sysv_abi_push_dummy_call (struct gdbarch *gdbarch, CORE_ADDR func_addr, static enum return_value_convention do_ppc_sysv_return_value (struct gdbarch *gdbarch, struct type *type, - struct regcache *regcache, const void *inval, - void *outval, int broken_gcc) + struct regcache *regcache, void *readbuf, + const void *writebuf, int broken_gcc) { struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); gdb_assert (tdep->wordsize == 4); @@ -332,22 +332,22 @@ do_ppc_sysv_return_value (struct gdbarch *gdbarch, struct type *type, && TYPE_LENGTH (type) <= 8 && ppc_floating_point_unit_p (gdbarch)) { - if (outval) + if (readbuf) { /* Floats and doubles stored in "f1". Convert the value to the required type. */ char regval[MAX_REGISTER_SIZE]; struct type *regtype = register_type (gdbarch, FP0_REGNUM + 1); regcache_cooked_read (regcache, FP0_REGNUM + 1, regval); - convert_typed_floating (regval, regtype, outval, type); + convert_typed_floating (regval, regtype, readbuf, type); } - if (inval) + if (writebuf) { /* Floats and doubles stored in "f1". Convert the value to the register's "double" type. */ char regval[MAX_REGISTER_SIZE]; struct type *regtype = register_type (gdbarch, FP0_REGNUM); - convert_typed_floating (inval, type, regval, regtype); + convert_typed_floating (writebuf, type, regval, regtype); regcache_cooked_write (regcache, FP0_REGNUM + 1, regval); } return RETURN_VALUE_REGISTER_CONVENTION; @@ -355,28 +355,28 @@ do_ppc_sysv_return_value (struct gdbarch *gdbarch, struct type *type, if ((TYPE_CODE (type) == TYPE_CODE_INT && TYPE_LENGTH (type) == 8) || (TYPE_CODE (type) == TYPE_CODE_FLT && TYPE_LENGTH (type) == 8)) { - if (outval) + if (readbuf) { /* A long long, or a double stored in the 32 bit r3/r4. */ regcache_cooked_read (regcache, tdep->ppc_gp0_regnum + 3, - (bfd_byte *) outval + 0); + (bfd_byte *) readbuf + 0); regcache_cooked_read (regcache, tdep->ppc_gp0_regnum + 4, - (bfd_byte *) outval + 4); + (bfd_byte *) readbuf + 4); } - if (inval) + if (writebuf) { /* A long long, or a double stored in the 32 bit r3/r4. */ regcache_cooked_write (regcache, tdep->ppc_gp0_regnum + 3, - (bfd_byte *) inval + 0); + (const bfd_byte *) writebuf + 0); regcache_cooked_write (regcache, tdep->ppc_gp0_regnum + 4, - (bfd_byte *) inval + 4); + (const bfd_byte *) writebuf + 4); } return RETURN_VALUE_REGISTER_CONVENTION; } if (TYPE_CODE (type) == TYPE_CODE_INT && TYPE_LENGTH (type) <= tdep->wordsize) { - if (outval) + if (readbuf) { /* Some sort of integer stored in r3. Since TYPE isn't bigger than the register, sign extension isn't a problem @@ -384,14 +384,14 @@ do_ppc_sysv_return_value (struct gdbarch *gdbarch, struct type *type, ULONGEST regval; regcache_cooked_read_unsigned (regcache, tdep->ppc_gp0_regnum + 3, ®val); - store_unsigned_integer (outval, TYPE_LENGTH (type), regval); + store_unsigned_integer (readbuf, TYPE_LENGTH (type), regval); } - if (inval) + if (writebuf) { /* Some sort of integer stored in r3. Use unpack_long since that should handle any required sign extension. */ regcache_cooked_write_unsigned (regcache, tdep->ppc_gp0_regnum + 3, - unpack_long (type, inval)); + unpack_long (type, writebuf)); } return RETURN_VALUE_REGISTER_CONVENTION; } @@ -399,15 +399,15 @@ do_ppc_sysv_return_value (struct gdbarch *gdbarch, struct type *type, && TYPE_CODE (type) == TYPE_CODE_ARRAY && TYPE_VECTOR (type) && tdep->ppc_vr0_regnum >= 0) { - if (outval) + if (readbuf) { /* Altivec places the return value in "v2". */ - regcache_cooked_read (regcache, tdep->ppc_vr0_regnum + 2, outval); + regcache_cooked_read (regcache, tdep->ppc_vr0_regnum + 2, readbuf); } - if (inval) + if (writebuf) { /* Altivec places the return value in "v2". */ - regcache_cooked_write (regcache, tdep->ppc_vr0_regnum + 2, inval); + regcache_cooked_write (regcache, tdep->ppc_vr0_regnum + 2, writebuf); } return RETURN_VALUE_REGISTER_CONVENTION; } @@ -420,15 +420,15 @@ do_ppc_sysv_return_value (struct gdbarch *gdbarch, struct type *type, corresponds to the entire r3 value for e500, whereas GDB's r3 only corresponds to the least significant 32-bits. So place the 64-bit DSP type's value in ev3. */ - if (outval) - regcache_cooked_read (regcache, tdep->ppc_ev0_regnum + 3, outval); - if (inval) - regcache_cooked_write (regcache, tdep->ppc_ev0_regnum + 3, inval); + if (readbuf) + regcache_cooked_read (regcache, tdep->ppc_ev0_regnum + 3, readbuf); + if (writebuf) + regcache_cooked_write (regcache, tdep->ppc_ev0_regnum + 3, writebuf); return RETURN_VALUE_REGISTER_CONVENTION; } if (broken_gcc && TYPE_LENGTH (type) <= 8) { - if (outval) + if (readbuf) { /* GCC screwed up. The last register isn't "left" aligned. Need to extract the least significant part of each @@ -446,12 +446,12 @@ do_ppc_sysv_return_value (struct gdbarch *gdbarch, struct type *type, regcache_cooked_read_unsigned (regcache, tdep->ppc_gp0_regnum + 3 + word, ®); - store_unsigned_integer (((bfd_byte *) outval + store_unsigned_integer (((bfd_byte *) readbuf + word * tdep->wordsize), len, reg); word++; } } - if (inval) + if (writebuf) { /* GCC screwed up. The last register isn't "left" aligned. Need to extract the least significant part of each @@ -466,7 +466,7 @@ do_ppc_sysv_return_value (struct gdbarch *gdbarch, struct type *type, break; if (len > tdep->wordsize) len = tdep->wordsize; - reg = extract_unsigned_integer (((bfd_byte *) inval + reg = extract_unsigned_integer (((const bfd_byte *) writebuf + word * tdep->wordsize), len); regcache_cooked_write_unsigned (regcache, tdep->ppc_gp0_regnum + 3 + word, @@ -478,7 +478,7 @@ do_ppc_sysv_return_value (struct gdbarch *gdbarch, struct type *type, } if (TYPE_LENGTH (type) <= 8) { - if (outval) + if (readbuf) { /* This matches SVr4 PPC, it does not match GCC. */ /* The value is right-padded to 8 bytes and then loaded, as @@ -489,16 +489,16 @@ do_ppc_sysv_return_value (struct gdbarch *gdbarch, struct type *type, if (TYPE_LENGTH (type) > tdep->wordsize) regcache_cooked_read (regcache, tdep->ppc_gp0_regnum + 4, regvals + 1 * tdep->wordsize); - memcpy (outval, regvals, TYPE_LENGTH (type)); + memcpy (readbuf, regvals, TYPE_LENGTH (type)); } - if (inval) + if (writebuf) { /* This matches SVr4 PPC, it does not match GCC. */ /* The value is padded out to 8 bytes and then loaded, as two "words" into r3/r4. */ char regvals[MAX_REGISTER_SIZE * 2]; memset (regvals, 0, sizeof regvals); - memcpy (regvals, inval, TYPE_LENGTH (type)); + memcpy (regvals, writebuf, TYPE_LENGTH (type)); regcache_cooked_write (regcache, tdep->ppc_gp0_regnum + 3, regvals + 0 * tdep->wordsize); if (TYPE_LENGTH (type) > tdep->wordsize) @@ -512,17 +512,21 @@ do_ppc_sysv_return_value (struct gdbarch *gdbarch, struct type *type, enum return_value_convention ppc_sysv_abi_return_value (struct gdbarch *gdbarch, struct type *valtype, - struct regcache *regcache, const void *inval, void *outval) + struct regcache *regcache, void *readbuf, + const void *writebuf) { - return do_ppc_sysv_return_value (gdbarch, valtype, regcache, inval, outval, 0); + return do_ppc_sysv_return_value (gdbarch, valtype, regcache, readbuf, + writebuf, 0); } enum return_value_convention -ppc_sysv_abi_broken_return_value (struct gdbarch *gdbarch, struct type *valtype, - struct regcache *regcache, const void *inval, - void *outval) +ppc_sysv_abi_broken_return_value (struct gdbarch *gdbarch, + struct type *valtype, + struct regcache *regcache, + void *readbuf, const void *writebuf) { - return do_ppc_sysv_return_value (gdbarch, valtype, regcache, inval, outval, 1); + return do_ppc_sysv_return_value (gdbarch, valtype, regcache, readbuf, + writebuf, 1); } /* Pass the arguments in either registers, or in the stack. Using the @@ -821,14 +825,14 @@ ppc64_sysv_abi_push_dummy_call (struct gdbarch *gdbarch, CORE_ADDR func_addr, 0 if the return-value is instead stored on the stack (a.k.a., struct return convention). - For a return-value stored in a register: when INVAL is non-NULL, + For a return-value stored in a register: when WRITEBUF is non-NULL, copy the buffer to the corresponding register return-value location - location; when OUTVAL is non-NULL, fill the buffer from the + location; when READBUF is non-NULL, fill the buffer from the corresponding register return-value location. */ enum return_value_convention ppc64_sysv_abi_return_value (struct gdbarch *gdbarch, struct type *valtype, - struct regcache *regcache, const void *inval, - void *outval) + struct regcache *regcache, void *readbuf, + const void *writebuf) { struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); /* Floats and doubles in F1. */ @@ -836,35 +840,35 @@ ppc64_sysv_abi_return_value (struct gdbarch *gdbarch, struct type *valtype, { char regval[MAX_REGISTER_SIZE]; struct type *regtype = register_type (gdbarch, FP0_REGNUM); - if (inval != NULL) + if (writebuf != NULL) { - convert_typed_floating (inval, valtype, regval, regtype); + convert_typed_floating (writebuf, valtype, regval, regtype); regcache_cooked_write (regcache, FP0_REGNUM + 1, regval); } - if (outval != NULL) + if (readbuf != NULL) { regcache_cooked_read (regcache, FP0_REGNUM + 1, regval); - convert_typed_floating (regval, regtype, outval, valtype); + convert_typed_floating (regval, regtype, readbuf, valtype); } return RETURN_VALUE_REGISTER_CONVENTION; } if (TYPE_CODE (valtype) == TYPE_CODE_INT && TYPE_LENGTH (valtype) <= 8) { /* Integers in r3. */ - if (inval != NULL) + if (writebuf != NULL) { /* Be careful to sign extend the value. */ regcache_cooked_write_unsigned (regcache, tdep->ppc_gp0_regnum + 3, - unpack_long (valtype, inval)); + unpack_long (valtype, writebuf)); } - if (outval != NULL) + if (readbuf != NULL) { /* Extract the integer from r3. Since this is truncating the value, there isn't a sign extension problem. */ ULONGEST regval; regcache_cooked_read_unsigned (regcache, tdep->ppc_gp0_regnum + 3, ®val); - store_unsigned_integer (outval, TYPE_LENGTH (valtype), regval); + store_unsigned_integer (readbuf, TYPE_LENGTH (valtype), regval); } return RETURN_VALUE_REGISTER_CONVENTION; } @@ -872,10 +876,10 @@ ppc64_sysv_abi_return_value (struct gdbarch *gdbarch, struct type *valtype, if (TYPE_CODE (valtype) == TYPE_CODE_PTR) { /* All pointers live in r3. */ - if (inval != NULL) - regcache_cooked_write (regcache, tdep->ppc_gp0_regnum + 3, inval); - if (outval != NULL) - regcache_cooked_read (regcache, tdep->ppc_gp0_regnum + 3, outval); + if (writebuf != NULL) + regcache_cooked_write (regcache, tdep->ppc_gp0_regnum + 3, writebuf); + if (readbuf != NULL) + regcache_cooked_read (regcache, tdep->ppc_gp0_regnum + 3, readbuf); return RETURN_VALUE_REGISTER_CONVENTION; } if (TYPE_CODE (valtype) == TYPE_CODE_ARRAY @@ -886,12 +890,12 @@ ppc64_sysv_abi_return_value (struct gdbarch *gdbarch, struct type *valtype, /* Small character arrays are returned, right justified, in r3. */ int offset = (register_size (gdbarch, tdep->ppc_gp0_regnum + 3) - TYPE_LENGTH (valtype)); - if (inval != NULL) + if (writebuf != NULL) regcache_cooked_write_part (regcache, tdep->ppc_gp0_regnum + 3, - offset, TYPE_LENGTH (valtype), inval); - if (outval != NULL) + offset, TYPE_LENGTH (valtype), writebuf); + if (readbuf != NULL) regcache_cooked_read_part (regcache, tdep->ppc_gp0_regnum + 3, - offset, TYPE_LENGTH (valtype), outval); + offset, TYPE_LENGTH (valtype), readbuf); return RETURN_VALUE_REGISTER_CONVENTION; } /* Big floating point values get stored in adjacent floating @@ -899,17 +903,17 @@ ppc64_sysv_abi_return_value (struct gdbarch *gdbarch, struct type *valtype, if (TYPE_CODE (valtype) == TYPE_CODE_FLT && (TYPE_LENGTH (valtype) == 16 || TYPE_LENGTH (valtype) == 32)) { - if (inval || outval != NULL) + if (writebuf || readbuf != NULL) { int i; for (i = 0; i < TYPE_LENGTH (valtype) / 8; i++) { - if (inval != NULL) + if (writebuf != NULL) regcache_cooked_write (regcache, FP0_REGNUM + 1 + i, - (const bfd_byte *) inval + i * 8); - if (outval != NULL) + (const bfd_byte *) writebuf + i * 8); + if (readbuf != NULL) regcache_cooked_read (regcache, FP0_REGNUM + 1 + i, - (bfd_byte *) outval + i * 8); + (bfd_byte *) readbuf + i * 8); } } return RETURN_VALUE_REGISTER_CONVENTION; @@ -926,19 +930,19 @@ ppc64_sysv_abi_return_value (struct gdbarch *gdbarch, struct type *valtype, char regval[MAX_REGISTER_SIZE]; struct type *regtype = register_type (current_gdbarch, FP0_REGNUM); - if (inval != NULL) + if (writebuf != NULL) { - convert_typed_floating ((const bfd_byte *) inval + + convert_typed_floating ((const bfd_byte *) writebuf + i * (TYPE_LENGTH (valtype) / 2), valtype, regval, regtype); regcache_cooked_write (regcache, FP0_REGNUM + 1 + i, regval); } - if (outval != NULL) + if (readbuf != NULL) { regcache_cooked_read (regcache, FP0_REGNUM + 1 + i, regval); convert_typed_floating (regval, regtype, - (bfd_byte *) outval + + (bfd_byte *) readbuf + i * (TYPE_LENGTH (valtype) / 2), valtype); } @@ -954,12 +958,12 @@ ppc64_sysv_abi_return_value (struct gdbarch *gdbarch, struct type *valtype, int i; for (i = 0; i < 4; i++) { - if (inval != NULL) + if (writebuf != NULL) regcache_cooked_write (regcache, FP0_REGNUM + 1 + i, - (const bfd_byte *) inval + i * 8); - if (outval != NULL) + (const bfd_byte *) writebuf + i * 8); + if (readbuf != NULL) regcache_cooked_read (regcache, FP0_REGNUM + 1 + i, - (bfd_byte *) outval + i * 8); + (bfd_byte *) readbuf + i * 8); } } return RETURN_VALUE_REGISTER_CONVENTION; diff --git a/gdb/ppc-tdep.h b/gdb/ppc-tdep.h index 7adf579..1c1c9ef 100644 --- a/gdb/ppc-tdep.h +++ b/gdb/ppc-tdep.h @@ -37,13 +37,13 @@ CORE_ADDR ppc_linux_frame_chain (struct frame_info *); enum return_value_convention ppc_sysv_abi_return_value (struct gdbarch *gdbarch, struct type *valtype, struct regcache *regcache, - const void *inval, - void *outval); + void *readbuf, + const void *writebuf); enum return_value_convention ppc_sysv_abi_broken_return_value (struct gdbarch *gdbarch, struct type *valtype, struct regcache *regcache, - const void *inval, - void *outval); + void *readbuf, + const void *writebuf); CORE_ADDR ppc_sysv_abi_push_dummy_call (struct gdbarch *gdbarch, CORE_ADDR func_addr, struct regcache *regcache, @@ -68,8 +68,8 @@ void ppc_linux_supply_fpregset (char *buf); enum return_value_convention ppc64_sysv_abi_return_value (struct gdbarch *gdbarch, struct type *valtype, struct regcache *regcache, - const void *inval, - void *outval); + void *readbuf, + const void *writebuf); /* From rs6000-tdep.c... */ CORE_ADDR rs6000_frame_saved_pc (struct frame_info *fi); diff --git a/gdb/ppcnbsd-tdep.c b/gdb/ppcnbsd-tdep.c index ab535c4..adc2a4f 100644 --- a/gdb/ppcnbsd-tdep.c +++ b/gdb/ppcnbsd-tdep.c @@ -210,7 +210,8 @@ ppcnbsd_pc_in_sigtramp (CORE_ADDR pc, char *func_name) static enum return_value_convention ppcnbsd_return_value (struct gdbarch *gdbarch, struct type *valtype, - struct regcache *regcache, const void *inval, void *outval) + struct regcache *regcache, void *readbuf, + const void *writebuf) { if ((TYPE_CODE (valtype) == TYPE_CODE_STRUCT || TYPE_CODE (valtype) == TYPE_CODE_UNION) @@ -223,7 +224,7 @@ ppcnbsd_return_value (struct gdbarch *gdbarch, struct type *valtype, return RETURN_VALUE_STRUCT_CONVENTION; else return ppc_sysv_abi_broken_return_value (gdbarch, valtype, regcache, - inval, outval); + readbuf, writebuf); } static void diff --git a/gdb/stack.c b/gdb/stack.c index 723f1e5..dc8733e 100644 --- a/gdb/stack.c +++ b/gdb/stack.c @@ -1935,8 +1935,9 @@ The location at which to store the function's return value is unknown.\n"; gdb_assert (gdbarch_return_value (current_gdbarch, return_type, NULL, NULL, NULL) == RETURN_VALUE_REGISTER_CONVENTION); - gdbarch_return_value (current_gdbarch, return_type, current_regcache, - VALUE_CONTENTS (return_value), NULL); + gdbarch_return_value (current_gdbarch, return_type, + current_regcache, NULL /*read*/, + VALUE_CONTENTS (return_value) /*write*/); } } diff --git a/gdb/values.c b/gdb/values.c index aba500c..a8d8480 100644 --- a/gdb/values.c +++ b/gdb/values.c @@ -1243,7 +1243,7 @@ register_value_being_returned (struct type *valtype, struct regcache *retbuf) NULL, NULL, NULL) == RETURN_VALUE_REGISTER_CONVENTION); gdbarch_return_value (current_gdbarch, valtype, retbuf, - NULL, VALUE_CONTENTS_RAW (val)); + VALUE_CONTENTS_RAW (val) /*read*/, NULL /*write*/); return val; } -- 2.7.4