From 5cb0f2d5b67ce2b4f60d5ad0b0a26ef918e8244f Mon Sep 17 00:00:00 2001 From: Tom Tromey Date: Fri, 9 Sep 2022 06:39:56 -0600 Subject: [PATCH] Convert selected architectures to gdbarch_return_value_as_value This converts a few selected architectures to use gdbarch_return_value_as_value rather than gdbarch_return_value. The architectures are just the ones that I am able to test. This patch should not introduce any behavior changes. --- gdb/aarch64-tdep.c | 10 ++++++++-- gdb/amd64-tdep.c | 13 ++++++++++--- gdb/amd64-windows-tdep.c | 11 +++++++++-- gdb/arm-tdep.c | 11 +++++++++-- gdb/i386-tdep.c | 21 ++++++++++++++++----- gdb/ppc-linux-tdep.c | 12 ++++++++++-- gdb/riscv-tdep.c | 11 +++++++++-- gdb/sparc-tdep.c | 11 +++++++++-- gdb/sparc64-tdep.c | 1 + 9 files changed, 81 insertions(+), 20 deletions(-) diff --git a/gdb/aarch64-tdep.c b/gdb/aarch64-tdep.c index 3cc0d3b234d..0371387ac78 100644 --- a/gdb/aarch64-tdep.c +++ b/gdb/aarch64-tdep.c @@ -2446,8 +2446,14 @@ aarch64_store_return_value (struct type *type, struct regcache *regs, static enum return_value_convention aarch64_return_value (struct gdbarch *gdbarch, struct value *func_value, struct type *valtype, struct regcache *regcache, - gdb_byte *readbuf, const gdb_byte *writebuf) + struct value **read_value, const gdb_byte *writebuf) { + gdb_byte *readbuf = nullptr; + if (read_value != nullptr) + { + *read_value = allocate_value (valtype); + readbuf = value_contents_raw (*read_value).data (); + } if (valtype->code () == TYPE_CODE_STRUCT || valtype->code () == TYPE_CODE_UNION @@ -3765,7 +3771,7 @@ aarch64_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches) set_gdbarch_dwarf2_reg_to_regnum (gdbarch, aarch64_dwarf_reg_to_regnum); /* Returning results. */ - set_gdbarch_return_value (gdbarch, aarch64_return_value); + set_gdbarch_return_value_as_value (gdbarch, aarch64_return_value); /* Disassembly. */ set_gdbarch_print_insn (gdbarch, aarch64_gdb_print_insn); diff --git a/gdb/amd64-tdep.c b/gdb/amd64-tdep.c index 0f2dab8b479..69d1f86b47a 100644 --- a/gdb/amd64-tdep.c +++ b/gdb/amd64-tdep.c @@ -789,7 +789,7 @@ amd64_classify (struct type *type, enum amd64_reg_class theclass[2]) static enum return_value_convention amd64_return_value (struct gdbarch *gdbarch, struct value *function, struct type *type, struct regcache *regcache, - gdb_byte *readbuf, const gdb_byte *writebuf) + struct value **read_value, const gdb_byte *writebuf) { enum amd64_reg_class theclass[2]; int len = type->length (); @@ -799,7 +799,14 @@ amd64_return_value (struct gdbarch *gdbarch, struct value *function, int sse_reg = 0; int i; - gdb_assert (!(readbuf && writebuf)); + gdb_assert (!(read_value && writebuf)); + + gdb_byte *readbuf = nullptr; + if (read_value != nullptr) + { + *read_value = allocate_value (type); + readbuf = value_contents_raw (*read_value).data (); + } /* 1. Classify the return type with the classification algorithm. */ amd64_classify (type, theclass); @@ -3236,7 +3243,7 @@ amd64_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch, set_gdbarch_register_to_value (gdbarch, i387_register_to_value); set_gdbarch_value_to_register (gdbarch, i387_value_to_register); - set_gdbarch_return_value (gdbarch, amd64_return_value); + set_gdbarch_return_value_as_value (gdbarch, amd64_return_value); set_gdbarch_skip_prologue (gdbarch, amd64_skip_prologue); diff --git a/gdb/amd64-windows-tdep.c b/gdb/amd64-windows-tdep.c index 14477e61fdd..6f7dbaa7002 100644 --- a/gdb/amd64-windows-tdep.c +++ b/gdb/amd64-windows-tdep.c @@ -355,11 +355,18 @@ amd64_windows_push_dummy_call static enum return_value_convention amd64_windows_return_value (struct gdbarch *gdbarch, struct value *function, struct type *type, struct regcache *regcache, - gdb_byte *readbuf, const gdb_byte *writebuf) + struct value **read_value, const gdb_byte *writebuf) { int len = type->length (); int regnum = -1; + gdb_byte *readbuf = nullptr; + if (read_value != nullptr) + { + *read_value = allocate_value (type); + readbuf = value_contents_raw (*read_value).data (); + } + /* See if our value is returned through a register. If it is, then store the associated register number in REGNUM. */ switch (type->code ()) @@ -1297,7 +1304,7 @@ amd64_windows_init_abi_common (gdbarch_info info, struct gdbarch *gdbarch) /* Function calls. */ set_gdbarch_push_dummy_call (gdbarch, amd64_windows_push_dummy_call); - set_gdbarch_return_value (gdbarch, amd64_windows_return_value); + set_gdbarch_return_value_as_value (gdbarch, amd64_windows_return_value); set_gdbarch_skip_main_prologue (gdbarch, amd64_skip_main_prologue); set_gdbarch_skip_trampoline_code (gdbarch, amd64_windows_skip_trampoline_code); diff --git a/gdb/arm-tdep.c b/gdb/arm-tdep.c index 7c9adbd9a0f..fa104392aec 100644 --- a/gdb/arm-tdep.c +++ b/gdb/arm-tdep.c @@ -9138,8 +9138,15 @@ arm_store_return_value (struct type *type, struct regcache *regs, static enum return_value_convention arm_return_value (struct gdbarch *gdbarch, struct value *function, struct type *valtype, struct regcache *regcache, - gdb_byte *readbuf, const gdb_byte *writebuf) + struct value **read_value, const gdb_byte *writebuf) { + gdb_byte *readbuf = nullptr; + if (read_value != nullptr) + { + *read_value = allocate_value (valtype); + readbuf = value_contents_raw (*read_value).data (); + } + arm_gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); struct type *func_type = function ? value_type (function) : NULL; enum arm_vfp_cprc_base_type vfp_base_type; @@ -10675,7 +10682,7 @@ arm_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches) set_gdbarch_register_name (gdbarch, arm_register_name); /* Returning results. */ - set_gdbarch_return_value (gdbarch, arm_return_value); + set_gdbarch_return_value_as_value (gdbarch, arm_return_value); /* Disassembly. */ set_gdbarch_print_insn (gdbarch, gdb_print_insn_arm); diff --git a/gdb/i386-tdep.c b/gdb/i386-tdep.c index 88daca47635..cc41dd80864 100644 --- a/gdb/i386-tdep.c +++ b/gdb/i386-tdep.c @@ -3030,10 +3030,17 @@ i386_reg_struct_return_p (struct gdbarch *gdbarch, struct type *type) static enum return_value_convention i386_return_value (struct gdbarch *gdbarch, struct value *function, struct type *type, struct regcache *regcache, - gdb_byte *readbuf, const gdb_byte *writebuf) + struct value **read_value, const gdb_byte *writebuf) { enum type_code code = type->code (); + gdb_byte *readbuf = nullptr; + if (read_value != nullptr) + { + *read_value = allocate_value (type); + readbuf = value_contents_raw (*read_value).data (); + } + if (((code == TYPE_CODE_STRUCT || code == TYPE_CODE_UNION || code == TYPE_CODE_ARRAY) @@ -3081,9 +3088,13 @@ i386_return_value (struct gdbarch *gdbarch, struct value *function, here. */ if (code == TYPE_CODE_STRUCT && type->num_fields () == 1) { - type = check_typedef (type->field (0).type ()); - return i386_return_value (gdbarch, function, type, regcache, - readbuf, writebuf); + struct type *inner_type = check_typedef (type->field (0).type ()); + enum return_value_convention result + = i386_return_value (gdbarch, function, inner_type, regcache, + read_value, writebuf); + if (read_value != nullptr) + deprecated_set_value_type (*read_value, type); + return result; } if (readbuf) @@ -8572,7 +8583,7 @@ i386_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches) set_gdbarch_register_to_value (gdbarch, i386_register_to_value); set_gdbarch_value_to_register (gdbarch, i386_value_to_register); - set_gdbarch_return_value (gdbarch, i386_return_value); + set_gdbarch_return_value_as_value (gdbarch, i386_return_value); set_gdbarch_skip_prologue (gdbarch, i386_skip_prologue); diff --git a/gdb/ppc-linux-tdep.c b/gdb/ppc-linux-tdep.c index 0c676a89935..918d8aad7da 100644 --- a/gdb/ppc-linux-tdep.c +++ b/gdb/ppc-linux-tdep.c @@ -249,8 +249,15 @@ ppc_linux_memory_remove_breakpoint (struct gdbarch *gdbarch, static enum return_value_convention ppc_linux_return_value (struct gdbarch *gdbarch, struct value *function, struct type *valtype, struct regcache *regcache, - gdb_byte *readbuf, const gdb_byte *writebuf) + struct value **read_value, const gdb_byte *writebuf) { + gdb_byte *readbuf = nullptr; + if (read_value != nullptr) + { + *read_value = allocate_value (valtype); + readbuf = value_contents_raw (*read_value).data (); + } + if ((valtype->code () == TYPE_CODE_STRUCT || valtype->code () == TYPE_CODE_UNION) && !((valtype->length () == 16 || valtype->length () == 8) @@ -2102,7 +2109,8 @@ ppc_linux_init_abi (struct gdbarch_info info, (well ignoring vectors that is). When this was corrected, it wasn't fixed for GNU/Linux native platform. Use the PowerOpen struct convention. */ - set_gdbarch_return_value (gdbarch, ppc_linux_return_value); + set_gdbarch_return_value_as_value (gdbarch, ppc_linux_return_value); + set_gdbarch_return_value (gdbarch, nullptr); set_gdbarch_memory_remove_breakpoint (gdbarch, ppc_linux_memory_remove_breakpoint); diff --git a/gdb/riscv-tdep.c b/gdb/riscv-tdep.c index 4b79c8906b5..bfda24ab3be 100644 --- a/gdb/riscv-tdep.c +++ b/gdb/riscv-tdep.c @@ -3221,13 +3221,20 @@ riscv_return_value (struct gdbarch *gdbarch, struct value *function, struct type *type, struct regcache *regcache, - gdb_byte *readbuf, + struct value **read_value, const gdb_byte *writebuf) { struct riscv_call_info call_info (gdbarch); struct riscv_arg_info info; struct type *arg_type; + gdb_byte *readbuf = nullptr; + if (read_value != nullptr) + { + *read_value = allocate_value (type); + readbuf = value_contents_raw (*read_value).data (); + } + arg_type = check_typedef (type); riscv_arg_location (gdbarch, &info, &call_info, arg_type, false); @@ -3888,7 +3895,7 @@ riscv_gdbarch_init (struct gdbarch_info info, set_gdbarch_type_align (gdbarch, riscv_type_align); /* Information about the target architecture. */ - set_gdbarch_return_value (gdbarch, riscv_return_value); + set_gdbarch_return_value_as_value (gdbarch, riscv_return_value); set_gdbarch_breakpoint_kind_from_pc (gdbarch, riscv_breakpoint_kind_from_pc); set_gdbarch_sw_breakpoint_from_kind (gdbarch, riscv_sw_breakpoint_from_kind); set_gdbarch_have_nonsteppable_watchpoint (gdbarch, 1); diff --git a/gdb/sparc-tdep.c b/gdb/sparc-tdep.c index 70053f45131..91cf391ec8a 100644 --- a/gdb/sparc-tdep.c +++ b/gdb/sparc-tdep.c @@ -1496,10 +1496,17 @@ sparc32_store_return_value (struct type *type, struct regcache *regcache, static enum return_value_convention sparc32_return_value (struct gdbarch *gdbarch, struct value *function, struct type *type, struct regcache *regcache, - gdb_byte *readbuf, const gdb_byte *writebuf) + struct value **read_value, const gdb_byte *writebuf) { enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); + gdb_byte *readbuf = nullptr; + if (read_value != nullptr) + { + *read_value = allocate_value (type); + readbuf = value_contents_raw (*read_value).data (); + } + /* The psABI says that "...every stack frame reserves the word at %fp+64. If a function returns a structure, union, or quad-precision value, this word should hold the address of the @@ -1853,7 +1860,7 @@ sparc32_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches) set_gdbarch_push_dummy_code (gdbarch, sparc32_push_dummy_code); set_gdbarch_push_dummy_call (gdbarch, sparc32_push_dummy_call); - set_gdbarch_return_value (gdbarch, sparc32_return_value); + set_gdbarch_return_value_as_value (gdbarch, sparc32_return_value); set_gdbarch_stabs_argument_has_addr (gdbarch, sparc32_stabs_argument_has_addr); diff --git a/gdb/sparc64-tdep.c b/gdb/sparc64-tdep.c index 9162f334e86..96910be3f0e 100644 --- a/gdb/sparc64-tdep.c +++ b/gdb/sparc64-tdep.c @@ -1835,6 +1835,7 @@ sparc64_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch) set_gdbarch_push_dummy_call (gdbarch, sparc64_push_dummy_call); set_gdbarch_return_value (gdbarch, sparc64_return_value); + set_gdbarch_return_value_as_value (gdbarch, default_gdbarch_return_value); set_gdbarch_stabs_argument_has_addr (gdbarch, default_stabs_argument_has_addr); -- 2.30.2