From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (qmail 32537 invoked by alias); 18 Jan 2004 01:06:45 -0000 Mailing-List: contact gdb-patches-help@sources.redhat.com; run by ezmlm Precedence: bulk List-Subscribe: List-Archive: List-Post: List-Help: , Sender: gdb-patches-owner@sources.redhat.com Received: (qmail 31750 invoked from network); 18 Jan 2004 01:05:04 -0000 Received: from unknown (HELO localhost.redhat.com) (65.49.4.239) by sources.redhat.com with SMTP; 18 Jan 2004 01:05:04 -0000 Received: from gnu.org (localhost [127.0.0.1]) by localhost.redhat.com (Postfix) with ESMTP id 7543A2B8F; Sat, 17 Jan 2004 20:04:53 -0500 (EST) Message-ID: <4009DBB5.2030605@gnu.org> Date: Sun, 18 Jan 2004 01:06:00 -0000 From: Andrew Cagney User-Agent: Mozilla/5.0 (X11; U; NetBSD macppc; en-US; rv:1.0.2) Gecko/20030820 MIME-Version: 1.0 To: gdb-patches@sources.redhat.com Subject: [patch/rfc:rfa:doco] Deprecate extract_struct_value_address Content-Type: multipart/mixed; boundary="------------060504070609000102070009" X-SW-Source: 2004-01/txt/msg00461.txt.bz2 This is a multi-part message in MIME format. --------------060504070609000102070009 Content-Type: text/plain; charset=us-ascii; format=flowed Content-Transfer-Encoding: 7bit Content-length: 954 Hello, Ref: [rfc] Struct return values http://sources.redhat.com/ml/gdb/2004-01/msg00123.html This deprecates the existing extract_struct_value_address, clearing the way for a replacement such as extract_returned_value_address. As the comments note, other than the 32-bit SPARC, no ABI has so far been identified that allows for the robust implementation of an extract struct-convention return-value's address method. Further, a quick glance through the remaining extract methods suggests that they too are broken - the're all trying to extract the return-value from a register and typical ABIs don't guarentee that the return-value address register is preserved across function calls. The patch also adds a bunch of comments to core-GDB to [hopefully] point the way to the required changes needed to make the 32-bit SPARC ABIs case work. I don't have a SPARC handy so MarkK, over to you :-/ Comments? I'll give this part a week. Andrew --------------060504070609000102070009 Content-Type: text/plain; name="diffs" Content-Transfer-Encoding: 7bit Content-Disposition: inline; filename="diffs" Content-length: 22471 2004-01-17 Andrew Cagney * gdbarch.sh (EXTRACT_STRUCT_VALUE_ADDRESS): Deprecate. Add comments mentioning extract_returned_value_address. * infcmd.c (print_return_value): Update. Add comments on extract_returned_value_address. * stack.c (return_command): Add comments on extract_returned_value_address. * values.c: Update comment. * m32r-tdep.c: Update comment. * sparc-tdep.c: Update comment. * ia64-tdep.c (ia64_use_struct_convention): Update comment. * xstormy16-tdep.c (xstormy16_gdbarch_init): Update. * sh64-tdep.c (sh64_gdbarch_init): Update. * sh-tdep.c (sh_gdbarch_init): Update. * s390-tdep.c (s390_gdbarch_init): Update. * rs6000-tdep.c (rs6000_gdbarch_init): Update. * m68klinux-tdep.c (m68k_linux_init_abi): Update. * m68k-tdep.c (m68k_gdbarch_init): Update. * m68hc11-tdep.c (m68hc11_gdbarch_init): Update. * m32r-tdep.c (m32r_gdbarch_init): Update. * ia64-tdep.c (ia64_gdbarch_init): Update. * h8300-tdep.c (h8300_gdbarch_init): Update. * frv-tdep.c (frv_gdbarch_init): Update. * arm-tdep.c (arm_gdbarch_init): Update. * alpha-tdep.c (alpha_gdbarch_init): Update. Index: doc/ChangeLog 2004-01-17 Andrew Cagney * gdbint.texinfo (Target Architecture Definition): Rename EXTRACT_STRUCT_VALUE_ADDRESS to DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS. Index: alpha-tdep.c =================================================================== RCS file: /cvs/src/src/gdb/alpha-tdep.c,v retrieving revision 1.124 diff -u -r1.124 alpha-tdep.c --- alpha-tdep.c 13 Jan 2004 21:38:45 -0000 1.124 +++ alpha-tdep.c 18 Jan 2004 00:04:34 -0000 @@ -1537,8 +1537,7 @@ set_gdbarch_use_struct_convention (gdbarch, always_use_struct_convention); set_gdbarch_extract_return_value (gdbarch, alpha_extract_return_value); set_gdbarch_store_return_value (gdbarch, alpha_store_return_value); - set_gdbarch_extract_struct_value_address (gdbarch, - alpha_extract_struct_value_address); + set_gdbarch_deprecated_extract_struct_value_address (gdbarch, alpha_extract_struct_value_address); /* Settings for calling functions in the inferior. */ set_gdbarch_push_dummy_call (gdbarch, alpha_push_dummy_call); Index: arm-tdep.c =================================================================== RCS file: /cvs/src/src/gdb/arm-tdep.c,v retrieving revision 1.157 diff -u -r1.157 arm-tdep.c --- arm-tdep.c 17 Jan 2004 15:34:11 -0000 1.157 +++ arm-tdep.c 18 Jan 2004 00:05:02 -0000 @@ -2906,8 +2906,7 @@ set_gdbarch_extract_return_value (gdbarch, arm_extract_return_value); set_gdbarch_store_return_value (gdbarch, arm_store_return_value); set_gdbarch_use_struct_convention (gdbarch, arm_use_struct_convention); - set_gdbarch_extract_struct_value_address (gdbarch, - arm_extract_struct_value_address); + set_gdbarch_deprecated_extract_struct_value_address (gdbarch, arm_extract_struct_value_address); /* Single stepping. */ /* XXX For an RDI target we should ask the target if it can single-step. */ Index: frv-tdep.c =================================================================== RCS file: /cvs/src/src/gdb/frv-tdep.c,v retrieving revision 1.66 diff -u -r1.66 frv-tdep.c --- frv-tdep.c 17 Jan 2004 15:34:11 -0000 1.66 +++ frv-tdep.c 18 Jan 2004 00:05:20 -0000 @@ -1402,7 +1402,7 @@ set_gdbarch_deprecated_store_struct_return (gdbarch, frv_store_struct_return); set_gdbarch_store_return_value (gdbarch, frv_store_return_value); - set_gdbarch_extract_struct_value_address (gdbarch, frv_extract_struct_value_address); + set_gdbarch_deprecated_extract_struct_value_address (gdbarch, frv_extract_struct_value_address); /* Frame stuff. */ set_gdbarch_unwind_pc (gdbarch, frv_unwind_pc); Index: gdbarch.sh =================================================================== RCS file: /cvs/src/src/gdb/gdbarch.sh,v retrieving revision 1.293 diff -u -r1.293 gdbarch.sh --- gdbarch.sh 17 Jan 2004 23:21:21 -0000 1.293 +++ gdbarch.sh 18 Jan 2004 00:29:11 -0000 @@ -606,11 +606,7 @@ # The deprecated methods RETURN_VALUE_ON_STACK, EXTRACT_RETURN_VALUE, # STORE_RETURN_VALUE and USE_STRUCT_CONVENTION have all been folded -# into RETURN_VALUE. For the moment do not try to fold in -# EXTRACT_STRUCT_VALUE_ADDRESS as, dependant on the ABI, the debug -# info, and the level of effort, it may well be possible to find the -# address of a structure being return on the stack. Someone else can -# make that change. +# into RETURN_VALUE. f:2:RETURN_VALUE_ON_STACK:int:return_value_on_stack:struct type *type:type:::generic_return_value_on_stack_not::0 f:2:EXTRACT_RETURN_VALUE:void:extract_return_value:struct type *type, struct regcache *regcache, void *valbuf:type, regcache, valbuf:::legacy_extract_return_value::0 @@ -619,8 +615,27 @@ f:2:DEPRECATED_STORE_RETURN_VALUE:void:deprecated_store_return_value:struct type *type, char *valbuf:type, valbuf f:2:USE_STRUCT_CONVENTION:int:use_struct_convention:int gcc_p, struct type *value_type:gcc_p, value_type:::generic_use_struct_convention::0 -F:2:EXTRACT_STRUCT_VALUE_ADDRESS:CORE_ADDR:extract_struct_value_address:struct regcache *regcache:regcache -# +# As of 2004-01-17 only the 32-bit SPARC ABI has been identified as an +# ABI suitable for the implementation of a robust extract +# struct-convention return-value address method (the sparc saves the +# address in the callers frame). All the other cases so far examined, +# the DEPRECATED_EXTRACT_STRUCT_VALUE implementation has been +# erreneous - the code was incorrectly assuming that the return-value +# address, stored in a register, was preserved across the entire +# function call. + +# For the moment retain DEPRECATED_EXTRACT_STRUCT_VALUE as a marker of +# the ABIs that are still to be analyzed - perhaps this should simply +# be deleted. The commented out extract_returned_value_address method +# is provided as a starting point for the 32-bit SPARC. It, or +# something like it, along with changes to both infcmd.c and stack.c +# will be needed for that case to work. NB: It is passed the callers +# frame since it is only after the callee has returned that this +# function is used. + +#M:::CORE_ADDR:extract_returned_value_address:struct frame_info *caller_frame:caller_frame +F:2:DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS:CORE_ADDR:deprecated_extract_struct_value_address:struct regcache *regcache:regcache + F:2:DEPRECATED_FRAME_INIT_SAVED_REGS:void:deprecated_frame_init_saved_regs:struct frame_info *frame:frame F:2:DEPRECATED_INIT_EXTRA_FRAME_INFO:void:deprecated_init_extra_frame_info:int fromleaf, struct frame_info *frame:fromleaf, frame # Index: h8300-tdep.c =================================================================== RCS file: /cvs/src/src/gdb/h8300-tdep.c,v retrieving revision 1.89 diff -u -r1.89 h8300-tdep.c --- h8300-tdep.c 17 Jan 2004 15:34:11 -0000 1.89 +++ h8300-tdep.c 18 Jan 2004 00:29:11 -0000 @@ -1328,8 +1328,7 @@ set_gdbarch_frameless_function_invocation (gdbarch, frameless_look_for_prologue); - set_gdbarch_extract_struct_value_address (gdbarch, - h8300_extract_struct_value_address); + set_gdbarch_deprecated_extract_struct_value_address (gdbarch, h8300_extract_struct_value_address); set_gdbarch_use_struct_convention (gdbarch, always_use_struct_convention); set_gdbarch_breakpoint_from_pc (gdbarch, h8300_breakpoint_from_pc); set_gdbarch_push_dummy_code (gdbarch, h8300_push_dummy_code); Index: ia64-tdep.c =================================================================== RCS file: /cvs/src/src/gdb/ia64-tdep.c,v retrieving revision 1.109 diff -u -r1.109 ia64-tdep.c --- ia64-tdep.c 17 Jan 2004 15:34:11 -0000 1.109 +++ ia64-tdep.c 18 Jan 2004 00:29:19 -0000 @@ -2709,9 +2709,9 @@ #endif /* HAVE_LIBUNWIND_IA64_H */ -/* Should we use EXTRACT_STRUCT_VALUE_ADDRESS instead of - EXTRACT_RETURN_VALUE? GCC_P is true if compiled with gcc - and TYPE is the type (which is known to be struct, union or array). */ +/* Should we use DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS instead of + EXTRACT_RETURN_VALUE? GCC_P is true if compiled with gcc and TYPE + is the type (which is known to be struct, union or array). */ int ia64_use_struct_convention (int gcc_p, struct type *type) { @@ -3400,7 +3400,7 @@ set_gdbarch_extract_return_value (gdbarch, ia64_extract_return_value); set_gdbarch_store_return_value (gdbarch, ia64_store_return_value); - set_gdbarch_extract_struct_value_address (gdbarch, ia64_extract_struct_value_address); + set_gdbarch_deprecated_extract_struct_value_address (gdbarch, ia64_extract_struct_value_address); set_gdbarch_memory_insert_breakpoint (gdbarch, ia64_memory_insert_breakpoint); set_gdbarch_memory_remove_breakpoint (gdbarch, ia64_memory_remove_breakpoint); Index: infcmd.c =================================================================== RCS file: /cvs/src/src/gdb/infcmd.c,v retrieving revision 1.100 diff -u -r1.100 infcmd.c --- infcmd.c 17 Jan 2004 20:17:40 -0000 1.100 +++ infcmd.c 18 Jan 2004 00:29:20 -0000 @@ -1080,6 +1080,9 @@ ui_out_field_stream (uiout, "return-value", stb); ui_out_text (uiout, "\n"); } + /* FIXME: cagney/2004-01-17: When both return_value and + extract_returned_value_address are available, should use that to + find the address of and then extract the returned value. */ /* FIXME: 2003-09-27: When returning from a nested inferior function call, it's possible (with no help from the architecture vector) to locate and return/print a "struct return" value. This is just @@ -1102,9 +1105,9 @@ } else { - if (EXTRACT_STRUCT_VALUE_ADDRESS_P ()) + if (DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS_P ()) { - CORE_ADDR addr = EXTRACT_STRUCT_VALUE_ADDRESS (stop_registers); + CORE_ADDR addr = DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS (stop_registers); if (!addr) error ("Function return value unknown."); value = value_at (value_type, addr, NULL); Index: m32r-tdep.c =================================================================== RCS file: /cvs/src/src/gdb/m32r-tdep.c,v retrieving revision 1.22 diff -u -r1.22 m32r-tdep.c --- m32r-tdep.c 17 Jan 2004 15:34:12 -0000 1.22 +++ m32r-tdep.c 18 Jan 2004 00:29:23 -0000 @@ -75,9 +75,9 @@ return sp & ~3; } -/* Should we use EXTRACT_STRUCT_VALUE_ADDRESS instead of - EXTRACT_RETURN_VALUE? GCC_P is true if compiled with gcc - and TYPE is the type (which is known to be struct, union or array). +/* Should we use DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS instead of + EXTRACT_RETURN_VALUE? GCC_P is true if compiled with gcc and TYPE + is the type (which is known to be struct, union or array). The m32r returns anything less than 8 bytes in size in registers. */ @@ -939,8 +939,7 @@ set_gdbarch_extract_return_value (gdbarch, m32r_extract_return_value); set_gdbarch_push_dummy_call (gdbarch, m32r_push_dummy_call); set_gdbarch_store_return_value (gdbarch, m32r_store_return_value); - set_gdbarch_extract_struct_value_address (gdbarch, - m32r_extract_struct_value_address); + set_gdbarch_deprecated_extract_struct_value_address (gdbarch, m32r_extract_struct_value_address); set_gdbarch_use_struct_convention (gdbarch, m32r_use_struct_convention); set_gdbarch_skip_prologue (gdbarch, m32r_skip_prologue); Index: m68hc11-tdep.c =================================================================== RCS file: /cvs/src/src/gdb/m68hc11-tdep.c,v retrieving revision 1.96 diff -u -r1.96 m68hc11-tdep.c --- m68hc11-tdep.c 17 Jan 2004 22:45:44 -0000 1.96 +++ m68hc11-tdep.c 18 Jan 2004 00:29:23 -0000 @@ -1553,7 +1553,7 @@ set_gdbarch_store_return_value (gdbarch, m68hc11_store_return_value); set_gdbarch_store_return_value (gdbarch, m68hc11_store_return_value); - set_gdbarch_extract_struct_value_address (gdbarch, m68hc11_extract_struct_value_address); + set_gdbarch_deprecated_extract_struct_value_address (gdbarch, m68hc11_extract_struct_value_address); set_gdbarch_use_struct_convention (gdbarch, m68hc11_use_struct_convention); set_gdbarch_skip_prologue (gdbarch, m68hc11_skip_prologue); set_gdbarch_inner_than (gdbarch, core_addr_lessthan); Index: m68k-tdep.c =================================================================== RCS file: /cvs/src/src/gdb/m68k-tdep.c,v retrieving revision 1.76 diff -u -r1.76 m68k-tdep.c --- m68k-tdep.c 13 Jan 2004 21:38:46 -0000 1.76 +++ m68k-tdep.c 18 Jan 2004 00:29:51 -0000 @@ -1118,8 +1118,7 @@ set_gdbarch_extract_return_value (gdbarch, m68k_extract_return_value); set_gdbarch_store_return_value (gdbarch, m68k_store_return_value); - set_gdbarch_extract_struct_value_address (gdbarch, - m68k_extract_struct_value_address); + set_gdbarch_deprecated_extract_struct_value_address (gdbarch, m68k_extract_struct_value_address); set_gdbarch_use_struct_convention (gdbarch, m68k_use_struct_convention); set_gdbarch_frameless_function_invocation (gdbarch, Index: m68klinux-tdep.c =================================================================== RCS file: /cvs/src/src/gdb/m68klinux-tdep.c,v retrieving revision 1.8 diff -u -r1.8 m68klinux-tdep.c --- m68klinux-tdep.c 9 Jul 2003 21:36:08 -0000 1.8 +++ m68klinux-tdep.c 18 Jan 2004 00:29:52 -0000 @@ -294,8 +294,7 @@ set_gdbarch_extract_return_value (gdbarch, m68k_linux_extract_return_value); set_gdbarch_store_return_value (gdbarch, m68k_linux_store_return_value); - set_gdbarch_extract_struct_value_address (gdbarch, - m68k_linux_extract_struct_value_address); + set_gdbarch_deprecated_extract_struct_value_address (gdbarch, m68k_linux_extract_struct_value_address); set_gdbarch_pc_in_sigtramp (gdbarch, m68k_linux_pc_in_sigtramp); Index: rs6000-tdep.c =================================================================== RCS file: /cvs/src/src/gdb/rs6000-tdep.c,v retrieving revision 1.176 diff -u -r1.176 rs6000-tdep.c --- rs6000-tdep.c 17 Jan 2004 15:34:12 -0000 1.176 +++ rs6000-tdep.c 18 Jan 2004 00:30:27 -0000 @@ -2892,7 +2892,7 @@ else set_gdbarch_push_dummy_call (gdbarch, rs6000_push_dummy_call); - set_gdbarch_extract_struct_value_address (gdbarch, rs6000_extract_struct_value_address); + set_gdbarch_deprecated_extract_struct_value_address (gdbarch, rs6000_extract_struct_value_address); set_gdbarch_deprecated_pop_frame (gdbarch, rs6000_pop_frame); set_gdbarch_skip_prologue (gdbarch, rs6000_skip_prologue); Index: s390-tdep.c =================================================================== RCS file: /cvs/src/src/gdb/s390-tdep.c,v retrieving revision 1.119 diff -u -r1.119 s390-tdep.c --- s390-tdep.c 13 Jan 2004 21:38:47 -0000 1.119 +++ s390-tdep.c 18 Jan 2004 00:30:39 -0000 @@ -2628,7 +2628,7 @@ set_gdbarch_stab_reg_to_regnum (gdbarch, s390_stab_reg_to_regnum); set_gdbarch_dwarf_reg_to_regnum (gdbarch, s390_stab_reg_to_regnum); set_gdbarch_dwarf2_reg_to_regnum (gdbarch, s390_stab_reg_to_regnum); - set_gdbarch_extract_struct_value_address (gdbarch, s390_cannot_extract_struct_value_address); + set_gdbarch_deprecated_extract_struct_value_address (gdbarch, s390_cannot_extract_struct_value_address); /* Parameters for inferior function calls. */ set_gdbarch_deprecated_pc_in_call_dummy (gdbarch, deprecated_pc_in_call_dummy_at_entry_point); Index: sh-tdep.c =================================================================== RCS file: /cvs/src/src/gdb/sh-tdep.c,v retrieving revision 1.155 diff -u -r1.155 sh-tdep.c --- sh-tdep.c 17 Jan 2004 15:34:12 -0000 1.155 +++ sh-tdep.c 18 Jan 2004 00:30:45 -0000 @@ -2239,8 +2239,7 @@ set_gdbarch_store_return_value (gdbarch, sh_default_store_return_value); set_gdbarch_extract_return_value (gdbarch, sh_default_extract_return_value); - set_gdbarch_extract_struct_value_address (gdbarch, - sh_extract_struct_value_address); + set_gdbarch_deprecated_extract_struct_value_address (gdbarch, sh_extract_struct_value_address); set_gdbarch_skip_prologue (gdbarch, sh_skip_prologue); set_gdbarch_inner_than (gdbarch, core_addr_lessthan); Index: sh64-tdep.c =================================================================== RCS file: /cvs/src/src/gdb/sh64-tdep.c,v retrieving revision 1.19 diff -u -r1.19 sh64-tdep.c --- sh64-tdep.c 17 Jan 2004 19:38:58 -0000 1.19 +++ sh64-tdep.c 18 Jan 2004 00:30:46 -0000 @@ -2887,7 +2887,7 @@ set_gdbarch_deprecated_push_return_address (gdbarch, sh64_push_return_address); set_gdbarch_deprecated_dummy_write_sp (gdbarch, deprecated_write_sp); set_gdbarch_deprecated_store_struct_return (gdbarch, sh64_store_struct_return); - set_gdbarch_extract_struct_value_address (gdbarch, sh64_extract_struct_value_address); + set_gdbarch_deprecated_extract_struct_value_address (gdbarch, sh64_extract_struct_value_address); set_gdbarch_use_struct_convention (gdbarch, sh64_use_struct_convention); set_gdbarch_deprecated_pop_frame (gdbarch, sh64_pop_frame); set_gdbarch_elf_make_msymbol_special (gdbarch, Index: sparc-tdep.c =================================================================== RCS file: /cvs/src/src/gdb/sparc-tdep.c,v retrieving revision 1.142 diff -u -r1.142 sparc-tdep.c --- sparc-tdep.c 17 Jan 2004 22:45:44 -0000 1.142 +++ sparc-tdep.c 18 Jan 2004 00:30:46 -0000 @@ -837,8 +837,8 @@ #if 0 /* NOTE: cagney/2004-01-17: For the moment disable this method. The architecture and CORE-gdb will need new code (and a replacement for - EXTRACT_STRUCT_VALUE_ADDRESS) before this can be made to work - robustly. Here is a possible function signature: */ + DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS) before this can be made to + work robustly. Here is a possible function signature: */ /* NOTE: cagney/2004-01-17: So far only the 32-bit SPARC ABI has been identifed as having a way to robustly recover the address of a struct-convention return-value (after the function has returned). Index: stack.c =================================================================== RCS file: /cvs/src/src/gdb/stack.c,v retrieving revision 1.99 diff -u -r1.99 stack.c --- stack.c 12 Jan 2004 18:33:47 -0000 1.99 +++ stack.c 18 Jan 2004 00:30:47 -0000 @@ -1857,6 +1857,9 @@ is discarded, side effects such as "return i++" still occure. */ return_value = NULL; + /* FIXME: cagney/2004-01-17: If the architecture implements both + return_value and extract_returned_value_address, should allow + "return" to work - don't set return_value to NULL. */ else if (!gdbarch_return_value_p (current_gdbarch) && (TYPE_CODE (return_type) == TYPE_CODE_STRUCT || TYPE_CODE (return_type) == TYPE_CODE_UNION)) @@ -1926,6 +1929,10 @@ STORE_RETURN_VALUE (return_type, current_regcache, VALUE_CONTENTS (return_value)); } + /* FIXME: cagney/2004-01-17: If extract_returned_value_address + is available and the function is using + RETURN_VALUE_STRUCT_CONVENTION, should use it to find the + address of the returned value so that it can be assigned. */ else { gdb_assert (gdbarch_return_value (current_gdbarch, return_type, Index: values.c =================================================================== RCS file: /cvs/src/src/gdb/values.c,v retrieving revision 1.63 diff -u -r1.63 values.c --- values.c 19 Nov 2003 16:27:56 -0000 1.63 +++ values.c 18 Jan 2004 00:30:54 -0000 @@ -1247,9 +1247,9 @@ return val; } -/* Should we use EXTRACT_STRUCT_VALUE_ADDRESS instead of - EXTRACT_RETURN_VALUE? GCC_P is true if compiled with gcc - and TYPE is the type (which is known to be struct, union or array). +/* Should we use DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS instead of + EXTRACT_RETURN_VALUE? GCC_P is true if compiled with gcc and TYPE + is the type (which is known to be struct, union or array). On most machines, the struct convention is used unless we are using gcc and the type is of a special size. */ Index: xstormy16-tdep.c =================================================================== RCS file: /cvs/src/src/gdb/xstormy16-tdep.c,v retrieving revision 1.69 diff -u -r1.69 xstormy16-tdep.c --- xstormy16-tdep.c 17 Jan 2004 19:38:58 -0000 1.69 +++ xstormy16-tdep.c 18 Jan 2004 00:30:55 -0000 @@ -1086,7 +1086,7 @@ set_gdbarch_deprecated_pop_frame (gdbarch, xstormy16_pop_frame); set_gdbarch_deprecated_store_struct_return (gdbarch, xstormy16_store_struct_return); set_gdbarch_deprecated_store_return_value (gdbarch, xstormy16_store_return_value); - set_gdbarch_extract_struct_value_address (gdbarch, xstormy16_extract_struct_value_address); + set_gdbarch_deprecated_extract_struct_value_address (gdbarch, xstormy16_extract_struct_value_address); set_gdbarch_use_struct_convention (gdbarch, xstormy16_use_struct_convention); set_gdbarch_deprecated_call_dummy_words (gdbarch, call_dummy_words); Index: doc/gdbint.texinfo =================================================================== RCS file: /cvs/src/src/gdb/doc/gdbint.texinfo,v retrieving revision 1.180 diff -u -r1.180 gdbint.texinfo --- doc/gdbint.texinfo 17 Jan 2004 18:24:15 -0000 1.180 +++ doc/gdbint.texinfo 18 Jan 2004 00:31:52 -0000 @@ -3222,18 +3222,18 @@ This method has been deprecated in favour of @code{gdbarch_return_value} (@pxref{gdbarch_return_value}). -@item EXTRACT_STRUCT_VALUE_ADDRESS(@var{regbuf}) -@findex EXTRACT_STRUCT_VALUE_ADDRESS -@anchor{EXTRACT_STRUCT_VALUE_ADDRESS} +@item DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS(@var{regbuf}) +@findex DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS +@anchor{DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS} When defined, extract from the array @var{regbuf} (containing the raw register state) the @code{CORE_ADDR} at which a function should return its structure value. @xref{gdbarch_return_value}. -@item EXTRACT_STRUCT_VALUE_ADDRESS_P() -@findex EXTRACT_STRUCT_VALUE_ADDRESS_P -Predicate for @code{EXTRACT_STRUCT_VALUE_ADDRESS}. +@item DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS_P() +@findex DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS_P +Predicate for @code{DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS}. @item DEPRECATED_FP_REGNUM @findex DEPRECATED_FP_REGNUM @@ -3842,7 +3842,7 @@ @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 +@xref{DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS}, for a description of how return-values that use the struct convention are handled. @emph{Maintainer note: This method replaces separate predicate, extract, --------------060504070609000102070009--