This commit was manufactured by cvs2svn to create branch 'jimb-jimb-ppc64-linux-20030509-branchpoint

ppc64-linux-20030509-branch'. Sprout from kettenis_i386newframe-20030419-branch 2003-04-19 14:43:51 UTC nobody 'This commit was manufactured by cvs2svn to create branch' Cherrypick from kettenis_i386newframe-20030419-branch 2003-05-04 03:57:40 UTC nobody 'This commit was manufactured by cvs2svn to create branch': bfd/elf32-m68hc1x.h gdb/infcall.h gdb/mi/mi-cmd-symbol.c gdb/testsuite/gdb.mi/mi1-symbol.exp Cherrypick from master 2003-05-09 16:41:42 UTC Martin Schwidefsky <schwidefsky@de.ibm.com> ' * elf32-s390.c (allocate_dynrelocs, elf_s390_relocate_section):': ChangeLog MAINTAINERS Makefile.in Makefile.tpl bfd/ChangeLog bfd/Makefile.am bfd/Makefile.in bfd/acinclude.m4 bfd/aclocal.m4 bfd/archures.c bfd/bfd-in.h bfd/bfd-in2.h bfd/coff-h8300.c bfd/coffcode.h bfd/configure bfd/configure.in bfd/cpu-arm.c bfd/cpu-h8300.c bfd/cpu-sh.c bfd/elf-bfd.h bfd/elf-m10200.c bfd/elf-m10300.c bfd/elf.c bfd/elf32-arm.h bfd/elf32-h8300.c bfd/elf32-hppa.c bfd/elf32-i386.c bfd/elf32-ip2k.c bfd/elf32-iq2000.c bfd/elf32-m32r.c bfd/elf32-m68hc11.c bfd/elf32-m68hc12.c bfd/elf32-m68hc1x.c bfd/elf32-m68k.c bfd/elf32-mips.c bfd/elf32-ppc.c bfd/elf32-s390.c bfd/elf32-sh.c bfd/elf32-sh64-com.c bfd/elf32-sh64.c bfd/elf32-v850.c bfd/elf32-xstormy16.c bfd/elf32-xtensa.c bfd/elf64-alpha.c bfd/elf64-hppa.c bfd/elf64-mips.c bfd/elf64-mmix.c bfd/elf64-ppc.c bfd/elf64-s390.c bfd/elf64-sh64.c bfd/elf64-sparc.c bfd/elf64-x86-64.c bfd/elfcode.h bfd/elflink.c bfd/elflink.h bfd/elfxx-ia64.c bfd/elfxx-mips.c bfd/reloc.c bfd/section.c bfd/version.h bfd/xtensa-isa.c bfd/xtensa-modules.c config-ml.in cpu/ChangeLog gdb/ChangeLog gdb/Makefile.in gdb/ada-lang.c gdb/ada-valprint.c gdb/alpha-nat.c gdb/alpha-tdep.c gdb/alpha-tdep.h gdb/alphabsd-nat.c gdb/alphafbsd-tdep.c gdb/alphanbsd-tdep.c gdb/arch-utils.c gdb/arch-utils.h gdb/arm-linux-tdep.c gdb/arm-tdep.c gdb/avr-tdep.c gdb/blockframe.c gdb/breakpoint.c gdb/breakpoint.h gdb/c-lang.c gdb/charset.c gdb/charset.h gdb/cli/cli-cmds.c gdb/cli/cli-cmds.h gdb/config/djgpp/fnchange.lst gdb/config/i386/nto.mt gdb/config/i386/tm-nto.h gdb/config/ia64/tm-ia64.h gdb/config/m68k/tm-vx68.h gdb/config/mips/tm-mips.h gdb/config/pa/nm-hppah.h gdb/config/pa/tm-hppa.h gdb/config/pa/tm-hppa64.h gdb/config/s390/tm-s390.h gdb/config/sparc/tm-sp64.h gdb/config/sparc/tm-sparc.h gdb/config/tm-nto.h gdb/config/vax/nm-vax.h gdb/configure.tgt gdb/corefile.c gdb/cp-support.c gdb/cris-tdep.c gdb/d10v-tdep.c gdb/defs.h gdb/disasm.c gdb/disasm.h gdb/doc/ChangeLog gdb/doc/gdb.texinfo gdb/doc/gdbint.texinfo gdb/dummy-frame.c gdb/dummy-frame.h gdb/dve3900-rom.c gdb/dwarf2cfi.c gdb/dwarf2loc.c gdb/dwarf2read.c gdb/eval.c gdb/findvar.c gdb/fork-child.c gdb/frame.c gdb/frame.h gdb/frv-tdep.c gdb/gcore.c gdb/gdbarch.c gdb/gdbarch.h gdb/gdbarch.sh gdb/gdbcmd.h gdb/gdbserver/ChangeLog gdb/gdbserver/low-nbsd.c gdb/gdbthread.h gdb/h8300-tdep.c gdb/hppa-tdep.c gdb/hppab-nat.c gdb/hppah-nat.c gdb/hpux-thread.c gdb/i386-linux-nat.c gdb/i386-nto-tdep.c gdb/i386-tdep.c gdb/i387-tdep.c gdb/ia64-tdep.c gdb/infcall.c gdb/infcmd.c gdb/inferior.h gdb/infptrace.c gdb/infrun.c gdb/irix4-nat.c gdb/linespec.c gdb/lynx-nat.c gdb/m68hc11-tdep.c gdb/m68k-tdep.c gdb/m68klinux-nat.c gdb/maint.c gdb/mcore-tdep.c gdb/mi/ChangeLog gdb/mi/mi-cmds.c gdb/mi/mi-cmds.h gdb/mi/mi-main.c gdb/mips-linux-tdep.c gdb/mips-nat.c gdb/mips-tdep.c gdb/mipsv4-nat.c gdb/mn10300-tdep.c gdb/monitor.c gdb/nlm/i386.c gdb/nlm/i386.h gdb/ns32k-tdep.c gdb/ns32knbsd-nat.c gdb/nto-tdep.c gdb/nto-tdep.h gdb/objc-lang.c gdb/objfiles.c gdb/ppc-linux-nat.c gdb/printcmd.c gdb/procfs.c gdb/regcache.c gdb/regcache.h gdb/remote-array.c gdb/remote-e7000.c gdb/remote-mips.c gdb/remote-rdp.c gdb/remote-sim.c gdb/remote.c gdb/rom68k-rom.c gdb/rs6000-nat.c gdb/rs6000-tdep.c gdb/s390-tdep.c gdb/scm-lang.c gdb/sentinel-frame.c gdb/sh-tdep.c gdb/sol-thread.c gdb/sparc-tdep.c gdb/stack.c gdb/std-regs.c gdb/symmisc.c gdb/symtab.c gdb/symtab.h gdb/target.c gdb/target.h gdb/testsuite/ChangeLog gdb/testsuite/Makefile.in gdb/testsuite/configure gdb/testsuite/configure.in gdb/testsuite/gdb.asm/asm-source.exp gdb/testsuite/gdb.asm/s390x.inc gdb/testsuite/gdb.base/charset.exp gdb/testsuite/gdb.base/maint.exp gdb/testsuite/gdb.base/signals.exp gdb/testsuite/gdb.base/watchpoint.exp gdb/testsuite/gdb.c++/maint.exp gdb/testsuite/gdb.mi/ChangeLog gdb/testsuite/gdb.objc/Makefile.in gdb/testsuite/gdb.objc/basicclass.exp gdb/testsuite/gdb.objc/basicclass.m gdb/testsuite/gdb.threads/schedlock.exp gdb/testsuite/lib/gdb.exp gdb/thread-db.c gdb/thread.c gdb/tracepoint.c gdb/tui/ChangeLog gdb/tui/tuiDisassem.c gdb/tui/tuiRegs.c gdb/v850-tdep.c gdb/valarith.c gdb/valops.c gdb/value.h gdb/vax-tdep.c gdb/version.in gdb/x86-64-tdep.c gdb/xstormy16-tdep.c include/ChangeLog include/bfdlink.h include/coff/ChangeLog include/coff/h8300.h include/elf/ChangeLog include/elf/common.h include/elf/h8.h include/gdb/ChangeLog include/gdb/sim-d10v.h include/hashtab.h include/xtensa-isa-internal.h libiberty/ChangeLog libiberty/aclocal.m4 libiberty/config.in libiberty/configure libiberty/configure.in libiberty/cp-demangle.c libiberty/hashtab.c libiberty/splay-tree.c libiberty/vsnprintf.c opcodes/ChangeLog opcodes/fr30-desc.c opcodes/fr30-desc.h opcodes/fr30-opc.c opcodes/fr30-opc.h opcodes/frv-desc.c opcodes/frv-desc.h opcodes/frv-opc.c opcodes/frv-opc.h opcodes/i386-dis.c opcodes/ip2k-desc.c opcodes/ip2k-desc.h opcodes/ip2k-opc.c opcodes/ip2k-opc.h opcodes/m32r-desc.c opcodes/m32r-desc.h opcodes/m32r-opc.c opcodes/m32r-opc.h opcodes/m32r-opinst.c opcodes/openrisc-desc.c opcodes/openrisc-desc.h opcodes/openrisc-opc.c opcodes/openrisc-opc.h opcodes/xstormy16-desc.c opcodes/xstormy16-desc.h opcodes/xstormy16-opc.c opcodes/xstormy16-opc.h opcodes/z8k-dis.c sim/d10v/ChangeLog sim/d10v/interp.c sim/igen/ChangeLog sim/igen/compare_igen_models sim/mips/ChangeLog sim/mips/cp1.c sim/mips/cp1.h sim/mips/mdmx.c sim/mips/mdmx.igen sim/mips/mips3d.igen sim/mips/sb1.igen src-release
author: nobody <> 2003-05-09 16:41:43 +0000
committer: nobody <> 2003-05-09 16:41:43 +0000
commit: b41719d9f61907f1c810753438454c6f5656347b (patch)
tree: a9a2a8e140602339a92e5990e1238c48b6d14f34 /gdb
parent: 291862d73dc6b445dae7638c7490d74473dea27c (diff)
download: binutils-gdb-b41719d9f61907f1c810753438454c6f5656347b.tar.gz
170 files changed, 7073 insertions, 3751 deletions
diff --git a/gdb/ChangeLog b/gdb/ChangeLog
index ad86a9055ca..9c58b41c498 100644
--- a/gdb/ChangeLog
+++ b/gdb/ChangeLog
@@ -1,3 +1,726 @@
+2003-05-08  Andrew Cagney  <cagney@redhat.com>
+
+	* regcache.h (max_register_size): Delete declaration.
+	* regcache.c (max_register_size): Delete function.
+	(struct regcache_descr): Delete field "max_register_size".
+	(init_regcache_descr, init_legacy_regcache_descr): Assert that all
+	registers fit in MAX_REGISTER_SIZE.
+	(regcache_save): Replace max_register_size with MAX_REGISTER_SIZE.
+	(regcache_restore, regcache_xfer_part, regcache_dump): Ditto.
+	* thread-db.c: Replace max_register_size with MAX_REGISTER_SIZE.
+	* sh-tdep.c, rom68k-rom.c, remote-sim.c, remote-mips.c: Ditto.
+	* remote-e7000.c, monitor.c, mipsv4-nat.c, mips-nat.c: Ditto.
+	* m68klinux-nat.c, lynx-nat.c, irix4-nat.c: Ditto.
+	* hpux-thread.c, hppah-nat.c, hppab-nat.c, hppa-tdep.c: Ditto.
+	* dve3900-rom.c, hppa-tdep.c: Ditto.
+
+2003-05-08  David Carlton  <carlton@math.stanford.edu>
+
+	* valops.c (push_word): Fix typo.
+
+2003-05-08  Andrew Cagney  <cagney@redhat.com>
+
+	* gdbarch.sh: Delete references to MAX_REGISTER_RAW_SIZE.
+	* gdbarch.h: Re-generate.
+	* defs.h (MAX_REGISTER_RAW_SIZE): Delete macro.
+	(legacy_max_register_raw_size): Delete declaration.
+	* regcache.c (legacy_max_register_raw_size): Delete function.
+	* valops.c: Replace MAX_REGISTER_RAW_SIZE with MAX_REGISTER_SIZE.
+	* target.c, stack.c, sparc-tdep.c, sh-tdep.c: Ditto.
+	* rs6000-tdep.c, rs6000-nat.c, remote.c, remote-sim.c: Ditto.
+	* remote-rdp.c, remote-array.c, regcache.c: Ditto.
+	* ppc-linux-nat.c, monitor.c, mn10300-tdep.c: Ditto.
+	* mips-tdep.c, mips-linux-tdep.c, m68klinux-nat.c: Ditto.
+	* infptrace.c, ia64-tdep.c, i386-tdep.c, frame.c: Ditto.
+	* findvar.c, dwarf2cfi.c: Ditto.
+
+2003-05-08  Andrew Cagney  <cagney@redhat.com>
+
+	* mips-tdep.c (read_signed_register): New function, moved to here
+	from "regcache.c".
+	(read_signed_register_pid): Ditto.
+	* regcache.c (read_signed_register_pid): Delete function, moved to
+	"mips-tdep.c".
+	(read_signed_register): Ditto.
+	* regcache.h (read_signed_register): Delete declaration.
+	(read_signed_register_pid): Delete declaration.
+
+2003-05-08  Andrew Cagney  <cagney@redhat.com>
+
+	* gdbarch.sh: Add comments on MAX_REGISTER_SIZE.
+	* gdbarch.h: Re-generate.
+	* defs.h (MAX_REGISTER_VIRTUAL_SIZE): Delete macro.
+	(legacy_max_register_virtual_size): Delete declaration.
+	* infcmd.c (default_print_registers_info): Use MAX_REGISTER_SIZE.
+	* d10v-tdep.c (d10v_print_registers_info): Ditto.
+	* tracepoint.c (memrange_sortmerge): Ditto.
+	* sparc-tdep.c (sparc_print_registers): Ditto.
+	* regcache.c (legacy_max_register_virtual_size): Delete function.
+
+2002-05-08  J. Brobecker  <brobecker@gnat.com>
+
+	* fork-child.c (escape_bang_in_quoted_argument): New function.
+	(fork_inferior): Escape '!' characters in quoted arguments
+	only when needed.
+
+2003-05-08  J. Brobecker  <brobecker@gnat.com>
+
+	* dwarf2read.c (set_cu_language): Set the language to "minimal" if
+	the language of the CU is not currently supported by GDB.
+
+2003-05-08  J. Brobecker  <brobecker@gnat.com>
+
+	* defs.h (language): Add language_minimal enum value.
+	* c-lang.c (minimal_language_defn): New language definition.
+	(_initialize_c_language): Add the new minimal language to the list
+	of languages known to GDB.
+
+2003-05-08  Kevin Buettner  <kevinb@redhat.com>
+
+	* frame.c (get_frame_type): Don't attempt to lazily initialize
+	frame's unwinder for legacy frames.
+
+2003-05-07  Andrew Cagney  <cagney@redhat.com>
+
+	* ia64-tdep.c (ia64_remote_translate_xfer_address): Add "gdbarch"
+	and "regcache" parameters.
+	* avr-tdep.c (avr_remote_translate_xfer_address): Ditto.
+
+2003-05-07  Jeff Johnston  <jjohnstn@redhat.com>
+ 
+ 	* dwarf2read.c (dwarf_decode_lines): Only use output of 
+	check_cu_functions() when calling record_line().  Do not update 
+	the current address.
+
+2003-05-07  Andrew Cagney  <cagney@redhat.com>
+
+	* fork-child.c (startup_inferior): Delete #ifdef STARTUP_INFERIOR
+	code.
+
+2003-05-07  Jim Blandy  <jimb@redhat.com>
+
+	Rename commands 'maint list symtabs' and 'maint list psymtabs' to
+	'maint info symtabs' and 'maint info psymtabs'.
+	* symmisc.c (maintenance_info_symtabs, maintenance_info_psymtabs):
+	Renamed from maintenance_list_symtabs and maintenance_list_psymtabs.
+	* symtab.h (maintenance_info_symtabs, maintenance_info_psymtabs):
+	Declarations updated.
+	* maint.c (maintenance_list_command): Delete.
+	(_initialize_maint_cmds): Update calls to add_cmd.
+	* gdbcmd.h (maintenancelistlist): Delete declaration.
+	* cli/cli-cmds.c (maintenancelistlist): Delete.
+	(init_cmd_lists): Don't initialize it.
+	* cli/cli-cmds.h (maintenancelistlist): Delete declaration.
+
+2003-05-07  Andrew Cagney  <cagney@redhat.com>
+
+	* d10v-tdep.c (remote_d10v_translate_xfer_address): Add
+	"regcache".
+	(d10v_print_registers_info): Update.
+	(d10v_dmap_register, d10v_imap_register): Delete functions.
+	(struct gdbarch_tdep): Add "regcache" parameter to "dmap_register"
+	and "imap_register".
+	(d10v_ts2_dmap_register, d10v_ts2_imap_register): Add "regcache".
+	(d10v_ts3_dmap_register, d10v_ts3_imap_register): Add "regcache".
+	* arch-utils.c (generic_remote_translate_xfer_address): Add
+	"regcache" and "gdbarch" parameters.
+	* gdbarch.sh (REMOTE_TRANSLATE_XFER_ADDRESS): Add "regcache"
+	parameter.  Change class to multi-arch.
+	* gdbarch.h, gdbarch.c: Re-generate.
+	* remote.c (remote_xfer_memory): Use
+	gdbarch_remote_translate_xfer_address.
+	
+2003-05-07  Jeff Johnston  <jjohnstn@redhat.com>
+
+	* infrun.c (prev_pc): Move declaration ahead of proceed().
+	(proceed): Refresh prev_pc value before resuming.
+	(stop_stepping): Remove code to refresh prev_pc.
+
+2003-05-06  Kris Warkentin <kewarken@qnx.com>
+
+	* nto-tdep.c: Removed stray comment.
+
+2003-05-06  Kris Warkentin <kewarken@qnx.com>
+
+	* i386-nto-tdep.c: Fix old K&R function definitions.
+	* nto-tdep.c: Likewise and change stat.h include to gdb_stat.h.
+	Also change add_show_from_set() call to add_setshow_cmd().
+	* nto-tdep.h: Remove PARAMS and grep ^func ARI hits.
+
+2003-05-05  Andrew Cagney  <cagney@redhat.com>
+
+	* dummy-frame.c: Include "command.h" and "gdbcmd.h".
+	(fprint_dummy_frames): New function.
+	(maintenance_print_dummy_frames): New function.
+	(_initialize_dummy_frame): Add command "maint print dummy-frames".
+	* frame.c (fprint_frame_id): Make global.
+	* frame.h (fprint_frame_id): Declare.
+	* Makefile.in (dummy-frame.o): Update dependencies.
+
+2003-05-05  Andrew Cagney  <cagney@redhat.com>
+
+	* gdbarch.sh (DEPRECATED_REGISTER_SIZE): Rename REGISTER_SIZE.
+	(DEPRECATED_SIZEOF_CALL_DUMMY_WORDS): Rename
+	SIZEOF_CALL_DUMMY_WORDS.
+	(DEPRECATED_CALL_DUMMY_WORDS): Rename CALL_DUMMY_WORDS.
+	(DEPRECATED_FIX_CALL_DUMMY): Rename FIX_CALL_DUMMY.
+	(DEPRECATED_CALL_DUMMY_BREAKPOINT_OFFSET): Rename
+	CALL_DUMMY_BREAKPOINT_OFFSET.
+	(DEPRECATED_CALL_DUMMY_START_OFFSET): Rename
+	CALL_DUMMY_START_OFFSET.
+	(DEPRECATED_CALL_DUMMY_LENGTH): Rename CALL_DUMMY_LENGTH.
+	* gdbarch.h, gdbarch.c: Re-generate.
+	* alpha-tdep.c, alphafbsd-tdep.c, arm-linux-tdep.c: Update.
+	* arm-tdep.c, avr-tdep.c, breakpoint.c, cris-tdep.c: Update.
+	* dummy-frame.c, dummy-frame.h, frv-tdep.c, gdbarch.c: Update.
+	* gdbarch.h, gdbarch.sh, h8300-tdep.c, hppa-tdep.c: Update.
+	* i386-tdep.c, ia64-tdep.c, infcall.c, inferior.h: Update.
+	* m68hc11-tdep.c, m68k-tdep.c, mcore-tdep.c: Update.
+	* mips-tdep.c, mn10300-tdep.c, ns32k-tdep.c: Update.
+	* rs6000-tdep.c, s390-tdep.c, sh-tdep.c, sol-thread.c: Update.
+	* sparc-tdep.c, target.c, v850-tdep.c, valops.c: Update.
+	* vax-tdep.c, x86-64-tdep.c, xstormy16-tdep.c: Update.
+	* config/ia64/tm-ia64.h, config/m68k/tm-vx68.h: Update.
+	* config/mips/tm-mips.h, config/pa/nm-hppah.h: Update.
+	* config/pa/tm-hppa.h, config/pa/tm-hppa64.h: Update.
+	* config/s390/tm-s390.h, config/sparc/tm-sp64.h: Update.
+	* config/sparc/tm-sparc.h: Update.
+
+2003-05-05  Kris Warkentin <kewarken@qnx.com>
+
+	* configure.tgt: Add i[3456]86-*-nto*.
+	* i386-nto-tdep.c: New file.  i386 specific support for QNX Neutrino.
+	* nto-tdep.c: New file. Neutrino target support routines.
+	* nto-tdep.h: New file. Neutrino target header.
+	* config/tm-qnxnto.h: New file.
+	* config/i386/i386nto.mt: New file.
+	* config/i386/tm-i386nto.h: New file.
+	
+2003-05-04  Andrew Cagney  <cagney@redhat.com>
+
+	* gdbthread.h (save_infrun_state): Drop prev_func_name parameter.
+	(load_infrun_state): Ditto.
+	(struct thread_info): Drop "prev_func_name" field.
+	* thread.c (load_infrun_state): Update.
+	(save_infrun_state): Update.
+	* infrun.c (prev_func_name): Delete variable.
+	(init_wait_for_inferior): Do not clear prev_func_name.
+	(stop_stepping, keep_going, context_switch): Do not swap
+	prev_func_name.
+	(handle_inferior_event, check_sigtramp2): Use pc_in_sigtramp
+	instead of PC_IN_SIGTRAMP.
+
+2003-05-04  Andrew Cagney  <cagney@redhat.com>
+
+	* sentinel-frame.c (sentinel_frame_prev_register): Replace
+	REGISTER_BYTE with register_offset_hack.
+	* regcache.c (init_regcache_descr): When REGISTER_BYTE_P, check
+	that REGISTER_BYTE is consistent with the regcache.
+	* gdbarch.sh (REGISTER_BYTE): Add a predicate.
+	* gdbarch.h, gdbarch.c: Regenerate.
+	
+2003-05-04  Mark Kettenis  <kettenis@gnu.org>
+
+	* i387-tdep.c (fxsave_offset): Add entries for %xmm8-%xmm15.
+	(FXSAVE_ADDR, i387_supply_fxsave): Add support for %xmm8-%xmm15.
+
+	* i386-linux-nat.c (supply_gregset): Remove unnecessary casts.
+
+2003-05-03  J. Brobecker  <brobecker@gnat.com>
+
+	From Thierry Schneider <tpschneider1@yahoo.com>
+	* Makfile.in (SUBDIR_MI_OBS): Add dependency on mi-cmd-symbol.o.
+	(SUBDIR_MI_SRCS): Add mi-cmd-symbol.c.
+	(mi-cmd-symbol.o): Add rule.
+
+2003-05-03  Andrew Cagney  <cagney@redhat.com>
+
+	* gdbarch.sh (PUSH_DUMMY_CODE): New architecture method, add
+	comments noteing that it replaces the old FIX_CALL_DUMMY code.
+	* gdbarch.h, gdbarch.c: Re-generate.
+	* d10v-tdep.c (d10v_push_dummy_code): New function.
+	(d10v_gdbarch_init): Set push_dummy_code.
+	* infcall.c (legacy_push_dummy_code): New function.
+	(generic_push_dummy_code): New function.
+	(push_dummy_code): New function.
+	(call_function_by_hand): Call push_dummy_code.  Pass bp_addr,
+	instead of dummy_addr, to push_dummy_call.  Move call to
+	generic_save_call_dummy_addr to outside of CALL_DUMMY_LOCATION
+	switch.
+	* sparc-tdep.c (sparc_gdbarch_init): Mention push_dummy_code.
+
+2003-05-03  Andrew Cagney  <cagney@redhat.com>
+
+	* disasm.h (print_insn): Declare.
+	* disasm.c (init_gdb_disassemble_info): New function.
+	(gdb_disassembly): Call init_gdb_disassemble_info.
+	(gdb_print_insn): New function.
+	* v850-tdep.c (v850_scan_prologue): Call gdb_print_insn, instead
+	of TARGET_PRINT_INSN.  Send debug info to "gdb_stdlog".
+	* mcore-tdep.c: Include "disasm.h"
+	(mcore_dump_insn): Call gdb_print_insn, instead of TARGET_PRINT_INSN.
+	* d10v-tdep.c: Include "disasm.h".
+	(display_trace): Call gdb_print_insn, instead of print_insn.
+	(print_insn): Delete function.
+	* printcmd.c: Include "disasm.h".
+	(print_insn): Delete function.
+	(print_formatted): Call gdb_print_insn, instead of print_insn.
+	* Makefile.in (printcmd.o): Update dependencies.
+	(mcore-tdep.o, d10v-tdep.o): Ditto.
+	
+2003-05-02  Andrew Cagney  <cagney@redhat.com>
+
+	* std-regs.c (value_of_builtin_frame_pc_reg): Delete #ifdef
+	PC_REGNUM, re-indent.
+	* stack.c (frame_info): Use "pc" for the name of get_frame_pc when
+	PC_REGNUM isn't set.
+
+	* gdbarch.sh (REGISTER_SIZE, REGISTER_BYTES): Make optional.
+	* gdbarch.h, gdbarch.c: Re-generate.
+	* d10v-tdep.c (d10v_gdbarch_init): Do not set register_size,
+	register_virtual_size, pc_regnum, or register_bytes.
+	(D10V_PC_REGNUM): Rename _PC_REGNUM.
+	(d10v_register_type): Use D10V_PC_REGNUM.
+	(d10v_print_registers_info, d10v_read_pc): Ditto.
+	(d10v_write_pc, d10v_eva_prepare_to_trace): Ditto.
+	(d10v_unwind_pc, d10v_frame_prev_register): Ditto.
+
+2003-05-02  David Carlton  <carlton@bactrian.org>
+
+	* objfiles.c (allocate_objfile): For anonymous objfiles, allocate
+	the name with mstrsave.
+
+2003-05-02  Elena Zannoni  <ezannoni@redhat.com>
+
+	* charset.c (GDB_DEFAULT_TARGET_CHARSET,
+	GDB_DEFAULT_HOST_CHARSET): Move to earlier in the file.
+	(host_charset_name, target_charset_name): New vars for use by
+	set/show commands.
+	(host_charset_enum, target_charset_enum): New enums for set/show
+	commands.
+	(set_charset_sfunc, set_host_charset_sfunc,
+	set_target_charset_sfunc): New functions.
+	(set_host_charset, set_target_charset): Make static.
+	(list_charsets, set_host_charset_command,
+	set_target_charset_command): Delete functions.
+	(show_charset_command): Rewrite as....
+	(show_charset): Hook this up with the set/show command mechanism.
+	(_initialize_charset): Change names of charsets to match the
+	set/show enums. Use host_charset_name and target_charset_name.
+	Use set/show mechanism for charset, host-charset, target-charset
+	commands. Do not make 'show host-charset' and 'show
+	target-charset' be aliases of 'show charset'.
+
+	* charset.h (set_host_charset, set_target_charset): Don't export,
+	they are not used outside the file.
+
+2003-05-01  Andrew Cagney  <cagney@redhat.com>
+
+	* disasm.c (gdb_disassemble_from_exec): Delete global variable.
+	(gdb_disassembly): Make "di" non static, always initialize and
+	cleanup.  Always use dis_asm_read_memory.
+	(gdb_dis_asm_read_memory): Delete function.
+
+2003-05-01  Andrew Cagney  <cagney@redhat.com>
+
+	* d10v-tdep.c (d10v_frame_align): Replace d10v_stack_align.
+	(d10v_gdbarch_init): Set frame_align instead of stack_align.
+
+2003-04-30  Andrew Cagney  <cagney@redhat.com>
+
+	* gdbarch.sh (deprecated_tm_print_insn_info): Rename
+	"tm_print_insn_info".
+	(TARGET_PRINT_INSN_INFO): Delete macro.
+	(dis_asm_read_memory): Delete function declaration.
+	(dis_asm_memory_error, dis_asm_print_address): Ditto.
+	(tm_print_insn_info): Delete variable definition.
+	(_initialize_gdbarch): Do not initialize "tm_print_insn_info".
+	* gdbarch.h, gdbarch.c: Re-generate.
+	* d10v-tdep.c (display_trace): Replace "tm_print_insn_info" with
+	"deprecated_tm_print_insn_info".
+	* mcore-tdep.c (mcore_dump_insn): Ditto.
+	* mips-tdep.c (mips_gdbarch_init): Ditto.
+	* sparc-tdep.c (_initialize_sparc_tdep): Ditto.
+	* v850-tdep.c (v850_scan_prologue, v850_gdbarch_init): Ditto.
+	* ia64-tdep.c (_initialize_ia64_tdep): Ditto.
+	* printcmd.c (print_insn): Use "deprecated_tm_print_insn_info"
+	instead of TARGET_PRINT_INSN_INFO, add comment.
+	* s390-tdep.c (s390_get_frame_info): Instead of
+	"dis_asm_read_memory", use "deprecated_tm_print_insn_info".
+	(s390_check_function_end, s390_is_sigreturn): Ditto.
+	* corefile.c (dis_asm_read_memory): Move to "disasm.c".
+	(dis_asm_memory_error, dis_asm_print_address): Ditto.
+	* disasm.c: Include "gdbcore.h".
+	(_initialize_disasm): New function, initialize
+	"deprecated_tm_print_insn_info".
+	(deprecated_tm_print_insn_info): New variable.
+	(dis_asm_read_memory): Moved from "corefile.c", made static.
+	(dis_asm_print_address, dis_asm_memory_error): Ditto.
+	* Makefile.in (disasm.o): Update dependencies.
+
+2003-04-30  Andrew Cagney  <cagney@redhat.com>
+
+	* sparc-tdep.c (SPARC_HAS_FPU): When multi-arch, define as 1.
+
+2003-04-29  Adam Fedor  <fedor@gnu.org>
+
+	* eval.c (evaluate_subexp_standard): Handle ObjC ops.
+	* infcall.c (find_function_addr): Make non-static.
+	* infcall.h (find_function_addr): Declare.
+	* Makefile.in (eval.o): Update dependencies.
+
+2003-04-28  Adam Fedor  <fedor@gnu.org>
+
+	* symtab.c (symbol_find_demangled_name): Check for and demangle
+	ObjC symbols.
+	(symbol_init_demangled_name): Init for language_objc as well.
+
+2003-04-28  Andrew Cagney  <cagney@redhat.com>
+
+	* gdbarch.sh (DEPRECATED_TARGET_READ_FP): Replace TARGET_READ_FP.
+	(DEPRECATED_FP_REGNUM): Replace FP_REGNUM.
+	* gdbarch.h, gdbarch.c: Re-generate.
+	* infcall.c (call_function_by_hand): Use DEPRECATED_FP_REGNUM,
+	DEPRECATED_TARGET_READ_FP, or "sp" to create the dummy frame ID.
+	* inferior.h (deprecated_read_fp): Rename read_fp.
+	(generic_target_read_fp): Delete declaration.
+	* regcache.c (generic_target_read_fp): Delete function.
+	(deprecated_read_fp): Replace read_fp, use
+	DEPRECATED_TARGET_READ_FP or DEPRECATED_FP_REGNUM.
+	* d10v-tdep.c (d10v_read_fp): Delete function.
+	(d10v_gdbarch_init): Do not set deprecated_read_fp.
+
+	* sparc-tdep.c (sparc_gdbarch_init): Do not set
+	deprecated_target_read_fp to generic_target_read_fp.
+	* sh-tdep.c (sh_gdbarch_init): Ditto.
+	* rs6000-tdep.c (rs6000_gdbarch_init): Ditto.
+	* m68hc11-tdep.c (m68hc11_gdbarch_init): Ditto.
+	* frv-tdep.c (frv_gdbarch_init): Ditto.
+
+	* xstormy16-tdep.c (xstormy16_gdbarch_init): Set
+	deprecated_fp_regnum.
+	* x86-64-tdep.c (x86_64_init_abi): Ditto.
+	* vax-tdep.c (vax_gdbarch_init): Ditto.
+	* v850-tdep.c (v850_gdbarch_init): Ditto.
+	* sparc-tdep.c (sparc_gdbarch_init): Ditto.
+	* sh-tdep.c (sh_gdbarch_init): Ditto.
+	* s390-tdep.c (s390_gdbarch_init): Ditto.
+	* rs6000-tdep.c (rs6000_gdbarch_init): Ditto.
+	* mn10300-tdep.c (mn10300_gdbarch_init): Ditto.
+	* mcore-tdep.c (mcore_gdbarch_init): Ditto.
+	* m68k-tdep.c (m68k_gdbarch_init): Ditto.
+	* m68hc11-tdep.c (m68hc11_gdbarch_init): Ditto.
+	* ia64-tdep.c (ia64_gdbarch_init): Ditto.
+	* i386-tdep.c (i386_gdbarch_init): Ditto.
+	* hppa-tdep.c (hppa_gdbarch_init): Ditto.
+	* h8300-tdep.c (h8300_gdbarch_init): Ditto.
+	* frv-tdep.c (frv_gdbarch_init): Ditto.
+	* cris-tdep.c (cris_gdbarch_init): Ditto.
+	* avr-tdep.c (avr_gdbarch_init): Ditto.
+	* arm-tdep.c (arm_gdbarch_init): Ditto.
+	* alpha-tdep.c (alpha_gdbarch_init): Ditto.
+
+	* x86-64-tdep.c (x86_64_init_abi): Set deprecated_target_read_fp.
+	* v850-tdep.c (v850_gdbarch_init): Ditto.
+	* sparc-tdep.c (sparc_gdbarch_init): Ditto.
+	* sh-tdep.c (sh_gdbarch_init): Ditto.
+	* s390-tdep.c (s390_gdbarch_init): Ditto.
+	* rs6000-tdep.c (rs6000_gdbarch_init): Ditto.
+	* mn10300-tdep.c (mn10300_gdbarch_init): Ditto.
+	* mips-tdep.c (mips_gdbarch_init): Ditto.
+	* m68hc11-tdep.c (m68hc11_gdbarch_init): Ditto.
+	* ia64-tdep.c (ia64_gdbarch_init): Ditto.
+	* hppa-tdep.c (hppa_gdbarch_init): Ditto.
+	* frv-tdep.c (frv_gdbarch_init): Ditto.
+	* avr-tdep.c (avr_gdbarch_init): Ditto.
+	* arm-tdep.c (arm_gdbarch_init): Ditto.
+
+	* vax-tdep.c (vax_frame_init_saved_regs): Replace FP_REGNUM with
+	DEPRECATED_FP_REGNUM.
+	(vax_push_dummy_frame, vax_pop_frame): Ditto.
+	* std-regs.c (value_of_builtin_frame_fp_reg): Ditto.
+	* sparc-tdep.c (sparc_init_extra_frame_info): Ditto.
+	(sparc_push_dummy_frame, sparc64_read_fp): Ditto.
+	(sparc32_register_virtual_type): Ditto.
+	* sh-tdep.c (sh64_frame_chain): Ditto.
+	(sh64_get_saved_register, sh64_pop_frame): Ditto.
+	(sh_nofp_frame_init_saved_regs): Ditto.
+	(sh64_nofp_frame_init_saved_regs): Ditto.
+	(sh_fp_frame_init_saved_regs): Ditto.
+	* remote-mips.c (mips_wait, mips_fetch_registers): Ditto.
+	* remote-e7000.c (fetch_regs_from_dump): Ditto.
+	* procfs.c (procfs_fetch_registers): Ditto.
+	(procfs_store_registers): Ditto.
+	* ns32knbsd-nat.c (fetch_inferior_registers): Ditto.
+	(store_inferior_registers, fetch_core_registers): Ditto.
+	(fetch_kcore_registers, clear_regs): Ditto.
+	* ns32k-tdep.c (ns32k_frame_init_saved_regs): Ditto.
+	(ns32k_push_dummy_frame, ns32k_pop_frame): Ditto.
+	* nlm/i386.h (DEPRECATED_FP_REGNUM): Ditto.
+	* nlm/i386.c (do_status): Ditto.
+	* mipsv4-nat.c (supply_gregset): Ditto.
+	* mips-tdep.c: Ditto for comments.
+	* mips-nat.c (fetch_inferior_registers): Ditto.
+	(store_inferior_registers, fetch_core_registers): Ditto.
+	* m68k-tdep.c (m68k_push_dummy_frame): Ditto.
+	(m68k_pop_frame, m68k_frame_init_saved_regs): Ditto.
+	* i386-tdep.c (i386_frame_init_saved_regs): Ditto.
+	(i386_do_pop_frame, i386_register_type): Ditto.
+	* hppa-tdep.c (hppa_frame_chain): Ditto.
+	(hppa_push_dummy_frame, find_dummy_frame_regs): Ditto.
+	(hppa_pop_frame, hppa_read_fp): Ditto.
+	(skip_prologue_hard_way, hppa_frame_find_saved_regs): Ditto.
+	* cris-tdep.c (cris_examine, cris_pop_frame): Ditto.
+	* config/vax/nm-vax.h (REGISTER_U_ADDR): Ditto.
+	* config/sparc/tm-sparc.h (DEPRECATED_FP_REGNUM): Ditto.
+	* config/sparc/tm-sp64.h (DEPRECATED_FP_REGNUM): Ditto.
+	* config/s390/tm-s390.h (DEPRECATED_FP_REGNUM): Ditto.
+	* config/pa/tm-hppa64.h (DEPRECATED_FP_REGNUM): Ditto.
+	* config/ia64/tm-ia64.h (DEPRECATED_FP_REGNUM): Ditto.
+	* blockframe.c: Ditto for comments.
+	* arch-utils.h: Ditto for comments.
+	* arch-utils.c (legacy_virtual_frame_pointer): Ditto.
+	* alphanbsd-tdep.c (fetch_core_registers): Ditto.
+	* alphabsd-nat.c (fetch_inferior_registers): Ditto.
+	* alpha-tdep.h: Ditto for comments.
+	* alpha-tdep.c (alpha_cannot_fetch_register): Ditto.
+	(alpha_cannot_store_register): Ditto.
+	(alpha_push_dummy_frame): Ditto.
+	* alpha-nat.c (supply_gregset): Ditto.
+
+	* config/sparc/tm-sp64.h (DEPRECATED_TARGET_READ_FP): Update.
+	* config/pa/tm-hppa64.h (DEPRECATED_TARGET_READ_FP): Update.
+	* config/sparc/tm-sparc.h: Update comment.
+
+	* hppa-tdep.c (hppa_init_extra_frame_info): Use
+	deprecated_read_fp instead of TARGET_READ_FP.
+	(hppa_init_extra_frame_info, hppa_frame_chain): Ditto.
+	(hppa_push_dummy_frame, hppa_read_fp): Ditto.
+	* sparc-tdep.c (sparc_init_extra_frame_info): Use
+	deprecated_read_fp instead of read_fp.
+	* s390-tdep.c (s390_push_arguments): Ditto.
+	* ia64-tdep.c (ia64_gdbarch_init): Ditto.
+	* frame.h: Ditto in comments.
+	* frame.c (legacy_get_prev_frame): Ditto.
+	* dummy-frame.c (dummy_frame_this_id): Ditto.
+	* arm-tdep.c (arm_init_extra_frame_info): Ditto.
+
+2003-04-28  Andrew Cagney  <cagney@redhat.com>
+
+	* gdbarch.sh (deprecated_tm_print_insn): Rename tm_print_insn.
+	* gdbarch.h, gdbarch.c: Re-generate.
+	* xstormy16-tdep.c (_initialize_xstormy16_tdep): Update.
+	* vax-tdep.c (_initialize_vax_tdep): Update.
+	* v850-tdep.c (_initialize_v850_tdep): Update.
+	* sparc-tdep.c (_initialize_sparc_tdep): Update.
+	* s390-tdep.c (_initialize_s390_tdep): Update.
+	* ns32k-tdep.c (_initialize_ns32k_tdep): Update.
+	* mn10300-tdep.c (_initialize_mn10300_tdep): Update.
+	* mips-tdep.c (_initialize_mips_tdep): Update.
+	* mcore-tdep.c (_initialize_mcore_tdep): Update.
+	* m68k-tdep.c (_initialize_m68k_tdep): Update.
+	* ia64-tdep.c (_initialize_ia64_tdep): Update.
+	* hppa-tdep.c (_initialize_hppa_tdep): Update.
+	* h8300-tdep.c (_initialize_h8300_tdep): Update.
+	* frv-tdep.c (_initialize_frv_tdep): Update.
+	* cris-tdep.c (cris_delayed_get_disassembler): Update.
+	(_initialize_cris_tdep): Update.
+	* arch-utils.c (legacy_print_insn): Update.
+	* alpha-tdep.c (_initialize_alpha_tdep): Update.
+
+2003-04-26  Adam Fedor  <fedor@gnu.org>
+
+	* linespec.c (decode_objc): New function to decode ObjC calls
+	(decode_line_1): Check for ObjC calls (using decode_objc)
+	* Makefile (linespec.o): Update dependencies.
+
+2003-04-26  Daniel Jacobowitz  <drow@mvista.com>
+
+	* breakpoint.h (struct breakpoint_ops): New.
+	(struct breakpoint): Add ops member.
+
+	* breakpoint.c (print_bp_stop_message, print_one_breakpoint)
+	(mention): Use new breakpoint ops member.
+	(set_raw_breakpoint): Initialize ops field to NULL.
+	(print_exception_catchpoint, print_one_exception_catchpoint)
+	(print_mention_exception_catchpoint, handle_gnu_v3_exceptions): New.
+	(gnu_v3_exception_catchpoint_ops): New.
+	(catch_exception_command_1): Call handle_gnu_v3_exceptions.
+
+2003-04-25  Adam Fedor  <fedor@gnu.org>
+
+	* Makefile.in (COMMON_OBS): Add objc-lang.o
+
+2003-04-25  Andrew Cagney  <cagney@redhat.com>
+
+	* d10v-tdep.c (print_insn): Delete function.
+	(display_trace): Use TARGET_PRINT_INSN.
+	(_initialize_d10v_tdep): Do not set tm_print_insn.
+	(d10v_gdbarch_init): Set print_insn.
+
+2003-04-25  Andrew Cagney  <cagney@redhat.com>
+
+	* d10v-tdep.c (d10v_extract_return_value): Delete call to printf.
+	(_initialize_d10v_tdep): Use add_setshow_boolean_cmd.
+	(d10v_frame_unwind_cache): Use FRAME_OBSTACK_CALLOC.
+	(NR_DMAP_REGS, A0_REGNUM): Delete, replaced by ...
+	(nr_dmap_regs, a0_regnum): ... new functions.
+	(d10v_print_registers_info): Use a0_regnum, use register_size.
+	(d10v_register_byte): Delete function.
+	(d10v_register_raw_size): Delete function.
+	(d10v_register_type): Use a0_regnum.
+	(d10v_print_registers_info): Use a0_regnum.
+	(D10V_SP_REGNUM): Rename _SP_REGNUM, replace it and SP_REGNUM.
+	(d10v_gdbarch_init): Do not set register_byte or
+	register_raw_size, use D10V_SP_REGNUM to set sp_regnum.
+	(d10v_pointer_to_address): Use extract_unsigned_integer instead of
+	extract_address.
+	(trace_command): Use XCALLOC.
+	(print_insn): Delete reference to tm_print_insn.
+	(saved_regs_unwinder): Use store_unsigned_integer instead of
+	store_address.
+	* frame.h (FRAME_OBSTACK_CALLOC): Define
+
+2003-04-25  David Carlton  <carlton@bactrian.org>
+
+	* config/djgpp/fnchange.lst: Add testsuite/gdb.c++/maint.exp.
+
+2003-04-24  Adam Fedor  <fedor@gnu.org>
+
+	* objc-lang.c: Include "valprint.h"
+	* Makefile.in (objc-lang.o): Update dependencies.
+
+2003-04-24  Adam Fedor  <fedor@gnu.org>
+
+	* objc-lang.c (FETCH_ARGUMENT, CONVERT_FUNCPTR): Remove 
+	architecture dependant compilation and mark as unimplemented
+	(until they get put in the gdbarch vector).
+
+2003-04-23  David Carlton  <carlton@bactrian.org>
+
+	* cp-support.c (cp_find_first_component): Accept 'operator' in
+	more locations.
+
+2003-04-23  Andrew Cagney  <cagney@redhat.com>
+
+	* infcall.c (call_function_by_hand): Eliminate redundant
+	indentation.  Move "saved_async" and "old_cleanups" to where they
+	are needed.
+	
+2003-04-23  Andrew Cagney  <cagney@redhat.com>
+
+	* infcall.c (call_function_by_hand): Eliminate the variables "rc"
+	and "buffer".  Move the "name" code to where it is needed.
+
+2003-04-23  Andrew Cagney  <cagney@redhat.com>
+
+	* infcall.c (call_function_by_hand): Move variables "start_sp",
+	"dummy", "sizeof_dummy1" and "dummy1" and corresponding dummy call
+	code to ON_STACK switch branch.
+	
+2003-04-23  Andrew Cagney  <cagney@redhat.com>
+
+	* infcall.c (call_function_by_hand): Make declaration of "i",
+	"sal", "bpt" and "old_sp" more local to their use.  Delete #if
+	lint.
+
+2003-04-23  Andrew Cagney  <cagney@redhat.com>
+
+	* infcall.c (call_function_by_hand): Delete variable
+	"n_method_args".  Localize "param_type"'s declaration to the loop
+	that it is used.  Reinstate code assigning to said variable -
+	deleted on 2002-06-14.  Rationalize calls to value_args_coerce.
+	Rationalize code using "param_type".
+
+2003-04-22  Andrew Cagney  <cagney@redhat.com>
+
+	* infcall.c (call_function_by_hand): Use new variable "bp_addr" to
+	compute the breakpoint address.  Only call FIX_CALL_DUMMY when
+	ON_STACK.  Eliminate the variable "addr".  Do not pass "real_pc"
+	to DEPRECATED_PUSH_RETURN_ADDRESS.
+
+2003-04-22  Kevin Buettner  <kevinb@redhat.com>
+
+	* dwarf2loc.c (dwarf2_evaluate_loc_desc): Invoke DWARF2_REG_TO_REGNUM
+	on the DWARF2 register number prior to fetching a register.
+
+2003-04-22  J. Brobecker  <brobecker@gnat.com>
+
+	* config/pa/tm-hppa.h (SOFT_FLOAT): Delete this macro.
+	Update all the tests using SOFT_FLOAT considering the fact that
+	this macro was always set to 0. 
+	* config/pa/tm-hppa64.h: Update all the tests using SOFT_FLOAT
+	considering the fact that this macro was always set to 0.
+	* hppa-tdep.h (hppa_store_return_value): Likewise.
+	(hppa_extract_return_value): Likewise.
+
+2003-04-22  J. Brobecker  <brobecker@gnat.com>
+
+	* config/pa/tm-hppa.h: Remove obsolete code, was used by
+	the hppa-pro target only.
+
+2003-04-21  J. Brobecker  <brobecker@gnat.com>
+
+	Ongoing multi-arch conversion effort for HP/UX:
+	* config/pa/tm-hppa.h: Move all macro that are no longer
+	defined now that GDB_MULTI_ARCH is now set to 1 from here...
+	* config/pa/tm-hppa64.h: ... to here (hppa64 is not multiarch'ed yet).
+
+2003-04-21  J. Brobecker  <brobecker@gnat.com>
+
+	* config/pa/tm-hppa.h: Obsolete a section that was only used
+	for hppa-pro.
+
+2003-04-21  J. Brobecker  <brobecker@gnat.com>
+
+	Ongoing multi-arch conversion for HP/UX.
+	* config/pa/tm-hppa.h (GDB_MULTI_ARCH): Set to 1. Do not define
+	if already defined (allows hppa64 to stay non-multiarched for now).
+	* config/pa/tm-hppa64.h (GDB_MULTI_ARCH): Define.
+
+2003-04-21  Andrew Cagney  <cagney@redhat.com>
+
+	* frame.c (frame_id_eq): Fail when the code_addr's do not match.
+
+2003-04-21  Andrew Cagney  <cagney@redhat.com>
+
+	* i386-tdep.c (i386_gdbarch_init): Replace "mmx_num_regs" with
+	"i386_num_mmx_regs".
+
+2003-04-21  Andrew Cagney  <cagney@redhat.com>
+
+	* infcall.c: New file.
+	* infcall.h: New file.
+	* valarith.c: Include "infcall.h".
+	* scm-lang.c, objc-lang.cm, hppa-tdep.c, gcore.c: Ditto.
+	* eval.c, ada-valprint.c, ada-lang.c: Ditto.
+	* Makefile.in (valarith.o, scm-lang.o): Update dependencies.
+	(objc-lang.o, hppa-tdep.o, gcore.o): Update dependencies.
+	(eval.o, ada-valprint.o, ada-lang.o): Update dependencies.
+	(SFILES): Add "infcall.c"
+	(COMMON_OBS): Add "infcall.o".
+	(infcall.o): Specify dependencies.
+	* value.h (call_function_by_hand): Delete declaration.
+	* inferior.h (run_stack_dummy): Delete declaration.
+	* infcmd.c (breakpoint_auto_delete_contents): Move to "infcall.c".
+	(run_stack_dummy): Move to "infcall.c", merged into
+	call_function_by_hand.
+	* valops.c (call_function_by_hand): Moved to "infcall.c".
+	(find_function_addr, value_arg_coerce): Ditto.
+	(unwindonsignal_p, coerce_float_to_double): Ditto.
+	(_initialize_valops): Move "set/show coerce-float-to-double", and
+	"set/show unwindonsignal" commands to "infcall.c".
+	* v850-tdep.c, target.h: Update comments.
+	* sparc-tdep.c (sparc_fix_call_dummy): Update comments.
+	* sh-tdep.c (sh_init_extra_frame_info): Update comments.
+	(sh64_init_extra_frame_info): Update comments.
+	* mn10300-tdep.c: Update comments.
+	* mcore-tdep.c (mcore_init_extra_frame_info): Update comments.
+	* config/sparc/tm-sparc.h: Update comments.
+	* breakpoint.h: Update comments.
+	* avr-tdep.c (avr_init_extra_frame_info): Update comments.
+	* arm-tdep.c: Update comment.
+
 2003-04-19  Mark Kettenis  <kettenis@gnu.org>
 
 	* i386-tdep.c (i386_num_register_names): New variable.
diff --git a/gdb/Makefile.in b/gdb/Makefile.in
index a78ef16099a..43d544dab14 100644
--- a/gdb/Makefile.in
+++ b/gdb/Makefile.in
@@ -168,14 +168,14 @@ SUBDIR_CLI_UNINSTALL=
 SUBDIR_MI_OBS = \
 	mi-out.o mi-console.o \
 	mi-cmds.o mi-cmd-env.o mi-cmd-var.o mi-cmd-break.o mi-cmd-stack.o \
-	mi-cmd-file.o mi-cmd-disas.o \
+	mi-cmd-file.o mi-cmd-disas.o mi-cmd-symbol.o \
 	mi-interp.o \
 	mi-main.o mi-parse.o mi-getopt.o
 SUBDIR_MI_SRCS = \
 	mi/mi-out.c mi/mi-console.c \
 	mi/mi-cmds.c mi/mi-cmd-env.c \
 	mi/mi-cmd-var.c mi/mi-cmd-break.c mi/mi-cmd-stack.c \
-	mi/mi-cmd-file.c mi/mi-cmd-disas.c \
+	mi/mi-cmd-file.c mi/mi-cmd-disas.c mi/mi-cmd-symbol.c \
 	mi/mi-interp.c \
 	mi/mi-main.c mi/mi-parse.c mi/mi-getopt.c
 SUBDIR_MI_DEPS =
@@ -521,7 +521,9 @@ SFILES = ada-exp.y ada-lang.c ada-typeprint.c ada-valprint.c ada-tasks.c \
 	frame-unwind.c \
 	gdbarch.c arch-utils.c gdbtypes.c gnu-v2-abi.c gnu-v3-abi.c \
 	hpacc-abi.c \
-	inf-loop.c infcmd.c inflow.c infrun.c \
+	inf-loop.c \
+	infcall.c \
+	infcmd.c inflow.c infrun.c \
 	interps.c \
 	jv-exp.y jv-lang.c jv-valprint.c jv-typeprint.c \
 	kod.c kod-cisco.c \
@@ -669,6 +671,7 @@ i386_linux_tdep_h = i386-linux-tdep.h
 i386_tdep_h = i386-tdep.h
 i387_tdep_h = i387-tdep.h
 inf_loop_h = inf-loop.h
+infcall_h = infcall.h
 inferior_h = inferior.h $(breakpoint_h) $(target_h) $(frame_h)
 inflow_h = inflow.h $(terminal_h)
 interps_h = interps.h
@@ -834,7 +837,9 @@ TAGFILES_WITH_SRCDIR = $(HFILES_WITH_SRCDIR)
 COMMON_OBS = version.o blockframe.o breakpoint.o findvar.o regcache.o \
 	charset.o disasm.o dummy-frame.o \
 	source.o values.o eval.o valops.o valarith.o valprint.o printcmd.o \
-	block.o symtab.o symfile.o symmisc.o linespec.o infcmd.o infrun.o \
+	block.o symtab.o symfile.o symmisc.o linespec.o \
+	infcall.o \
+	infcmd.o infrun.o \
 	expprint.o environ.o stack.o thread.o \
 	interps.o \
 	macrotab.o macrocmd.o macroexp.o macroscope.o \
@@ -849,7 +854,7 @@ COMMON_OBS = version.o blockframe.o breakpoint.o findvar.o regcache.o \
 	dbxread.o coffread.o coff-pe-read.o elfread.o \
 	dwarfread.o dwarf2read.o mipsread.o stabsread.o corefile.o \
 	dwarf2expr.o dwarf2loc.o \
-	c-lang.o f-lang.o \
+	c-lang.o f-lang.o objc-lang.o \
 	ui-out.o cli-out.o \
 	varobj.o wrapper.o \
 	jv-lang.o jv-valprint.o jv-typeprint.o \
@@ -1488,7 +1493,8 @@ abug-rom.o: abug-rom.c $(defs_h) $(gdbcore_h) $(target_h) $(monitor_h) \
 ada-lang.o: ada-lang.c $(gdb_string_h) $(demangle_h) $(defs_h) $(symtab_h) \
 	$(gdbtypes_h) $(gdbcmd_h) $(expression_h) $(parser_defs_h) \
 	$(language_h) $(c_lang_h) $(inferior_h) $(symfile_h) $(objfiles_h) \
-	$(breakpoint_h) $(gdbcore_h) $(ada_lang_h) $(ui_out_h) $(block_h)
+	$(breakpoint_h) $(gdbcore_h) $(ada_lang_h) $(ui_out_h) $(block_h) \
+	$(infcall_h)
 ada-tasks.o: ada-tasks.c $(defs_h) $(command_h) $(value_h) $(language_h) \
 	$(inferior_h) $(symtab_h) $(target_h) $(gdbcore_h) $(gregset_h) \
 	$(ada_lang_h)
@@ -1498,7 +1504,7 @@ ada-typeprint.o: ada-typeprint.c $(defs_h) $(gdb_obstack_h) $(bfd_h) \
 	$(c_lang_h) $(typeprint_h) $(ada_lang_h) $(gdb_string_h)
 ada-valprint.o: ada-valprint.c $(defs_h) $(symtab_h) $(gdbtypes_h) \
 	$(expression_h) $(value_h) $(demangle_h) $(valprint_h) $(language_h) \
-	$(annotate_h) $(ada_lang_h) $(c_lang_h)
+	$(annotate_h) $(ada_lang_h) $(c_lang_h) $(infcall_h)
 aix-thread.o: aix-thread.c $(defs_h) $(gdb_assert_h) $(gdbthread_h) \
 	$(target_h) $(inferior_h) $(regcache_h) $(gdbcmd_h) $(language_h) \
 	$(ppc_tdep_h)
@@ -1634,7 +1640,7 @@ d10v-tdep.o: d10v-tdep.c $(defs_h) $(frame_h) $(frame_unwind_h) \
 	$(gdb_string_h) $(value_h) $(inferior_h) $(dis_asm_h) $(symfile_h) \
 	$(objfiles_h) $(language_h) $(arch_utils_h) $(regcache_h) \
 	$(remote_h) $(floatformat_h) $(gdb_sim_d10v_h) $(sim_regno_h) \
-	$(gdb_assert_h)
+	$(gdb_assert_h) $(disasm_h)
 dbug-rom.o: dbug-rom.c $(defs_h) $(gdbcore_h) $(target_h) $(monitor_h) \
 	$(serial_h) $(regcache_h) $(m68k_tdep_h)
 dbxread.o: dbxread.c $(defs_h) $(gdb_string_h) $(gdb_obstack_h) \
@@ -1650,13 +1656,14 @@ demangle.o: demangle.c $(defs_h) $(command_h) $(gdbcmd_h) $(demangle_h) \
 dink32-rom.o: dink32-rom.c $(defs_h) $(gdbcore_h) $(target_h) $(monitor_h) \
 	$(serial_h) $(symfile_h) $(inferior_h) $(regcache_h)
 disasm.o: disasm.c $(defs_h) $(gdb_string_h) $(target_h) $(value_h) \
-	$(disasm_h) $(ui_out_h)
+	$(disasm_h) $(ui_out_h) $(gdbcore_h)
 doublest.o: doublest.c $(defs_h) $(doublest_h) $(floatformat_h) \
 	$(gdb_assert_h) $(gdb_string_h) $(gdbtypes_h)
 dpx2-nat.o: dpx2-nat.c $(defs_h) $(gdbcore_h) $(gdb_string_h)
 dsrec.o: dsrec.c $(defs_h) $(serial_h) $(srec_h)
 dummy-frame.o: dummy-frame.c $(defs_h) $(dummy_frame_h) $(regcache_h) \
-	$(frame_h) $(inferior_h) $(gdb_assert_h) $(frame_unwind_h)
+	$(frame_h) $(inferior_h) $(gdb_assert_h) $(frame_unwind_h) \
+	$(command_h) $(gdbcmd_h)
 dve3900-rom.o: dve3900-rom.c $(defs_h) $(gdbcore_h) $(target_h) $(monitor_h) \
 	$(serial_h) $(inferior_h) $(command_h) $(gdb_string_h) $(regcache_h)
 dwarf2cfi.o: dwarf2cfi.c $(defs_h) $(gdbcore_h) $(symtab_h) $(symfile_h) \
@@ -1681,7 +1688,7 @@ elfread.o: elfread.c $(defs_h) $(bfd_h) $(gdb_string_h) $(elf_bfd_h) \
 environ.o: environ.c $(defs_h) $(environ_h) $(gdb_string_h)
 eval.o: eval.c $(defs_h) $(gdb_string_h) $(symtab_h) $(gdbtypes_h) \
 	$(value_h) $(expression_h) $(target_h) $(frame_h) $(language_h) \
-	$(f_lang_h) $(cp_abi_h)
+	$(f_lang_h) $(cp_abi_h) $(infcall_h) $(objc-lang.h) $(block_h)
 event-loop.o: event-loop.c $(defs_h) $(event_loop_h) $(event_top_h) \
 	$(gdb_string_h)
 event-top.o: event-top.c $(defs_h) $(top_h) $(inferior_h) $(target_h) \
@@ -1723,7 +1730,7 @@ frame-unwind.o: frame-unwind.c $(defs_h) $(frame_h) $(frame_unwind_h) \
 frv-tdep.o: frv-tdep.c $(defs_h) $(inferior_h) $(symfile_h) $(gdbcore_h) \
 	$(arch_utils_h) $(regcache_h)
 gcore.o: gcore.c $(defs_h) $(cli_decode_h) $(inferior_h) $(gdbcore_h) \
-	$(elf_bfd_h) $(symfile_h) $(objfiles_h)
+	$(elf_bfd_h) $(symfile_h) $(objfiles_h) $(infcall_h)
 gdb.o: gdb.c $(defs_h) $(main_h) $(gdb_string_h) $(interps_h)
 gdb-events.o: gdb-events.c $(defs_h) $(gdb_events_h) $(gdbcmd_h)
 gdbarch.o: gdbarch.c $(defs_h) $(arch_utils_h) $(gdbcmd_h) $(inferior_h) \
@@ -1758,9 +1765,9 @@ hpacc-abi.o: hpacc-abi.c $(defs_h) $(value_h) $(gdb_regex_h) $(gdb_string_h) \
 	$(gdbtypes_h) $(gdbcore_h) $(cp_abi_h)
 hppa-tdep.o: hppa-tdep.c $(defs_h) $(frame_h) $(bfd_h) $(inferior_h) \
 	$(value_h) $(regcache_h) $(completer_h) $(language_h) $(osabi_h) \
-	$(gdb_assert_h) $(infttrace_h) $(symtab_h) $(a_out_encap_h) \
-	$(gdb_stat_h) $(gdb_wait_h) $(gdbcore_h) $(gdbcmd_h) $(target_h) \
-	$(symfile_h) $(objfiles_h)
+	$(gdb_assert_h) $(infttrace_h) $(symtab_h) $(infcall_h) \
+	$(a_out_encap_h) $(gdb_stat_h) $(gdb_wait_h) $(gdbcore_h) \
+	$(gdbcmd_h) $(target_h) $(symfile_h) $(objfiles_h)
 hppa-hpux-tdep.o: hppa-hpux-tdep.c $(defs_h) $(arch_utils_h) $(gdbcore_h) \
 	$(osabi_h) $(gdb_string_h)
 hppab-nat.o: hppab-nat.c $(defs_h) $(inferior_h) $(target_h) $(regcache_h)
@@ -1830,6 +1837,9 @@ ia64-tdep.o: ia64-tdep.c $(defs_h) $(inferior_h) $(symfile_h) $(gdbcore_h) \
 	$(value_h) $(objfiles_h) $(elf_common_h) $(elf_bfd_h)
 inf-loop.o: inf-loop.c $(defs_h) $(inferior_h) $(target_h) $(event_loop_h) \
 	$(event_top_h) $(inf_loop_h) $(remote_h)
+infcall.o: infcall.c $(defs_h) $(breakpoint_h) $(target_h) $(regcache_h) \
+	$(inferior_h) $(gdb_assert_h) $(block_h) $(gdbcore_h) $(language_h) \
+	$(symfile_h) $(gdbcmd_h) $(command_h) $(gdb_string_h)
 infcmd.o: infcmd.c $(defs_h) $(gdb_string_h) $(symtab_h) $(gdbtypes_h) \
 	$(frame_h) $(inferior_h) $(environ_h) $(value_h) $(gdbcmd_h) \
 	$(symfile_h) $(gdbcore_h) $(target_h) $(language_h) $(symfile_h) \
@@ -1877,7 +1887,7 @@ lin-lwp.o: lin-lwp.c $(defs_h) $(gdb_assert_h) $(gdb_string_h) $(gdb_wait_h) \
 	$(gdbthread_h) $(inferior_h) $(target_h) $(regcache_h) $(gdbcmd_h)
 linespec.o: linespec.c $(defs_h) $(symtab_h) $(frame_h) $(command_h) \
 	$(symfile_h) $(objfiles_h) $(demangle_h) $(value_h) $(completer_h) \
-	$(cp_abi_h) $(source_h) $(parser_defs_h) $(block_h)
+	$(cp_abi_h) $(source_h) $(parser_defs_h) $(block_h) $(objc_lang_h)
 linux-proc.o: linux-proc.c $(defs_h) $(inferior_h) $(regcache_h) \
 	$(gregset_h) $(gdbcore_h) $(gdbthread_h) $(elf_bfd_h) \
 	$(cli_decode_h) $(gdb_string_h)
@@ -1936,7 +1946,7 @@ mcore-rom.o: mcore-rom.c $(defs_h) $(gdbcore_h) $(target_h) $(monitor_h) \
 	$(gdb_string_h) $(regcache_h) $(serial_h)
 mcore-tdep.o: mcore-tdep.c $(defs_h) $(frame_h) $(symtab_h) $(value_h) \
 	$(gdbcmd_h) $(regcache_h) $(symfile_h) $(gdbcore_h) $(inferior_h) \
-	$(arch_utils_h) $(gdb_string_h)
+	$(arch_utils_h) $(gdb_string_h) $(disasm_h)
 mdebugread.o: mdebugread.c $(defs_h) $(symtab_h) $(gdbtypes_h) $(gdbcore_h) \
 	$(symfile_h) $(objfiles_h) $(gdb_obstack_h) $(buildsym_h) \
 	$(stabsread_h) $(complaints_h) $(demangle_h) $(gdb_assert_h) \
@@ -1995,9 +2005,9 @@ ns32knbsd-tdep.o: ns32knbsd-tdep.c $(defs_h) $(ns32k_tdep_h) $(gdb_string_h) \
 	$(osabi_h)
 objc-lang.o: objc-lang.c $(defs_h) $(symtab_h) $(gdbtypes_h) $(expression_h) \
 	$(parser_defs_h) $(language_h) $(c_lang_h) $(objc_lang_h) \
-	$(complaints_h) $(value_h) $(symfile_h) $(objfiles_h) \
-	$(gdb_string_h) $(target_h) $(gdbcore_h) $(gdbcmd_h) $(frame_h) \
-	$(gdb_regex_h) $(regcache_h) $(block_h)
+	$(complaints_h) $(value_h) $(symfile_h) $(objfiles_h) $(gdb_string_h) \
+	$(target_h) $(gdbcore_h) $(gdbcmd_h) $(frame_h) $(gdb_regex_h) \
+	$(regcache_h) $(block_h) $(infcall_h) $(valprint_h)
 objfiles.o: objfiles.c $(defs_h) $(bfd_h) $(symtab_h) $(symfile_h) \
 	$(objfiles_h) $(gdb_stabs_h) $(target_h) $(bcache_h) $(gdb_stat_h) \
 	$(gdb_obstack_h) $(gdb_string_h) $(breakpoint_h) $(mmalloc_h) \
@@ -2052,7 +2062,7 @@ printcmd.o: printcmd.c $(defs_h) $(gdb_string_h) $(frame_h) $(symtab_h) \
 	$(gdbtypes_h) $(value_h) $(language_h) $(expression_h) $(gdbcore_h) \
 	$(gdbcmd_h) $(target_h) $(breakpoint_h) $(demangle_h) $(valprint_h) \
 	$(annotate_h) $(symfile_h) $(objfiles_h) $(completer_h) $(ui_out_h) \
-	$(gdb_assert_h) $(block_h)
+	$(gdb_assert_h) $(block_h) $(disasm_h)
 proc-api.o: proc-api.c $(defs_h) $(gdbcmd_h) $(completer_h) $(gdb_wait_h) \
 	$(proc_utils_h)
 proc-events.o: proc-events.c $(defs_h)
@@ -2150,7 +2160,7 @@ scm-exp.o: scm-exp.c $(defs_h) $(symtab_h) $(gdbtypes_h) $(expression_h) \
 	$(scm_tags_h)
 scm-lang.o: scm-lang.c $(defs_h) $(symtab_h) $(gdbtypes_h) $(expression_h) \
 	$(parser_defs_h) $(language_h) $(value_h) $(c_lang_h) $(scm_lang_h) \
-	$(scm_tags_h) $(gdb_string_h) $(gdbcore_h) $(source_h)
+	$(scm_tags_h) $(source_h) $(gdb_string_h) $(gdbcore_h) $(infcall_h)
 scm-valprint.o: scm-valprint.c $(defs_h) $(symtab_h) $(gdbtypes_h) \
 	$(expression_h) $(parser_defs_h) $(language_h) $(value_h) \
 	$(scm_lang_h) $(valprint_h) $(gdbcore_h)
@@ -2266,7 +2276,7 @@ symtab.o: symtab.c $(defs_h) $(symtab_h) $(gdbtypes_h) $(gdbcore_h) \
 	$(gdbcmd_h) $(call_cmds_h) $(gdb_regex_h) $(expression_h) \
 	$(language_h) $(demangle_h) $(inferior_h) $(linespec_h) \
 	$(filenames_h) $(gdb_obstack_h) $(gdb_string_h) $(gdb_stat_h) \
-	$(cp_abi_h) $(source_h) $(block_h)
+	$(cp_abi_h) $(source_h) $(block_h) $(objc_lang_h)
 target.o: target.c $(defs_h) $(gdb_string_h) $(target_h) $(gdbcmd_h) \
 	$(symtab_h) $(inferior_h) $(bfd_h) $(symfile_h) $(objfiles_h) \
 	$(gdb_wait_h) $(dcache_h) $(regcache_h)
@@ -2308,7 +2318,7 @@ v850ice.o: v850ice.c $(defs_h) $(gdb_string_h) $(frame_h) $(symtab_h) \
 	$(gdbcore_h) $(value_h) $(command_h) $(regcache_h)
 valarith.o: valarith.c $(defs_h) $(value_h) $(symtab_h) $(gdbtypes_h) \
 	$(expression_h) $(target_h) $(language_h) $(gdb_string_h) \
-	$(doublest_h)
+	$(doublest_h) $(infcall_h)
 valops.o: valops.c $(defs_h) $(symtab_h) $(gdbtypes_h) $(value_h) $(frame_h) \
 	$(inferior_h) $(gdbcore_h) $(target_h) $(demangle_h) $(language_h) \
 	$(gdbcmd_h) $(regcache_h) $(cp_abi_h) $(gdb_string_h) \
@@ -2566,6 +2576,9 @@ mi-cmd-env.o: $(srcdir)/mi/mi-cmd-env.c $(defs_h) $(inferior_h) $(value_h) \
 mi-cmd-stack.o: $(srcdir)/mi/mi-cmd-stack.c $(defs_h) $(target_h) $(frame_h) \
 	$(value_h) $(mi_cmds_h) $(ui_out_h) $(symtab_h) $(block_h)
 	$(CC) -c $(INTERNAL_CFLAGS) $(srcdir)/mi/mi-cmd-stack.c
+mi-cmd-symbol.o: $(srcdir)/mi/mi-cmd-symbol.c $(defs_h) \
+	$(mi_cmds_h) $(ui_out_h) $(symtab_h)
+	$(CC) -c $(INTERNAL_CFLAGS) $(srcdir)/mi/mi-cmd-symbol.c
 mi-cmd-var.o: $(srcdir)/mi/mi-cmd-var.c $(defs_h) $(mi_cmds_h) $(ui_out_h) \
 	$(mi_out_h) $(varobj_h) $(value_h) $(gdb_string_h)
 	$(CC) -c $(INTERNAL_CFLAGS) $(srcdir)/mi/mi-cmd-var.c
diff --git a/gdb/ada-lang.c b/gdb/ada-lang.c
index bc0809d3e2a..b047442d6f3 100644
--- a/gdb/ada-lang.c
+++ b/gdb/ada-lang.c
@@ -39,6 +39,7 @@ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
 #include "ada-lang.h"
 #include "ui-out.h"
 #include "block.h"
+#include "infcall.h"
 
 struct cleanup *unresolved_names;
 
diff --git a/gdb/ada-valprint.c b/gdb/ada-valprint.c
index 8633f2c7893..5b90c0683cd 100644
--- a/gdb/ada-valprint.c
+++ b/gdb/ada-valprint.c
@@ -30,6 +30,7 @@ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
 #include "annotate.h"
 #include "ada-lang.h"
 #include "c-lang.h"
+#include "infcall.h"
 
 /* Encapsulates arguments to ada_val_print. */
 struct ada_val_print_args
diff --git a/gdb/alpha-nat.c b/gdb/alpha-nat.c
index 548869b2fa8..af0a336cf6a 100644
--- a/gdb/alpha-nat.c
+++ b/gdb/alpha-nat.c
@@ -212,7 +212,7 @@ supply_gregset (gdb_gregset_t *gregsetp)
 
   /* Fill inaccessible registers with zero.  */
   supply_register (ALPHA_ZERO_REGNUM, zerobuf);
-  supply_register (FP_REGNUM, zerobuf);
+  supply_register (DEPRECATED_FP_REGNUM, zerobuf);
 }
 
 void
diff --git a/gdb/alpha-tdep.c b/gdb/alpha-tdep.c
index d61f359c1f5..c1648b48b48 100644
--- a/gdb/alpha-tdep.c
+++ b/gdb/alpha-tdep.c
@@ -66,8 +66,6 @@ static gdbarch_frame_locals_address_ftype alpha_frame_locals_address;
 
 static gdbarch_skip_prologue_ftype alpha_skip_prologue;
 
-static gdbarch_fix_call_dummy_ftype alpha_fix_call_dummy;
-
 static gdbarch_get_longjmp_target_ftype alpha_get_longjmp_target;
 
 struct frame_extra_info
@@ -293,13 +291,13 @@ alpha_register_name (int regno)
 static int
 alpha_cannot_fetch_register (int regno)
 {
-  return (regno == FP_REGNUM || regno == ALPHA_ZERO_REGNUM);
+  return (regno == DEPRECATED_FP_REGNUM || regno == ALPHA_ZERO_REGNUM);
 }
 
 static int
 alpha_cannot_store_register (int regno)
 {
-  return (regno == FP_REGNUM || regno == ALPHA_ZERO_REGNUM);
+  return (regno == DEPRECATED_FP_REGNUM || regno == ALPHA_ZERO_REGNUM);
 }
 
 static int
@@ -1269,7 +1267,7 @@ alpha_push_dummy_frame (void)
      be read as zero and will help us to catch any errors in the dummy frame
      retrieval code.  */
   PROC_DUMMY_FRAME (proc_desc) = sp;
-  PROC_FRAME_REG (proc_desc) = FP_REGNUM;
+  PROC_FRAME_REG (proc_desc) = DEPRECATED_FP_REGNUM;
   PROC_FRAME_OFFSET (proc_desc) = 0;
   sp += PROC_REG_OFFSET (proc_desc);
   write_register (SP_REGNUM, sp);
@@ -1806,12 +1804,12 @@ alpha_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
   /* Register info */
   set_gdbarch_num_regs (gdbarch, ALPHA_NUM_REGS);
   set_gdbarch_sp_regnum (gdbarch, ALPHA_SP_REGNUM);
-  set_gdbarch_fp_regnum (gdbarch, ALPHA_FP_REGNUM);
+  set_gdbarch_deprecated_fp_regnum (gdbarch, ALPHA_FP_REGNUM);
   set_gdbarch_pc_regnum (gdbarch, ALPHA_PC_REGNUM);
   set_gdbarch_fp0_regnum (gdbarch, ALPHA_FP0_REGNUM);
 
   set_gdbarch_register_name (gdbarch, alpha_register_name);
-  set_gdbarch_register_size (gdbarch, ALPHA_REGISTER_SIZE);
+  set_gdbarch_deprecated_register_size (gdbarch, ALPHA_REGISTER_SIZE);
   set_gdbarch_register_bytes (gdbarch, ALPHA_REGISTER_BYTES);
   set_gdbarch_register_byte (gdbarch, alpha_register_byte);
   set_gdbarch_register_raw_size (gdbarch, alpha_register_raw_size);
@@ -1859,8 +1857,8 @@ alpha_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
      stopping the user call is achieved via a bp_call_dummy breakpoint.
      But we need a fake CALL_DUMMY definition to enable the proper
      call_function_by_hand and to avoid zero length array warnings.  */
-  set_gdbarch_call_dummy_words (gdbarch, alpha_call_dummy_words);
-  set_gdbarch_sizeof_call_dummy_words (gdbarch, 0);
+  set_gdbarch_deprecated_call_dummy_words (gdbarch, alpha_call_dummy_words);
+  set_gdbarch_deprecated_sizeof_call_dummy_words (gdbarch, 0);
   set_gdbarch_frame_args_address (gdbarch, alpha_frame_args_address);
   set_gdbarch_frame_locals_address (gdbarch, alpha_frame_locals_address);
   set_gdbarch_deprecated_init_extra_frame_info (gdbarch, alpha_init_extra_frame_info);
@@ -1873,7 +1871,7 @@ alpha_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
   set_gdbarch_deprecated_push_dummy_frame (gdbarch, alpha_push_dummy_frame);
   /* Should be using push_dummy_call.  */
   set_gdbarch_deprecated_dummy_write_sp (gdbarch, generic_target_write_sp);
-  set_gdbarch_fix_call_dummy (gdbarch, alpha_fix_call_dummy);
+  set_gdbarch_deprecated_fix_call_dummy (gdbarch, alpha_fix_call_dummy);
   set_gdbarch_deprecated_init_frame_pc (gdbarch, init_frame_pc_noop);
   set_gdbarch_deprecated_init_frame_pc_first (gdbarch, alpha_init_frame_pc_first);
 
@@ -1925,7 +1923,7 @@ _initialize_alpha_tdep (void)
 
   gdbarch_register (bfd_arch_alpha, alpha_gdbarch_init, alpha_dump_tdep);
 
-  tm_print_insn = print_insn_alpha;
+  deprecated_tm_print_insn = print_insn_alpha;
 
   /* Let the user set the fence post for heuristic_proc_start.  */
 
diff --git a/gdb/alpha-tdep.h b/gdb/alpha-tdep.h
index 76f91f32bf4..0e8aefbfe16 100644
--- a/gdb/alpha-tdep.h
+++ b/gdb/alpha-tdep.h
@@ -40,12 +40,12 @@
 /* Largest value REGISTER_VIRTUAL_SIZE can have.  */
 #define ALPHA_MAX_REGISTER_VIRTUAL_SIZE 8
 
-/* Register numbers of various important registers.
-   Note that most of these values are "real" register numbers,
-   and correspond to the general registers of the machine,
-   and FP_REGNUM is a "phony" register number which is too large
-   to be an actual register number as far as the user is concerned
-   but serves to get the desired value when passed to read_register.  */
+/* Register numbers of various important registers.  Note that most of
+   these values are "real" register numbers, and correspond to the
+   general registers of the machine, and DEPRECATED_FP_REGNUM is a
+   "phony" register number which is too large to be an actual register
+   number as far as the user is concerned but serves to get the
+   desired value when passed to read_register.  */
 
 #define ALPHA_V0_REGNUM	     0  /* Function integer return value */
 #define ALPHA_T7_REGNUM	     8  /* Return address register for OSF/1 __add* */
diff --git a/gdb/alphabsd-nat.c b/gdb/alphabsd-nat.c
index b26d3ea7c48..a20b36f575e 100644
--- a/gdb/alphabsd-nat.c
+++ b/gdb/alphabsd-nat.c
@@ -113,7 +113,7 @@ fetch_inferior_registers (int regno)
     }
 
   /* Reset virtual frame pointer.  */
-  supply_register (FP_REGNUM, NULL);
+  supply_register (DEPRECATED_FP_REGNUM, NULL);
 }
 
 /* Store register REGNO back into the inferior.  If REGNO is -1, do
diff --git a/gdb/alphafbsd-tdep.c b/gdb/alphafbsd-tdep.c
index 6b1b068d9cf..3d8eafb2927 100644
--- a/gdb/alphafbsd-tdep.c
+++ b/gdb/alphafbsd-tdep.c
@@ -32,7 +32,7 @@ alphafbsd_use_struct_convention (int gcc_p, struct type *type)
 
   /* All aggregate types that won't fit in a register must be returned
      in memory.  */
-  if (TYPE_LENGTH (type) > REGISTER_SIZE)
+  if (TYPE_LENGTH (type) > DEPRECATED_REGISTER_SIZE)
     return 1;
 
   /* The only aggregate types that can be returned in a register are
diff --git a/gdb/alphanbsd-tdep.c b/gdb/alphanbsd-tdep.c
index 6137c5e98de..a4a77c1c00c 100644
--- a/gdb/alphanbsd-tdep.c
+++ b/gdb/alphanbsd-tdep.c
@@ -70,7 +70,7 @@ fetch_core_registers (char *core_reg_sect, unsigned core_reg_size, int which,
   for (regno = 0; regno < ALPHA_ZERO_REGNUM; regno++)
     supply_register (regno, regs + (regmap[regno] * 8));
   supply_register (ALPHA_ZERO_REGNUM, NULL);
-  supply_register (FP_REGNUM, NULL);
+  supply_register (DEPRECATED_FP_REGNUM, NULL);
   supply_register (PC_REGNUM, regs + (28 * 8));
 
   /* Floating point registers.  */
diff --git a/gdb/arch-utils.c b/gdb/arch-utils.c
index 825bd5cb76f..2f555ff6fa8 100644
--- a/gdb/arch-utils.c
+++ b/gdb/arch-utils.c
@@ -191,7 +191,9 @@ LONGEST legacy_call_dummy_words[1];
 int legacy_sizeof_call_dummy_words = sizeof (legacy_call_dummy_words);
 
 void
-generic_remote_translate_xfer_address (CORE_ADDR gdb_addr, int gdb_len,
+generic_remote_translate_xfer_address (struct gdbarch *gdbarch,
+				       struct regcache *regcache,
+				       CORE_ADDR gdb_addr, int gdb_len,
 				       CORE_ADDR * rem_addr, int *rem_len)
 {
   *rem_addr = gdb_addr;
@@ -209,7 +211,7 @@ generic_prologue_frameless_p (CORE_ADDR ip)
 int
 legacy_print_insn (bfd_vma vma, disassemble_info *info)
 {
-  return (*tm_print_insn) (vma, info);
+  return (*deprecated_tm_print_insn) (vma, info);
 }
 
 /* Helper functions for INNER_THAN */
@@ -410,7 +412,8 @@ cannot_register_not (int regnum)
 }
 
 /* Legacy version of target_virtual_frame_pointer().  Assumes that
-   there is an FP_REGNUM and that it is the same, cooked or raw.  */
+   there is an DEPRECATED_FP_REGNUM and that it is the same, cooked or
+   raw.  */
 
 void
 legacy_virtual_frame_pointer (CORE_ADDR pc,
@@ -422,8 +425,8 @@ legacy_virtual_frame_pointer (CORE_ADDR pc,
      register and an offset can determine this.  I think it should
      instead generate a byte code expression as that would work better
      with things like Dwarf2's CFI.  */
-  if (FP_REGNUM >= 0 && FP_REGNUM < NUM_REGS)
-    *frame_regnum = FP_REGNUM;
+  if (DEPRECATED_FP_REGNUM >= 0 && DEPRECATED_FP_REGNUM < NUM_REGS)
+    *frame_regnum = DEPRECATED_FP_REGNUM;
   else if (SP_REGNUM >= 0 && SP_REGNUM < NUM_REGS)
     *frame_regnum = SP_REGNUM;
   else
diff --git a/gdb/arch-utils.h b/gdb/arch-utils.h
index f3874a0c250..cf515a4f76d 100644
--- a/gdb/arch-utils.h
+++ b/gdb/arch-utils.h
@@ -141,7 +141,8 @@ void default_coff_make_msymbol_special (int val, struct minimal_symbol *msym);
 int cannot_register_not (int regnum);
 
 /* Legacy version of target_virtual_frame_pointer().  Assumes that
-   there is an FP_REGNUM and that it is the same, cooked or raw.  */
+   there is an DEPRECATED_FP_REGNUM and that it is the same, cooked or
+   raw.  */
 
 extern gdbarch_virtual_frame_pointer_ftype legacy_virtual_frame_pointer;
 
diff --git a/gdb/arm-linux-tdep.c b/gdb/arm-linux-tdep.c
index 91fa88fe0ad..60c8ae492a9 100644
--- a/gdb/arm-linux-tdep.c
+++ b/gdb/arm-linux-tdep.c
@@ -46,7 +46,7 @@
 
 static const char arm_linux_arm_le_breakpoint[] = {0x01,0x00,0x9f,0xef};
 
-/* CALL_DUMMY_WORDS:
+/* DEPRECATED_CALL_DUMMY_WORDS:
    This sequence of words is the instructions
 
    mov  lr, pc
@@ -115,10 +115,10 @@ arm_linux_push_arguments (int nargs, struct value **args, CORE_ADDR sp,
   /* Walk through the list of args and determine how large a temporary
      stack is required.  Need to take care here as structs may be
      passed on the stack, and we have to to push them.  */
-  nstack_size = -4 * REGISTER_SIZE;	/* Some arguments go into A1-A4.  */
+  nstack_size = -4 * DEPRECATED_REGISTER_SIZE;	/* Some arguments go into A1-A4.  */
 
   if (struct_return)			/* The struct address goes in A1.  */
-    nstack_size += REGISTER_SIZE;
+    nstack_size += DEPRECATED_REGISTER_SIZE;
 
   /* Walk through the arguments and add their size to nstack_size.  */
   for (argnum = 0; argnum < nargs; argnum++)
@@ -131,7 +131,7 @@ arm_linux_push_arguments (int nargs, struct value **args, CORE_ADDR sp,
 
       /* ANSI C code passes float arguments as integers, K&R code
          passes float arguments as doubles.  Correct for this here.  */
-      if (TYPE_CODE_FLT == TYPE_CODE (arg_type) && REGISTER_SIZE == len)
+      if (TYPE_CODE_FLT == TYPE_CODE (arg_type) && DEPRECATED_REGISTER_SIZE == len)
 	nstack_size += FP_REGISTER_VIRTUAL_SIZE;
       else
 	nstack_size += len;
@@ -178,7 +178,7 @@ arm_linux_push_arguments (int nargs, struct value **args, CORE_ADDR sp,
          .stabs records the type as FP_FLOAT.  In this latter case
          the compiler converts the float arguments to double before
          calling the function.  */
-      if (TYPE_CODE_FLT == typecode && REGISTER_SIZE == len)
+      if (TYPE_CODE_FLT == typecode && DEPRECATED_REGISTER_SIZE == len)
 	{
 	  DOUBLEST dblval;
 	  dblval = deprecated_extract_floating (val, len);
@@ -203,7 +203,7 @@ arm_linux_push_arguments (int nargs, struct value **args, CORE_ADDR sp,
          registers and stack.  */
       while (len > 0)
 	{
-	  int partial_len = len < REGISTER_SIZE ? len : REGISTER_SIZE;
+	  int partial_len = len < DEPRECATED_REGISTER_SIZE ? len : DEPRECATED_REGISTER_SIZE;
 
 	  if (argreg <= ARM_LAST_ARG_REGNUM)
 	    {
@@ -214,8 +214,8 @@ arm_linux_push_arguments (int nargs, struct value **args, CORE_ADDR sp,
 	  else
 	    {
 	      /* Push the arguments onto the stack.  */
-	      write_memory ((CORE_ADDR) fp, val, REGISTER_SIZE);
-	      fp += REGISTER_SIZE;
+	      write_memory ((CORE_ADDR) fp, val, DEPRECATED_REGISTER_SIZE);
+	      fp += DEPRECATED_REGISTER_SIZE;
 	    }
 
 	  len -= partial_len;
@@ -530,9 +530,8 @@ arm_linux_init_abi (struct gdbarch_info info,
   tdep->jb_pc = ARM_LINUX_JB_PC;
   tdep->jb_elt_size = ARM_LINUX_JB_ELEMENT_SIZE;
 
-  set_gdbarch_call_dummy_words (gdbarch, arm_linux_call_dummy_words);
-  set_gdbarch_sizeof_call_dummy_words (gdbarch,
-				       sizeof (arm_linux_call_dummy_words));
+  set_gdbarch_deprecated_call_dummy_words (gdbarch, arm_linux_call_dummy_words);
+  set_gdbarch_deprecated_sizeof_call_dummy_words (gdbarch, sizeof (arm_linux_call_dummy_words));
 
   /* The following two overrides shouldn't be needed.  */
   set_gdbarch_deprecated_extract_return_value (gdbarch, arm_linux_extract_return_value);
diff --git a/gdb/arm-tdep.c b/gdb/arm-tdep.c
index 0a029e84702..d2e3ef598a0 100644
--- a/gdb/arm-tdep.c
+++ b/gdb/arm-tdep.c
@@ -1118,7 +1118,7 @@ arm_init_extra_frame_info (int fromleaf, struct frame_info *fi)
 	  else if (fromleaf)
 	    /* If we were called by a frameless fn.  then our frame is
 	       still in the frame pointer register on the board...  */
-	    deprecated_update_frame_base_hack (fi, read_fp ());
+	    deprecated_update_frame_base_hack (fi, deprecated_read_fp ());
 	}
 
       /* Calculate actual addresses of saved registers using offsets
@@ -1237,7 +1237,7 @@ arm_push_dummy_frame (void)
   write_register (ARM_SP_REGNUM, sp);
 }
 
-/* CALL_DUMMY_WORDS:
+/* DEPRECATED_CALL_DUMMY_WORDS:
    This sequence of words is the instructions
 
    mov  lr,pc
@@ -1257,17 +1257,17 @@ static LONGEST arm_call_dummy_words[] =
 
    FIXME rearnsha 2002-02018: Tweeking current_gdbarch is not an
    optimal solution, but the call to arm_fix_call_dummy is immediately
-   followed by a call to run_stack_dummy, which is the only function
-   where call_dummy_breakpoint_offset is actually used.  */
+   followed by a call to call_function_by_hand, which is the only
+   function where call_dummy_breakpoint_offset is actually used.  */
 
 
 static void
 arm_set_call_dummy_breakpoint_offset (void)
 {
   if (caller_is_thumb)
-    set_gdbarch_call_dummy_breakpoint_offset (current_gdbarch, 4);
+    set_gdbarch_deprecated_call_dummy_breakpoint_offset (current_gdbarch, 4);
   else
-    set_gdbarch_call_dummy_breakpoint_offset (current_gdbarch, 8);
+    set_gdbarch_deprecated_call_dummy_breakpoint_offset (current_gdbarch, 8);
 }
 
 /* Fix up the call dummy, based on whether the processor is currently
@@ -1430,7 +1430,7 @@ arm_push_dummy_call (struct gdbarch *gdbarch, struct regcache *regcache,
   /* Some platforms require a double-word aligned stack.  Make sure sp
      is correctly aligned before we start.  We always do this even if
      it isn't really needed -- it can never hurt things.  */
-  sp &= ~(CORE_ADDR)(2 * REGISTER_SIZE - 1);
+  sp &= ~(CORE_ADDR)(2 * DEPRECATED_REGISTER_SIZE - 1);
 
   /* The struct_return pointer occupies the first parameter
      passing register.  */
@@ -1477,7 +1477,7 @@ arm_push_dummy_call (struct gdbarch *gdbarch, struct regcache *regcache,
 	 registers and stack.  */
       while (len > 0)
 	{
-	  int partial_len = len < REGISTER_SIZE ? len : REGISTER_SIZE;
+	  int partial_len = len < DEPRECATED_REGISTER_SIZE ? len : DEPRECATED_REGISTER_SIZE;
 
 	  if (argreg <= ARM_LAST_ARG_REGNUM)
 	    {
@@ -1487,7 +1487,7 @@ arm_push_dummy_call (struct gdbarch *gdbarch, struct regcache *regcache,
 	      if (arm_debug)
 		fprintf_unfiltered (gdb_stdlog, "arg %d in %s = 0x%s\n",
 				    argnum, REGISTER_NAME (argreg),
-				    phex (regval, REGISTER_SIZE));
+				    phex (regval, DEPRECATED_REGISTER_SIZE));
 	      regcache_cooked_write_unsigned (regcache, argreg, regval);
 	      argreg++;
 	    }
@@ -1497,8 +1497,8 @@ arm_push_dummy_call (struct gdbarch *gdbarch, struct regcache *regcache,
 	      if (arm_debug)
 		fprintf_unfiltered (gdb_stdlog, "arg %d @ sp + %d\n",
 				    argnum, nstack);
-	      si = push_stack_item (si, val, REGISTER_SIZE);
-	      nstack += REGISTER_SIZE;
+	      si = push_stack_item (si, val, DEPRECATED_REGISTER_SIZE);
+	      nstack += DEPRECATED_REGISTER_SIZE;
 	    }
 	      
 	  len -= partial_len;
@@ -1799,7 +1799,7 @@ thumb_get_next_pc (CORE_ADDR pc)
 
       /* Fetch the saved PC from the stack.  It's stored above
          all of the other registers.  */
-      offset = bitcount (bits (inst1, 0, 7)) * REGISTER_SIZE;
+      offset = bitcount (bits (inst1, 0, 7)) * DEPRECATED_REGISTER_SIZE;
       sp = read_register (ARM_SP_REGNUM);
       nextpc = (CORE_ADDR) read_memory_integer (sp + offset, 4);
       nextpc = ADDR_BITS_REMOVE (nextpc);
@@ -2309,10 +2309,10 @@ arm_use_struct_convention (int gcc_p, struct type *type)
 
   /* In the ARM ABI, "integer" like aggregate types are returned in
      registers.  For an aggregate type to be integer like, its size
-     must be less than or equal to REGISTER_SIZE and the offset of
-     each addressable subfield must be zero.  Note that bit fields are
-     not addressable, and all addressable subfields of unions always
-     start at offset zero.
+     must be less than or equal to DEPRECATED_REGISTER_SIZE and the
+     offset of each addressable subfield must be zero.  Note that bit
+     fields are not addressable, and all addressable subfields of
+     unions always start at offset zero.
 
      This function is based on the behaviour of GCC 2.95.1.
      See: gcc/arm.c: arm_return_in_memory() for details.
@@ -2326,7 +2326,7 @@ arm_use_struct_convention (int gcc_p, struct type *type)
 
   /* All aggregate types that won't fit in a register must be returned
      in memory.  */
-  if (TYPE_LENGTH (type) > REGISTER_SIZE)
+  if (TYPE_LENGTH (type) > DEPRECATED_REGISTER_SIZE)
     {
       return 1;
     }
@@ -2348,11 +2348,11 @@ arm_use_struct_convention (int gcc_p, struct type *type)
       int i;
       /* Need to check if this struct/union is "integer" like.  For
          this to be true, its size must be less than or equal to
-         REGISTER_SIZE and the offset of each addressable subfield
-         must be zero.  Note that bit fields are not addressable, and
-         unions always start at offset zero.  If any of the subfields
-         is a floating point type, the struct/union cannot be an
-         integer type.  */
+         DEPRECATED_REGISTER_SIZE and the offset of each addressable
+         subfield must be zero.  Note that bit fields are not
+         addressable, and unions always start at offset zero.  If any
+         of the subfields is a floating point type, the struct/union
+         cannot be an integer type.  */
 
       /* For each field in the object, check:
          1) Is it FP? --> yes, nRc = 1;
@@ -2930,15 +2930,15 @@ arm_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
   tdep->lowest_pc = 0x20;
   tdep->jb_pc = -1;	/* Longjump support not enabled by default.  */
 
-  set_gdbarch_call_dummy_words (gdbarch, arm_call_dummy_words);
-  set_gdbarch_sizeof_call_dummy_words (gdbarch, 0);
+  set_gdbarch_deprecated_call_dummy_words (gdbarch, arm_call_dummy_words);
+  set_gdbarch_deprecated_sizeof_call_dummy_words (gdbarch, 0);
 
   set_gdbarch_push_dummy_call (gdbarch, arm_push_dummy_call);
 
   /* Frame handling.  */
   set_gdbarch_deprecated_frame_chain_valid (gdbarch, arm_frame_chain_valid);
   set_gdbarch_deprecated_init_extra_frame_info (gdbarch, arm_init_extra_frame_info);
-  set_gdbarch_read_fp (gdbarch, arm_read_fp);
+  set_gdbarch_deprecated_target_read_fp (gdbarch, arm_read_fp);
   set_gdbarch_deprecated_frame_chain (gdbarch, arm_frame_chain);
   set_gdbarch_frameless_function_invocation
     (gdbarch, arm_frameless_function_invocation);
@@ -2972,7 +2972,7 @@ arm_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
 
   /* Information about registers, etc.  */
   set_gdbarch_print_float_info (gdbarch, arm_print_float_info);
-  set_gdbarch_fp_regnum (gdbarch, ARM_FP_REGNUM);	/* ??? */
+  set_gdbarch_deprecated_fp_regnum (gdbarch, ARM_FP_REGNUM);	/* ??? */
   set_gdbarch_sp_regnum (gdbarch, ARM_SP_REGNUM);
   set_gdbarch_pc_regnum (gdbarch, ARM_PC_REGNUM);
   set_gdbarch_register_byte (gdbarch, arm_register_byte);
@@ -2991,7 +2991,7 @@ arm_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
   set_gdbarch_register_sim_regno (gdbarch, arm_register_sim_regno);
 
   /* Integer registers are 4 bytes.  */
-  set_gdbarch_register_size (gdbarch, 4);
+  set_gdbarch_deprecated_register_size (gdbarch, 4);
   set_gdbarch_register_name (gdbarch, arm_register_name);
 
   /* Returning results.  */
diff --git a/gdb/avr-tdep.c b/gdb/avr-tdep.c
index b787c8141cf..386b3861629 100644
--- a/gdb/avr-tdep.c
+++ b/gdb/avr-tdep.c
@@ -396,7 +396,9 @@ avr_read_fp (void)
    pointer? */
 
 static void
-avr_remote_translate_xfer_address (CORE_ADDR memaddr, int nr_bytes,
+avr_remote_translate_xfer_address (struct gdbarch *gdbarch,
+				   struct regcache *regcache,
+				   CORE_ADDR memaddr, int nr_bytes,
 				   CORE_ADDR *targ_addr, int *targ_len)
 {
   long out_addr;
@@ -753,8 +755,8 @@ avr_init_extra_frame_info (int fromleaf, struct frame_info *fi)
   if (DEPRECATED_PC_IN_CALL_DUMMY (get_frame_pc (fi), get_frame_base (fi),
 				   get_frame_base (fi)))
     {
-      /* We need to setup fi->frame here because run_stack_dummy gets it wrong
-         by assuming it's always FP.  */
+      /* We need to setup fi->frame here because call_function_by_hand
+         gets it wrong by assuming it's always FP.  */
       deprecated_update_frame_base_hack (fi, deprecated_read_register_dummy (get_frame_pc (fi), get_frame_base (fi),
 									     AVR_PC_REGNUM));
     }
@@ -1145,18 +1147,18 @@ avr_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
 
   set_gdbarch_read_pc (gdbarch, avr_read_pc);
   set_gdbarch_write_pc (gdbarch, avr_write_pc);
-  set_gdbarch_read_fp (gdbarch, avr_read_fp);
+  set_gdbarch_deprecated_target_read_fp (gdbarch, avr_read_fp);
   set_gdbarch_read_sp (gdbarch, avr_read_sp);
   set_gdbarch_deprecated_dummy_write_sp (gdbarch, avr_write_sp);
 
   set_gdbarch_num_regs (gdbarch, AVR_NUM_REGS);
 
   set_gdbarch_sp_regnum (gdbarch, AVR_SP_REGNUM);
-  set_gdbarch_fp_regnum (gdbarch, AVR_FP_REGNUM);
+  set_gdbarch_deprecated_fp_regnum (gdbarch, AVR_FP_REGNUM);
   set_gdbarch_pc_regnum (gdbarch, AVR_PC_REGNUM);
 
   set_gdbarch_register_name (gdbarch, avr_register_name);
-  set_gdbarch_register_size (gdbarch, 1);
+  set_gdbarch_deprecated_register_size (gdbarch, 1);
   set_gdbarch_register_bytes (gdbarch, AVR_NUM_REG_BYTES);
   set_gdbarch_register_byte (gdbarch, avr_register_byte);
   set_gdbarch_register_raw_size (gdbarch, avr_register_raw_size);
@@ -1168,7 +1170,7 @@ avr_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
   set_gdbarch_print_insn (gdbarch, print_insn_avr);
 
   set_gdbarch_call_dummy_address (gdbarch, avr_call_dummy_address);
-  set_gdbarch_call_dummy_words (gdbarch, avr_call_dummy_words);
+  set_gdbarch_deprecated_call_dummy_words (gdbarch, avr_call_dummy_words);
 
 /*    set_gdbarch_believe_pcc_promotion (gdbarch, 1); // TRoth: should this be set? */
 
diff --git a/gdb/blockframe.c b/gdb/blockframe.c
index 47e576e8211..fce25e469a7 100644
--- a/gdb/blockframe.c
+++ b/gdb/blockframe.c
@@ -523,14 +523,14 @@ block_innermost_frame (struct block *block)
    top of the stack frame which we are checking, where "bottom" and
    "top" refer to some section of memory which contains the code for
    the call dummy.  Calls to this macro assume that the contents of
-   SP_REGNUM and FP_REGNUM (or the saved values thereof), respectively,
-   are the things to pass.
-
-   This won't work on the 29k, where SP_REGNUM and FP_REGNUM don't
-   have that meaning, but the 29k doesn't use ON_STACK.  This could be
-   fixed by generalizing this scheme, perhaps by passing in a frame
-   and adding a few fields, at least on machines which need them for
-   DEPRECATED_PC_IN_CALL_DUMMY.
+   SP_REGNUM and DEPRECATED_FP_REGNUM (or the saved values thereof),
+   respectively, are the things to pass.
+
+   This won't work on the 29k, where SP_REGNUM and
+   DEPRECATED_FP_REGNUM don't have that meaning, but the 29k doesn't
+   use ON_STACK.  This could be fixed by generalizing this scheme,
+   perhaps by passing in a frame and adding a few fields, at least on
+   machines which need them for DEPRECATED_PC_IN_CALL_DUMMY.
 
    Something simpler, like checking for the stack segment, doesn't work,
    since various programs (threads implementations, gcc nested function
diff --git a/gdb/breakpoint.c b/gdb/breakpoint.c
index 8ab9e541f23..66b319e842b 100644
--- a/gdb/breakpoint.c
+++ b/gdb/breakpoint.c
@@ -1697,7 +1697,7 @@ deprecated_frame_in_dummy (struct frame_info *frame)
        for signals.exp in the testsuite.  */
 	&& (get_frame_pc (frame)
 	    >= (b->address
-		- SIZEOF_CALL_DUMMY_WORDS / sizeof (LONGEST) * REGISTER_SIZE))
+		- DEPRECATED_SIZEOF_CALL_DUMMY_WORDS / sizeof (LONGEST) * DEPRECATED_REGISTER_SIZE))
 	&& get_frame_pc (frame) <= b->address)
       return 1;
   }
@@ -2271,9 +2271,15 @@ print_bp_stop_message (bpstat bs)
       break;
 
     case print_it_normal:
-      /* Normal case, we handle everything in print_it_typical. */
-      return print_it_typical (bs);
+      /* Normal case.  Call the breakpoint's print_it method, or
+	 print_it_typical.  */
+      if (bs->breakpoint_at != NULL && bs->breakpoint_at->ops != NULL
+	  && bs->breakpoint_at->ops->print_it != NULL)
+	return bs->breakpoint_at->ops->print_it (bs->breakpoint_at);
+      else
+	return print_it_typical (bs);
       break;
+
     default:
       internal_error (__FILE__, __LINE__,
 		      "print_bp_stop_message: unrecognized enum value");
@@ -3265,143 +3271,147 @@ print_one_breakpoint (struct breakpoint *b,
       else
 	strcat (wrap_indent, "                   ");
     }
-  switch (b->type)
-    {
-    case bp_none:
-      internal_error (__FILE__, __LINE__,
-		      "print_one_breakpoint: bp_none encountered\n");
-      break;
 
-    case bp_watchpoint:
-    case bp_hardware_watchpoint:
-    case bp_read_watchpoint:
-    case bp_access_watchpoint:
-      /* Field 4, the address, is omitted (which makes the columns
-	 not line up too nicely with the headers, but the effect
-	 is relatively readable).  */
-      if (addressprint)
-	ui_out_field_skip (uiout, "addr");
-      annotate_field (5);
-      print_expression (b->exp, stb->stream);
-      ui_out_field_stream (uiout, "what", stb);
-      break;
-      
-    case bp_catch_load:
-    case bp_catch_unload:
-      /* Field 4, the address, is omitted (which makes the columns
-	 not line up too nicely with the headers, but the effect
-	 is relatively readable).  */
-      if (addressprint)
-	ui_out_field_skip (uiout, "addr");
-      annotate_field (5);
-      if (b->dll_pathname == NULL)
-	{
-	  ui_out_field_string (uiout, "what", "<any library>");
-	  ui_out_spaces (uiout, 1);
-	}
-      else
-	{
-	  ui_out_text (uiout, "library \"");
-	  ui_out_field_string (uiout, "what", b->dll_pathname);
-	  ui_out_text (uiout, "\" ");
-	}
-      break;
-      
-    case bp_catch_fork:
-    case bp_catch_vfork:
-      /* Field 4, the address, is omitted (which makes the columns
-	 not line up too nicely with the headers, but the effect
-	 is relatively readable).  */
-      if (addressprint)
-	ui_out_field_skip (uiout, "addr");
-      annotate_field (5);
-      if (b->forked_inferior_pid != 0)
-	{
-	  ui_out_text (uiout, "process ");
-	  ui_out_field_int (uiout, "what", b->forked_inferior_pid);
-	  ui_out_spaces (uiout, 1);
-	}
-      
-    case bp_catch_exec:
-      /* Field 4, the address, is omitted (which makes the columns
-	 not line up too nicely with the headers, but the effect
-	 is relatively readable).  */
-      if (addressprint)
-	ui_out_field_skip (uiout, "addr");
-      annotate_field (5);
-      if (b->exec_pathname != NULL)
-	{
-	  ui_out_text (uiout, "program \"");
-	  ui_out_field_string (uiout, "what", b->exec_pathname);
-	  ui_out_text (uiout, "\" ");
-	}
-      break;
+  if (b->ops != NULL && b->ops->print_one != NULL)
+    b->ops->print_one (b, last_addr);
+  else
+    switch (b->type)
+      {
+      case bp_none:
+	internal_error (__FILE__, __LINE__,
+			"print_one_breakpoint: bp_none encountered\n");
+	break;
 
-    case bp_catch_catch:
-      /* Field 4, the address, is omitted (which makes the columns
-	 not line up too nicely with the headers, but the effect
-	 is relatively readable).  */
-      if (addressprint)
-	ui_out_field_skip (uiout, "addr");
-      annotate_field (5);
-      ui_out_field_string (uiout, "what", "exception catch");
-      ui_out_spaces (uiout, 1);
-      break;
+      case bp_watchpoint:
+      case bp_hardware_watchpoint:
+      case bp_read_watchpoint:
+      case bp_access_watchpoint:
+	/* Field 4, the address, is omitted (which makes the columns
+	   not line up too nicely with the headers, but the effect
+	   is relatively readable).  */
+	if (addressprint)
+	  ui_out_field_skip (uiout, "addr");
+	annotate_field (5);
+	print_expression (b->exp, stb->stream);
+	ui_out_field_stream (uiout, "what", stb);
+	break;
+
+      case bp_catch_load:
+      case bp_catch_unload:
+	/* Field 4, the address, is omitted (which makes the columns
+	   not line up too nicely with the headers, but the effect
+	   is relatively readable).  */
+	if (addressprint)
+	  ui_out_field_skip (uiout, "addr");
+	annotate_field (5);
+	if (b->dll_pathname == NULL)
+	  {
+	    ui_out_field_string (uiout, "what", "<any library>");
+	    ui_out_spaces (uiout, 1);
+	  }
+	else
+	  {
+	    ui_out_text (uiout, "library \"");
+	    ui_out_field_string (uiout, "what", b->dll_pathname);
+	    ui_out_text (uiout, "\" ");
+	  }
+	break;
+
+      case bp_catch_fork:
+      case bp_catch_vfork:
+	/* Field 4, the address, is omitted (which makes the columns
+	   not line up too nicely with the headers, but the effect
+	   is relatively readable).  */
+	if (addressprint)
+	  ui_out_field_skip (uiout, "addr");
+	annotate_field (5);
+	if (b->forked_inferior_pid != 0)
+	  {
+	    ui_out_text (uiout, "process ");
+	    ui_out_field_int (uiout, "what", b->forked_inferior_pid);
+	    ui_out_spaces (uiout, 1);
+	  }
+
+      case bp_catch_exec:
+	/* Field 4, the address, is omitted (which makes the columns
+	   not line up too nicely with the headers, but the effect
+	   is relatively readable).  */
+	if (addressprint)
+	  ui_out_field_skip (uiout, "addr");
+	annotate_field (5);
+	if (b->exec_pathname != NULL)
+	  {
+	    ui_out_text (uiout, "program \"");
+	    ui_out_field_string (uiout, "what", b->exec_pathname);
+	    ui_out_text (uiout, "\" ");
+	  }
+	break;
+
+      case bp_catch_catch:
+	/* Field 4, the address, is omitted (which makes the columns
+	   not line up too nicely with the headers, but the effect
+	   is relatively readable).  */
+	if (addressprint)
+	  ui_out_field_skip (uiout, "addr");
+	annotate_field (5);
+	ui_out_field_string (uiout, "what", "exception catch");
+	ui_out_spaces (uiout, 1);
+	break;
+
+      case bp_catch_throw:
+	/* Field 4, the address, is omitted (which makes the columns
+	   not line up too nicely with the headers, but the effect
+	   is relatively readable).  */
+	if (addressprint)
+	  ui_out_field_skip (uiout, "addr");
+	annotate_field (5);
+	ui_out_field_string (uiout, "what", "exception throw");
+	ui_out_spaces (uiout, 1);
+	break;
+
+      case bp_breakpoint:
+      case bp_hardware_breakpoint:
+      case bp_until:
+      case bp_finish:
+      case bp_longjmp:
+      case bp_longjmp_resume:
+      case bp_step_resume:
+      case bp_through_sigtramp:
+      case bp_watchpoint_scope:
+      case bp_call_dummy:
+      case bp_shlib_event:
+      case bp_thread_event:
+      case bp_overlay_event:
+	if (addressprint)
+	  {
+	    annotate_field (4);
+	    ui_out_field_core_addr (uiout, "addr", b->address);
+	  }
+	annotate_field (5);
+	*last_addr = b->address;
+	if (b->source_file)
+	  {
+	    sym = find_pc_sect_function (b->address, b->section);
+	    if (sym)
+	      {
+		ui_out_text (uiout, "in ");
+		ui_out_field_string (uiout, "func",
+				     SYMBOL_PRINT_NAME (sym));
+		ui_out_wrap_hint (uiout, wrap_indent);
+		ui_out_text (uiout, " at ");
+	      }
+	    ui_out_field_string (uiout, "file", b->source_file);
+	    ui_out_text (uiout, ":");
+	    ui_out_field_int (uiout, "line", b->line_number);
+	  }
+	else
+	  {
+	    print_address_symbolic (b->address, stb->stream, demangle, "");
+	    ui_out_field_stream (uiout, "at", stb);
+	  }
+	break;
+      }
 
-    case bp_catch_throw:
-      /* Field 4, the address, is omitted (which makes the columns
-	 not line up too nicely with the headers, but the effect
-	 is relatively readable).  */
-      if (addressprint)
-	ui_out_field_skip (uiout, "addr");
-      annotate_field (5);
-      ui_out_field_string (uiout, "what", "exception throw");
-      ui_out_spaces (uiout, 1);
-      break;
-      
-    case bp_breakpoint:
-    case bp_hardware_breakpoint:
-    case bp_until:
-    case bp_finish:
-    case bp_longjmp:
-    case bp_longjmp_resume:
-    case bp_step_resume:
-    case bp_through_sigtramp:
-    case bp_watchpoint_scope:
-    case bp_call_dummy:
-    case bp_shlib_event:
-    case bp_thread_event:
-    case bp_overlay_event:
-      if (addressprint)
-	{
-	  annotate_field (4);
-	  ui_out_field_core_addr (uiout, "addr", b->address);
-	}
-      annotate_field (5);
-      *last_addr = b->address;
-      if (b->source_file)
-	{
-	  sym = find_pc_sect_function (b->address, b->section);
-	  if (sym)
-	    {
-	      ui_out_text (uiout, "in ");
-	      ui_out_field_string (uiout, "func",
-				   SYMBOL_PRINT_NAME (sym));
-	      ui_out_wrap_hint (uiout, wrap_indent);
-	      ui_out_text (uiout, " at ");
-	    }
-	  ui_out_field_string (uiout, "file", b->source_file);
-	  ui_out_text (uiout, ":");
-	  ui_out_field_int (uiout, "line", b->line_number);
-	}
-      else
-	{
-	  print_address_symbolic (b->address, stb->stream, demangle, "");
-	  ui_out_field_stream (uiout, "at", stb);
-	}
-      break;
-    }
-  
   if (b->thread != -1)
     {
       /* FIXME: This seems to be redundant and lost here; see the
@@ -3851,6 +3861,7 @@ set_raw_breakpoint (struct symtab_and_line sal, enum bptype bptype)
   b->triggered_dll_pathname = NULL;
   b->forked_inferior_pid = 0;
   b->exec_pathname = NULL;
+  b->ops = NULL;
 
   /* Add this breakpoint to the end of the chain
      so that a list of breakpoints will come out in order
@@ -4413,103 +4424,107 @@ mention (struct breakpoint *b)
     create_breakpoint_hook (b);
   breakpoint_create_event (b->number);
 
-  switch (b->type)
-    {
-    case bp_none:
-      printf_filtered ("(apparently deleted?) Eventpoint %d: ", b->number);
-      break;
-    case bp_watchpoint:
-      ui_out_text (uiout, "Watchpoint ");
-      ui_out_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "wpt");
-      ui_out_field_int (uiout, "number", b->number);
-      ui_out_text (uiout, ": ");
-      print_expression (b->exp, stb->stream);
-      ui_out_field_stream (uiout, "exp", stb);
-      do_cleanups (ui_out_chain);
-      break;
-    case bp_hardware_watchpoint:
-      ui_out_text (uiout, "Hardware watchpoint ");
-      ui_out_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "wpt");
-      ui_out_field_int (uiout, "number", b->number);
-      ui_out_text (uiout, ": ");
-      print_expression (b->exp, stb->stream);
-      ui_out_field_stream (uiout, "exp", stb);
-      do_cleanups (ui_out_chain);
-      break;
-    case bp_read_watchpoint:
-      ui_out_text (uiout, "Hardware read watchpoint ");
-      ui_out_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "hw-rwpt");
-      ui_out_field_int (uiout, "number", b->number);
-      ui_out_text (uiout, ": ");
-      print_expression (b->exp, stb->stream);
-      ui_out_field_stream (uiout, "exp", stb);
-      do_cleanups (ui_out_chain);
-      break;
-    case bp_access_watchpoint:
-      ui_out_text (uiout, "Hardware access (read/write) watchpoint ");
-      ui_out_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "hw-awpt");
-      ui_out_field_int (uiout, "number", b->number);
-      ui_out_text (uiout, ": ");
-      print_expression (b->exp, stb->stream);
-      ui_out_field_stream (uiout, "exp", stb);
-      do_cleanups (ui_out_chain);
-      break;
-    case bp_breakpoint:
-      if (ui_out_is_mi_like_p (uiout))
-	{
-	  say_where = 0;
-	  break;
-	}
-      printf_filtered ("Breakpoint %d", b->number);
-      say_where = 1;
-      break;
-    case bp_hardware_breakpoint:
-      if (ui_out_is_mi_like_p (uiout))
-	{
-	  say_where = 0;
-	  break;
-	}
-      printf_filtered ("Hardware assisted breakpoint %d", b->number);
-      say_where = 1;
-      break;
-    case bp_catch_load:
-    case bp_catch_unload:
-      printf_filtered ("Catchpoint %d (%s %s)",
-		       b->number,
-		       (b->type == bp_catch_load) ? "load" : "unload",
-		       (b->dll_pathname != NULL) ? 
-		       b->dll_pathname : "<any library>");
-      break;
-    case bp_catch_fork:
-    case bp_catch_vfork:
-      printf_filtered ("Catchpoint %d (%s)",
-		       b->number,
-		       (b->type == bp_catch_fork) ? "fork" : "vfork");
-      break;
-    case bp_catch_exec:
-      printf_filtered ("Catchpoint %d (exec)",
-		       b->number);
-      break;
-    case bp_catch_catch:
-    case bp_catch_throw:
-      printf_filtered ("Catchpoint %d (%s)",
-		       b->number,
-		       (b->type == bp_catch_catch) ? "catch" : "throw");
-      break;
+  if (b->ops != NULL && b->ops->print_mention != NULL)
+    b->ops->print_mention (b);
+  else
+    switch (b->type)
+      {
+      case bp_none:
+	printf_filtered ("(apparently deleted?) Eventpoint %d: ", b->number);
+	break;
+      case bp_watchpoint:
+	ui_out_text (uiout, "Watchpoint ");
+	ui_out_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "wpt");
+	ui_out_field_int (uiout, "number", b->number);
+	ui_out_text (uiout, ": ");
+	print_expression (b->exp, stb->stream);
+	ui_out_field_stream (uiout, "exp", stb);
+	do_cleanups (ui_out_chain);
+	break;
+      case bp_hardware_watchpoint:
+	ui_out_text (uiout, "Hardware watchpoint ");
+	ui_out_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "wpt");
+	ui_out_field_int (uiout, "number", b->number);
+	ui_out_text (uiout, ": ");
+	print_expression (b->exp, stb->stream);
+	ui_out_field_stream (uiout, "exp", stb);
+	do_cleanups (ui_out_chain);
+	break;
+      case bp_read_watchpoint:
+	ui_out_text (uiout, "Hardware read watchpoint ");
+	ui_out_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "hw-rwpt");
+	ui_out_field_int (uiout, "number", b->number);
+	ui_out_text (uiout, ": ");
+	print_expression (b->exp, stb->stream);
+	ui_out_field_stream (uiout, "exp", stb);
+	do_cleanups (ui_out_chain);
+	break;
+      case bp_access_watchpoint:
+	ui_out_text (uiout, "Hardware access (read/write) watchpoint ");
+	ui_out_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "hw-awpt");
+	ui_out_field_int (uiout, "number", b->number);
+	ui_out_text (uiout, ": ");
+	print_expression (b->exp, stb->stream);
+	ui_out_field_stream (uiout, "exp", stb);
+	do_cleanups (ui_out_chain);
+	break;
+      case bp_breakpoint:
+	if (ui_out_is_mi_like_p (uiout))
+	  {
+	    say_where = 0;
+	    break;
+	  }
+	printf_filtered ("Breakpoint %d", b->number);
+	say_where = 1;
+	break;
+      case bp_hardware_breakpoint:
+	if (ui_out_is_mi_like_p (uiout))
+	  {
+	    say_where = 0;
+	    break;
+	  }
+	printf_filtered ("Hardware assisted breakpoint %d", b->number);
+	say_where = 1;
+	break;
+      case bp_catch_load:
+      case bp_catch_unload:
+	printf_filtered ("Catchpoint %d (%s %s)",
+			 b->number,
+			 (b->type == bp_catch_load) ? "load" : "unload",
+			 (b->dll_pathname != NULL) ? 
+			 b->dll_pathname : "<any library>");
+	break;
+      case bp_catch_fork:
+      case bp_catch_vfork:
+	printf_filtered ("Catchpoint %d (%s)",
+			 b->number,
+			 (b->type == bp_catch_fork) ? "fork" : "vfork");
+	break;
+      case bp_catch_exec:
+	printf_filtered ("Catchpoint %d (exec)",
+			 b->number);
+	break;
+      case bp_catch_catch:
+      case bp_catch_throw:
+	printf_filtered ("Catchpoint %d (%s)",
+			 b->number,
+			 (b->type == bp_catch_catch) ? "catch" : "throw");
+	break;
+
+      case bp_until:
+      case bp_finish:
+      case bp_longjmp:
+      case bp_longjmp_resume:
+      case bp_step_resume:
+      case bp_through_sigtramp:
+      case bp_call_dummy:
+      case bp_watchpoint_scope:
+      case bp_shlib_event:
+      case bp_thread_event:
+      case bp_overlay_event:
+	break;
+      }
 
-    case bp_until:
-    case bp_finish:
-    case bp_longjmp:
-    case bp_longjmp_resume:
-    case bp_step_resume:
-    case bp_through_sigtramp:
-    case bp_call_dummy:
-    case bp_watchpoint_scope:
-    case bp_shlib_event:
-    case bp_thread_event:
-    case bp_overlay_event:
-      break;
-    }
   if (say_where)
     {
       if (addressprint || b->source_file == NULL)
@@ -5449,7 +5464,7 @@ watch_command_1 (char *arg, int accessflag, int from_tty)
 
 #if !defined(TARGET_REGION_SIZE_OK_FOR_HW_WATCHPOINT)
 #define TARGET_REGION_SIZE_OK_FOR_HW_WATCHPOINT(BYTE_SIZE) \
-    ((BYTE_SIZE) <= (REGISTER_SIZE))
+    ((BYTE_SIZE) <= (DEPRECATED_REGISTER_SIZE))
 #endif
 
 #if !defined(TARGET_REGION_OK_FOR_HW_WATCHPOINT)
@@ -6004,6 +6019,90 @@ create_exception_catchpoint (int tempflag, char *cond_string,
   mention (b);
 }
 
+static enum print_stop_action
+print_exception_catchpoint (struct breakpoint *b)
+{
+  annotate_catchpoint (b->number);
+
+  if (strstr (b->addr_string, "throw") != NULL)
+    printf_filtered ("\nCatchpoint %d (exception thrown)\n",
+		     b->number);
+  else
+    printf_filtered ("\nCatchpoint %d (exception caught)\n",
+		     b->number);
+
+  return PRINT_SRC_AND_LOC;
+}
+
+static void
+print_one_exception_catchpoint (struct breakpoint *b, CORE_ADDR *last_addr)
+{
+  if (addressprint)
+    {
+      annotate_field (4);
+      ui_out_field_core_addr (uiout, "addr", b->address);
+    }
+  annotate_field (5);
+  *last_addr = b->address;
+  if (strstr (b->addr_string, "throw") != NULL)
+    ui_out_field_string (uiout, "what", "exception throw");
+  else
+    ui_out_field_string (uiout, "what", "exception catch");
+}
+
+static void
+print_mention_exception_catchpoint (struct breakpoint *b)
+{
+  if (strstr (b->addr_string, "throw") != NULL)
+    printf_filtered ("Catchpoint %d (throw)", b->number);
+  else
+    printf_filtered ("Catchpoint %d (catch)", b->number);
+}
+
+static struct breakpoint_ops gnu_v3_exception_catchpoint_ops = {
+  print_exception_catchpoint,
+  print_one_exception_catchpoint,
+  print_mention_exception_catchpoint
+};
+
+static int
+handle_gnu_v3_exceptions (int tempflag, char *cond_string,
+			  enum exception_event_kind ex_event, int from_tty)
+{
+  char *trigger_func_name, *nameptr;
+  struct symtabs_and_lines sals;
+  struct breakpoint *b;
+
+  if (ex_event == EX_EVENT_CATCH)
+    trigger_func_name = xstrdup ("__cxa_begin_catch");
+  else
+    trigger_func_name = xstrdup ("__cxa_throw");
+
+  nameptr = trigger_func_name;
+  sals = decode_line_1 (&nameptr, 1, NULL, 0, NULL);
+  if (sals.nelts == 0)
+    {
+      free (trigger_func_name);
+      return 0;
+    }
+
+  b = set_raw_breakpoint (sals.sals[0], bp_breakpoint);
+  set_breakpoint_count (breakpoint_count + 1);
+  b->number = breakpoint_count;
+  b->cond = NULL;
+  b->cond_string = (cond_string == NULL) ? 
+    NULL : savestring (cond_string, strlen (cond_string));
+  b->thread = -1;
+  b->addr_string = trigger_func_name;
+  b->enable_state = bp_enabled;
+  b->disposition = tempflag ? disp_del : disp_donttouch;
+  b->ops = &gnu_v3_exception_catchpoint_ops;
+
+  free (sals.sals);
+  mention (b);
+  return 1;
+}
+
 /* Deal with "catch catch" and "catch throw" commands */
 
 static void
@@ -6024,6 +6123,9 @@ catch_exception_command_1 (enum exception_event_kind ex_event, char *arg,
       (ex_event != EX_EVENT_CATCH))
     error ("Unsupported or unknown exception event; cannot catch it");
 
+  if (handle_gnu_v3_exceptions (tempflag, cond_string, ex_event, from_tty))
+    return;
+
   /* See if we can find a callback routine */
   sal = target_enable_exception_callback (ex_event, 1);
 
diff --git a/gdb/breakpoint.h b/gdb/breakpoint.h
index e8c8750eef4..86eec4ae310 100644
--- a/gdb/breakpoint.h
+++ b/gdb/breakpoint.h
@@ -184,6 +184,24 @@ enum target_hw_bp_type
     hw_execute = 3		/* Execute HW breakpoint */
   };
 
+/* This structure is a collection of function pointers that, if available,
+   will be called instead of the performing the default action for this
+   bptype.  */
+
+struct breakpoint_ops 
+{
+  /* The normal print routine for this breakpoint, called when we
+     hit it.  */
+  enum print_stop_action (*print_it) (struct breakpoint *);
+
+  /* Display information about this breakpoint, for "info breakpoints".  */
+  void (*print_one) (struct breakpoint *, CORE_ADDR *);
+
+  /* Display information about this breakpoint after setting it (roughly
+     speaking; this is called from "mention").  */
+  void (*print_mention) (struct breakpoint *);
+};
+
 /* Note that the ->silent field is not currently used by any commands
    (though the code is in there if it was to be, and set_raw_breakpoint
    does set it to 0).  I implemented it because I thought it would be
@@ -306,6 +324,9 @@ struct breakpoint
     char *exec_pathname;
 
     asection *section;
+
+    /* Methods associated with this breakpoint.  */
+    struct breakpoint_ops *ops;
   };
 
 /* The following stuff is an abstract data type "bpstat" ("breakpoint
@@ -623,7 +644,7 @@ extern void set_longjmp_resume_breakpoint (CORE_ADDR, struct frame_id);
    enabled watchpoints.  When disabled, the watchpoints are marked
    call_disabled.  When reenabled, they are marked enabled.
 
-   The intended client of these functions is infcmd.c\run_stack_dummy.
+   The intended client of these functions is call_function_by_hand.
 
    The inferior must be stopped, and all breakpoints removed, when
    these functions are used.
diff --git a/gdb/c-lang.c b/gdb/c-lang.c
index e492b9a205e..fbdf0054afa 100644
--- a/gdb/c-lang.c
+++ b/gdb/c-lang.c
@@ -651,10 +651,47 @@ const struct language_defn asm_language_defn =
   LANG_MAGIC
 };
 
+/* The following language_defn does not represent a real language.
+   It just provides a minimal support a-la-C that should allow users
+   to do some simple operations when debugging applications that use
+   a language currently not supported by GDB.  */
+
+const struct language_defn minimal_language_defn =
+{
+  "minimal",			/* Language name */
+  language_minimal,
+  c_builtin_types,
+  range_check_off,
+  type_check_off,
+  case_sensitive_on,
+  c_preprocess_and_parse,
+  c_error,
+  evaluate_subexp_standard,
+  c_printchar,			/* Print a character constant */
+  c_printstr,			/* Function to print string constant */
+  c_emit_char,			/* Print a single char */
+  c_create_fundamental_type,	/* Create fundamental type in this language */
+  c_print_type,			/* Print a type using appropriate syntax */
+  c_val_print,			/* Print a value using appropriate syntax */
+  c_value_print,		/* Print a top-level value */
+  NULL,				/* Language specific skip_trampoline */
+  NULL,				/* Language specific symbol demangler */
+  {"", "", "", ""},		/* Binary format info */
+  {"0%lo", "0", "o", ""},	/* Octal format info */
+  {"%ld", "", "d", ""},		/* Decimal format info */
+  {"0x%lx", "0x", "x", ""},	/* Hex format info */
+  c_op_print_tab,		/* expression operators for printing */
+  1,				/* c-style arrays */
+  0,				/* String lower bound */
+  &builtin_type_char,		/* Type of string elements */
+  LANG_MAGIC
+};
+
 void
 _initialize_c_language (void)
 {
   add_language (&c_language_defn);
   add_language (&cplus_language_defn);
   add_language (&asm_language_defn);
+  add_language (&minimal_language_defn);
 }
diff --git a/gdb/charset.c b/gdb/charset.c
index 4f5e5b45b68..0062e281e99 100644
--- a/gdb/charset.c
+++ b/gdb/charset.c
@@ -96,7 +96,7 @@ struct charset {
   struct charset *next;
 
   /* The name of the character set.  Comparisons on character set
-     names are case-insensitive.  */
+     names are case-sensitive.  */
   const char *name;
 
   /* Non-zero iff this character set can be used as a host character
@@ -125,7 +125,7 @@ struct translation {
 
   /* This structure describes functions going from the FROM character
      set to the TO character set.  Comparisons on character set names
-     are case-insensitive.  */
+     are case-sensitive.  */
   const char *from, *to;
 
   /* Pointers to translation-specific functions, and data pointers to
@@ -156,16 +156,32 @@ struct translation {
 /* The global lists of character sets and translations.  */
 
 
-/* Character set names are always compared ignoring case.  */
-static int
-strcmp_case_insensitive (const char *p, const char *q)
-{
-  while (*p && *q && tolower (*p) == tolower (*q))
-    p++, q++;
+#ifndef GDB_DEFAULT_HOST_CHARSET
+#define GDB_DEFAULT_HOST_CHARSET "ISO-8859-1"
+#endif
 
-  return tolower (*p) - tolower (*q);
-}
+#ifndef GDB_DEFAULT_TARGET_CHARSET
+#define GDB_DEFAULT_TARGET_CHARSET "ISO-8859-1"
+#endif
+
+static const char *host_charset_name = GDB_DEFAULT_HOST_CHARSET;
+static const char *target_charset_name = GDB_DEFAULT_TARGET_CHARSET;
 
+static const char *host_charset_enum[] = 
+{
+  "ASCII",
+  "ISO-8859-1",
+  0
+};
+
+static const char *target_charset_enum[] = 
+{
+  "ASCII",
+  "ISO-8859-1",
+  "EBCDIC-US",
+  "IBM1047",
+  0
+};
 
 /* The global list of all the charsets GDB knows about.  */
 static struct charset *all_charsets;
@@ -192,7 +208,7 @@ lookup_charset (const char *name)
   struct charset *cs;
 
   for (cs = all_charsets; cs; cs = cs->next)
-    if (! strcmp_case_insensitive (name, cs->name))
+    if (! strcmp (name, cs->name))
       return cs;
 
   return NULL;
@@ -217,8 +233,8 @@ lookup_translation (const char *from, const char *to)
   struct translation *t;
 
   for (t = all_translations; t; t = t->next)
-    if (! strcmp_case_insensitive (from, t->from)
-        && ! strcmp_case_insensitive (to, t->to))
+    if (! strcmp (from, t->from)
+        && ! strcmp (to, t->to))
       return t;
 
   return 0;
@@ -897,6 +913,26 @@ static void *target_char_to_host_baton;
 static struct cached_iconv cached_iconv_host_to_target;
 static struct cached_iconv cached_iconv_target_to_host;
 
+
+/* Charset structures manipulation functions.  */
+
+static struct charset *
+lookup_charset_or_error (const char *name)
+{
+  struct charset *cs = lookup_charset (name);
+
+  if (! cs)
+    error ("GDB doesn't know of any character set named `%s'.", name);
+
+  return cs;
+}
+
+static void
+check_valid_host_charset (struct charset *cs)
+{
+  if (! cs->valid_host_charset)
+    error ("GDB can't use `%s' as its host character set.", cs->name);
+}
 
 /* Set the host and target character sets to HOST and TARGET.  */
 static void
@@ -986,35 +1022,76 @@ set_host_and_target_charsets (struct charset *host, struct charset *target)
   current_target_charset = target;
 }
 
+/* Do the real work of setting the host charset.  */
+static void
+set_host_charset (const char *charset)
+{
+  struct charset *cs = lookup_charset_or_error (charset);
+  check_valid_host_charset (cs);
+  set_host_and_target_charsets (cs, current_target_charset);
+}
 
-static struct charset *
-lookup_charset_or_error (const char *name)
+/* Do the real work of setting the target charset.  */
+static void
+set_target_charset (const char *charset)
 {
-  struct charset *cs = lookup_charset (name);
+  struct charset *cs = lookup_charset_or_error (charset);
 
-  if (! cs)
-    error ("GDB doesn't know of any character set named `%s'.", name);
+  set_host_and_target_charsets (current_host_charset, cs);
+}
 
-  return cs;
+
+/* 'Set charset', 'set host-charset', 'set target-charset', 'show
+   charset' sfunc's.  */
+
+/* This is the sfunc for the 'set charset' command.  */
+static void
+set_charset_sfunc (char *charset, int from_tty, struct cmd_list_element *c)
+{
+  struct charset *cs = lookup_charset_or_error (host_charset_name);
+  check_valid_host_charset (cs);
+  /* CAREFUL: set the target charset here as well. */
+  target_charset_name = host_charset_name;
+  set_host_and_target_charsets (cs, cs);
 }
-    
 
+/* 'set host-charset' command sfunc.  We need a wrapper here because
+   the function needs to have a specific signature.  */
 static void
-check_valid_host_charset (struct charset *cs)
+set_host_charset_sfunc (char *charset, int from_tty,
+			  struct cmd_list_element *c)
 {
-  if (! cs->valid_host_charset)
-    error ("GDB can't use `%s' as its host character set.", cs->name);
+  set_host_charset (host_charset_name);
 }
 
+/* Wrapper for the 'set target-charset' command.  */
+static void
+set_target_charset_sfunc (char *charset, int from_tty,
+			    struct cmd_list_element *c)
+{
+  set_target_charset (target_charset_name);
+}
 
-void
-set_host_charset (const char *charset)
+/* sfunc for the 'show charset' command.  */
+static void
+show_charset (char *arg, int from_tty)
 {
-  struct charset *cs = lookup_charset_or_error (charset);
-  check_valid_host_charset (cs);
-  set_host_and_target_charsets (cs, current_target_charset);
+  if (current_host_charset == current_target_charset)
+    {
+      printf_filtered ("The current host and target character set is `%s'.\n",
+                       host_charset ());
+    }
+  else
+    {
+      printf_filtered ("The current host character set is `%s'.\n",
+                       host_charset ());
+      printf_filtered ("The current target character set is `%s'.\n",
+                       target_charset ());
+    }
 }
 
+
+/* Accessor functions.  */
 
 const char *
 host_charset (void)
@@ -1022,16 +1099,6 @@ host_charset (void)
   return current_host_charset->name;
 }
 
-
-void
-set_target_charset (const char *charset)
-{
-  struct charset *cs = lookup_charset_or_error (charset);
-
-  set_host_and_target_charsets (current_host_charset, cs);
-}
-
-
 const char *
 target_charset (void)
 {
@@ -1094,104 +1161,14 @@ target_char_to_host (int target_char, int *host_char)
 
 
 
-/* Commands.  */
-
-
-/* List the valid character sets.  If HOST_ONLY is non-zero, list only
-   those character sets which can be used as GDB's host character set.  */
-static void
-list_charsets (int host_only)
-{
-  struct charset *cs;
-
-  printf_filtered ("Valid character sets are:\n");
-
-  for (cs = all_charsets; cs; cs = cs->next)
-    if (host_only && cs->valid_host_charset)
-      printf_filtered ("  %s\n", cs->name);
-    else
-      printf_filtered ("  %s %s\n",
-                       cs->name,
-                       cs->valid_host_charset ? "*" : " ");
-
-  if (! host_only)
-    printf_filtered ("* - can be used as a host character set\n");
-}
-
-
-static void
-set_charset_command (char *arg, int from_tty)
-{
-  if (! arg || arg[0] == '\0')
-    list_charsets (0);
-  else
-    {
-      struct charset *cs = lookup_charset_or_error (arg);
-      check_valid_host_charset (cs);
-      set_host_and_target_charsets (cs, cs); 
-    }
-}
-
-
-static void
-set_host_charset_command (char *arg, int from_tty)
-{
-  if (! arg || arg[0] == '\0')
-    list_charsets (1);
-  else
-    {
-      struct charset *cs = lookup_charset_or_error (arg);
-      check_valid_host_charset (cs);
-      set_host_and_target_charsets (cs, current_target_charset);
-    }
-}
-
-
-static void
-set_target_charset_command (char *arg, int from_tty)
-{
-  if (! arg || arg[0] == '\0')
-    list_charsets (0);
-  else
-    {
-      struct charset *cs = lookup_charset_or_error (arg);
-      set_host_and_target_charsets (current_host_charset, cs);
-    }
-}
-
-
-static void
-show_charset_command (char *arg, int from_tty)
-{
-  if (current_host_charset == current_target_charset)
-    {
-      printf_filtered ("The current host and target character set is `%s'.\n",
-                       host_charset ());
-    }
-  else
-    {
-      printf_filtered ("The current host character set is `%s'.\n",
-                       host_charset ());
-      printf_filtered ("The current target character set is `%s'.\n",
-                       target_charset ());
-    }
-}
-
-
-
 /* The charset.c module initialization function.  */
 
-#ifndef GDB_DEFAULT_HOST_CHARSET
-#define GDB_DEFAULT_HOST_CHARSET "ISO-8859-1"
-#endif
-
-#ifndef GDB_DEFAULT_TARGET_CHARSET
-#define GDB_DEFAULT_TARGET_CHARSET "ISO-8859-1"
-#endif
 
 void
 _initialize_charset (void)
 {
+  struct cmd_list_element *new_cmd;
+
   /* Register all the character set GDB knows about.
 
      You should use the same names that iconv does, where possible, to
@@ -1204,28 +1181,28 @@ _initialize_charset (void)
      when a translation's function pointer for a particular operation
      is zero.  Hopefully, these defaults will be correct often enough
      that we won't need to provide too many translations.  */
-  register_charset (simple_charset ("ascii", 1,
+  register_charset (simple_charset ("ASCII", 1,
                                     ascii_print_literally, 0,
                                     ascii_to_control, 0));
-  register_charset (iso_8859_family_charset ("iso-8859-1"));
-  register_charset (ebcdic_family_charset ("ebcdic-us"));
-  register_charset (ebcdic_family_charset ("ibm1047"));
+  register_charset (iso_8859_family_charset ("ISO-8859-1"));
+  register_charset (ebcdic_family_charset ("EBCDIC-US"));
+  register_charset (ebcdic_family_charset ("IBM1047"));
   register_iconv_charsets ();
 
   {
     struct { char *from; char *to; int *table; } tlist[] = {
-      { "ascii",      "iso-8859-1", ascii_to_iso_8859_1_table },
-      { "ascii",      "ebcdic-us",  ascii_to_ebcdic_us_table },
-      { "ascii",      "ibm1047",    ascii_to_ibm1047_table },
-      { "iso-8859-1", "ascii",      iso_8859_1_to_ascii_table },
-      { "iso-8859-1", "ebcdic-us",  iso_8859_1_to_ebcdic_us_table },
-      { "iso-8859-1", "ibm1047",    iso_8859_1_to_ibm1047_table },
-      { "ebcdic-us",  "ascii",      ebcdic_us_to_ascii_table },
-      { "ebcdic-us",  "iso-8859-1", ebcdic_us_to_iso_8859_1_table },
-      { "ebcdic-us",  "ibm1047",    ebcdic_us_to_ibm1047_table },
-      { "ibm1047",    "ascii",      ibm1047_to_ascii_table },
-      { "ibm1047",    "iso-8859-1", ibm1047_to_iso_8859_1_table },
-      { "ibm1047",    "ebcdic-us",  ibm1047_to_ebcdic_us_table }
+      { "ASCII",      "ISO-8859-1", ascii_to_iso_8859_1_table },
+      { "ASCII",      "EBCDIC-US",  ascii_to_ebcdic_us_table },
+      { "ASCII",      "IBM1047",    ascii_to_ibm1047_table },
+      { "ISO-8859-1", "ASCII",      iso_8859_1_to_ascii_table },
+      { "ISO-8859-1", "EBCDIC-US",  iso_8859_1_to_ebcdic_us_table },
+      { "ISO-8859-1", "IBM1047",    iso_8859_1_to_ibm1047_table },
+      { "EBCDIC-US",  "ASCII",      ebcdic_us_to_ascii_table },
+      { "EBCDIC-US",  "ISO-8859-1", ebcdic_us_to_iso_8859_1_table },
+      { "EBCDIC-US",  "IBM1047",    ebcdic_us_to_ibm1047_table },
+      { "IBM1047",    "ASCII",      ibm1047_to_ascii_table },
+      { "IBM1047",    "ISO-8859-1", ibm1047_to_iso_8859_1_table },
+      { "IBM1047",    "EBCDIC-US",  ibm1047_to_ebcdic_us_table }
     };
 
     int i;
@@ -1236,40 +1213,63 @@ _initialize_charset (void)
                                                       tlist[i].table));
   }
 
-  set_host_charset (GDB_DEFAULT_HOST_CHARSET);
-  set_target_charset (GDB_DEFAULT_TARGET_CHARSET);
-
-  add_cmd ("charset", class_support, set_charset_command,
-           "Use CHARSET as the host and target character set.\n"
-           "The `host character set' is the one used by the system GDB is running on.\n"
-           "The `target character set' is the one used by the program being debugged.\n"
-           "You may only use supersets of ASCII for your host character set; GDB does\n"
-           "not support any others.\n"
-           "To see a list of the character sets GDB supports, type `set charset'\n"
-           "with no argument.",
-           &setlist);
-
-  add_cmd ("host-charset", class_support, set_host_charset_command,
-           "Use CHARSET as the host character set.\n"
-           "The `host character set' is the one used by the system GDB is running on.\n"
-           "You may only use supersets of ASCII for your host character set; GDB does\n"
-           "not support any others.\n"
-           "To see a list of the character sets GDB supports, type `set host-charset'\n"
-           "with no argument.",
-           &setlist);
-
-  add_cmd ("target-charset", class_support, set_target_charset_command,
-           "Use CHARSET as the target character set.\n"
-           "The `target character set' is the one used by the program being debugged.\n"
-           "GDB translates characters and strings between the host and target\n"
-           "character sets as needed.\n"
-           "To see a list of the character sets GDB supports, type `set target-charset'\n"
-           "with no argument.",
-           &setlist);
-
-  add_cmd ("charset", class_support, show_charset_command,
-           "Show the current host and target character sets.",
-           &showlist);
-  add_alias_cmd ("host-charset", "charset", class_alias, 1, &showlist);
-  add_alias_cmd ("target-charset", "charset", class_alias, 1, &showlist);
+  set_host_charset (host_charset_name);
+  set_target_charset (target_charset_name);
+
+  new_cmd = add_set_enum_cmd ("charset",
+			      class_support,
+			      host_charset_enum,
+			      &host_charset_name,
+                              "Set the host and target character sets.\n"
+                              "The `host character set' is the one used by the system GDB is running on.\n"
+                              "The `target character set' is the one used by the program being debugged.\n"
+                              "You may only use supersets of ASCII for your host character set; GDB does\n"
+                              "not support any others.\n"
+                              "To see a list of the character sets GDB supports, type `set charset <TAB>'.",
+			      &setlist);
+
+  /* Note that the sfunc below needs to set target_charset_name, because 
+     the 'set charset' command sets two variables.  */
+  set_cmd_sfunc (new_cmd, set_charset_sfunc);
+  /* Don't use set_from_show - need to print some extra info. */
+  add_cmd ("charset", class_support, show_charset,
+	   "Show the host and target character sets.\n"
+	   "The `host character set' is the one used by the system GDB is running on.\n"
+	   "The `target character set' is the one used by the program being debugged.\n"
+	   "You may only use supersets of ASCII for your host character set; GDB does\n"
+	   "not support any others.\n"
+	   "To see a list of the character sets GDB supports, type `set charset <TAB>'.", 
+	   &showlist);
+
+
+  new_cmd = add_set_enum_cmd ("host-charset",
+			      class_support,
+			      host_charset_enum,
+			      &host_charset_name,
+			      "Set the host character set.\n"
+			      "The `host character set' is the one used by the system GDB is running on.\n"
+			      "You may only use supersets of ASCII for your host character set; GDB does\n"
+			      "not support any others.\n"
+			      "To see a list of the character sets GDB supports, type `set host-charset <TAB>'.",
+			      &setlist);
+
+  set_cmd_sfunc (new_cmd, set_host_charset_sfunc);
+
+  add_show_from_set (new_cmd, &showlist);
+
+
+
+  new_cmd = add_set_enum_cmd ("target-charset",
+			      class_support,
+			      target_charset_enum,
+			      &target_charset_name,
+			      "Set the target character set.\n"
+			      "The `target character set' is the one used by the program being debugged.\n"
+			      "GDB translates characters and strings between the host and target\n"
+			      "character sets as needed.\n"
+			      "To see a list of the character sets GDB supports, type `set target-charset'<TAB>",
+			      &setlist);
+
+  set_cmd_sfunc (new_cmd, set_target_charset_sfunc);
+  add_show_from_set (new_cmd, &showlist);
 }
diff --git a/gdb/charset.h b/gdb/charset.h
index 10578cb9243..31dbe6f9f3d 100644
--- a/gdb/charset.h
+++ b/gdb/charset.h
@@ -46,23 +46,12 @@
    the requirements above, it's easy to plug an entry into GDB's table
    that uses iconv to handle the details.  */
 
-
-/* Set the host character set to CHARSET.  CHARSET must be a superset
-   of ASCII, since GDB's code assumes this.  */
-void set_host_charset (const char *charset);
-
-
-/* Set the target character set to CHARSET.  */
-void set_target_charset (const char *charset);
-
-
 /* Return the name of the current host/target character set.  The
    result is owned by the charset module; the caller should not free
    it.  */
 const char *host_charset (void);
 const char *target_charset (void);
 
-
 /* In general, the set of C backslash escapes (\n, \f) is specific to
    the character set.  Not all character sets will have form feed
    characters, for example.
diff --git a/gdb/cli/cli-cmds.c b/gdb/cli/cli-cmds.c
index c33c242bad5..108329a50c7 100644
--- a/gdb/cli/cli-cmds.c
+++ b/gdb/cli/cli-cmds.c
@@ -171,10 +171,6 @@ struct cmd_list_element *maintenanceinfolist;
 
 struct cmd_list_element *maintenanceprintlist;
 
-/* Chain containing all defined "maintenance list" subcommands. */
-
-struct cmd_list_element *maintenancelistlist;
-
 struct cmd_list_element *setprintlist;
 
 struct cmd_list_element *showprintlist;
@@ -1036,7 +1032,6 @@ init_cmd_lists (void)
   maintenancelist = NULL;
   maintenanceinfolist = NULL;
   maintenanceprintlist = NULL;
-  maintenancelistlist = NULL;
   setprintlist = NULL;
   showprintlist = NULL;
   setchecklist = NULL;
diff --git a/gdb/cli/cli-cmds.h b/gdb/cli/cli-cmds.h
index 1f340efa101..a6e574edd71 100644
--- a/gdb/cli/cli-cmds.h
+++ b/gdb/cli/cli-cmds.h
@@ -87,10 +87,6 @@ extern struct cmd_list_element *maintenanceinfolist;
 
 extern struct cmd_list_element *maintenanceprintlist;
 
-/* Chain containing all defined "maintenance list" subcommands. */
-
-extern struct cmd_list_element *maintenancelistlist;
-
 extern struct cmd_list_element *setprintlist;
 
 extern struct cmd_list_element *showprintlist;
diff --git a/gdb/config/djgpp/fnchange.lst b/gdb/config/djgpp/fnchange.lst
index b426652e364..9e87a63343e 100644
--- a/gdb/config/djgpp/fnchange.lst
+++ b/gdb/config/djgpp/fnchange.lst
@@ -232,6 +232,7 @@
 @V@/gdb/testsuite/gdb.c++/m-static1.cc @V@/gdb/testsuite/gdb.cxx/m-stat1.cc
 @V@/gdb/testsuite/gdb.c++/m-static.exp @V@/gdb/testsuite/gdb.cxx/m-static.exp
 @V@/gdb/testsuite/gdb.c++/m-static.h @V@/gdb/testsuite/gdb.cxx/m-static.h
+@V@/gdb/testsuite/gdb.c++/maint.exp @V@/gdb/testsuite/gdb.cxx/maint.exp
 @V@/gdb/testsuite/gdb.c++/member-ptr.cc @V@/gdb/testsuite/gdb.cxx/member-ptr.cc
 @V@/gdb/testsuite/gdb.c++/member-ptr.exp @V@/gdb/testsuite/gdb.cxx/member-ptr.exp
 @V@/gdb/testsuite/gdb.c++/method.cc @V@/gdb/testsuite/gdb.cxx/method.cc
diff --git a/gdb/config/i386/nto.mt b/gdb/config/i386/nto.mt
new file mode 100644
index 00000000000..6655f3eee74
--- /dev/null
+++ b/gdb/config/i386/nto.mt
@@ -0,0 +1,4 @@
+# Target: Intel 386 running qnx6.
+TDEPFILES = i386-tdep.o i387-tdep.o corelow.o solib.o solib-svr4.o \
+	i386-nto-tdep.o nto-tdep.o remote-nto.o
+TM_FILE = tm-nto.h
diff --git a/gdb/config/i386/tm-nto.h b/gdb/config/i386/tm-nto.h
new file mode 100644
index 00000000000..ff5eb7837e0
--- /dev/null
+++ b/gdb/config/i386/tm-nto.h
@@ -0,0 +1,33 @@
+/* QNX Neutrino target header.
+ 
+   Copyright 2003 Free Software Foundation, Inc.
+
+   This code was donated by QNX Software Systems Ltd.
+
+   This file is part of GDB.
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 59 Temple Place - Suite 330,
+   Boston, MA 02111-1307, USA.  */
+
+#ifndef TM_NTO_H
+#define TM_NTO_H 1
+
+/* Pick up most of what we need from the generic i386 target include file.  */
+#include "i386/tm-i386.h"
+#include "tm-nto.h"
+
+#include "solib.h"
+
+#endif /* TM_NTO_H */
diff --git a/gdb/config/ia64/tm-ia64.h b/gdb/config/ia64/tm-ia64.h
index 9ebe9ae7a9a..feeef09bb0c 100644
--- a/gdb/config/ia64/tm-ia64.h
+++ b/gdb/config/ia64/tm-ia64.h
@@ -31,7 +31,7 @@
    used in push_word and a few other places; REGISTER_RAW_SIZE is the
    real way to know how big a register is.  */
 
-#define REGISTER_SIZE 8
+#define DEPRECATED_REGISTER_SIZE 8
 
 #undef  NUM_REGS
 #define NUM_REGS 590
@@ -40,7 +40,7 @@
 
 #define PC_REGNUM	IA64_IP_REGNUM
 #define SP_REGNUM	IA64_GR12_REGNUM
-#define FP_REGNUM	IA64_VFP_REGNUM
+#define DEPRECATED_FP_REGNUM	IA64_VFP_REGNUM
 
 /* Total amount of space needed to store our copies of the machine's
    register state, the array `registers'.  On the ia64, all registers
diff --git a/gdb/config/m68k/tm-vx68.h b/gdb/config/m68k/tm-vx68.h
index f7e8fca6f2b..271eb7ef70e 100644
--- a/gdb/config/m68k/tm-vx68.h
+++ b/gdb/config/m68k/tm-vx68.h
@@ -79,4 +79,4 @@
 /* Number of registers in a ptrace_getfpregs call. */
 
 #define VX_SIZE_FPREGS (8 * REGISTER_RAW_SIZE (FP0_REGNUM) \
-			+ (3 * REGISTER_SIZE))
+			+ (3 * DEPRECATED_REGISTER_SIZE))
diff --git a/gdb/config/mips/tm-mips.h b/gdb/config/mips/tm-mips.h
index dada6155713..f9aebbe1f5a 100644
--- a/gdb/config/mips/tm-mips.h
+++ b/gdb/config/mips/tm-mips.h
@@ -49,10 +49,10 @@ extern int mips_step_skips_delay (CORE_ADDR);
    used in push_word and a few other places; REGISTER_RAW_SIZE is the
    real way to know how big a register is.  */
 
-#define REGISTER_SIZE 4
+#define DEPRECATED_REGISTER_SIZE 4
 
 /* The size of a register.  This is predefined in tm-mips64.h.  We
-   can't use REGISTER_SIZE because that is used for various other
+   can't use DEPRECATED_REGISTER_SIZE because that is used for various other
    things.  */
 
 #ifndef MIPS_REGSIZE
diff --git a/gdb/config/pa/nm-hppah.h b/gdb/config/pa/nm-hppah.h
index 2cc1e300365..f8a2a117fa2 100644
--- a/gdb/config/pa/nm-hppah.h
+++ b/gdb/config/pa/nm-hppah.h
@@ -121,9 +121,10 @@ extern int hppa_can_use_hw_watchpoint (int type, int cnt, int ot);
 #define TARGET_CAN_USE_HARDWARE_WATCHPOINT(type, cnt, ot) \
         hppa_can_use_hw_watchpoint(type, cnt, ot)
 
-/* The PA can also watch memory regions of arbitrary size, since we're using
-   a page-protection scheme.  (On some targets, apparently watch registers
-   are used, which can only accomodate regions of REGISTER_SIZE.) */
+/* The PA can also watch memory regions of arbitrary size, since we're
+   using a page-protection scheme.  (On some targets, apparently watch
+   registers are used, which can only accomodate regions of
+   DEPRECATED_REGISTER_SIZE.)  */
 #define TARGET_REGION_SIZE_OK_FOR_HW_WATCHPOINT(byte_count) \
         (1)
 
diff --git a/gdb/config/pa/tm-hppa.h b/gdb/config/pa/tm-hppa.h
index c0b3e2630ea..7daa6f5eadf 100644
--- a/gdb/config/pa/tm-hppa.h
+++ b/gdb/config/pa/tm-hppa.h
@@ -27,7 +27,9 @@
 /* Wonder if this is correct?  Should be using push_dummy_call().  */
 #define DEPRECATED_DUMMY_WRITE_SP(SP) generic_target_write_sp (SP)
 
-#define GDB_MULTI_ARCH 0
+#ifndef GDB_MULTI_ARCH
+#define GDB_MULTI_ARCH 1
+#endif
 
 /* NOTE: cagney/2002-11-24: This is a guess.  */
 #define DEPRECATED_USE_GENERIC_DUMMY_FRAMES 0
@@ -43,11 +45,6 @@ struct value;
 struct type;
 struct inferior_status;
 
-/* By default assume we don't have to worry about software floating point.  */
-#ifndef SOFT_FLOAT
-#define SOFT_FLOAT 0
-#endif
-
 /* Get at various relevent fields of an instruction word. */
 
 #define MASK_5 0x1f
@@ -61,96 +58,14 @@ struct inferior_status;
   ((X) >> (31 - (TO)) & ((1 << ((TO) - (FROM) + 1)) - 1))
 #endif
 
-#if !GDB_MULTI_ARCH
-extern int hppa_reg_struct_has_addr (int gcc_p, struct type *type);
-#define REG_STRUCT_HAS_ADDR(gcc_p,type) hppa_reg_struct_has_addr (gcc_p,type)
-#endif
-
-/* Offset from address of function to start of its code.
-   Zero on most machines.  */
-
-#if !GDB_MULTI_ARCH
-#define FUNCTION_START_OFFSET 0
-#endif
-
-/* Advance PC across any function entry prologue instructions
-   to reach some "real" code.  */
-
-#if !GDB_MULTI_ARCH
-extern CORE_ADDR hppa_skip_prologue (CORE_ADDR);
-#define SKIP_PROLOGUE(pc) (hppa_skip_prologue (pc))
-#endif
-
-/* If PC is in some function-call trampoline code, return the PC
-   where the function itself actually starts.  If not, return NULL.  */
-
-#if !GDB_MULTI_ARCH
-#define	SKIP_TRAMPOLINE_CODE(pc) hppa_skip_trampoline_code (pc)
-extern CORE_ADDR hppa_skip_trampoline_code (CORE_ADDR);
-#endif
-
-/* Return non-zero if we are in an appropriate trampoline. */
-
-#if !GDB_MULTI_ARCH
-#define IN_SOLIB_CALL_TRAMPOLINE(pc, name) \
-   hppa_in_solib_call_trampoline (pc, name)
-extern int hppa_in_solib_call_trampoline (CORE_ADDR, char *);
-#endif
-
-#if !GDB_MULTI_ARCH
-#define IN_SOLIB_RETURN_TRAMPOLINE(pc, name) \
-  hppa_in_solib_return_trampoline (pc, name)
-extern int hppa_in_solib_return_trampoline (CORE_ADDR, char *);
-#endif
-
-#if !GDB_MULTI_ARCH
-#undef	DEPRECATED_SAVED_PC_AFTER_CALL
-#define DEPRECATED_SAVED_PC_AFTER_CALL(frame) hppa_saved_pc_after_call (frame)
-extern CORE_ADDR hppa_saved_pc_after_call (struct frame_info *);
-#endif
-
-#if !GDB_MULTI_ARCH
-extern int hppa_inner_than (CORE_ADDR lhs, CORE_ADDR rhs);
-#define INNER_THAN(lhs,rhs) hppa_inner_than(lhs,rhs)
-#endif
-
-#if !GDB_MULTI_ARCH
-extern CORE_ADDR hppa_stack_align (CORE_ADDR sp);
-#define STACK_ALIGN(sp) hppa_stack_align (sp)
-#endif
-
 /* Sequence of bytes for breakpoint instruction.  */
 
 #define BREAKPOINT {0x00, 0x01, 0x00, 0x04}
 #define BREAKPOINT32 0x10004
 
-/* Amount PC must be decremented by after a breakpoint.
-   This is often the number of bytes in BREAKPOINT
-   but not always.
-
-   Not on the PA-RISC */
-
-#if !GDB_MULTI_ARCH
-#define DECR_PC_AFTER_BREAK 0
-#endif
-
 extern int hppa_pc_requires_run_before_use (CORE_ADDR pc);
 #define PC_REQUIRES_RUN_BEFORE_USE(pc) hppa_pc_requires_run_before_use (pc)
 
-/* Say how long (ordinary) registers are.  This is a piece of bogosity
-   used in push_word and a few other places; REGISTER_RAW_SIZE is the
-   real way to know how big a register is.  */
-
-#if !GDB_MULTI_ARCH
-#define REGISTER_SIZE 4
-#endif
-
-/* Number of machine registers */
-
-#if !GDB_MULTI_ARCH
-#define NUM_REGS 128
-#endif
-
 /* Initializer for an array of names of registers.
    There should be NUM_REGS strings in this initializer.
    They are in rows of eight entries  */
@@ -184,13 +99,6 @@ extern int hppa_pc_requires_run_before_use (CORE_ADDR pc);
 				   other r registers.  */
 #define FLAGS_REGNUM 0		/* Various status flags */
 #define RP_REGNUM 2		/* return pointer */
-#if !GDB_MULTI_ARCH
-#define FP_REGNUM 3		/* Contains address of executing stack */
-				/* frame */
-#endif
-#if !GDB_MULTI_ARCH
-#define SP_REGNUM 30		/* Contains address of top of stack */
-#endif
 #define SAR_REGNUM 32		/* Shift Amount Register */
 #define IPSW_REGNUM 41		/* Interrupt Processor Status Word */
 #define PCOQ_HEAD_REGNUM 33	/* instruction offset queue head */
@@ -205,9 +113,6 @@ extern int hppa_pc_requires_run_before_use (CORE_ADDR pc);
 #define CCR_REGNUM 54		/* Coprocessor Configuration Register */
 #define TR0_REGNUM 57		/* Temporary Registers (cr24 -> cr31) */
 #define CR27_REGNUM 60		/* Base register for thread-local storage, cr27 */
-#if !GDB_MULTI_ARCH
-#define FP0_REGNUM 64		/* floating point reg. 0 (fspr) */
-#endif
 #define FP4_REGNUM 72
 
 #define ARG0_REGNUM 26		/* The first argument of a callee. */
@@ -215,14 +120,6 @@ extern int hppa_pc_requires_run_before_use (CORE_ADDR pc);
 #define ARG2_REGNUM 24		/* The third argument of a callee. */
 #define ARG3_REGNUM 23		/* The fourth argument of a callee. */
 
-/* compatibility with the rest of gdb. */
-#if !GDB_MULTI_ARCH
-#define PC_REGNUM PCOQ_HEAD_REGNUM
-#endif
-#if !GDB_MULTI_ARCH
-#define NPC_REGNUM PCOQ_TAIL_REGNUM
-#endif
-
 /*
  * Processor Status Word Masks
  */
@@ -260,107 +157,12 @@ extern int hppa_pc_requires_run_before_use (CORE_ADDR pc);
 #define DEPRECATED_DO_REGISTERS_INFO(_regnum, fp) pa_do_registers_info (_regnum, fp)
 extern void pa_do_registers_info (int, int);
 
-#if 0
-#define STRCAT_REGISTER(regnum, fpregs, stream, precision) pa_do_strcat_registers_info (regnum, fpregs, stream, precision)
-extern void pa_do_strcat_registers_info (int, int, struct ui_file *, enum precision_type);
-#endif
-
 /* PA specific macro to see if the current instruction is nullified. */
 #ifndef INSTRUCTION_NULLIFIED
 extern int hppa_instruction_nullified (void);
 #define INSTRUCTION_NULLIFIED hppa_instruction_nullified ()
 #endif
 
-/* Number of bytes of storage in the actual machine representation
-   for register N.  On the PA-RISC, all regs are 4 bytes, including
-   the FP registers (they're accessed as two 4 byte halves).  */
-
-#if !GDB_MULTI_ARCH
-extern int hppa_register_raw_size (int reg_nr);
-#define REGISTER_RAW_SIZE(N) hppa_register_raw_size (N)
-#endif
-
-/* Total amount of space needed to store our copies of the machine's
-   register state, the array `registers'.  */
-#if !GDB_MULTI_ARCH
-#define REGISTER_BYTES (NUM_REGS * 4)
-#endif
-
-#if !GDB_MULTI_ARCH
-extern int hppa_register_byte (int reg_nr);
-#define REGISTER_BYTE(N) hppa_register_byte (N)
-#endif
-
-/* Number of bytes of storage in the program's representation
-   for register N. */
-
-#if !GDB_MULTI_ARCH
-#define REGISTER_VIRTUAL_SIZE(N) REGISTER_RAW_SIZE(N)
-#endif
-
-/* Largest value REGISTER_RAW_SIZE can have.  */
-
-#if !GDB_MULTI_ARCH
-#define DEPRECATED_MAX_REGISTER_RAW_SIZE 4
-#endif
-
-/* Largest value REGISTER_VIRTUAL_SIZE can have.  */
-
-#if !GDB_MULTI_ARCH
-#define DEPRECATED_MAX_REGISTER_VIRTUAL_SIZE 8
-#endif
-
-#if !GDB_MULTI_ARCH
-extern struct type * hppa_register_virtual_type (int reg_nr);
-#define REGISTER_VIRTUAL_TYPE(N) hppa_register_virtual_type (N)
-#endif
-
-#if !GDB_MULTI_ARCH
-extern void hppa_store_struct_return (CORE_ADDR addr, CORE_ADDR sp);
-#define STORE_STRUCT_RETURN(ADDR, SP) hppa_store_struct_return (ADDR, SP)
-#endif
-
-/* Extract from an array REGBUF containing the (raw) register state
-   a function return value of type TYPE, and copy that, in virtual format,
-   into VALBUF.  */
-
-#if !GDB_MULTI_ARCH
-void hppa_extract_return_value (struct type *type, char *regbuf, char *valbuf);
-#define DEPRECATED_EXTRACT_RETURN_VALUE(TYPE,REGBUF,VALBUF) \
-  hppa_extract_return_value (TYPE, REGBUF, VALBUF);
-#endif
-
- /* elz: decide whether the function returning a value of type type
-    will put it on the stack or in the registers.
-    The pa calling convention says that:
-    register 28 (called ret0 by gdb) contains any ASCII char,
-    and any non_floating point value up to 32-bits.
-    reg 28 and 29 contain non-floating point up tp 64 bits and larger
-    than 32 bits. (higer order word in reg 28).
-    fr4: floating point up to 64 bits
-    sr1: space identifier (32-bit)
-    stack: any lager than 64-bit, with the address in r28
-  */
-#if !GDB_MULTI_ARCH
-extern use_struct_convention_fn hppa_use_struct_convention;
-#define USE_STRUCT_CONVENTION(gcc_p,type) hppa_use_struct_convention (gcc_p,type)
-#endif
-
-/* Write into appropriate registers a function return value
-   of type TYPE, given in virtual format.  */
-
-#if !GDB_MULTI_ARCH
-extern void hppa_store_return_value (struct type *type, char *valbuf);
-#define DEPRECATED_STORE_RETURN_VALUE(TYPE,VALBUF) \
-  hppa_store_return_value (TYPE, VALBUF);
-#endif
-
-#if !GDB_MULTI_ARCH
-extern CORE_ADDR hppa_extract_struct_value_address (char *regbuf);
-#define DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS(REGBUF) \
-  hppa_extract_struct_value_address (REGBUF)
-#endif
-
 /* elz: Return a large value, which is stored on the stack at addr.
    This is defined only for the hppa, at this moment.  The above macro
    DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS is not called anymore,
@@ -376,93 +178,12 @@ struct value *hppa_value_returned_from_stack (register struct type *valtype,
 #define VALUE_RETURNED_FROM_STACK(valtype,addr) \
   hppa_value_returned_from_stack (valtype, addr)
 
-#if !GDB_MULTI_ARCH
-extern int hppa_cannot_store_register (int regnum);
-#define CANNOT_STORE_REGISTER(regno) hppa_cannot_store_register (regno)
-#endif
-
-#if !GDB_MULTI_ARCH
-#define DEPRECATED_INIT_EXTRA_FRAME_INFO(fromleaf, frame) hppa_init_extra_frame_info (fromleaf, frame)
-extern void hppa_init_extra_frame_info (int, struct frame_info *);
-#endif
-
-/* Describe the pointer in each stack frame to the previous stack frame
-   (its caller).  */
-
-/* DEPRECATED_FRAME_CHAIN takes a frame's nominal address and produces
-   the frame's chain-pointer.  */
-
-/* In the case of the PA-RISC, the frame's nominal address
-   is the address of a 4-byte word containing the calling frame's
-   address (previous FP).  */
-
-#if !GDB_MULTI_ARCH
-#define DEPRECATED_FRAME_CHAIN(thisframe) hppa_frame_chain (thisframe)
-extern CORE_ADDR hppa_frame_chain (struct frame_info *);
-#endif
-
-#if !GDB_MULTI_ARCH
-extern int hppa_frame_chain_valid (CORE_ADDR, struct frame_info *);
-#define DEPRECATED_FRAME_CHAIN_VALID(chain, thisframe) hppa_frame_chain_valid (chain, thisframe)
-#endif
-
-/* Define other aspects of the stack frame.  */
-
-/* A macro that tells us whether the function invocation represented
-   by FI does not have a frame on the stack associated with it.  If it
-   does not, FRAMELESS is set to 1, else 0.  */
-#if !GDB_MULTI_ARCH
-#define FRAMELESS_FUNCTION_INVOCATION(FI) \
-  (hppa_frameless_function_invocation (FI))
-extern int hppa_frameless_function_invocation (struct frame_info *);
-#endif
-
-#if !GDB_MULTI_ARCH
-extern CORE_ADDR hppa_frame_saved_pc (struct frame_info *frame);
-#define DEPRECATED_FRAME_SAVED_PC(FRAME) hppa_frame_saved_pc (FRAME)
-#endif
-
-#if !GDB_MULTI_ARCH
-extern CORE_ADDR hppa_frame_args_address (struct frame_info *fi);
-#define FRAME_ARGS_ADDRESS(fi) hppa_frame_args_address (fi)
-#endif
-
-#if !GDB_MULTI_ARCH
-extern CORE_ADDR hppa_frame_locals_address (struct frame_info *fi);
-#define FRAME_LOCALS_ADDRESS(fi) hppa_frame_locals_address (fi)
-#endif
-
-#if !GDB_MULTI_ARCH
-extern int hppa_frame_num_args (struct frame_info *frame);
-#define FRAME_NUM_ARGS(fi) hppa_frame_num_args (fi)
-#endif
-
-#if !GDB_MULTI_ARCH
-#define FRAME_ARGS_SKIP 0
-#endif
-
 extern void hppa_frame_init_saved_regs (struct frame_info *);
 #define DEPRECATED_FRAME_INIT_SAVED_REGS(FI) \
   hppa_frame_init_saved_regs (FI)
 
-/* Things needed for making the inferior call functions.  */
-
-#if !GDB_MULTI_ARCH
-#define DEPRECATED_PUSH_DUMMY_FRAME hppa_push_dummy_frame ()
-extern void hppa_push_dummy_frame (void);
-#endif
-
-/* Discard from the stack the innermost frame, 
-   restoring all saved registers.  */
-#if !GDB_MULTI_ARCH
-#define DEPRECATED_POP_FRAME  hppa_pop_frame ()
-extern void hppa_pop_frame (void);
-#endif
-
 #define INSTRUCTION_SIZE 4
 
-#ifndef PA_LEVEL_0
-
 /* Non-level zero PA's have space registers (but they don't always have
    floating-point, do they????  */
 
@@ -544,52 +265,8 @@ extern void hppa_pop_frame (void);
                     0xe6c00002, 0xe4202000, 0x6bdf3fd1, 0x00010004,\
                     0x00151820, 0xe6c00002, 0x08000240, 0x08000240}
 
-#if !GDB_MULTI_ARCH
-#define CALL_DUMMY_LENGTH (INSTRUCTION_SIZE * 28)
-#endif
 #define REG_PARM_STACK_SPACE 16
 
-#else /* defined PA_LEVEL_0 */
-
-/* FIXME: brobecker 2002-12-26.  PA_LEVEL_0 is only defined for the
-   hppa-pro target, which should be obsoleted soon.  The following
-   section will therefore not be included in the multiarch conversion.  */
-/* This is the call dummy for a level 0 PA.  Level 0's don't have space
-   registers (or floating point?), so we skip all that inter-space call stuff,
-   and avoid touching the fp regs.
-
-   call_dummy
-
-   ldw -36(%sp), %arg0
-   ldw -40(%sp), %arg1
-   ldw -44(%sp), %arg2
-   ldw -48(%sp), %arg3
-   ldil 0, %r31                 ; FUNC_LDIL_OFFSET must point here
-   ldo 0(%r31), %r31            ; FUNC_LDO_OFFSET must point here
-   ble 0(%sr0, %r31)
-   copy %r31, %r2
-   break 4, 8 
-   nop                          ; restore_pc_queue expects these
-   bv,n 0(%r22)                 ; instructions to be here...
-   nop
- */
-
-/* Define offsets into the call dummy for the target function address */
-#define FUNC_LDIL_OFFSET (INSTRUCTION_SIZE * 4)
-#define FUNC_LDO_OFFSET (INSTRUCTION_SIZE * 5)
-
-#define CALL_DUMMY {0x4bda3fb9, 0x4bd93fb1, 0x4bd83fa9, 0x4bd73fa1,\
-		    0x23e00000, 0x37ff0000, 0xe7e00000, 0x081f0242,\
-		    0x00010004, 0x08000240, 0xeac0c002, 0x08000240}
-
-#define CALL_DUMMY_LENGTH (INSTRUCTION_SIZE * 12)
-
-#endif /* defined PA_LEVEL_0 */
-
-#if !GDB_MULTI_ARCH
-#define CALL_DUMMY_START_OFFSET 0
-#endif
-
 /* If we've reached a trap instruction within the call dummy, then
    we'll consider that to mean that we've reached the call dummy's
    end after its successful completion. */
@@ -597,42 +274,25 @@ extern void hppa_pop_frame (void);
   (DEPRECATED_PC_IN_CALL_DUMMY((pc), (sp), (frame_address)) && \
    (read_memory_integer((pc), 4) == BREAKPOINT32))
 
-/*
- * Insert the specified number of args and function address
- * into a call sequence of the above form stored at DUMMYNAME.
- *
- * On the hppa we need to call the stack dummy through $$dyncall.
- * Therefore our version of FIX_CALL_DUMMY takes an extra argument,
- * real_pc, which is the location where gdb should start up the
- * inferior to do the function call.
- */
+/* Insert the specified number of args and function address into a
+   call sequence of the above form stored at DUMMYNAME.
+
+   On the hppa we need to call the stack dummy through $$dyncall.
+   Therefore our version of DEPRECATED_FIX_CALL_DUMMY takes an extra
+   argument, real_pc, which is the location where gdb should start up
+   the inferior to do the function call.  */
 
 /* FIXME: brobecker 2002-12-26.  This macro is going to cause us some
-   problems before we can go to multiarch partial as it has been diverted
-   on HPUX to return the value of the PC!  */
-#define FIX_CALL_DUMMY hppa_fix_call_dummy
+   problems before we can go to multiarch partial as it has been
+   diverted on HPUX to return the value of the PC!  */
+/* NOTE: cagney/2003-05-03: This has been replaced by push_dummy_code.
+   Hopefully that has all the parameters HP/UX needs.  */
+#define DEPRECATED_FIX_CALL_DUMMY hppa_fix_call_dummy
 extern CORE_ADDR hppa_fix_call_dummy (char *, CORE_ADDR, CORE_ADDR, int,
 		                      struct value **, struct type *, int);
 
-#if !GDB_MULTI_ARCH
-#define DEPRECATED_PUSH_ARGUMENTS(nargs, args, sp, struct_return, struct_addr) \
-  (hppa_push_arguments((nargs), (args), (sp), (struct_return), (struct_addr)))
-extern CORE_ADDR hppa_push_arguments (int, struct value **, CORE_ADDR, int,
-				      CORE_ADDR);
-#endif
-
-
-#if !GDB_MULTI_ARCH
-extern CORE_ADDR hppa_smash_text_address (CORE_ADDR addr);
-#define SMASH_TEXT_ADDRESS(addr) hppa_smash_text_address (addr)
-#endif
-
 #define	GDB_TARGET_IS_HPPA
 
-#if !GDB_MULTI_ARCH
-#define BELIEVE_PCC_PROMOTION 1
-#endif
-
 /*
  * Unwind table and descriptor.
  */
@@ -752,27 +412,6 @@ typedef struct obj_private_struct
   }
 obj_private_data_t;
 
-#if 0
-extern void target_write_pc (CORE_ADDR, int);
-extern CORE_ADDR target_read_pc (int);
-extern CORE_ADDR skip_trampoline_code (CORE_ADDR, char *);
-#endif
-
-#if !GDB_MULTI_ARCH
-#define TARGET_READ_PC(pid) hppa_target_read_pc (pid)
-extern CORE_ADDR hppa_target_read_pc (ptid_t);
-#endif
-
-#if !GDB_MULTI_ARCH
-#define TARGET_WRITE_PC(v,pid) hppa_target_write_pc (v,pid)
-extern void hppa_target_write_pc (CORE_ADDR, ptid_t);
-#endif
-
-#if !GDB_MULTI_ARCH
-#define TARGET_READ_FP() hppa_target_read_fp ()
-extern CORE_ADDR hppa_target_read_fp (void);
-#endif
-
 /* For a number of horrible reasons we may have to adjust the location
    of variables on the stack.  Ugh.  */
 #define HPREAD_ADJUST_STACK_ADDRESS(ADDR) hpread_adjust_stack_address(ADDR)
diff --git a/gdb/config/pa/tm-hppa64.h b/gdb/config/pa/tm-hppa64.h
index 503e42688df..81bf7caeb08 100644
--- a/gdb/config/pa/tm-hppa64.h
+++ b/gdb/config/pa/tm-hppa64.h
@@ -28,6 +28,324 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
    gotten working yet.  */
 #define GDB_TARGET_IS_HPPA_20W
 
+/* FIXME: brobecker 2003-04-21: Although 32bit hppa is partially multiarched,
+   the conversion for hppa64 hasn't been completed yet.  */
+#define GDB_MULTI_ARCH 0
+
+/* FIXME: brobecker 2003-04-21: All the definition from this point until
+   the include of pa/tm-hppah.h are extracted from tm-hppa.h.  They have
+   been temporarily moved here, until hppa64 is multiarched too.  */
+
+#if !GDB_MULTI_ARCH
+extern int hppa_reg_struct_has_addr (int gcc_p, struct type *type);
+#define REG_STRUCT_HAS_ADDR(gcc_p,type) hppa_reg_struct_has_addr (gcc_p,type)
+#endif
+
+/* Offset from address of function to start of its code.
+   Zero on most machines.  */
+
+#if !GDB_MULTI_ARCH
+#define FUNCTION_START_OFFSET 0
+#endif
+
+/* Advance PC across any function entry prologue instructions
+   to reach some "real" code.  */
+
+#if !GDB_MULTI_ARCH
+extern CORE_ADDR hppa_skip_prologue (CORE_ADDR);
+#define SKIP_PROLOGUE(pc) (hppa_skip_prologue (pc))
+#endif
+
+/* If PC is in some function-call trampoline code, return the PC
+   where the function itself actually starts.  If not, return NULL.  */
+
+#if !GDB_MULTI_ARCH
+#define	SKIP_TRAMPOLINE_CODE(pc) hppa_skip_trampoline_code (pc)
+extern CORE_ADDR hppa_skip_trampoline_code (CORE_ADDR);
+#endif
+
+/* Return non-zero if we are in an appropriate trampoline. */
+
+#if !GDB_MULTI_ARCH
+#define IN_SOLIB_CALL_TRAMPOLINE(pc, name) \
+   hppa_in_solib_call_trampoline (pc, name)
+extern int hppa_in_solib_call_trampoline (CORE_ADDR, char *);
+#endif
+
+#if !GDB_MULTI_ARCH
+#define IN_SOLIB_RETURN_TRAMPOLINE(pc, name) \
+  hppa_in_solib_return_trampoline (pc, name)
+extern int hppa_in_solib_return_trampoline (CORE_ADDR, char *);
+#endif
+
+#if !GDB_MULTI_ARCH
+#undef	DEPRECATED_SAVED_PC_AFTER_CALL
+#define DEPRECATED_SAVED_PC_AFTER_CALL(frame) hppa_saved_pc_after_call (frame)
+extern CORE_ADDR hppa_saved_pc_after_call (struct frame_info *);
+#endif
+
+#if !GDB_MULTI_ARCH
+extern int hppa_inner_than (CORE_ADDR lhs, CORE_ADDR rhs);
+#define INNER_THAN(lhs,rhs) hppa_inner_than(lhs,rhs)
+#endif
+
+#if !GDB_MULTI_ARCH
+extern CORE_ADDR hppa_stack_align (CORE_ADDR sp);
+#define STACK_ALIGN(sp) hppa_stack_align (sp)
+#endif
+
+/* Amount PC must be decremented by after a breakpoint.
+   This is often the number of bytes in BREAKPOINT
+   but not always.
+
+   Not on the PA-RISC */
+
+#if !GDB_MULTI_ARCH
+#define DECR_PC_AFTER_BREAK 0
+#endif
+
+/* Say how long (ordinary) registers are.  This is a piece of bogosity
+   used in push_word and a few other places; REGISTER_RAW_SIZE is the
+   real way to know how big a register is.  */
+
+#if !GDB_MULTI_ARCH
+#define DEPRECATED_REGISTER_SIZE 4
+#endif
+
+/* Number of machine registers */
+
+#if !GDB_MULTI_ARCH
+#define NUM_REGS 128
+#endif
+
+#if !GDB_MULTI_ARCH
+#define DEPRECATED_FP_REGNUM 3		/* Contains address of executing stack */
+				/* frame */
+#endif
+#if !GDB_MULTI_ARCH
+#define SP_REGNUM 30		/* Contains address of top of stack */
+#endif
+
+#if !GDB_MULTI_ARCH
+#define FP0_REGNUM 64		/* floating point reg. 0 (fspr) */
+#endif
+
+/* compatibility with the rest of gdb. */
+#if !GDB_MULTI_ARCH
+#define PC_REGNUM PCOQ_HEAD_REGNUM
+#endif
+#if !GDB_MULTI_ARCH
+#define NPC_REGNUM PCOQ_TAIL_REGNUM
+#endif
+
+/* Number of bytes of storage in the actual machine representation
+   for register N.  On the PA-RISC, all regs are 4 bytes, including
+   the FP registers (they're accessed as two 4 byte halves).  */
+
+#if !GDB_MULTI_ARCH
+extern int hppa_register_raw_size (int reg_nr);
+#define REGISTER_RAW_SIZE(N) hppa_register_raw_size (N)
+#endif
+
+/* Total amount of space needed to store our copies of the machine's
+   register state, the array `registers'.  */
+#if !GDB_MULTI_ARCH
+#define REGISTER_BYTES (NUM_REGS * 4)
+#endif
+
+#if !GDB_MULTI_ARCH
+extern int hppa_register_byte (int reg_nr);
+#define REGISTER_BYTE(N) hppa_register_byte (N)
+#endif
+
+/* Number of bytes of storage in the program's representation
+   for register N. */
+
+#if !GDB_MULTI_ARCH
+#define REGISTER_VIRTUAL_SIZE(N) REGISTER_RAW_SIZE(N)
+#endif
+
+/* Largest value REGISTER_RAW_SIZE can have.  */
+
+#if !GDB_MULTI_ARCH
+#define DEPRECATED_MAX_REGISTER_RAW_SIZE 4
+#endif
+
+/* Largest value REGISTER_VIRTUAL_SIZE can have.  */
+
+#if !GDB_MULTI_ARCH
+#define DEPRECATED_MAX_REGISTER_VIRTUAL_SIZE 8
+#endif
+
+#if !GDB_MULTI_ARCH
+extern struct type * hppa_register_virtual_type (int reg_nr);
+#define REGISTER_VIRTUAL_TYPE(N) hppa_register_virtual_type (N)
+#endif
+
+#if !GDB_MULTI_ARCH
+extern void hppa_store_struct_return (CORE_ADDR addr, CORE_ADDR sp);
+#define STORE_STRUCT_RETURN(ADDR, SP) hppa_store_struct_return (ADDR, SP)
+#endif
+
+/* Extract from an array REGBUF containing the (raw) register state
+   a function return value of type TYPE, and copy that, in virtual format,
+   into VALBUF.  */
+
+#if !GDB_MULTI_ARCH
+void hppa_extract_return_value (struct type *type, char *regbuf, char *valbuf);
+#define DEPRECATED_EXTRACT_RETURN_VALUE(TYPE,REGBUF,VALBUF) \
+  hppa_extract_return_value (TYPE, REGBUF, VALBUF);
+#endif
+
+ /* elz: decide whether the function returning a value of type type
+    will put it on the stack or in the registers.
+    The pa calling convention says that:
+    register 28 (called ret0 by gdb) contains any ASCII char,
+    and any non_floating point value up to 32-bits.
+    reg 28 and 29 contain non-floating point up tp 64 bits and larger
+    than 32 bits. (higer order word in reg 28).
+    fr4: floating point up to 64 bits
+    sr1: space identifier (32-bit)
+    stack: any lager than 64-bit, with the address in r28
+  */
+#if !GDB_MULTI_ARCH
+extern use_struct_convention_fn hppa_use_struct_convention;
+#define USE_STRUCT_CONVENTION(gcc_p,type) hppa_use_struct_convention (gcc_p,type)
+#endif
+
+/* Write into appropriate registers a function return value
+   of type TYPE, given in virtual format.  */
+
+#if !GDB_MULTI_ARCH
+extern void hppa_store_return_value (struct type *type, char *valbuf);
+#define DEPRECATED_STORE_RETURN_VALUE(TYPE,VALBUF) \
+  hppa_store_return_value (TYPE, VALBUF);
+#endif
+
+#if !GDB_MULTI_ARCH
+extern CORE_ADDR hppa_extract_struct_value_address (char *regbuf);
+#define DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS(REGBUF) \
+  hppa_extract_struct_value_address (REGBUF)
+#endif
+
+#if !GDB_MULTI_ARCH
+extern int hppa_cannot_store_register (int regnum);
+#define CANNOT_STORE_REGISTER(regno) hppa_cannot_store_register (regno)
+#endif
+
+#if !GDB_MULTI_ARCH
+#define DEPRECATED_INIT_EXTRA_FRAME_INFO(fromleaf, frame) hppa_init_extra_frame_info (fromleaf, frame)
+extern void hppa_init_extra_frame_info (int, struct frame_info *);
+#endif
+
+/* Describe the pointer in each stack frame to the previous stack frame
+   (its caller).  */
+
+/* DEPRECATED_FRAME_CHAIN takes a frame's nominal address and produces
+   the frame's chain-pointer.  */
+
+/* In the case of the PA-RISC, the frame's nominal address
+   is the address of a 4-byte word containing the calling frame's
+   address (previous FP).  */
+
+#if !GDB_MULTI_ARCH
+#define DEPRECATED_FRAME_CHAIN(thisframe) hppa_frame_chain (thisframe)
+extern CORE_ADDR hppa_frame_chain (struct frame_info *);
+#endif
+
+#if !GDB_MULTI_ARCH
+extern int hppa_frame_chain_valid (CORE_ADDR, struct frame_info *);
+#define DEPRECATED_FRAME_CHAIN_VALID(chain, thisframe) hppa_frame_chain_valid (chain, thisframe)
+#endif
+
+/* Define other aspects of the stack frame.  */
+
+/* A macro that tells us whether the function invocation represented
+   by FI does not have a frame on the stack associated with it.  If it
+   does not, FRAMELESS is set to 1, else 0.  */
+#if !GDB_MULTI_ARCH
+#define FRAMELESS_FUNCTION_INVOCATION(FI) \
+  (hppa_frameless_function_invocation (FI))
+extern int hppa_frameless_function_invocation (struct frame_info *);
+#endif
+
+#if !GDB_MULTI_ARCH
+extern CORE_ADDR hppa_frame_saved_pc (struct frame_info *frame);
+#define DEPRECATED_FRAME_SAVED_PC(FRAME) hppa_frame_saved_pc (FRAME)
+#endif
+
+#if !GDB_MULTI_ARCH
+extern CORE_ADDR hppa_frame_args_address (struct frame_info *fi);
+#define FRAME_ARGS_ADDRESS(fi) hppa_frame_args_address (fi)
+#endif
+
+#if !GDB_MULTI_ARCH
+extern CORE_ADDR hppa_frame_locals_address (struct frame_info *fi);
+#define FRAME_LOCALS_ADDRESS(fi) hppa_frame_locals_address (fi)
+#endif
+
+#if !GDB_MULTI_ARCH
+extern int hppa_frame_num_args (struct frame_info *frame);
+#define FRAME_NUM_ARGS(fi) hppa_frame_num_args (fi)
+#endif
+
+#if !GDB_MULTI_ARCH
+#define FRAME_ARGS_SKIP 0
+#endif
+
+/* Things needed for making the inferior call functions.  */
+
+#if !GDB_MULTI_ARCH
+#define DEPRECATED_PUSH_DUMMY_FRAME hppa_push_dummy_frame ()
+extern void hppa_push_dummy_frame (void);
+#endif
+
+/* Discard from the stack the innermost frame, 
+   restoring all saved registers.  */
+#if !GDB_MULTI_ARCH
+#define DEPRECATED_POP_FRAME  hppa_pop_frame ()
+extern void hppa_pop_frame (void);
+#endif
+
+#if !GDB_MULTI_ARCH
+#define DEPRECATED_CALL_DUMMY_LENGTH (INSTRUCTION_SIZE * 28)
+#endif
+
+#if !GDB_MULTI_ARCH
+#define DEPRECATED_CALL_DUMMY_START_OFFSET 0
+#endif
+
+#if !GDB_MULTI_ARCH
+#define DEPRECATED_PUSH_ARGUMENTS(nargs, args, sp, struct_return, struct_addr) \
+  (hppa_push_arguments((nargs), (args), (sp), (struct_return), (struct_addr)))
+extern CORE_ADDR hppa_push_arguments (int, struct value **, CORE_ADDR, int,
+				      CORE_ADDR);
+#endif
+
+#if !GDB_MULTI_ARCH
+extern CORE_ADDR hppa_smash_text_address (CORE_ADDR addr);
+#define SMASH_TEXT_ADDRESS(addr) hppa_smash_text_address (addr)
+#endif
+
+#if !GDB_MULTI_ARCH
+#define BELIEVE_PCC_PROMOTION 1
+#endif
+
+#if !GDB_MULTI_ARCH
+#define TARGET_READ_PC(pid) hppa_target_read_pc (pid)
+extern CORE_ADDR hppa_target_read_pc (ptid_t);
+#endif
+
+#if !GDB_MULTI_ARCH
+#define TARGET_WRITE_PC(v,pid) hppa_target_write_pc (v,pid)
+extern void hppa_target_write_pc (CORE_ADDR, ptid_t);
+#endif
+
+#if !GDB_MULTI_ARCH
+#define DEPRECATED_TARGET_READ_FP() hppa_target_read_fp ()
+extern CORE_ADDR hppa_target_read_fp (void);
+#endif
+
 #include "pa/tm-hppah.h"
 
 #define HPUX_1100 1
@@ -39,8 +357,8 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
    push_word and a few other places, but REGISTER_RAW_SIZE is
    the real way to know how big a register is.  */
 
-#undef REGISTER_SIZE
-#define REGISTER_SIZE 8
+#undef DEPRECATED_REGISTER_SIZE
+#define DEPRECATED_REGISTER_SIZE 8
 
 /* Number of bytes of storage in the actual machine representation
    for register N.  On the PA-RISC 2.0, all regs are 8 bytes, including
@@ -183,14 +501,14 @@ call_dummy
                     0xe820f0000fb110d3LL, 0x0001000400151820LL,\
                     0xe6c0000008000240LL}
 
-#define CALL_DUMMY_BREAKPOINT_OFFSET 22 * 4
+#define DEPRECATED_CALL_DUMMY_BREAKPOINT_OFFSET 22 * 4
 
-/* CALL_DUMMY_LENGTH is computed based on the size of a word on the target
-   machine, not the size of an instruction.  Since a word on this target
-   holds two instructions we have to divide the instruction size by two to
-   get the word size of the dummy.  */
-#undef CALL_DUMMY_LENGTH
-#define CALL_DUMMY_LENGTH (INSTRUCTION_SIZE * 26 / 2)
+/* DEPRECATED_CALL_DUMMY_LENGTH is computed based on the size of a
+   word on the target machine, not the size of an instruction.  Since
+   a word on this target holds two instructions we have to divide the
+   instruction size by two to get the word size of the dummy.  */
+#undef DEPRECATED_CALL_DUMMY_LENGTH
+#define DEPRECATED_CALL_DUMMY_LENGTH (INSTRUCTION_SIZE * 26 / 2)
 
 /* The PA64 ABI mandates a 16 byte stack alignment.  */
 #undef STACK_ALIGN
@@ -219,15 +537,15 @@ call_dummy
  */ 
 #define DEPRECATED_EXTRACT_RETURN_VALUE(TYPE,REGBUF,VALBUF) \
   { \
-    if (TYPE_CODE (TYPE) == TYPE_CODE_FLT && !SOFT_FLOAT) \
+    if (TYPE_CODE (TYPE) == TYPE_CODE_FLT) \
       memcpy ((VALBUF), \
 	      ((char *)(REGBUF)) + REGISTER_BYTE (FP4_REGNUM) + \
-              (REGISTER_SIZE - TYPE_LENGTH (TYPE)), \
+              (DEPRECATED_REGISTER_SIZE - TYPE_LENGTH (TYPE)), \
 	      TYPE_LENGTH (TYPE)); \
-    else if  (is_integral_type(TYPE) || SOFT_FLOAT)   \
+    else if  (is_integral_type(TYPE))   \
        memcpy ((VALBUF), \
                (char *)(REGBUF) + REGISTER_BYTE (28) + \
-               (REGISTER_SIZE - TYPE_LENGTH (TYPE)), \
+               (DEPRECATED_REGISTER_SIZE - TYPE_LENGTH (TYPE)), \
                TYPE_LENGTH (TYPE)); \
     else if (TYPE_LENGTH (TYPE) <= 8)   \
        memcpy ((VALBUF), \
@@ -253,16 +571,16 @@ call_dummy
 #undef DEPRECATED_STORE_RETURN_VALUE
 #define DEPRECATED_STORE_RETURN_VALUE(TYPE,VALBUF) \
   { \
-    if (TYPE_CODE (TYPE) == TYPE_CODE_FLT && !SOFT_FLOAT) \
+    if (TYPE_CODE (TYPE) == TYPE_CODE_FLT) \
       deprecated_write_register_bytes \
 	      (REGISTER_BYTE (FP4_REGNUM) + \
-              (REGISTER_SIZE - TYPE_LENGTH (TYPE)), \
+              (DEPRECATED_REGISTER_SIZE - TYPE_LENGTH (TYPE)), \
               (VALBUF), \
 	      TYPE_LENGTH (TYPE)); \
-    else if (is_integral_type(TYPE) || SOFT_FLOAT)   \
+    else if (is_integral_type(TYPE))   \
        deprecated_write_register_bytes \
               (REGISTER_BYTE (28) + \
-                 (REGISTER_SIZE - TYPE_LENGTH (TYPE)), \
+                 (DEPRECATED_REGISTER_SIZE - TYPE_LENGTH (TYPE)), \
                (VALBUF), \
                TYPE_LENGTH (TYPE)); \
     else if (TYPE_LENGTH (TYPE) <= 8)   \
diff --git a/gdb/config/s390/tm-s390.h b/gdb/config/s390/tm-s390.h
index 1c6e6787099..37bf770e94f 100644
--- a/gdb/config/s390/tm-s390.h
+++ b/gdb/config/s390/tm-s390.h
@@ -24,15 +24,15 @@
 #define TM_S390_H 1
 
 #define S390_NUM_GPRS      (16)
-#define S390_GPR_SIZE      REGISTER_SIZE
-#define S390_PSW_MASK_SIZE REGISTER_SIZE
-#define S390_PSW_ADDR_SIZE REGISTER_SIZE
+#define S390_GPR_SIZE      DEPRECATED_REGISTER_SIZE
+#define S390_PSW_MASK_SIZE DEPRECATED_REGISTER_SIZE
+#define S390_PSW_ADDR_SIZE DEPRECATED_REGISTER_SIZE
 #define S390_NUM_FPRS      (16)
 #define S390_FPR_SIZE      (8)
 #define S390_FPC_SIZE      (4)
 #define S390_FPC_PAD_SIZE  (4)	/* gcc insists on aligning the fpregs */
 #define S390_NUM_CRS       (16)
-#define S390_CR_SIZE       REGISTER_SIZE
+#define S390_CR_SIZE       DEPRECATED_REGISTER_SIZE
 #define S390_NUM_ACRS      (16)
 #define S390_ACR_SIZE      (4)
 
@@ -80,7 +80,7 @@ int s390_register_byte (int reg_nr);
 #define PC_REGNUM S390_PC_REGNUM
 #define NUM_REGS  S390_NUM_REGS
 #define NUM_FREGS S390_NUM_FPRS
-#define FP_REGNUM S390_FP_REGNUM
+#define DEPRECATED_FP_REGNUM S390_FP_REGNUM
 #define SP_REGNUM S390_SP_REGNUM
 /* Obviously ptrace for user program tracing cannot be allowed
   mess with control registers (except per registers for hardware watchpoints),
@@ -94,7 +94,7 @@ int s390_cannot_fetch_register (int regno);
 int s390x_register_raw_size (int reg_nr);
 #define REGISTER_RAW_SIZE(reg_nr) s390x_register_raw_size(reg_nr)
 #define GDB_TARGET_IS_ESAME (1)
-#define REGISTER_SIZE       (8)
+#define DEPRECATED_REGISTER_SIZE       (8)
 #define REGISTER_BYTES S390X_REGISTER_BYTES
 
 #else /*  CONFIG_ARCH_S390X */
@@ -102,7 +102,7 @@ int s390x_register_raw_size (int reg_nr);
 int s390_register_raw_size (int reg_nr);
 #define REGISTER_RAW_SIZE(reg_nr) s390_register_raw_size(reg_nr)
 #define GDB_TARGET_IS_ESAME (0)
-#define REGISTER_SIZE       (4)
+#define DEPRECATED_REGISTER_SIZE       (4)
 #define REGISTER_BYTES S390_REGISTER_BYTES
 
 #endif /* CONFIG_ARCH_S390X */
diff --git a/gdb/config/sparc/tm-sp64.h b/gdb/config/sparc/tm-sp64.h
index 2d2193d207f..b371d1297b3 100644
--- a/gdb/config/sparc/tm-sp64.h
+++ b/gdb/config/sparc/tm-sp64.h
@@ -90,26 +90,26 @@ struct type;
 
 #undef  CALL_DUMMY
 #define CALL_DUMMY {0}
-#undef  CALL_DUMMY_LENGTH
-#define CALL_DUMMY_LENGTH 0
+#undef  DEPRECATED_CALL_DUMMY_LENGTH
+#define DEPRECATED_CALL_DUMMY_LENGTH 0
 #undef  CALL_DUMMY_CALL_OFFSET
 #define CALL_DUMMY_CALL_OFFSET 0
-#undef  CALL_DUMMY_START_OFFSET
-#define CALL_DUMMY_START_OFFSET 0
-#undef  CALL_DUMMY_BREAKPOINT_OFFSET
-#define CALL_DUMMY_BREAKPOINT_OFFSET 0
+#undef  DEPRECATED_CALL_DUMMY_START_OFFSET
+#define DEPRECATED_CALL_DUMMY_START_OFFSET 0
+#undef  DEPRECATED_CALL_DUMMY_BREAKPOINT_OFFSET
+#define DEPRECATED_CALL_DUMMY_BREAKPOINT_OFFSET 0
 #undef  CALL_DUMMY_LOCATION 
 #define CALL_DUMMY_LOCATION AT_ENTRY_POINT
 #undef  DEPRECATED_PC_IN_CALL_DUMMY
 #define DEPRECATED_PC_IN_CALL_DUMMY(pc, sp, frame_address) deprecated_pc_in_call_dummy_at_entry_point (pc, sp, frame_address)
 #undef  DEPRECATED_CALL_DUMMY_STACK_ADJUST
 #define DEPRECATED_CALL_DUMMY_STACK_ADJUST 128
-#undef  SIZEOF_CALL_DUMMY_WORDS
-#define SIZEOF_CALL_DUMMY_WORDS 0
+#undef  DEPRECATED_SIZEOF_CALL_DUMMY_WORDS
+#define DEPRECATED_SIZEOF_CALL_DUMMY_WORDS 0
 #undef  CALL_DUMMY_ADDRESS
 #define CALL_DUMMY_ADDRESS() entry_point_address()
-#undef  FIX_CALL_DUMMY
-#define FIX_CALL_DUMMY(DUMMYNAME, PC, FUN, NARGS, ARGS, TYPE, GCC_P) 
+#undef  DEPRECATED_FIX_CALL_DUMMY
+#define DEPRECATED_FIX_CALL_DUMMY(DUMMYNAME, PC, FUN, NARGS, ARGS, TYPE, GCC_P) 
 #undef  DEPRECATED_PUSH_RETURN_ADDRESS
 #define DEPRECATED_PUSH_RETURN_ADDRESS(PC, SP) sparc_at_entry_push_return_address (PC, SP)
 extern CORE_ADDR sparc_at_entry_push_return_address (CORE_ADDR pc,
@@ -147,20 +147,20 @@ extern void sparc_at_entry_store_struct_return (CORE_ADDR addr, CORE_ADDR sp);
 #define DEPRECATED_CALL_DUMMY_STACK_ADJUST 128
 
 /* Size of the call dummy in bytes. */
-#undef  CALL_DUMMY_LENGTH
-#define CALL_DUMMY_LENGTH 192
+#undef  DEPRECATED_CALL_DUMMY_LENGTH
+#define DEPRECATED_CALL_DUMMY_LENGTH 192
 
 /* Offset within CALL_DUMMY of the 'call' instruction. */
-#undef  CALL_DUMMY_START_OFFSET
-#define CALL_DUMMY_START_OFFSET 148
+#undef  DEPRECATED_CALL_DUMMY_START_OFFSET
+#define DEPRECATED_CALL_DUMMY_START_OFFSET 148
 
 /* Offset within CALL_DUMMY of the 'call' instruction. */
 #undef  CALL_DUMMY_CALL_OFFSET
-#define CALL_DUMMY_CALL_OFFSET (CALL_DUMMY_START_OFFSET + (5 * 4))
+#define CALL_DUMMY_CALL_OFFSET (DEPRECATED_CALL_DUMMY_START_OFFSET + (5 * 4))
 
 /* Offset within CALL_DUMMY of the 'ta 1' instruction. */
-#undef  CALL_DUMMY_BREAKPOINT_OFFSET
-#define CALL_DUMMY_BREAKPOINT_OFFSET (CALL_DUMMY_START_OFFSET + (8 * 4))
+#undef  DEPRECATED_CALL_DUMMY_BREAKPOINT_OFFSET
+#define DEPRECATED_CALL_DUMMY_BREAKPOINT_OFFSET (DEPRECATED_CALL_DUMMY_START_OFFSET + (8 * 4))
 
 /* Call dummy will be located on the stack.  */
 #undef  CALL_DUMMY_LOCATION
@@ -169,15 +169,15 @@ extern void sparc_at_entry_store_struct_return (CORE_ADDR addr, CORE_ADDR sp);
 #define DEPRECATED_PC_IN_CALL_DUMMY(pc, sp, frame_address) deprecated_pc_in_call_dummy_on_stack (pc, sp, frame_address)
 
 /* Insert the function address into the call dummy.  */
-#undef  FIX_CALL_DUMMY
-#define FIX_CALL_DUMMY(dummyname, pc, fun, nargs, args, type, gcc_p) \
+#undef  DEPRECATED_FIX_CALL_DUMMY
+#define DEPRECATED_FIX_CALL_DUMMY(dummyname, pc, fun, nargs, args, type, gcc_p) \
  sparc_fix_call_dummy (dummyname, pc, fun, type, gcc_p)
 void sparc_fix_call_dummy (char *dummy, CORE_ADDR pc, CORE_ADDR fun,
 			   struct type *value_type, int using_gcc);
 
 
 /* The remainder of these will accept the default definition.  */
-#undef  SIZEOF_CALL_DUMMY_WORDS
+#undef  DEPRECATED_SIZEOF_CALL_DUMMY_WORDS
 #undef  DEPRECATED_PUSH_RETURN_ADDRESS
 #undef  CALL_DUMMY_ADDRESS
 #undef  STORE_STRUCT_RETURN
@@ -269,7 +269,7 @@ extern CORE_ADDR sparc64_read_fp ();
 extern void sparc64_write_sp (CORE_ADDR);
 
 #define TARGET_READ_SP() (sparc64_read_sp ())
-#define TARGET_READ_FP() (sparc64_read_fp ())
+#define DEPRECATED_TARGET_READ_FP() (sparc64_read_fp ())
 #define DEPRECATED_DUMMY_WRITE_SP(X) (sparc64_write_sp (X))
 
 #undef DEPRECATED_EXTRACT_RETURN_VALUE
@@ -297,7 +297,7 @@ extern void sp64_extract_return_value (struct type *, char[], char *, int);
 #define	L0_REGNUM 16		/* First local reg that's saved on stack frame
 				   rather than in machine registers */
 #define	I0_REGNUM 24		/* %i0 */
-#define	FP_REGNUM 30		/* Contains address of executing stack frame */
+#define	DEPRECATED_FP_REGNUM 30		/* Contains address of executing stack frame */
 #define	I7_REGNUM 31		/* Last local reg saved on stack frame */
 #define	FP0_REGNUM 32		/* Floating point register 0 */
 #endif
@@ -376,8 +376,8 @@ extern void sp64_extract_return_value (struct type *, char[], char *, int);
    used in push_word and a few other places; REGISTER_RAW_SIZE is the
    real way to know how big a register is.  */
 
-#undef  REGISTER_SIZE
-#define REGISTER_SIZE 8
+#undef  DEPRECATED_REGISTER_SIZE
+#define DEPRECATED_REGISTER_SIZE 8
 
 /* Number of bytes of storage in the actual machine representation
    for register N.  */
diff --git a/gdb/config/sparc/tm-sparc.h b/gdb/config/sparc/tm-sparc.h
index 414b69ec9ce..a44b04ed251 100644
--- a/gdb/config/sparc/tm-sparc.h
+++ b/gdb/config/sparc/tm-sparc.h
@@ -174,7 +174,7 @@ extern int sparc_intreg_size (void);
    used in push_word and a few other places; REGISTER_RAW_SIZE is the
    real way to know how big a register is.  */
 
-#define REGISTER_SIZE 4
+#define DEPRECATED_REGISTER_SIZE 4
 
 /* Number of machine registers */
 
@@ -182,7 +182,7 @@ extern int sparc_intreg_size (void);
 
 #define	SP_REGNUM 14		/* Contains address of top of stack, \
 				   which is also the bottom of the frame.  */
-#define	FP_REGNUM 30		/* Contains address of executing stack frame */
+#define	DEPRECATED_FP_REGNUM 30		/* Contains address of executing stack frame */
 
 #define	FP0_REGNUM 32		/* Floating point register 0 */
 
@@ -201,8 +201,9 @@ extern int sparc_intreg_size (void);
    remove the ins and locals from `registers', make sure that
    frame_register() can get them from the stack (even in the innermost
    frame), and make this the way to access them.  For the frame
-   pointer we would do that via TARGET_READ_FP.  On the other hand,
-   that is likely to be confusing or worse for flat frames.  */
+   pointer we would do that via DEPRECATED_TARGET_READ_FP.  On the
+   other hand, that is likely to be confusing or worse for flat
+   frames.  */
 
 #define REGISTER_BYTES (32*4+32*4+8*4)
 
@@ -545,9 +546,9 @@ extern CORE_ADDR init_frame_pc_noop (int fromleaf, struct frame_info *prev);
  *
  *   call_function then writes CALL_DUMMY, pushes the args onto the
  * stack, and adjusts the stack pointer.
- *
- *   run_stack_dummy then starts execution (in the middle of
- * CALL_DUMMY, as directed by call_function).  */
+ 
+   call_function_by_hand then starts execution (in the middle of
+   CALL_DUMMY, as directed by call_function).  */
 
 #ifndef CALL_DUMMY
 /* This sequence of words is the instructions
@@ -588,19 +589,19 @@ extern CORE_ADDR init_frame_pc_noop (int fromleaf, struct frame_info *prev);
 
 /* Size of the call dummy in bytes. */
 
-#define CALL_DUMMY_LENGTH 0x38
+#define DEPRECATED_CALL_DUMMY_LENGTH 0x38
 
 /* Offset within call dummy of first instruction to execute. */
 
-#define CALL_DUMMY_START_OFFSET 0
+#define DEPRECATED_CALL_DUMMY_START_OFFSET 0
 
 /* Offset within CALL_DUMMY of the 'call' instruction. */
 
-#define CALL_DUMMY_CALL_OFFSET (CALL_DUMMY_START_OFFSET + 0x24)
+#define CALL_DUMMY_CALL_OFFSET (DEPRECATED_CALL_DUMMY_START_OFFSET + 0x24)
 
 /* Offset within CALL_DUMMY of the 'ta 1' trap instruction. */
 
-#define CALL_DUMMY_BREAKPOINT_OFFSET (CALL_DUMMY_START_OFFSET + 0x30)
+#define DEPRECATED_CALL_DUMMY_BREAKPOINT_OFFSET (DEPRECATED_CALL_DUMMY_START_OFFSET + 0x30)
 
 #define DEPRECATED_CALL_DUMMY_STACK_ADJUST 68
 
@@ -625,7 +626,7 @@ extern CORE_ADDR init_frame_pc_noop (int fromleaf, struct frame_info *prev);
 /* Insert the specified number of args and function address
    into a call sequence of the above form stored at DUMMYNAME.  */
 
-#define FIX_CALL_DUMMY(DUMMYNAME, PC, FUN, NARGS, ARGS, TYPE, GCC_P) \
+#define DEPRECATED_FIX_CALL_DUMMY(DUMMYNAME, PC, FUN, NARGS, ARGS, TYPE, GCC_P) \
      sparc_fix_call_dummy (DUMMYNAME, PC, FUN, TYPE, GCC_P)
 void sparc_fix_call_dummy (char *dummy, CORE_ADDR pc, CORE_ADDR fun,
 			   struct type *value_type, int using_gcc);
diff --git a/gdb/config/tm-nto.h b/gdb/config/tm-nto.h
new file mode 100644
index 00000000000..359ff068b7a
--- /dev/null
+++ b/gdb/config/tm-nto.h
@@ -0,0 +1,61 @@
+/* Target machine sub-description for QNX Neutrino version 6.
+   This is included by other tm-*.h files to specify nto specific
+   stuff. 
+
+   Copyright 2003 Free Software Foundation, Inc.
+
+   This code was donated by QNX Software Systems Ltd.
+
+   This file is part of GDB.
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 59 Temple Place - Suite 330,
+   Boston, MA 02111-1307, USA.  */
+
+#ifndef _TM_QNXNTO_H
+#define _TM_QNXNTO_H
+
+#include "tm-sysv4.h"
+
+/* Setup the valid realtime signal range.  */
+#define REALTIME_LO 41
+#define REALTIME_HI 56
+
+/* Set up the undefined useable signals.  */
+#define RAW_SIGNAL_LO 32
+#define RAW_SIGNAL_HI (REALTIME_LO - 1)
+
+#define TARGET_SIGNAL_RAW_VALUES \
+TARGET_SIGNAL_RAW0, \
+TARGET_SIGNAL_RAW1, \
+TARGET_SIGNAL_RAW2, \
+TARGET_SIGNAL_RAW3, \
+TARGET_SIGNAL_RAW4, \
+TARGET_SIGNAL_RAW5, \
+TARGET_SIGNAL_RAW6, \
+TARGET_SIGNAL_RAW7, \
+TARGET_SIGNAL_RAW8
+
+#define TARGET_SIGNAL_RAW_TABLE \
+{"SIGNAL32", "Signal 32"}, \
+{"SIGNAL33", "Signal 33"}, \
+{"SIGNAL34", "Signal 34"}, \
+{"SIGNAL35", "Signal 35"}, \
+{"SIGNAL36", "Signal 36"}, \
+{"SIGNAL37", "Signal 37"}, \
+{"SIGNAL38", "Signal 38"}, \
+{"SIGNAL39", "Signal 39"}, \
+{"SIGNAL40", "Signal 40"}
+
+#endif /* _TM_QNXNTO_H */
diff --git a/gdb/config/vax/nm-vax.h b/gdb/config/vax/nm-vax.h
index efebd6b8936..2518047290f 100644
--- a/gdb/config/vax/nm-vax.h
+++ b/gdb/config/vax/nm-vax.h
@@ -24,6 +24,6 @@
 { addr = blockend - 0110 + regno * 4;			\
   if (regno == PC_REGNUM) addr = blockend - 8;		\
   if (regno == PS_REGNUM) addr = blockend - 4;		\
-  if (regno == FP_REGNUM) addr = blockend - 0120;	\
+  if (regno == DEPRECATED_FP_REGNUM) addr = blockend - 0120;	\
   if (regno == AP_REGNUM) addr = blockend - 0124;	\
   if (regno == SP_REGNUM) addr = blockend - 20; }
diff --git a/gdb/configure.tgt b/gdb/configure.tgt
index aeb9e2718e1..fe4cc5d4856 100644
--- a/gdb/configure.tgt
+++ b/gdb/configure.tgt
@@ -51,6 +51,7 @@ arm*-*-linux*)		gdb_target=linux
 			;;
 arm*-*-netbsd*)		gdb_target=nbsd
 			gdb_multi_arch=yes ;;
+arm-*-nto*)		gdb_target=nto ;;
 arm*-*-* | thumb*-*-* | strongarm*-*-*)
 			gdb_target=embed
                         configdirs="$configdirs rdi-share"
@@ -90,6 +91,7 @@ i[3456]86-*-netbsd*)	gdb_target=nbsd ;;
 i[3456]86-*-openbsd*)	gdb_target=obsd ;;
 i[3456]86-*-go32*)	gdb_target=i386aout ;;
 i[3456]86-*-msdosdjgpp*) gdb_target=go32 ;;
+i[3456]86-*-nto*)	gdb_target=nto ;;
 i[3456]86-*-lynxos*)	gdb_target=i386lynx ;;
 i[3456]86-*-solaris*)	gdb_target=i386sol2 ;;
 i[3456]86-*-sco*)	gdb_target=i386v ;;
@@ -216,6 +218,7 @@ sh-*-linux*)		gdb_target=linux
 			build_gdbserver=yes
 			;;
 sh*-*-netbsdelf*)	gdb_target=nbsd ;;
+sh-*-nto*)		gdb_target=nto ;;
 sh*)			gdb_target=embed ;;
 
 sparc-*-aout*)		gdb_target=sparc-em ;;
@@ -280,5 +283,6 @@ esac
 case "${target}" in
 *-*-linux*)	gdb_osabi=GDB_OSABI_LINUX ;;
 *-*-gnu*)	gdb_osabi=GDB_OSABI_HURD ;;
+*-*-nto*)	gdb_osabi=GDB_OSABI_QNXNTO ;;
 *-*-solaris*)	gdb_osabi=GDB_OSABI_SOLARIS ;;
 esac
diff --git a/gdb/corefile.c b/gdb/corefile.c
index 8a0073a83df..094a3eff0c1 100644
--- a/gdb/corefile.c
+++ b/gdb/corefile.c
@@ -238,28 +238,6 @@ read_memory (CORE_ADDR memaddr, char *myaddr, int len)
     memory_error (status, memaddr);
 }
 
-/* Like target_read_memory, but slightly different parameters.  */
-int
-dis_asm_read_memory (bfd_vma memaddr, bfd_byte *myaddr, unsigned int len,
-		     disassemble_info *info)
-{
-  return target_read_memory (memaddr, (char *) myaddr, len);
-}
-
-/* Like memory_error with slightly different parameters.  */
-void
-dis_asm_memory_error (int status, bfd_vma memaddr, disassemble_info *info)
-{
-  memory_error (status, memaddr);
-}
-
-/* Like print_address with slightly different parameters.  */
-void
-dis_asm_print_address (bfd_vma addr, struct disassemble_info *info)
-{
-  print_address (addr, info->stream);
-}
-
 /* Argument / return result struct for use with
    do_captured_read_memory_integer().  MEMADDR and LEN are filled in
    by gdb_read_memory_integer().  RESULT is the contents that were
diff --git a/gdb/cp-support.c b/gdb/cp-support.c
index ca47854def2..14456f8938f 100644
--- a/gdb/cp-support.c
+++ b/gdb/cp-support.c
@@ -57,16 +57,7 @@ static void first_component_command (char *arg, int from_tty);
      'foo' in an anonymous namespace gets demangled as "(anonymous
      namespace)::foo".
 
-   - And operator names can contain parentheses or angle brackets.
-     Fortunately, I _think_ that operator names can only occur in a
-     fairly restrictive set of locations (in particular, they have be
-     at depth 0, don't they?).  */
-
-/* NOTE: carlton/2003-02-21: Daniel Jacobowitz came up with an example
-   where operator names don't occur at depth 0.  Sigh.  (It involved a
-   template argument that was a pointer: I hadn't realized that was
-   possible.)  Handling such edge cases does not seem like a
-   high-priority problem to me.  */
+   - And operator names can contain parentheses or angle brackets.  */
 
 /* FIXME: carlton/2003-03-13: We have several functions here with
    overlapping functionality; can we combine them?  Also, do they
@@ -209,40 +200,14 @@ method_name_from_physname (const char *physname)
 unsigned int
 cp_find_first_component (const char *name)
 {
-  /* Names like 'operator<<' screw up the recursion, so let's
-     special-case them.  I _hope_ they can only occur at the start of
-     a component.  */
-
   unsigned int index = 0;
-
-  if (strncmp (name, "operator", LENGTH_OF_OPERATOR) == 0)
-    {
-      index += LENGTH_OF_OPERATOR;
-      while (isspace(name[index]))
-	++index;
-      switch (name[index])
-	{
-	case '<':
-	  if (name[index + 1] == '<')
-	    index += 2;
-	  else
-	    index += 1;
-	  break;
-	case '>':
-	case '-':
-	  if (name[index + 1] == '>')
-	    index += 2;
-	  else
-	    index += 1;
-	  break;
-	case '(':
-	  index += 2;
-	  break;
-	default:
-	  index += 1;
-	  break;
-	}
-    }
+  /* Operator names can show up in unexpected places.  Since these can
+     contain parentheses or angle brackets, they can screw up the
+     recursion.  But not every string 'operator' is part of an
+     operater name: e.g. you could have a variable 'cooperator'.  So
+     this variable tells us whether or not we should treat the string
+     'operator' as starting an operator.  */
+  int operator_possible = 1;
 
   for (;; ++index)
     {
@@ -261,6 +226,7 @@ cp_find_first_component (const char *name)
 	      gdb_assert (name[index] == ':');
 	      index += 2;
 	    }
+	  operator_possible = 1;
 	  break;
 	case '(':
 	  /* Similar comment as to '<'.  */
@@ -272,13 +238,63 @@ cp_find_first_component (const char *name)
 	      gdb_assert (name[index] == ':');
 	      index += 2;
 	    }
+	  operator_possible = 1;
 	  break;
 	case '>':
 	case ')':
 	case '\0':
 	case ':':
 	  return index;
+	case 'o':
+	  /* Operator names can screw up the recursion.  */
+	  if (operator_possible
+	      && strncmp (name + index, "operator", LENGTH_OF_OPERATOR) == 0)
+	    {
+	      index += LENGTH_OF_OPERATOR;
+	      while (isspace(name[index]))
+		++index;
+	      switch (name[index])
+		{
+		  /* Skip over one less than the appropriate number of
+		     characters: the for loop will skip over the last
+		     one.  */
+		case '<':
+		  if (name[index + 1] == '<')
+		    index += 1;
+		  else
+		    index += 0;
+		  break;
+		case '>':
+		case '-':
+		  if (name[index + 1] == '>')
+		    index += 1;
+		  else
+		    index += 0;
+		  break;
+		case '(':
+		  index += 1;
+		  break;
+		default:
+		  index += 0;
+		  break;
+		}
+	    }
+	  operator_possible = 0;
+	  break;
+	case ' ':
+	case ',':
+	case '.':
+	case '&':
+	case '*':
+	  /* NOTE: carlton/2003-04-18: I'm not sure what the precise
+	     set of relevant characters are here: it's necessary to
+	     include any character that can show up before 'operator'
+	     in a demangled name, and it's safe to include any
+	     character that can't be part of an identifier's name.  */
+	  operator_possible = 1;
+	  break;
 	default:
+	  operator_possible = 0;
 	  break;
 	}
     }
diff --git a/gdb/cris-tdep.c b/gdb/cris-tdep.c
index f03cd14e269..ff2d6d22abf 100644
--- a/gdb/cris-tdep.c
+++ b/gdb/cris-tdep.c
@@ -53,7 +53,7 @@ enum cris_num_regs
 };
 
 /* Register numbers of various important registers.
-   FP_REGNUM   Contains address of executing stack frame.
+   DEPRECATED_FP_REGNUM   Contains address of executing stack frame.
    STR_REGNUM  Contains the address of structure return values.
    RET_REGNUM  Contains the return value when shorter than or equal to 32 bits
    ARG1_REGNUM Contains the first parameter to a function.
@@ -65,8 +65,8 @@ enum cris_num_regs
    SRP_REGNUM  Subroutine return pointer register.
    BRP_REGNUM  Breakpoint return pointer register.  */
 
-/* FP_REGNUM = 8, SP_REGNUM = 14, and PC_REGNUM = 15 have been incorporated
-   into the multi-arch framework.  */
+/* DEPRECATED_FP_REGNUM = 8, SP_REGNUM = 14, and PC_REGNUM = 15 have
+   been incorporated into the multi-arch framework.  */
 
 enum cris_regnums
 {
@@ -529,7 +529,7 @@ cris_examine (CORE_ADDR ip, CORE_ADDR limit, struct frame_info *fi,
                 }
               get_frame_extra_info (fi)->leaf_function = 0;
             }
-          else if (regno == FP_REGNUM)
+          else if (regno == DEPRECATED_FP_REGNUM)
             {
               have_fp = 1;
             }
@@ -616,7 +616,7 @@ cris_examine (CORE_ADDR ip, CORE_ADDR limit, struct frame_info *fi,
               break;
             }
         }
-      else if (cris_get_operand2 (insn) == FP_REGNUM 
+      else if (cris_get_operand2 (insn) == DEPRECATED_FP_REGNUM 
                /* The size is a fixed-size.  */
                && ((insn & 0x0F00) >> 8) == 0x0001 
                /* A negative offset.  */
@@ -640,7 +640,7 @@ cris_examine (CORE_ADDR ip, CORE_ADDR limit, struct frame_info *fi,
               break;
             }
         }
-      else if (cris_get_operand2 (insn) == FP_REGNUM 
+      else if (cris_get_operand2 (insn) == DEPRECATED_FP_REGNUM 
                /* The size is a fixed-size.  */
                && ((insn & 0x0F00) >> 8) == 0x0001 
                /* A positive offset.  */
@@ -681,7 +681,7 @@ cris_examine (CORE_ADDR ip, CORE_ADDR limit, struct frame_info *fi,
 
   if (have_fp)
     {
-      get_frame_saved_regs (fi)[FP_REGNUM] = get_frame_base (fi);
+      get_frame_saved_regs (fi)[DEPRECATED_FP_REGNUM] = get_frame_base (fi);
       
       /* Calculate the addresses.  */
       for (regno = regsave; regno >= 0; regno--)
@@ -971,7 +971,7 @@ cris_abi_original_store_return_value (struct type *type, char *valbuf)
 {
   int len = TYPE_LENGTH (type);
   
-  if (len <= REGISTER_SIZE) 
+  if (len <= DEPRECATED_REGISTER_SIZE) 
     deprecated_write_register_bytes (REGISTER_BYTE (RET_REGNUM), valbuf, len);
   else
     internal_error (__FILE__, __LINE__, "cris_abi_original_store_return_value: type length too large.");
@@ -984,7 +984,7 @@ cris_abi_v2_store_return_value (struct type *type, char *valbuf)
 {
   int len = TYPE_LENGTH (type);
   
-  if (len <= 2 * REGISTER_SIZE)
+  if (len <= 2 * DEPRECATED_REGISTER_SIZE)
     {
       /* Note that this works since R10 and R11 are consecutive registers.  */
       deprecated_write_register_bytes (REGISTER_BYTE (RET_REGNUM), valbuf,
@@ -1057,7 +1057,7 @@ cris_abi_original_extract_return_value (struct type *type, char *regbuf,
 {
   int len = TYPE_LENGTH (type);
   
-  if (len <= REGISTER_SIZE)
+  if (len <= DEPRECATED_REGISTER_SIZE)
     memcpy (valbuf, regbuf + REGISTER_BYTE (RET_REGNUM), len);
   else
     internal_error (__FILE__, __LINE__, "cris_abi_original_extract_return_value: type length too large");
@@ -1071,7 +1071,7 @@ cris_abi_v2_extract_return_value (struct type *type, char *regbuf,
 {
   int len = TYPE_LENGTH (type);
   
-  if (len <= 2 * REGISTER_SIZE)
+  if (len <= 2 * DEPRECATED_REGISTER_SIZE)
     memcpy (valbuf, regbuf + REGISTER_BYTE (RET_REGNUM), len);
   else
     internal_error (__FILE__, __LINE__, "cris_abi_v2_extract_return_value: type length too large");
@@ -1216,8 +1216,8 @@ cris_init_extra_frame_info (int fromleaf, struct frame_info *fi)
 				   get_frame_base (fi),
 				   get_frame_base (fi)))
     {    
-      /* We need to setup fi->frame here because run_stack_dummy gets it wrong
-         by assuming it's always FP.  */
+      /* We need to setup fi->frame here because call_function_by_hand
+         gets it wrong by assuming it's always FP.  */
       deprecated_update_frame_base_hack (fi, deprecated_read_register_dummy (get_frame_pc (fi), get_frame_base (fi), SP_REGNUM));
       get_frame_extra_info (fi)->return_pc = 
         deprecated_read_register_dummy (get_frame_pc (fi),
@@ -1311,13 +1311,13 @@ cris_abi_original_push_arguments (int nargs, struct value **args,
   /* Make sure there's space on the stack.  Allocate space for data and a 
      parameter to refer to that data.  */
   for (argnum = 0, stack_alloc = 0; argnum < nargs; argnum++)
-    stack_alloc += (TYPE_LENGTH (VALUE_TYPE (args[argnum])) + REGISTER_SIZE);
+    stack_alloc += (TYPE_LENGTH (VALUE_TYPE (args[argnum])) + DEPRECATED_REGISTER_SIZE);
   sp -= stack_alloc;
   /* We may over-allocate a little here, but that won't hurt anything.  */
 
   /* Initialize stack frame pointers.  */
   fp_params = sp;
-  fp_data = sp + (nargs * REGISTER_SIZE);
+  fp_data = sp + (nargs * DEPRECATED_REGISTER_SIZE);
 
   /* Now load as many as possible of the first arguments into
      registers, and push the rest onto the stack.  */
@@ -1330,14 +1330,14 @@ cris_abi_original_push_arguments (int nargs, struct value **args,
       len = TYPE_LENGTH (type);
       val = (char *) VALUE_CONTENTS (args[argnum]);
     
-      if (len <= REGISTER_SIZE && argreg <= ARG4_REGNUM)
+      if (len <= DEPRECATED_REGISTER_SIZE && argreg <= ARG4_REGNUM)
         {
           /* Data fits in a register; put it in the first available 
              register.  */
           write_register (argreg, *(unsigned long *) val);
           argreg++;
         }
-      else if (len > REGISTER_SIZE && argreg <= ARG4_REGNUM)
+      else if (len > DEPRECATED_REGISTER_SIZE && argreg <= ARG4_REGNUM)
         {
           /* Data does not fit in register; pass it on the stack and
              put its address in the first available register.  */
@@ -1346,21 +1346,21 @@ cris_abi_original_push_arguments (int nargs, struct value **args,
           fp_data += len;
           argreg++;      
         }
-      else if (len > REGISTER_SIZE)
+      else if (len > DEPRECATED_REGISTER_SIZE)
         {
           /* Data does not fit in register; put both data and 
              parameter on the stack.  */
           write_memory (fp_data, val, len);
-          write_memory (fp_params, (char *) (&fp_data), REGISTER_SIZE);
+          write_memory (fp_params, (char *) (&fp_data), DEPRECATED_REGISTER_SIZE);
           fp_data += len;
-          fp_params += REGISTER_SIZE;
+          fp_params += DEPRECATED_REGISTER_SIZE;
         }
       else
         {
           /* Data fits in a register, but we are out of registers;
              put the parameter on the stack.  */
-          write_memory (fp_params, val, REGISTER_SIZE);
-          fp_params += REGISTER_SIZE;
+          write_memory (fp_params, val, DEPRECATED_REGISTER_SIZE);
+          fp_params += DEPRECATED_REGISTER_SIZE;
         }
     }
 
@@ -1401,20 +1401,21 @@ cris_abi_v2_push_arguments (int nargs, struct value **args, CORE_ADDR sp,
       int reg_demand;
       
       len = TYPE_LENGTH (VALUE_TYPE (args[argnum]));
-      reg_demand = (len / REGISTER_SIZE) + (len % REGISTER_SIZE != 0 ? 1 : 0);
+      reg_demand = (len / DEPRECATED_REGISTER_SIZE) + (len % DEPRECATED_REGISTER_SIZE != 0 ? 1 : 0);
 
-      /* reg_demand * REGISTER_SIZE is the amount of memory we might need to
-         allocate for this argument.  2 * REGISTER_SIZE is the amount of stack
-         space we might need to pass the argument itself (either by value or by
+      /* reg_demand * DEPRECATED_REGISTER_SIZE is the amount of memory
+         we might need to allocate for this argument.  2 *
+         DEPRECATED_REGISTER_SIZE is the amount of stack space we
+         might need to pass the argument itself (either by value or by
          reference).  */
-      stack_alloc += (reg_demand * REGISTER_SIZE + 2 * REGISTER_SIZE);
+      stack_alloc += (reg_demand * DEPRECATED_REGISTER_SIZE + 2 * DEPRECATED_REGISTER_SIZE);
     }
   sp -= stack_alloc;
   /* We may over-allocate a little here, but that won't hurt anything.  */
 
   /* Initialize frame pointers.  */
   fp_arg = sp;
-  fp_mem = sp + (nargs * (2 * REGISTER_SIZE));
+  fp_mem = sp + (nargs * (2 * DEPRECATED_REGISTER_SIZE));
 
   /* Now load as many as possible of the first arguments into registers,
      and push the rest onto the stack.  */
@@ -1432,9 +1433,9 @@ cris_abi_v2_push_arguments (int nargs, struct value **args, CORE_ADDR sp,
       val = (char *) VALUE_CONTENTS (args[argnum]);
       
       /* How may registers worth of storage do we need for this argument?  */
-      reg_demand = (len / REGISTER_SIZE) + (len % REGISTER_SIZE != 0 ? 1 : 0);
+      reg_demand = (len / DEPRECATED_REGISTER_SIZE) + (len % DEPRECATED_REGISTER_SIZE != 0 ? 1 : 0);
         
-      if (len <= (2 * REGISTER_SIZE)
+      if (len <= (2 * DEPRECATED_REGISTER_SIZE)
           && (argreg + reg_demand - 1 <= ARG4_REGNUM)) 
         {
           /* Data passed by value.  Fits in available register(s).  */
@@ -1442,10 +1443,10 @@ cris_abi_v2_push_arguments (int nargs, struct value **args, CORE_ADDR sp,
             {
               write_register (argreg, *(unsigned long *) val);
               argreg++;
-              val += REGISTER_SIZE;
+              val += DEPRECATED_REGISTER_SIZE;
             }
         }
-      else if (len <= (2 * REGISTER_SIZE) && argreg <= ARG4_REGNUM)
+      else if (len <= (2 * DEPRECATED_REGISTER_SIZE) && argreg <= ARG4_REGNUM)
         {
           /* Data passed by value. Does not fit in available register(s).  
              Use the register(s) first, then the stack.  */
@@ -1455,28 +1456,29 @@ cris_abi_v2_push_arguments (int nargs, struct value **args, CORE_ADDR sp,
                 {
                   write_register (argreg, *(unsigned long *) val);
                   argreg++;
-                  val += REGISTER_SIZE;
+                  val += DEPRECATED_REGISTER_SIZE;
                 }
               else
                 {
-                  /* I guess this memory write could write the remaining data
-                     all at once instead of in REGISTER_SIZE chunks.  */
-                  write_memory (fp_arg, val, REGISTER_SIZE);
-                  fp_arg += REGISTER_SIZE;
-                  val += REGISTER_SIZE;              
+                  /* I guess this memory write could write the
+                     remaining data all at once instead of in
+                     DEPRECATED_REGISTER_SIZE chunks.  */
+                  write_memory (fp_arg, val, DEPRECATED_REGISTER_SIZE);
+                  fp_arg += DEPRECATED_REGISTER_SIZE;
+                  val += DEPRECATED_REGISTER_SIZE;              
                 }
             }    
         }
-      else if (len > (2 * REGISTER_SIZE))
+      else if (len > (2 * DEPRECATED_REGISTER_SIZE))
         {
           /* Data passed by reference.  Put it on the stack.  */
           write_memory (fp_mem, val, len);
-          write_memory (fp_arg, (char *) (&fp_mem), REGISTER_SIZE);
+          write_memory (fp_arg, (char *) (&fp_mem), DEPRECATED_REGISTER_SIZE);
 
           /* fp_mem need not be word-aligned since it's just a chunk of
              memory being pointed at.  That is, += len would do.  */
-          fp_mem += reg_demand * REGISTER_SIZE;
-          fp_arg += REGISTER_SIZE;
+          fp_mem += reg_demand * DEPRECATED_REGISTER_SIZE;
+          fp_arg += DEPRECATED_REGISTER_SIZE;
         }
       else
         {
@@ -1486,7 +1488,7 @@ cris_abi_v2_push_arguments (int nargs, struct value **args, CORE_ADDR sp,
 
           /* fp_arg must be word-aligned (i.e., don't += len) to match
              the function prologue.  */
-          fp_arg += reg_demand * REGISTER_SIZE;
+          fp_arg += reg_demand * DEPRECATED_REGISTER_SIZE;
         }
     }
 
@@ -1536,7 +1538,7 @@ cris_pop_frame (void)
                                                      
       /* Restore general registers R0 - R7.  They were pushed on the stack 
          after SP was saved.  */
-      for (regno = 0; regno < FP_REGNUM; regno++)
+      for (regno = 0; regno < DEPRECATED_FP_REGNUM; regno++)
         {
           if (get_frame_saved_regs (fi)[regno])
             {
@@ -1545,12 +1547,12 @@ cris_pop_frame (void)
             }
         }
      
-      if (get_frame_saved_regs (fi)[FP_REGNUM])
+      if (get_frame_saved_regs (fi)[DEPRECATED_FP_REGNUM])
         {
           /* Pop the frame pointer (R8).  It was pushed before SP 
              was saved.  */
-          write_register (FP_REGNUM, 
-                          read_memory_integer (get_frame_saved_regs (fi)[FP_REGNUM], 4));
+          write_register (DEPRECATED_FP_REGNUM, 
+                          read_memory_integer (get_frame_saved_regs (fi)[DEPRECATED_FP_REGNUM], 4));
           stack_offset += 4;
 
           /* Not a leaf function.  */
@@ -1561,7 +1563,7 @@ cris_pop_frame (void)
             }
       
           /* Restore the SP and adjust for R8 and (possibly) SRP.  */
-          write_register (SP_REGNUM, get_frame_saved_regs (fi)[FP_REGNUM] + stack_offset);
+          write_register (SP_REGNUM, get_frame_saved_regs (fi)[DEPRECATED_FP_REGNUM] + stack_offset);
         } 
       else
         {
@@ -3548,7 +3550,7 @@ static void cris_gdb_func (enum cris_op_type op_type, unsigned short inst,
 static int
 cris_delayed_get_disassembler (bfd_vma addr, disassemble_info *info)
 {
-  tm_print_insn = cris_get_disassembler (exec_bfd);
+  deprecated_tm_print_insn = cris_get_disassembler (exec_bfd);
   return TARGET_PRINT_INSN (addr, info);
 }
 
@@ -3861,7 +3863,7 @@ _initialize_cris_tdep (void)
   gdbarch_register (bfd_arch_cris, cris_gdbarch_init, cris_dump_tdep);
   
   /* Used in disassembly.  */
-  tm_print_insn = cris_delayed_get_disassembler;
+  deprecated_tm_print_insn = cris_delayed_get_disassembler;
 
   /* CRIS-specific user-commands.  */
   c = add_set_cmd ("cris-version", class_support, var_integer, 
@@ -4182,14 +4184,14 @@ cris_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
   /* There are 32 registers (some of which may not be implemented).  */
   set_gdbarch_num_regs (gdbarch, 32);
   set_gdbarch_sp_regnum (gdbarch, 14);
-  set_gdbarch_fp_regnum (gdbarch, 8);
+  set_gdbarch_deprecated_fp_regnum (gdbarch, 8);
   set_gdbarch_pc_regnum (gdbarch, 15);
 
   set_gdbarch_register_name (gdbarch, cris_register_name);
   
   /* Length of ordinary registers used in push_word and a few other places. 
      REGISTER_RAW_SIZE is the real way to know how big a register is.  */
-  set_gdbarch_register_size (gdbarch, 4);
+  set_gdbarch_deprecated_register_size (gdbarch, 4);
   
   /* NEW */
   set_gdbarch_register_bytes_ok (gdbarch, cris_register_bytes_ok);
@@ -4260,8 +4262,8 @@ cris_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
   
   /* Defined to 1 to indicate that the target supports inferior function 
      calls.  */
-  set_gdbarch_call_dummy_words (gdbarch, 0);
-  set_gdbarch_sizeof_call_dummy_words (gdbarch, 0);
+  set_gdbarch_deprecated_call_dummy_words (gdbarch, 0);
+  set_gdbarch_deprecated_sizeof_call_dummy_words (gdbarch, 0);
   
   set_gdbarch_deprecated_get_saved_register (gdbarch, deprecated_generic_get_saved_register);
   
diff --git a/gdb/d10v-tdep.c b/gdb/d10v-tdep.c
index 45ac6820a1a..c184b4457e7 100644
--- a/gdb/d10v-tdep.c
+++ b/gdb/d10v-tdep.c
@@ -43,6 +43,7 @@
 #include "floatformat.h"
 #include "gdb/sim-d10v.h"
 #include "sim-regno.h"
+#include "disasm.h"
 
 #include "gdb_assert.h"
 
@@ -50,8 +51,8 @@ struct gdbarch_tdep
   {
     int a0_regnum;
     int nr_dmap_regs;
-    unsigned long (*dmap_register) (int nr);
-    unsigned long (*imap_register) (int nr);
+    unsigned long (*dmap_register) (void *regcache, int nr);
+    unsigned long (*imap_register) (void *regcache, int nr);
   };
 
 /* These are the addresses the D10V-EVA board maps data and
@@ -71,9 +72,9 @@ enum
     R3_REGNUM = 3,
     D10V_FP_REGNUM = 11,
     LR_REGNUM = 13,
-    _SP_REGNUM = 15,
+    D10V_SP_REGNUM = 15,
     PSW_REGNUM = 16,
-    _PC_REGNUM = 18,
+    D10V_PC_REGNUM = 18,
     NR_IMAP_REGS = 2,
     NR_A_REGS = 2,
     TS2_NUM_REGS = 37,
@@ -84,8 +85,17 @@ enum
     RET1_REGNUM = R0_REGNUM,
   };
 
-#define NR_DMAP_REGS (gdbarch_tdep (current_gdbarch)->nr_dmap_regs)
-#define A0_REGNUM (gdbarch_tdep (current_gdbarch)->a0_regnum)
+int
+nr_dmap_regs (struct gdbarch *gdbarch)
+{
+  return gdbarch_tdep (gdbarch)->nr_dmap_regs;
+}
+
+int
+a0_regnum (struct gdbarch *gdbarch)
+{
+  return gdbarch_tdep (gdbarch)->a0_regnum;
+}
 
 /* Local functions */
 
@@ -93,16 +103,16 @@ extern void _initialize_d10v_tdep (void);
 
 static CORE_ADDR d10v_read_sp (void);
 
-static CORE_ADDR d10v_read_fp (void);
-
 static void d10v_eva_prepare_to_trace (void);
 
 static void d10v_eva_get_trace_data (void);
 
 static CORE_ADDR
-d10v_stack_align (CORE_ADDR len)
+d10v_frame_align (struct gdbarch *gdbarch, CORE_ADDR sp)
 {
-  return (len + 1) & ~1;
+  /* Align to the size of an instruction (so that they can safely be
+     pushed onto the stack.  */
+  return sp & ~3;
 }
 
 /* Should we use EXTRACT_STRUCT_VALUE_ADDRESS instead of
@@ -226,7 +236,7 @@ d10v_ts3_register_name (int reg_nr)
    one of the segments.  */
 
 static unsigned long
-d10v_ts2_dmap_register (int reg_nr)
+d10v_ts2_dmap_register (void *regcache, int reg_nr)
 {
   switch (reg_nr)
     {
@@ -234,40 +244,38 @@ d10v_ts2_dmap_register (int reg_nr)
     case 1:
       return 0x2000;
     case 2:
-      return read_register (TS2_DMAP_REGNUM);
+      {
+	ULONGEST reg;
+	regcache_cooked_read_unsigned (regcache, TS2_DMAP_REGNUM, &reg);
+	return reg;
+      }
     default:
       return 0;
     }
 }
 
 static unsigned long
-d10v_ts3_dmap_register (int reg_nr)
-{
-  return read_register (TS3_DMAP0_REGNUM + reg_nr);
-}
-
-static unsigned long
-d10v_dmap_register (int reg_nr)
+d10v_ts3_dmap_register (void *regcache, int reg_nr)
 {
-  return gdbarch_tdep (current_gdbarch)->dmap_register (reg_nr);
+  ULONGEST reg;
+  regcache_cooked_read_unsigned (regcache, TS3_DMAP0_REGNUM + reg_nr, &reg);
+  return reg;
 }
 
 static unsigned long
-d10v_ts2_imap_register (int reg_nr)
+d10v_ts2_imap_register (void *regcache, int reg_nr)
 {
-  return read_register (TS2_IMAP0_REGNUM + reg_nr);
+  ULONGEST reg;
+  regcache_cooked_read_unsigned (regcache, TS2_IMAP0_REGNUM + reg_nr, &reg);
+  return reg;
 }
 
 static unsigned long
-d10v_ts3_imap_register (int reg_nr)
+d10v_ts3_imap_register (void *regcache, int reg_nr)
 {
-  return read_register (TS3_IMAP0_REGNUM + reg_nr);
-}
-
-static unsigned long
-d10v_imap_register (int reg_nr)
-{
-  return gdbarch_tdep (current_gdbarch)->imap_register (reg_nr);
+  ULONGEST reg;
+  regcache_cooked_read_unsigned (regcache, TS3_IMAP0_REGNUM + reg_nr, &reg);
+  return reg;
 }
 
 /* MAP GDB's internal register numbering (determined by the layout fo
@@ -307,49 +315,18 @@ d10v_ts3_register_sim_regno (int nr)
   return nr;
 }
 
-/* Index within `registers' of the first byte of the space for
-   register REG_NR.  */
-
-static int
-d10v_register_byte (int reg_nr)
-{
-  if (reg_nr < A0_REGNUM)
-    return (reg_nr * 2);
-  else if (reg_nr < (A0_REGNUM + NR_A_REGS))
-    return (A0_REGNUM * 2
-	    + (reg_nr - A0_REGNUM) * 8);
-  else
-    return (A0_REGNUM * 2
-	    + NR_A_REGS * 8
-	    + (reg_nr - A0_REGNUM - NR_A_REGS) * 2);
-}
-
-/* Number of bytes of storage in the actual machine representation for
-   register REG_NR.  */
-
-static int
-d10v_register_raw_size (int reg_nr)
-{
-  if (reg_nr < A0_REGNUM)
-    return 2;
-  else if (reg_nr < (A0_REGNUM + NR_A_REGS))
-    return 8;
-  else
-    return 2;
-}
-
 /* Return the GDB type object for the "standard" data type
    of data in register N.  */
 
 static struct type *
 d10v_register_type (struct gdbarch *gdbarch, int reg_nr)
 {
-  if (reg_nr == PC_REGNUM)
+  if (reg_nr == D10V_PC_REGNUM)
     return builtin_type_void_func_ptr;
-  if (reg_nr == _SP_REGNUM || reg_nr == D10V_FP_REGNUM)
+  if (reg_nr == D10V_SP_REGNUM || reg_nr == D10V_FP_REGNUM)
     return builtin_type_void_data_ptr;
-  else if (reg_nr >= A0_REGNUM
-      && reg_nr < (A0_REGNUM + NR_A_REGS))
+  else if (reg_nr >= a0_regnum (gdbarch)
+	   && reg_nr < (a0_regnum (gdbarch) + NR_A_REGS))
     return builtin_type_int64;
   else
     return builtin_type_int16;
@@ -415,8 +392,7 @@ d10v_address_to_pointer (struct type *type, void *buf, CORE_ADDR addr)
 static CORE_ADDR
 d10v_pointer_to_address (struct type *type, const void *buf)
 {
-  CORE_ADDR addr = extract_address (buf, TYPE_LENGTH (type));
-
+  CORE_ADDR addr = extract_unsigned_integer (buf, TYPE_LENGTH (type));
   /* Is it a code address?  */
   if (TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_FUNC
       || TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_METHOD
@@ -702,7 +678,7 @@ d10v_frame_unwind_cache (struct frame_info *next_frame,
 
   info = FRAME_OBSTACK_ZALLOC (struct d10v_unwind_cache);
   (*this_prologue_cache) = info;
-  info->saved_regs = frame_obstack_zalloc (SIZEOF_FRAME_SAVED_REGS);
+  info->saved_regs = FRAME_OBSTACK_CALLOC (NUM_REGS, CORE_ADDR);
 
   info->size = 0;
   info->return_pc = 0;
@@ -773,20 +749,20 @@ d10v_frame_unwind_cache (struct frame_info *next_frame,
          to before the first saved register giving the SP.  */
       prev_sp = this_base + info->size;
     }
-  else if (info->saved_regs[SP_REGNUM])
+  else if (info->saved_regs[D10V_SP_REGNUM])
     {
       /* The SP was saved (which is very unusual), the frame base is
 	 just the PREV's frame's TOP-OF-STACK.  */
-      this_base = read_memory_unsigned_integer (info->saved_regs[SP_REGNUM], 
+      this_base = read_memory_unsigned_integer (info->saved_regs[D10V_SP_REGNUM], 
 						register_size (current_gdbarch,
-							       SP_REGNUM));
+							       D10V_SP_REGNUM));
       prev_sp = this_base;
     }
   else
     {
       /* Assume that the FP is this frame's SP but with that pushed
          stack space added back.  */
-      frame_unwind_unsigned_register (next_frame, SP_REGNUM, &this_base);
+      frame_unwind_unsigned_register (next_frame, D10V_SP_REGNUM, &this_base);
       prev_sp = this_base + info->size;
     }
 
@@ -815,9 +791,9 @@ d10v_frame_unwind_cache (struct frame_info *next_frame,
       info->return_pc = d10v_make_iaddr (return_pc);
     }
 
-  /* The SP_REGNUM is special.  Instead of the address of the SP, the
+  /* The D10V_SP_REGNUM is special.  Instead of the address of the SP, the
      previous frame's SP value is saved.  */
-  info->saved_regs[SP_REGNUM] = info->prev_sp;
+  info->saved_regs[D10V_SP_REGNUM] = info->prev_sp;
 
   return info;
 }
@@ -826,6 +802,7 @@ static void
 d10v_print_registers_info (struct gdbarch *gdbarch, struct ui_file *file,
 			   struct frame_info *frame, int regnum, int all)
 {
+  struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
   if (regnum >= 0)
     {
       default_print_registers_info (gdbarch, file, frame, regnum, all);
@@ -834,7 +811,7 @@ d10v_print_registers_info (struct gdbarch *gdbarch, struct ui_file *file,
 
   {
     ULONGEST pc, psw, rpt_s, rpt_e, rpt_c;
-    frame_read_unsigned_register (frame, PC_REGNUM, &pc);
+    frame_read_unsigned_register (frame, D10V_PC_REGNUM, &pc);
     frame_read_unsigned_register (frame, PSW_REGNUM, &psw);
     frame_read_unsigned_register (frame, frame_map_name_to_regnum ("rpt_s", -1), &rpt_s);
     frame_read_unsigned_register (frame, frame_map_name_to_regnum ("rpt_e", -1), &rpt_e);
@@ -869,31 +846,34 @@ d10v_print_registers_info (struct gdbarch *gdbarch, struct ui_file *file,
       {
 	if (a > 0)
 	  fprintf_filtered (file, "    ");
-	fprintf_filtered (file, "IMAP%d %04lx", a, d10v_imap_register (a));
+	fprintf_filtered (file, "IMAP%d %04lx", a,
+			  tdep->imap_register (current_regcache, a));
       }
-    if (NR_DMAP_REGS == 1)
+    if (nr_dmap_regs (gdbarch) == 1)
       /* Registers DMAP0 and DMAP1 are constant.  Just return dmap2.  */
-      fprintf_filtered (file, "    DMAP %04lx\n", d10v_dmap_register (2));
+      fprintf_filtered (file, "    DMAP %04lx\n",
+			tdep->dmap_register (current_regcache, 2));
     else
       {
-	for (a = 0; a < NR_DMAP_REGS; a++)
+	for (a = 0; a < nr_dmap_regs (gdbarch); a++)
 	  {
-	    fprintf_filtered (file, "    DMAP%d %04lx", a, d10v_dmap_register (a));
+	    fprintf_filtered (file, "    DMAP%d %04lx", a,
+			      tdep->dmap_register (current_regcache, a));
 	  }
 	fprintf_filtered (file, "\n");
       }
   }
 
   {
-    char *num = alloca (max_register_size (gdbarch));
+    char num[MAX_REGISTER_SIZE];
     int a;
     fprintf_filtered (file, "A0-A%d", NR_A_REGS - 1);
-    for (a = A0_REGNUM; a < A0_REGNUM + NR_A_REGS; a++)
+    for (a = a0_regnum (gdbarch); a < a0_regnum (gdbarch) + NR_A_REGS; a++)
       {
 	int i;
 	fprintf_filtered (file, "  ");
-	frame_register_read (frame, a, num);
-	for (i = 0; i < max_register_size (current_gdbarch); i++)
+	frame_read_register (frame, a, num);
+	for (i = 0; i < register_size (current_gdbarch, a); i++)
 	  {
 	    fprintf_filtered (file, "%02x", (num[i] & 0xff));
 	  }
@@ -918,7 +898,7 @@ d10v_read_pc (ptid_t ptid)
 
   save_ptid = inferior_ptid;
   inferior_ptid = ptid;
-  pc = (int) read_register (PC_REGNUM);
+  pc = (int) read_register (D10V_PC_REGNUM);
   inferior_ptid = save_ptid;
   retval = d10v_make_iaddr (pc);
   return retval;
@@ -931,20 +911,14 @@ d10v_write_pc (CORE_ADDR val, ptid_t ptid)
 
   save_ptid = inferior_ptid;
   inferior_ptid = ptid;
-  write_register (PC_REGNUM, d10v_convert_iaddr_to_raw (val));
+  write_register (D10V_PC_REGNUM, d10v_convert_iaddr_to_raw (val));
   inferior_ptid = save_ptid;
 }
 
 static CORE_ADDR
 d10v_read_sp (void)
 {
-  return (d10v_make_daddr (read_register (SP_REGNUM)));
-}
-
-static CORE_ADDR
-d10v_read_fp (void)
-{
-  return (d10v_make_daddr (read_register (D10V_FP_REGNUM)));
+  return (d10v_make_daddr (read_register (D10V_SP_REGNUM)));
 }
 
 /* When arguments must be pushed onto the stack, they go on in reverse
@@ -984,6 +958,25 @@ pop_stack_item (struct stack_item *si)
 
 
 static CORE_ADDR
+d10v_push_dummy_code (struct gdbarch *gdbarch,
+		      CORE_ADDR sp, CORE_ADDR funaddr, int using_gcc,
+		      struct value **args, int nargs,
+		      struct type *value_type,
+		      CORE_ADDR *real_pc, CORE_ADDR *bp_addr)
+{
+  /* Allocate space sufficient for a breakpoint.  */
+  sp = (sp - 4) & ~3;
+  /* Store the address of that breakpoint taking care to first convert
+     it into a code (IADDR) address from a stack (DADDR) address.
+     This of course assumes that the two virtual addresses map onto
+     the same real address.  */
+  (*bp_addr) = d10v_make_iaddr (d10v_convert_iaddr_to_raw (sp));
+  /* d10v always starts the call at the callee's entry point.  */
+  (*real_pc) = funaddr;
+  return sp;
+}
+
+static CORE_ADDR
 d10v_push_dummy_call (struct gdbarch *gdbarch, struct regcache *regcache,
 		      CORE_ADDR dummy_addr, int nargs, struct value **args,
 		      CORE_ADDR sp, int struct_return, CORE_ADDR struct_addr)
@@ -1056,7 +1049,7 @@ d10v_push_dummy_call (struct gdbarch *gdbarch, struct regcache *regcache,
     }
 
   /* Finally, update the SP register.  */
-  regcache_cooked_write_unsigned (regcache, SP_REGNUM,
+  regcache_cooked_write_unsigned (regcache, D10V_SP_REGNUM,
 				  d10v_convert_daddr_to_raw (sp));
 
   return sp;
@@ -1071,12 +1064,6 @@ d10v_extract_return_value (struct type *type, struct regcache *regcache,
 			   void *valbuf)
 {
   int len;
-#if 0
-  printf("RET: TYPE=%d len=%d r%d=0x%x\n", TYPE_CODE (type), 
-	 TYPE_LENGTH (type), RET1_REGNUM - R0_REGNUM, 
-	 (int) extract_unsigned_integer (regbuf + REGISTER_BYTE(RET1_REGNUM), 
-					 register_size (current_gdbarch, RET1_REGNUM)));
-#endif
   if (TYPE_LENGTH (type) == 1)
     {
       ULONGEST c;
@@ -1115,15 +1102,16 @@ d10v_extract_return_value (struct type *type, struct regcache *regcache,
    VM system works, we just call that to do the translation. */
 
 static void
-remote_d10v_translate_xfer_address (CORE_ADDR memaddr, int nr_bytes,
+remote_d10v_translate_xfer_address (struct gdbarch *gdbarch,
+				    struct regcache *regcache,
+				    CORE_ADDR memaddr, int nr_bytes,
 				    CORE_ADDR *targ_addr, int *targ_len)
 {
+  struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
   long out_addr;
   long out_len;
-  out_len = sim_d10v_translate_addr (memaddr, nr_bytes,
-				     &out_addr,
-				     d10v_dmap_register,
-				     d10v_imap_register);
+  out_len = sim_d10v_translate_addr (memaddr, nr_bytes, &out_addr, regcache,
+				     tdep->dmap_register, tdep->imap_register);
   *targ_addr = out_addr;
   *targ_len = out_len;
 }
@@ -1195,9 +1183,9 @@ trace_command (char *args, int from_tty)
   /* Clear the host-side trace buffer, allocating space if needed.  */
   trace_data.size = 0;
   if (trace_data.counts == NULL)
-    trace_data.counts = (short *) xmalloc (65536 * sizeof (short));
+    trace_data.counts = XCALLOC (65536, short);
   if (trace_data.addrs == NULL)
-    trace_data.addrs = (CORE_ADDR *) xmalloc (65536 * sizeof (CORE_ADDR));
+    trace_data.addrs = XCALLOC (65536, CORE_ADDR);
 
   tracing = 1;
 
@@ -1236,31 +1224,13 @@ trace_info (char *args, int from_tty)
   printf_filtered ("Tracing is currently %s.\n", (tracing ? "on" : "off"));
 }
 
-/* Print the instruction at address MEMADDR in debugged memory,
-   on STREAM.  Returns length of the instruction, in bytes.  */
-
-static int
-print_insn (CORE_ADDR memaddr, struct ui_file *stream)
-{
-  /* If there's no disassembler, something is very wrong.  */
-  if (tm_print_insn == NULL)
-    internal_error (__FILE__, __LINE__,
-		    "print_insn: no disassembler");
-
-  if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG)
-    tm_print_insn_info.endian = BFD_ENDIAN_BIG;
-  else
-    tm_print_insn_info.endian = BFD_ENDIAN_LITTLE;
-  return TARGET_PRINT_INSN (memaddr, &tm_print_insn_info);
-}
-
 static void
 d10v_eva_prepare_to_trace (void)
 {
   if (!tracing)
     return;
 
-  last_pc = read_register (PC_REGNUM);
+  last_pc = read_register (D10V_PC_REGNUM);
 }
 
 /* Collect trace data from the target board and format it into a form
@@ -1414,7 +1384,7 @@ display_trace (int low, int high)
 	  printf_filtered (":");
 	  printf_filtered ("\t");
 	  wrap_here ("    ");
-	  next_address = next_address + print_insn (next_address, gdb_stdout);
+	  next_address += gdb_print_insn (next_address, gdb_stdout);
 	  printf_filtered ("\n");
 	  gdb_flush (gdb_stdout);
 	}
@@ -1425,7 +1395,7 @@ static CORE_ADDR
 d10v_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame)
 {
   ULONGEST pc;
-  frame_unwind_unsigned_register (next_frame, PC_REGNUM, &pc);
+  frame_unwind_unsigned_register (next_frame, D10V_PC_REGNUM, &pc);
   return d10v_make_iaddr (pc);
 }
 
@@ -1481,7 +1451,7 @@ saved_regs_unwinder (struct frame_info *next_frame,
 {
   if (this_saved_regs[regnum] != 0)
     {
-      if (regnum == SP_REGNUM)
+      if (regnum == D10V_SP_REGNUM)
 	{
 	  /* SP register treated specially.  */
 	  *optimizedp = 0;
@@ -1489,8 +1459,9 @@ saved_regs_unwinder (struct frame_info *next_frame,
 	  *addrp = 0;
 	  *realnump = -1;
 	  if (bufferp != NULL)
-	    store_address (bufferp, register_size (current_gdbarch, regnum),
-			   this_saved_regs[regnum]);
+	    store_unsigned_integer (bufferp,
+				    register_size (current_gdbarch, regnum),
+				    this_saved_regs[regnum]);
 	}
       else
 	{
@@ -1528,7 +1499,7 @@ d10v_frame_prev_register (struct frame_info *next_frame,
 {
   struct d10v_unwind_cache *info
     = d10v_frame_unwind_cache (next_frame, this_prologue_cache);
-  if (regnum == PC_REGNUM)
+  if (regnum == D10V_PC_REGNUM)
     {
       /* The call instruction saves the caller's PC in LR.  The
 	 function prologue of the callee may then save the LR on the
@@ -1579,7 +1550,7 @@ static struct frame_id
 d10v_unwind_dummy_id (struct gdbarch *gdbarch, struct frame_info *next_frame)
 {
   ULONGEST base;
-  frame_unwind_unsigned_register (next_frame, SP_REGNUM, &base);
+  frame_unwind_unsigned_register (next_frame, D10V_SP_REGNUM, &base);
   return frame_id_build (d10v_make_daddr (base), frame_pc_unwind (next_frame));
 }
 
@@ -1629,18 +1600,11 @@ d10v_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
 
   set_gdbarch_read_pc (gdbarch, d10v_read_pc);
   set_gdbarch_write_pc (gdbarch, d10v_write_pc);
-  set_gdbarch_read_fp (gdbarch, d10v_read_fp);
   set_gdbarch_read_sp (gdbarch, d10v_read_sp);
 
   set_gdbarch_num_regs (gdbarch, d10v_num_regs);
-  set_gdbarch_sp_regnum (gdbarch, 15);
-  set_gdbarch_pc_regnum (gdbarch, 18);
+  set_gdbarch_sp_regnum (gdbarch, D10V_SP_REGNUM);
   set_gdbarch_register_name (gdbarch, d10v_register_name);
-  set_gdbarch_register_size (gdbarch, 2);
-  set_gdbarch_register_bytes (gdbarch, (d10v_num_regs - 2) * 2 + 16);
-  set_gdbarch_register_byte (gdbarch, d10v_register_byte);
-  set_gdbarch_register_raw_size (gdbarch, d10v_register_raw_size);
-  set_gdbarch_register_virtual_size (gdbarch, generic_register_size);
   set_gdbarch_register_type (gdbarch, d10v_register_type);
 
   set_gdbarch_ptr_bit (gdbarch, 2 * TARGET_CHAR_BIT);
@@ -1675,6 +1639,7 @@ d10v_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
     }
 
   set_gdbarch_extract_return_value (gdbarch, d10v_extract_return_value);
+  set_gdbarch_push_dummy_code (gdbarch, d10v_push_dummy_code);
   set_gdbarch_push_dummy_call (gdbarch, d10v_push_dummy_call);
   set_gdbarch_store_return_value (gdbarch, d10v_store_return_value);
   set_gdbarch_extract_struct_value_address (gdbarch, d10v_extract_struct_value_address);
@@ -1692,7 +1657,7 @@ d10v_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
   set_gdbarch_frameless_function_invocation (gdbarch, frameless_look_for_prologue);
 
   set_gdbarch_frame_num_args (gdbarch, frame_num_args_unknown);
-  set_gdbarch_stack_align (gdbarch, d10v_stack_align);
+  set_gdbarch_frame_align (gdbarch, d10v_frame_align);
 
   set_gdbarch_register_sim_regno (gdbarch, d10v_register_sim_regno);
 
@@ -1708,6 +1673,8 @@ d10v_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
   /* Return the unwound PC value.  */
   set_gdbarch_unwind_pc (gdbarch, d10v_unwind_pc);
 
+  set_gdbarch_print_insn (gdbarch, print_insn_d10v);
+
   return gdbarch;
 }
 
@@ -1716,8 +1683,6 @@ _initialize_d10v_tdep (void)
 {
   register_gdbarch_init (bfd_arch_d10v, d10v_gdbarch_init);
 
-  tm_print_insn = print_insn_d10v;
-
   target_resume_hook = d10v_eva_prepare_to_trace;
   target_wait_loop_hook = d10v_eva_get_trace_data;
 
@@ -1738,13 +1703,13 @@ as reported by info trace (NOT addresses!).");
   add_info ("itrace", trace_info,
 	    "Display info about the trace data buffer.");
 
-  add_show_from_set (add_set_cmd ("itracedisplay", no_class,
-				  var_integer, (char *) &trace_display,
-			     "Set automatic display of trace.\n", &setlist),
-		     &showlist);
-  add_show_from_set (add_set_cmd ("itracesource", no_class,
-			   var_integer, (char *) &default_trace_show_source,
-		      "Set display of source code with trace.\n", &setlist),
-		     &showlist);
-
+  add_setshow_boolean_cmd ("itracedisplay", no_class, &trace_display,
+			   "Set automatic display of trace.\n",
+			   "Show automatic display of trace.\n",
+			   NULL, NULL, &setlist, &showlist);
+  add_setshow_boolean_cmd ("itracesource", no_class,
+			   &default_trace_show_source,
+			   "Set display of source code with trace.\n",
+			   "Show display of source code with trace.\n",
+			   NULL, NULL, &setlist, &showlist);
 }
diff --git a/gdb/defs.h b/gdb/defs.h
index 35d23df9caa..d4427830639 100644
--- a/gdb/defs.h
+++ b/gdb/defs.h
@@ -211,7 +211,8 @@ enum language
     language_m2,		/* Modula-2 */
     language_asm,		/* Assembly language */
     language_scm,    		/* Scheme / Guile */
-    language_pascal		/* Pascal */
+    language_pascal,		/* Pascal */
+    language_minimal		/* All other languages, minimal support only */
   };
 
 enum precision_type
@@ -1085,28 +1086,10 @@ extern void *alloca ();
 #include "arch-utils.h"
 #endif
 
-/* FIXME: cagney/2003-03-01: Hack to prop up old targets while they
-   migrate to the overhauled register cache.
-
-   The problem is that some architectures specify different sized raw
-   and cooked (nee virtual) register sizes.  They shouldn't.  Instead,
-   all architectures should just implement a gdbarch_register_type().
-   That can be used to compute all needed register attributes.  While
-   waiting for the conversion, provide compatibility macros that keep
-   old code working.  */
-
-#ifdef MAX_REGISTER_RAW_SIZE
-#error MAX_REGISTER_RAW_SIZE defined
-#endif
-extern int legacy_max_register_raw_size (void);
-#define MAX_REGISTER_RAW_SIZE legacy_max_register_raw_size ()
-
-#ifdef MAX_REGISTER_VIRTUAL_SIZE
-#error MAX_REGISTER_VIRTUAL_SIZE defined
-#endif
-extern int legacy_max_register_virtual_size (void);
-#define MAX_REGISTER_VIRTUAL_SIZE legacy_max_register_virtual_size ()
+/* Maximum size of a register.  Something small, but large enough for
+   all known ISAs.  If it turns out to be too small, make it bigger.  */
 
+enum { MAX_REGISTER_SIZE = 16 };
 
 /* Static target-system-dependent parameters for GDB. */
 
diff --git a/gdb/disasm.c b/gdb/disasm.c
index 511855b5901..c8a2029bae8 100644
--- a/gdb/disasm.c
+++ b/gdb/disasm.c
@@ -24,8 +24,8 @@
 #include "value.h"
 #include "ui-out.h"
 #include "gdb_string.h"
-
 #include "disasm.h"
+#include "gdbcore.h"
 
 /* Disassemble functions.
    FIXME: We should get rid of all the duplicate code in gdb that does
@@ -43,27 +43,26 @@ struct dis_line_entry
   CORE_ADDR end_pc;
 };
 
-/* This variable determines where memory used for disassembly is read from. */
-int gdb_disassemble_from_exec = -1;
-
-/* This is the memory_read_func for gdb_disassemble when we are
-   disassembling from the exec file. */
+/* Like target_read_memory, but slightly different parameters.  */
 static int
-gdb_dis_asm_read_memory (bfd_vma memaddr, bfd_byte * myaddr,
-			 unsigned int len, disassemble_info * info)
+dis_asm_read_memory (bfd_vma memaddr, bfd_byte *myaddr, unsigned int len,
+		     disassemble_info *info)
+{
+  return target_read_memory (memaddr, (char *) myaddr, len);
+}
+
+/* Like memory_error with slightly different parameters.  */
+static void
+dis_asm_memory_error (int status, bfd_vma memaddr, disassemble_info *info)
+{
+  memory_error (status, memaddr);
+}
+
+/* Like print_address with slightly different parameters.  */
+static void
+dis_asm_print_address (bfd_vma addr, struct disassemble_info *info)
 {
-  extern struct target_ops exec_ops;
-  int res;
-
-  errno = 0;
-  res = xfer_memory (memaddr, myaddr, len, 0, 0, &exec_ops);
-
-  if (res == len)
-    return 0;
-  else if (errno == 0)
-    return EIO;
-  else
-    return errno;
+  print_address (addr, info->stream);
 }
 
 static int
@@ -308,6 +307,32 @@ do_assembly_only (struct ui_out *uiout, disassemble_info * di,
   do_cleanups (ui_out_chain);
 }
 
+/* Initialize the disassemble info struct ready for the specified
+   stream.  */
+
+static disassemble_info
+gdb_disassemble_info (struct gdbarch *gdbarch, struct ui_file *file)
+{
+  disassemble_info di;
+  INIT_DISASSEMBLE_INFO_NO_ARCH (di, file,
+				 (fprintf_ftype) fprintf_unfiltered);
+  di.flavour = bfd_target_unknown_flavour;
+  di.memory_error_func = dis_asm_memory_error;
+  di.print_address_func = dis_asm_print_address;
+  /* NOTE: cagney/2003-04-28: The original code, from the old Insight
+     disassembler had a local optomization here.  By default it would
+     access the executable file, instead of the target memory (there
+     was a growing list of exceptions though).  Unfortunatly, the
+     heuristic was flawed.  Commands like "disassemble &variable"
+     didn't work as they relied on the access going to the target.
+     Further, it has been supperseeded by trust-read-only-sections
+     (although that should be superseeded by target_trust..._p()).  */
+  di.read_memory_func = dis_asm_read_memory;
+  di.mach = gdbarch_bfd_arch_info (gdbarch)->mach;
+  di.endian = gdbarch_byte_order (gdbarch);
+  return di;
+}
+
 void
 gdb_disassembly (struct ui_out *uiout,
 		char *file_string,
@@ -315,62 +340,14 @@ gdb_disassembly (struct ui_out *uiout,
 		int mixed_source_and_assembly,
 		int how_many, CORE_ADDR low, CORE_ADDR high)
 {
-  static disassemble_info di;
-  static int di_initialized;
+  struct ui_stream *stb = ui_out_stream_new (uiout);
+  struct cleanup *cleanups = make_cleanup_ui_out_stream_delete (stb);
+  disassemble_info di = gdb_disassemble_info (current_gdbarch, stb->stream);
   /* To collect the instruction outputted from opcodes. */
-  static struct ui_stream *stb = NULL;
   struct symtab *symtab = NULL;
   struct linetable_entry *le = NULL;
   int nlines = -1;
 
-  if (!di_initialized)
-    {
-      /* We don't add a cleanup for this, because the allocation of
-         the stream is done once only for each gdb run, and we need to
-         keep it around until the end. Hopefully there won't be any
-         errors in the init code below, that make this function bail
-         out. */
-      stb = ui_out_stream_new (uiout);
-      INIT_DISASSEMBLE_INFO_NO_ARCH (di, stb->stream,
-				     (fprintf_ftype) fprintf_unfiltered);
-      di.flavour = bfd_target_unknown_flavour;
-      di.memory_error_func = dis_asm_memory_error;
-      di.print_address_func = dis_asm_print_address;
-      di_initialized = 1;
-    }
-
-  di.mach = gdbarch_bfd_arch_info (current_gdbarch)->mach;
-  di.endian = gdbarch_byte_order (current_gdbarch);
-
-  /* If gdb_disassemble_from_exec == -1, then we use the following heuristic to
-     determine whether or not to do disassembly from target memory or from the
-     exec file:
-
-     If we're debugging a local process, read target memory, instead of the
-     exec file.  This makes disassembly of functions in shared libs work
-     correctly.  Also, read target memory if we are debugging native threads.
-
-     Else, we're debugging a remote process, and should disassemble from the
-     exec file for speed.  However, this is no good if the target modifies its
-     code (for relocation, or whatever).  */
-
-  if (gdb_disassemble_from_exec == -1)
-    {
-      if (strcmp (target_shortname, "child") == 0
-	  || strcmp (target_shortname, "procfs") == 0
-	  || strcmp (target_shortname, "vxprocess") == 0
-          || strcmp (target_shortname, "core") == 0
-	  || strstr (target_shortname, "-thread") != NULL)
-	gdb_disassemble_from_exec = 0;	/* It's a child process, read inferior mem */
-      else
-	gdb_disassemble_from_exec = 1;	/* It's remote, read the exec file */
-    }
-
-  if (gdb_disassemble_from_exec)
-    di.read_memory_func = gdb_dis_asm_read_memory;
-  else
-    di.read_memory_func = dis_asm_read_memory;
-
   /* Assume symtab is valid for whole PC range */
   symtab = find_pc_symtab (low);
 
@@ -389,5 +366,35 @@ gdb_disassembly (struct ui_out *uiout,
     do_mixed_source_and_assembly (uiout, &di, nlines, le, low,
 				  high, symtab, how_many, stb);
 
+  do_cleanups (cleanups);
   gdb_flush (gdb_stdout);
 }
+
+/* Print the instruction at address MEMADDR in debugged memory,
+   on STREAM.  Returns length of the instruction, in bytes.  */
+
+int
+gdb_print_insn (CORE_ADDR memaddr, struct ui_file *stream)
+{
+  disassemble_info di = gdb_disassemble_info (current_gdbarch, stream);
+  return TARGET_PRINT_INSN (memaddr, &di);
+}
+
+
+/* FIXME: cagney/2003-04-28: This global deprecated_tm_print_insn_info
+   is going away.  */
+disassemble_info deprecated_tm_print_insn_info;
+
+extern void _initialize_disasm (void);
+
+void
+_initialize_disasm (void)
+{
+  
+  INIT_DISASSEMBLE_INFO_NO_ARCH (deprecated_tm_print_insn_info, gdb_stdout,
+				 (fprintf_ftype)fprintf_filtered);
+  deprecated_tm_print_insn_info.flavour = bfd_target_unknown_flavour;
+  deprecated_tm_print_insn_info.read_memory_func = dis_asm_read_memory;
+  deprecated_tm_print_insn_info.memory_error_func = dis_asm_memory_error;
+  deprecated_tm_print_insn_info.print_address_func = dis_asm_print_address;
+}
diff --git a/gdb/disasm.h b/gdb/disasm.h
index 6a6df7e0b57..e4674d87d2d 100644
--- a/gdb/disasm.h
+++ b/gdb/disasm.h
@@ -28,4 +28,10 @@ extern void gdb_disassembly (struct ui_out *uiout,
 			     int line_num,
 			     int mixed_source_and_assembly,
 			     int how_many, CORE_ADDR low, CORE_ADDR high);
+
+/* Print the instruction at address MEMADDR in debugged memory, on
+   STREAM.  Returns length of the instruction, in bytes.  */
+
+extern int gdb_print_insn (CORE_ADDR memaddr, struct ui_file *stream);
+
 #endif
diff --git a/gdb/doc/ChangeLog b/gdb/doc/ChangeLog
index 473eb155d0e..e5258378b61 100644
--- a/gdb/doc/ChangeLog
+++ b/gdb/doc/ChangeLog
@@ -1,3 +1,59 @@
+2003-05-08  Jim Blandy  <jimb@redhat.com>
+
+	* gdb.texinfo (Dump/Restore Files): Update documentation for
+	'dump', 'append', and 'restore': note that format argument is
+	optional; simplify presentation of the command variants; and be
+	more precise about the formats.
+
+2003-05-07  Jim Blandy  <jimb@redhat.com>
+
+	* gdb.texinfo (Symbols): Update documentation: 'maint list
+	symtabs' and 'maint list psymtabs' have been renamed 'maint info
+	symtabs' and 'maint info psymtabs'.
+
+2003-05-05  Andrew Cagney  <cagney@redhat.com>
+
+	* gdbint.texinfo (Target Architecture Definition): Make
+	CALL_DUMMY_WORDS, SIZEOF_CALL_DUMMY_WORDS, CALL_DUMMY_LENGTH,
+	FIX_CALL_DUMMY, CALL_DUMMY_BREAKPOINT_OFFSET and
+	CALL_DUMMY_BREAKPOINT_OFFSET deprecated.
+
+2003-05-04  Andrew Cagney  <cagney@redhat.com>
+
+	* gdb.texinfo (Maintenance Commands): Document "maint print
+	dummy-frames".
+
+2003-05-04  Andrew Cagney  <cagney@redhat.com>
+
+	* gdb.texinfo (GDB/MI Symbol Query): Use @{ and @}.
+
+2003-05-03  J. Brobecker  <brobecker@gnat.com>
+
+	Thierry Schneider  <tpschneider1@yahoo.com>
+	* gdb.texinfo (section GDB/MI Symbol Query): Add documentation
+	for new MI command.
+
+2003-05-03  Andrew Cagney  <cagney@redhat.com>
+
+	* gdbint.texinfo (Target Architecture Definition): Document
+	push_dummy_code.  Add cross references.
+
+2003-05-02  Elena Zannoni  <ezannoni@redhat.com>
+
+	* gdb.texinfo (Character Sets): Update to reflect new behavior of
+	set/show charsets commands.
+
+2003-04-28  Andrew Cagney  <cagney@redhat.com>
+
+	* gdbint.texinfo (Target Architecture Definition): Replace
+	read_fp, TARGET_READ_FP and FP_REGNUM, with deprecated_read_fp,
+	DEPRECATED_TARGET_READ_FP and DEPRECATED_REGNUM.
+
+2003-04-28  Andrew Cagney  <cagney@redhat.com>
+
+	* gdbint.texinfo (Target Architecture Definition): Rename
+	"tm_print_insn" to "deprecated_tm_print_insn".
+
 2003-04-09  Jim Blandy  <jimb@redhat.com>
 
 	* gdb.texinfo (Symbols): Document 'maint list symtabs' and 'maint
diff --git a/gdb/doc/gdb.texinfo b/gdb/doc/gdb.texinfo
index 00a4ac7f9fc..9136e653773 100644
--- a/gdb/doc/gdb.texinfo
+++ b/gdb/doc/gdb.texinfo
@@ -5861,62 +5861,53 @@ Disable @value{GDBN} from caching target memory.  This is the default.
 @cindex append data to a file
 @cindex dump data to a file
 @cindex restore data from a file
-@kindex dump
-@kindex append
-@kindex restore
 
-The commands @code{dump}, @code{append}, and @code{restore} are used
-for copying data between target memory and a file.  Data is written
-into a file using @code{dump} or @code{append}, and restored from a 
-file into memory by using @code{restore}.  Files may be binary, srec,
-intel hex, or tekhex (but only binary files can be appended).
+You can use the commands @code{dump}, @code{append}, and
+@code{restore} to copy data between target memory and a file.  The
+@code{dump} and @code{append} commands write data to a file, and the
+@code{restore} command reads data from a file back into the inferior's
+memory.  Files may be in binary, Motorola S-record, Intel hex, or
+Tektronix Hex format; however, @value{GDBN} can only append to binary
+files.
 
 @table @code
-@kindex dump binary 
-@kindex append binary 
-@item dump binary memory @var{filename} @var{start_addr} @var{end_addr}
-Dump contents of memory from @var{start_addr} to @var{end_addr} into 
-raw binary format file @var{filename}.
-
-@item append binary memory @var{filename} @var{start_addr} @var{end_addr}
-Append contents of memory from @var{start_addr} to @var{end_addr} to
-raw binary format file @var{filename}.
-
-@item dump binary value @var{filename} @var{expression}
-Dump value of @var{expression} into raw binary format file @var{filename}.
 
-@item append binary memory @var{filename} @var{expression}
-Append value of @var{expression} to raw binary format file @var{filename}.
-
-@kindex dump ihex 
-@item dump ihex memory @var{filename} @var{start_addr} @var{end_addr}
-Dump contents of memory from @var{start_addr} to @var{end_addr} into 
-intel hex format file @var{filename}.
-
-@item dump ihex value @var{filename} @var{expression}
-Dump value of @var{expression} into intel hex format file @var{filename}.
-
-@kindex dump srec 
-@item dump srec memory @var{filename} @var{start_addr} @var{end_addr}
-Dump contents of memory from @var{start_addr} to @var{end_addr} into 
-srec format file @var{filename}.
+@kindex dump
+@item dump @r{[}@var{format}@r{]} memory @var{filename} @var{start_addr} @var{end_addr}
+@itemx dump @r{[}@var{format}@r{]} value @var{filename} @var{expr}
+Dump the contents of memory from @var{start_addr} to @var{end_addr},
+or the value of @var{expr}, to @var{filename} in the given format.
 
-@item dump srec value @var{filename} @var{expression}
-Dump value of @var{expression} into srec format file @var{filename}.
+The @var{format} parameter may be any one of:
+@table @code
+@item binary
+Raw binary form.
+@item ihex
+Intel hex format.
+@item srec
+Motorola S-record format.
+@item tekhex
+Tektronix Hex format.
+@end table
 
-@kindex dump tekhex 
-@item dump tekhex memory @var{filename} @var{start_addr} @var{end_addr}
-Dump contents of memory from @var{start_addr} to @var{end_addr} into 
-tekhex format file @var{filename}.
+@value{GDBN} uses the same definitions of these formats as the
+@sc{gnu} binary utilities, like @samp{objdump} and @samp{objcopy}.  If
+@var{format} is omitted, @value{GDBN} dumps the data in raw binary
+form.
 
-@item dump tekhex value @var{filename} @var{expression}
-Dump value of @var{expression} into tekhex format file @var{filename}.
+@kindex append
+@item append @r{[}binary@r{]} memory @var{filename} @var{start_addr} @var{end_addr}
+@itemx append @r{[}binary@r{]} value @var{filename} @var{expr}
+Append the contents of memory from @var{start_addr} to @var{end_addr},
+or the value of @var{expr}, to @var{filename}, in raw binary form.
+(@value{GDBN} can only append data to files in raw binary form.)
 
-@item restore @var{filename} [@var{binary}] @var{bias} @var{start} @var{end}
-Restore the contents of file @var{filename} into memory.  The @code{restore}
-command can automatically recognize any known bfd file format, except for
-raw binary.  To restore a raw binary file you must use the optional argument
-@var{binary} after the filename.
+@kindex restore
+@item restore @var{filename} @r{[}binary@r{]} @var{bias} @var{start} @var{end}
+Restore the contents of file @var{filename} into memory.  The
+@code{restore} command can automatically recognize any known @sc{bfd}
+file format, except for raw binary.  To restore a raw binary file you
+must specify the optional keyword @code{binary} after the filename.
 
 If @var{bias} is non-zero, its value will be added to the addresses 
 contained in the file.  Binary files always start at address zero, so
@@ -5952,7 +5943,7 @@ remote protocol (@pxref{Remote,Remote Debugging}) to debug a program
 running on an IBM mainframe, which uses the @sc{ebcdic} character set,
 then the host character set is Latin-1, and the target character set is
 @sc{ebcdic}.  If you give @value{GDBN} the command @code{set
-target-charset ebcdic-us}, then @value{GDBN} translates between
+target-charset EBCDIC-US}, then @value{GDBN} translates between
 @sc{ebcdic} and Latin 1 as you print character or string values, or use
 character and string literals in expressions.
 
@@ -5967,9 +5958,9 @@ support:
 @item set target-charset @var{charset}
 @kindex set target-charset
 Set the current target character set to @var{charset}.  We list the
-character set names @value{GDBN} recognizes below, but if you invoke the
-@code{set target-charset} command with no argument, @value{GDBN} lists
-the character sets it supports.
+character set names @value{GDBN} recognizes below, but if you type
+@code{set target-charset} followed by @key{TAB}@key{TAB}, @value{GDBN} will
+list the target character sets it supports.
 @end table
 
 @table @code
@@ -5983,28 +5974,29 @@ system it is running on; you can override that default using the
 
 @value{GDBN} can only use certain character sets as its host character
 set.  We list the character set names @value{GDBN} recognizes below, and
-indicate which can be host character sets, but if you invoke the
-@code{set host-charset} command with no argument, @value{GDBN} lists the
-character sets it supports, placing an asterisk (@samp{*}) after those
-it can use as a host character set.
+indicate which can be host character sets, but if you type
+@code{set target-charset} followed by @key{TAB}@key{TAB}, @value{GDBN} will
+list the host character sets it supports.
 
 @item set charset @var{charset}
 @kindex set charset
-Set the current host and target character sets to @var{charset}.  If you
-invoke the @code{set charset} command with no argument, it lists the
-character sets it supports.  @value{GDBN} can only use certain character
-sets as its host character set; it marks those in the list with an
-asterisk (@samp{*}).
+Set the current host and target character sets to @var{charset}.  As
+above, if you type @code{set charset} followed by @key{TAB}@key{TAB},
+@value{GDBN} will list the name of the character sets that can be used
+for both host and target.
+
 
 @item show charset
-@itemx show host-charset
-@itemx show target-charset
 @kindex show charset
+Show the names of the current host and target charsets. 
+
+@itemx show host-charset
 @kindex show host-charset
+Show the name of the current host charset. 
+
+@itemx show target-charset
 @kindex show target-charset
-Show the current host and target charsets.  The @code{show host-charset}
-and @code{show target-charset} commands are synonyms for @code{show
-charset}.
+Show the name of the current target charset. 
 
 @end table
 
@@ -6021,7 +6013,7 @@ character set.
 @item ISO-8859-1
 @cindex ISO 8859-1 character set
 @cindex ISO Latin 1 character set
-The ISO Latin 1 character set.  This extends ASCII with accented
+The ISO Latin 1 character set.  This extends @sc{ascii} with accented
 characters needed for French, German, and Spanish.  @value{GDBN} can use
 this as its host character set.
 
@@ -6080,16 +6072,16 @@ strings:
 
 @smallexample
 (gdb) show charset
-The current host and target character set is `iso-8859-1'.
+The current host and target character set is `ISO-8859-1'.
 (gdb) 
 @end smallexample
 
 For the sake of printing this manual, let's use @sc{ascii} as our
 initial character set:
 @smallexample
-(gdb) set charset ascii
+(gdb) set charset ASCII
 (gdb) show charset
-The current host and target character set is `ascii'.
+The current host and target character set is `ASCII'.
 (gdb) 
 @end smallexample
 
@@ -6131,17 +6123,13 @@ $5 = 200 '\310'
 (gdb) 
 @end smallexample
 
-If we invoke the @code{set target-charset} command without an argument,
+If we invoke the @code{set target-charset} followed by @key{TAB}@key{TAB},
 @value{GDBN} tells us the character sets it supports:
 
 @smallexample
 (gdb) set target-charset
-Valid character sets are:
-  ascii *
-  iso-8859-1 *
-  ebcdic-us  
-  ibm1047  
-* - can be used as a host character set
+ASCII       EBCDIC-US   IBM1047     ISO-8859-1  
+(gdb) set target-charset 
 @end smallexample
 
 We can select @sc{ibm1047} as our target character set, and examine the
@@ -6151,10 +6139,10 @@ target character set, @sc{ibm1047}, to the host character set,
 @sc{ascii}, and they display correctly:
 
 @smallexample
-(gdb) set target-charset ibm1047
+(gdb) set target-charset IBM1047
 (gdb) show charset
-The current host character set is `ascii'.
-The current target character set is `ibm1047'.
+The current host character set is `ASCII'.
+The current target character set is `IBM1047'.
 (gdb) print ascii_hello
 $6 = 0x401698 "\110\145%%?\054\040\167?\162%\144\041\012"
 (gdb) print ascii_hello[0]
@@ -6175,7 +6163,7 @@ $10 = 78 '+'
 (gdb) 
 @end smallexample
 
-The IBM1047 character set uses the number 78 to encode the @samp{+}
+The @sc{ibm1047} character set uses the number 78 to encode the @samp{+}
 character.
 
 
@@ -9034,14 +9022,14 @@ required for each object file from which @value{GDBN} has read some symbols.
 @xref{Files, ,Commands to specify files}, for a discussion of how
 @value{GDBN} reads symbols (in the description of @code{symbol-file}).
 
-@kindex maint list symtabs
-@kindex maint list psymtabs
+@kindex maint info symtabs
+@kindex maint info psymtabs
 @cindex listing @value{GDBN}'s internal symbol tables
 @cindex symbol tables, listing @value{GDBN}'s internal
 @cindex full symbol tables, listing @value{GDBN}'s internal
 @cindex partial symbol tables, listing @value{GDBN}'s internal
-@item maint list symtabs @r{[} @var{regexp} @r{]}
-@itemx maint list psymtabs @r{[} @var{regexp} @r{]}
+@item maint info symtabs @r{[} @var{regexp} @r{]}
+@itemx maint info psymtabs @r{[} @var{regexp} @r{]}
 
 List the @code{struct symtab} or @code{struct partial_symtab}
 structures whose names match @var{regexp}.  If @var{regexp} is not
@@ -9050,7 +9038,7 @@ copy into a @value{GDBN} debugging this one to examine a particular
 structure in more detail.  For example:
 
 @smallexample
-(@value{GDBP}) maint list psymtabs dwarf2read
+(@value{GDBP}) maint info psymtabs dwarf2read
 @{ objfile /home/gnu/build/gdb/gdb
   ((struct objfile *) 0x82e69d0)
   @{ psymtab /home/gnu/src/gdb/dwarf2read.c 
@@ -9063,7 +9051,7 @@ structure in more detail.  For example:
     dependencies (none)
   @}
 @}
-(@value{GDBP}) maint list symtabs
+(@value{GDBP}) maint info symtabs
 (@value{GDBP})
 @end smallexample
 @noindent
@@ -9077,7 +9065,7 @@ read the symtab for the compilation unit containing that function:
 (@value{GDBP}) break dwarf2_psymtab_to_symtab
 Breakpoint 1 at 0x814e5da: file /home/gnu/src/gdb/dwarf2read.c,
 line 1574.
-(@value{GDBP}) maint list symtabs
+(@value{GDBP}) maint info symtabs
 @{ objfile /home/gnu/build/gdb/gdb 
   ((struct objfile *) 0x82e69d0)
   @{ symtab /home/gnu/src/gdb/dwarf2read.c 
@@ -17117,6 +17105,32 @@ List the functions in the executable.
 N.A.
 
 
+@subheading The @code{-symbol-list-lines} Command
+@findex -symbol-list-lines
+
+@subsubheading Synopsis
+
+@smallexample
+ -symbol-list-lines @var{filename}
+@end smallexample
+
+Print the list of lines that contain code and their associated program
+addresses for the given source filename.  The entries are sorted in
+ascending PC order.
+
+@subsubheading @value{GDBN} Command
+
+There is no corresponding @value{GDBN} command.
+
+@subsubheading Example
+@smallexample
+(@value{GDBP})
+-symbol-list-lines basics.c
+^done,lines=[@{pc="0x08048554",line="7"@},@{pc="0x0804855a",line="8"@}]
+(@value{GDBP})
+@end smallexample
+
+
 @subheading The @code{-symbol-list-types} Command
 @findex -symbol-list-types
 
@@ -19350,6 +19364,28 @@ Create a core file? (y or n) @kbd{n}
 Takes an optional parameter that is used as the text of the error or
 warning message.
 
+@kindex maint print dummy-frames
+@item maint print dummy-frames
+
+Prints the contents of @value{GDBN}'s internal dummy-frame stack.
+
+@smallexample
+(gdb) @kbd{b add}
+@dots{}
+(gdb) @kbd{print add(2,3)}
+Breakpoint 2, add (a=2, b=3) at @dots{}
+58	  return (a + b);
+The program being debugged stopped while in a function called from GDB.
+@dots{}
+(gdb) @kbd{maint print dummy-frames}
+0x1a57c80: pc=0x01014068 fp=0x0200bddc sp=0x0200bdd6
+ top=0x0200bdd4 id=@{stack=0x200bddc,code=0x101405c@}
+ call_lo=0x01014000 call_hi=0x01014001
+(gdb) 
+@end smallexample
+
+Takes an optional file parameter.
+
 @kindex maint print registers
 @kindex maint print raw-registers
 @kindex maint print cooked-registers
diff --git a/gdb/doc/gdbint.texinfo b/gdb/doc/gdbint.texinfo
index 4ca81f6777d..28cdc82242a 100644
--- a/gdb/doc/gdbint.texinfo
+++ b/gdb/doc/gdbint.texinfo
@@ -241,16 +241,17 @@ machine-independent part of @value{GDBN}, except that it is used when
 setting up a new frame from scratch, as follows:
 
 @smallexample
-create_new_frame (read_register (FP_REGNUM), read_pc ()));
+create_new_frame (read_register (DEPRECATED_FP_REGNUM), read_pc ()));
 @end smallexample
 
 @cindex frame pointer register
-Other than that, all the meaning imparted to @code{FP_REGNUM} is
-imparted by the machine-dependent code.  So, @code{FP_REGNUM} can have
-any value that is convenient for the code that creates new frames.
-(@code{create_new_frame} calls @code{DEPRECATED_INIT_EXTRA_FRAME_INFO}
-if it is defined; that is where you should use the @code{FP_REGNUM}
-value, if your frames are nonstandard.)
+Other than that, all the meaning imparted to @code{DEPRECATED_FP_REGNUM}
+is imparted by the machine-dependent code.  So,
+@code{DEPRECATED_FP_REGNUM} can have any value that is convenient for
+the code that creates new frames.  (@code{create_new_frame} calls
+@code{DEPRECATED_INIT_EXTRA_FRAME_INFO} if it is defined; that is where
+you should use the @code{DEPRECATED_FP_REGNUM} value, if your frames are
+nonstandard.)
 
 @cindex frame chain
 Given a @value{GDBN} frame, define @code{DEPRECATED_FRAME_CHAIN} to
@@ -3084,8 +3085,8 @@ custom breakpoint insertion and removal routines if
 @code{BREAKPOINT_FROM_PC} needs to read the target's memory for some
 reason.
 
-@item CALL_DUMMY_WORDS
-@findex CALL_DUMMY_WORDS
+@item DEPRECATED_CALL_DUMMY_WORDS
+@findex DEPRECATED_CALL_DUMMY_WORDS
 Pointer to an array of @code{LONGEST} words of data containing
 host-byte-ordered @code{REGISTER_BYTES} sized values that partially
 specify the sequence of instructions needed for an inferior function
@@ -3094,19 +3095,32 @@ call.
 Should be deprecated in favor of a macro that uses target-byte-ordered
 data.
 
-@item SIZEOF_CALL_DUMMY_WORDS
-@findex SIZEOF_CALL_DUMMY_WORDS
-The size of @code{CALL_DUMMY_WORDS}.  This must return a positive value.
-See also @code{CALL_DUMMY_LENGTH}.
+This method has been replaced by @code{push_dummy_code}
+(@pxref{push_dummy_code}).
+
+@item DEPRECATED_SIZEOF_CALL_DUMMY_WORDS
+@findex DEPRECATED_SIZEOF_CALL_DUMMY_WORDS
+The size of @code{DEPRECATED_CALL_DUMMY_WORDS}.  This must return a
+positive value.  See also @code{DEPRECATED_CALL_DUMMY_LENGTH}.
+
+This method has been replaced by @code{push_dummy_code}
+(@pxref{push_dummy_code}).
 
 @item CALL_DUMMY
 @findex CALL_DUMMY
-A static initializer for @code{CALL_DUMMY_WORDS}.  Deprecated.
+A static initializer for @code{DEPRECATED_CALL_DUMMY_WORDS}.
+Deprecated.
+
+This method has been replaced by @code{push_dummy_code}
+(@pxref{push_dummy_code}).
 
 @item CALL_DUMMY_LOCATION
 @findex CALL_DUMMY_LOCATION
 See the file @file{inferior.h}.
 
+This method has been replaced by @code{push_dummy_code}
+(@pxref{push_dummy_code}).
+
 @item DEPRECATED_CALL_DUMMY_STACK_ADJUST
 @findex DEPRECATED_CALL_DUMMY_STACK_ADJUST
 Stack adjustment needed when performing an inferior function call.  This
@@ -3217,13 +3231,13 @@ If not defined, @code{EXTRACT_RETURN_VALUE} is used.
 @findex EXTRACT_STRUCT_VALUE_ADDRESS_P
 Predicate for @code{EXTRACT_STRUCT_VALUE_ADDRESS}.
 
-@item FP_REGNUM
-@findex FP_REGNUM
+@item DEPRECATED_FP_REGNUM
+@findex DEPRECATED_FP_REGNUM
 If the virtual frame pointer is kept in a register, then define this
 macro to be the number (greater than or equal to zero) of that register.
 
-This should only need to be defined if @code{TARGET_READ_FP} is not
-defined.
+This should only need to be defined if @code{DEPRECATED_TARGET_READ_FP}
+is not defined.
 
 @item FRAMELESS_FUNCTION_INVOCATION(@var{fi})
 @findex FRAMELESS_FUNCTION_INVOCATION
@@ -3706,6 +3720,28 @@ Returns the updated top-of-stack pointer.
 
 This method replaces @code{DEPRECATED_PUSH_ARGUMENTS}.
 
+@item CORE_ADDR push_dummy_code (@var{gdbarch}, @var{sp}, @var{funaddr}, @var{using_gcc}, @var{args}, @var{nargs}, @var{value_type}, @var{real_pc}, @var{bp_addr})
+@findex push_dummy_code
+@findex DEPRECATED_FIX_CALL_DUMMY
+@anchor{push_dummy_code} Given a stack based call dummy, push the
+instruction sequence (including space for a breakpoint) to which the
+called function should return.
+
+Set @var{bp_addr} to the address at which the breakpoint instruction
+should be inserted, @var{real_pc} to the resume address when starting
+the call sequence, and return the updated inner-most stack address.
+
+By default, the stack is grown sufficient to hold a frame-aligned
+(@pxref{frame_align}) breakpoint, @var{bp_addr} is set to the address
+reserved for that breakpoint, and @var{real_pc} set to @var{funaddr}.
+
+This method replaces @code{DEPRECATED_CALL_DUMMY_WORDS},
+@code{DEPRECATED_SIZEOF_CALL_DUMMY_WORDS}, @code{CALL_DUMMY},
+@code{CALL_DUMMY_LOCATION}, @code{DEPRECATED_REGISTER_SIZE},
+@code{GDB_TARGET_IS_HPPA},
+@code{DEPRECATED_CALL_DUMMY_BREAKPOINT_OFFSET}, and
+@code{DEPRECATED_FIX_CALL_DUMMY}.
+
 @item DEPRECATED_PUSH_DUMMY_FRAME
 @findex DEPRECATED_PUSH_DUMMY_FRAME
 Used in @samp{call_function_by_hand} to create an artificial stack frame.
@@ -3882,9 +3918,9 @@ Number of bits in a short integer; defaults to @code{2 * TARGET_CHAR_BIT}.
 @findex read_sp
 @findex read_fp
 These change the behavior of @code{read_pc}, @code{write_pc},
-@code{read_sp} and @code{read_fp}.  For most targets, these may be left
-undefined.  @value{GDBN} will call the read and write register functions
-with the relevant @code{_REGNUM} argument.
+@code{read_sp} and @code{deprecated_read_fp}.  For most targets, these
+may be left undefined.  @value{GDBN} will call the read and write
+register functions with the relevant @code{_REGNUM} argument.
 
 These macros are useful when a target keeps one of these registers in a
 hard to get at place; for example, part in a segment register and part
@@ -3892,10 +3928,10 @@ in an ordinary register.
 
 @item TARGET_VIRTUAL_FRAME_POINTER(@var{pc}, @var{regp}, @var{offsetp})
 @findex TARGET_VIRTUAL_FRAME_POINTER
-Returns a @code{(register, offset)} pair representing the virtual 
-frame pointer in use at the code address @var{pc}.  If virtual 
-frame pointers are not used, a default definition simply returns 
-@code{FP_REGNUM}, with an offset of zero.
+Returns a @code{(register, offset)} pair representing the virtual frame
+pointer in use at the code address @var{pc}.  If virtual frame pointers
+are not used, a default definition simply returns
+@code{DEPRECATED_FP_REGNUM}, with an offset of zero.
 
 @item TARGET_HAS_HARDWARE_WATCHPOINTS
 If non-zero, the target has support for hardware-assisted
@@ -3908,11 +3944,12 @@ This is the function used by @value{GDBN} to print an assembly
 instruction.  It prints the instruction at address @var{addr} in
 debugged memory and returns the length of the instruction, in bytes.  If
 a target doesn't define its own printing routine, it defaults to an
-accessor function for the global pointer @code{tm_print_insn}. This
-usually points to a function in the @code{opcodes} library (@pxref{Support
-Libraries, ,Opcodes}).  @var{info} is a structure (of type
-@code{disassemble_info}) defined in @file{include/dis-asm.h} used to
-pass information to the instruction decoding routine.
+accessor function for the global pointer
+@code{deprecated_tm_print_insn}.  This usually points to a function in
+the @code{opcodes} library (@pxref{Support Libraries, ,Opcodes}).
+@var{info} is a structure (of type @code{disassemble_info}) defined in
+@file{include/dis-asm.h} used to pass information to the instruction
+decoding routine.
 
 @item struct frame_id unwind_dummy_id (struct frame_info *@var{frame})
 @findex unwind_dummy_id
diff --git a/gdb/dummy-frame.c b/gdb/dummy-frame.c
index a320b7d3b9f..e16056c4412 100644
--- a/gdb/dummy-frame.c
+++ b/gdb/dummy-frame.c
@@ -29,6 +29,8 @@
 #include "inferior.h"
 #include "gdb_assert.h"
 #include "frame-unwind.h"
+#include "command.h"
+#include "gdbcmd.h"
 
 static void dummy_frame_this_id (struct frame_info *next_frame,
 				 void **this_prologue_cache,
@@ -149,8 +151,9 @@ generic_pc_in_call_dummy (CORE_ADDR pc, CORE_ADDR sp, CORE_ADDR fp)
    figure out what the real PC (as in the resume address) is BEFORE
    calling this function (Oh, and I'm not even sure that this function
    is called with an decremented PC, the call to pc_in_call_dummy() in
-   that file is conditional on !CALL_DUMMY_BREAKPOINT_OFFSET_P yet
-   generic dummy targets set CALL_DUMMY_BREAKPOINT_OFFSET. True?).  */
+   that file is conditional on
+   !DEPRECATED_CALL_DUMMY_BREAKPOINT_OFFSET_P yet generic dummy
+   targets set DEPRECATED_CALL_DUMMY_BREAKPOINT_OFFSET. True?).  */
 
 int
 pc_in_dummy_frame (CORE_ADDR pc)
@@ -374,7 +377,7 @@ dummy_frame_this_id (struct frame_info *next_frame,
 	 same sequence as is found a traditional unwinder.  Once all
 	 architectures supply the unwind_dummy_id method, this code
 	 can go away.  */
-      (*this_id) = frame_id_build (read_fp (), read_pc ());
+      (*this_id) = frame_id_build (deprecated_read_fp (), read_pc ());
     }
   else if (legacy_frame_p (current_gdbarch)
 	   && get_prev_frame (next_frame))
@@ -418,3 +421,49 @@ dummy_frame_p (CORE_ADDR pc)
   else
     return NULL;
 }
+
+static void
+fprint_dummy_frames (struct ui_file *file)
+{
+  struct dummy_frame *s;
+  for (s = dummy_frame_stack; s != NULL; s = s->next)
+    {
+      gdb_print_host_address (s, file);
+      fprintf_unfiltered (file, ":");
+      fprintf_unfiltered (file, " pc=0x%s", paddr (s->pc));
+      fprintf_unfiltered (file, " fp=0x%s", paddr (s->fp));
+      fprintf_unfiltered (file, " sp=0x%s", paddr (s->sp));
+      fprintf_unfiltered (file, " top=0x%s", paddr (s->top));
+      fprintf_unfiltered (file, " id=");
+      fprint_frame_id (file, s->id);
+      fprintf_unfiltered (file, " call_lo=0x%s", paddr (s->call_lo));
+      fprintf_unfiltered (file, " call_hi=0x%s", paddr (s->call_hi));
+      fprintf_unfiltered (file, "\n");
+    }
+}
+
+static void
+maintenance_print_dummy_frames (char *args, int from_tty)
+{
+  if (args == NULL)
+    fprint_dummy_frames (gdb_stdout);
+  else
+    {
+      struct ui_file *file = gdb_fopen (args, "w");
+      if (file == NULL)
+	perror_with_name ("maintenance print dummy-frames");
+      fprint_dummy_frames (file);    
+      ui_file_delete (file);
+    }
+}
+
+extern void _initialize_dummy_frame (void);
+
+void
+_initialize_dummy_frame (void)
+{
+  add_cmd ("dummy-frames", class_maintenance, maintenance_print_dummy_frames,
+	   "Print the contents of the internal dummy-frame stack.",
+	   &maintenanceprintlist);
+
+}
diff --git a/gdb/dummy-frame.h b/gdb/dummy-frame.h
index bb41e8d7988..3d38cc436cc 100644
--- a/gdb/dummy-frame.h
+++ b/gdb/dummy-frame.h
@@ -37,12 +37,13 @@ struct frame_id;
    generic enough to be used by many targets.
  
    The cheapest and most generic way to do CALL_DUMMY on a new target
-   is probably to define CALL_DUMMY to be empty, CALL_DUMMY_LENGTH to
-   zero, and CALL_DUMMY_LOCATION to AT_ENTRY.  Then you must remember
-   to define PUSH_RETURN_ADDRESS, because no call instruction will be
-   being executed by the target.  Also DEPRECATED_FRAME_CHAIN_VALID as
+   is probably to define CALL_DUMMY to be empty,
+   DEPRECATED_CALL_DUMMY_LENGTH to zero, and CALL_DUMMY_LOCATION to
+   AT_ENTRY.  Then you must remember to define PUSH_RETURN_ADDRESS,
+   because no call instruction will be being executed by the target.
+   Also DEPRECATED_FRAME_CHAIN_VALID as
    generic_{file,func}_frame_chain_valid and do not set
-   FIX_CALL_DUMMY.  */
+   DEPRECATED_FIX_CALL_DUMMY.  */
 
 /* If the PC falls in a dummy frame, return a dummy frame
    unwinder.  */
diff --git a/gdb/dve3900-rom.c b/gdb/dve3900-rom.c
index e7329f8988a..02a273c10e1 100644
--- a/gdb/dve3900-rom.c
+++ b/gdb/dve3900-rom.c
@@ -455,7 +455,7 @@ static void
 fetch_bitmapped_register (int regno, struct bit_field *bf)
 {
   unsigned long val;
-  unsigned char *regbuf = alloca (max_register_size (current_gdbarch));
+  unsigned char regbuf[MAX_REGISTER_SIZE];
   char *regname = NULL;
 
   if (regno >= sizeof (r3900_regnames) / sizeof (r3900_regnames[0]))
diff --git a/gdb/dwarf2cfi.c b/gdb/dwarf2cfi.c
index 81fa2071307..085c91cd311 100644
--- a/gdb/dwarf2cfi.c
+++ b/gdb/dwarf2cfi.c
@@ -1751,7 +1751,7 @@ cfi_write_fp (CORE_ADDR val)
 void
 cfi_pop_frame (struct frame_info *fi)
 {
-  char *regbuf = alloca (MAX_REGISTER_RAW_SIZE);
+  char regbuf[MAX_REGISTER_SIZE];
   int regnum;
 
   for (regnum = 0; regnum < NUM_REGS; regnum++)
diff --git a/gdb/dwarf2loc.c b/gdb/dwarf2loc.c
index 8927e8798b5..c236c11f37c 100644
--- a/gdb/dwarf2loc.c
+++ b/gdb/dwarf2loc.c
@@ -223,7 +223,10 @@ dwarf2_evaluate_loc_desc (struct symbol *var, struct frame_info *frame,
   result = dwarf_expr_fetch (ctx, 0);
 
   if (ctx->in_reg)
-    retval = value_from_register (SYMBOL_TYPE (var), result, frame);
+    {
+      int regnum = DWARF2_REG_TO_REGNUM (result);
+      retval = value_from_register (SYMBOL_TYPE (var), regnum, frame);
+    }
   else
     {
       retval = allocate_value (SYMBOL_TYPE (var));
diff --git a/gdb/dwarf2read.c b/gdb/dwarf2read.c
index 32a9f44b566..a0a2f9beaaa 100644
--- a/gdb/dwarf2read.c
+++ b/gdb/dwarf2read.c
@@ -4548,7 +4548,7 @@ set_cu_language (unsigned int lang)
     case DW_LANG_Pascal83:
     case DW_LANG_Modula2:
     default:
-      cu_language = language_unknown;
+      cu_language = language_minimal;
       break;
     }
   cu_language_defn = language_def (cu_language);
@@ -4878,8 +4878,8 @@ dwarf_decode_lines (struct line_header *lh, char *comp_dir, bfd *abfd,
 		* lh->minimum_instruction_length;
 	      line += lh->line_base + (adj_opcode % lh->line_range);
 	      /* append row to matrix using current values */
-	      address = check_cu_functions (address);
-	      record_line (current_subfile, line, address);
+	      record_line (current_subfile, line, 
+	                   check_cu_functions (address));
 	      basic_block = 1;
 	    }
 	  else switch (op_code)
@@ -4925,8 +4925,8 @@ dwarf_decode_lines (struct line_header *lh, char *comp_dir, bfd *abfd,
 		}
 	      break;
 	    case DW_LNS_copy:
-	      address = check_cu_functions (address);
-	      record_line (current_subfile, line, address);
+	      record_line (current_subfile, line, 
+	                   check_cu_functions (address));
 	      basic_block = 0;
 	      break;
 	    case DW_LNS_advance_pc:
diff --git a/gdb/eval.c b/gdb/eval.c
index d5d08927893..c266cd1e33e 100644
--- a/gdb/eval.c
+++ b/gdb/eval.c
@@ -32,6 +32,9 @@
 #include "language.h"		/* For CAST_IS_CONVERSION */
 #include "f-lang.h"		/* for array bound stuff */
 #include "cp-abi.h"
+#include "infcall.h"
+#include "objc-lang.h"
+#include "block.h"
 
 /* Defined in symtab.c */
 extern int hp_som_som_object_present;
@@ -471,6 +474,15 @@ evaluate_subexp_standard (struct type *expect_type,
 	goto nosideret;
       return value_string (&exp->elts[pc + 2].string, tem);
 
+    case OP_OBJC_NSSTRING:		/* Objective C Foundation Class NSString constant.  */
+      tem = longest_to_int (exp->elts[pc + 1].longconst);
+      (*pos) += 3 + BYTES_TO_EXP_ELEM (tem + 1);
+      if (noside == EVAL_SKIP)
+	{
+	  goto nosideret;
+	}
+      return (struct value *) value_nsstring (&exp->elts[pc + 2].string, tem + 1);
+
     case OP_BITSTRING:
       tem = longest_to_int (exp->elts[pc + 1].longconst);
       (*pos)
@@ -667,6 +679,275 @@ evaluate_subexp_standard (struct type *expect_type,
 	  return arg2;
 	}
 
+    case OP_OBJC_SELECTOR:
+      {				/* Objective C @selector operator.  */
+	char *sel = &exp->elts[pc + 2].string;
+	int len = longest_to_int (exp->elts[pc + 1].longconst);
+
+	(*pos) += 3 + BYTES_TO_EXP_ELEM (len + 1);
+	if (noside == EVAL_SKIP)
+	  goto nosideret;
+
+	if (sel[len] != 0)
+	  sel[len] = 0;		/* Make sure it's terminated.  */
+	return value_from_longest (lookup_pointer_type (builtin_type_void),
+				   lookup_child_selector (sel));
+      }
+
+    case OP_OBJC_MSGCALL:
+      {				/* Objective C message (method) call.  */
+
+	static unsigned long responds_selector = 0;
+	static unsigned long method_selector = 0;
+
+	unsigned long selector = 0;
+
+	int using_gcc = 0;
+	int struct_return = 0;
+	int sub_no_side = 0;
+
+	static struct value *msg_send = NULL;
+	static struct value *msg_send_stret = NULL;
+	static int gnu_runtime = 0;
+
+	struct value *target = NULL;
+	struct value *method = NULL;
+	struct value *called_method = NULL; 
+
+	struct type *selector_type = NULL;
+
+	struct value *ret = NULL;
+	CORE_ADDR addr = 0;
+
+	selector = exp->elts[pc + 1].longconst;
+	nargs = exp->elts[pc + 2].longconst;
+	argvec = (struct value **) alloca (sizeof (struct value *) 
+					   * (nargs + 5));
+
+	(*pos) += 3;
+
+	selector_type = lookup_pointer_type (builtin_type_void);
+	if (noside == EVAL_AVOID_SIDE_EFFECTS)
+	  sub_no_side = EVAL_NORMAL;
+	else
+	  sub_no_side = noside;
+
+	target = evaluate_subexp (selector_type, exp, pos, sub_no_side);
+
+	if (value_as_long (target) == 0)
+ 	  return value_from_longest (builtin_type_long, 0);
+	
+	if (lookup_minimal_symbol ("objc_msg_lookup", 0, 0))
+	  gnu_runtime = 1;
+	
+	/* Find the method dispatch (Apple runtime) or method lookup
+	   (GNU runtime) function for Objective-C.  These will be used
+	   to lookup the symbol information for the method.  If we
+	   can't find any symbol information, then we'll use these to
+	   call the method, otherwise we can call the method
+	   directly. The msg_send_stret function is used in the special
+	   case of a method that returns a structure (Apple runtime 
+	   only).  */
+	if (gnu_runtime)
+	  {
+	    msg_send = find_function_in_inferior ("objc_msg_lookup");
+	    msg_send_stret = find_function_in_inferior ("objc_msg_lookup");
+	  }
+	else
+	  {
+	    msg_send = find_function_in_inferior ("objc_msgSend");
+	    /* Special dispatcher for methods returning structs */
+	    msg_send_stret = find_function_in_inferior ("objc_msgSend_stret");
+	  }
+
+	/* Verify the target object responds to this method. The
+	   standard top-level 'Object' class uses a different name for
+	   the verification method than the non-standard, but more
+	   often used, 'NSObject' class. Make sure we check for both. */
+
+	responds_selector = lookup_child_selector ("respondsToSelector:");
+	if (responds_selector == 0)
+	  responds_selector = lookup_child_selector ("respondsTo:");
+	
+	if (responds_selector == 0)
+	  error ("no 'respondsTo:' or 'respondsToSelector:' method");
+	
+	method_selector = lookup_child_selector ("methodForSelector:");
+	if (method_selector == 0)
+	  method_selector = lookup_child_selector ("methodFor:");
+	
+	if (method_selector == 0)
+	  error ("no 'methodFor:' or 'methodForSelector:' method");
+
+	/* Call the verification method, to make sure that the target
+	 class implements the desired method. */
+
+	argvec[0] = msg_send;
+	argvec[1] = target;
+	argvec[2] = value_from_longest (builtin_type_long, responds_selector);
+	argvec[3] = value_from_longest (builtin_type_long, selector);
+	argvec[4] = 0;
+
+	ret = call_function_by_hand (argvec[0], 3, argvec + 1);
+	if (gnu_runtime)
+	  {
+	    /* Function objc_msg_lookup returns a pointer.  */
+	    argvec[0] = ret;
+	    ret = call_function_by_hand (argvec[0], 3, argvec + 1);
+	  }
+	if (value_as_long (ret) == 0)
+	  error ("Target does not respond to this message selector.");
+
+	/* Call "methodForSelector:" method, to get the address of a
+	   function method that implements this selector for this
+	   class.  If we can find a symbol at that address, then we
+	   know the return type, parameter types etc.  (that's a good
+	   thing). */
+
+	argvec[0] = msg_send;
+	argvec[1] = target;
+	argvec[2] = value_from_longest (builtin_type_long, method_selector);
+	argvec[3] = value_from_longest (builtin_type_long, selector);
+	argvec[4] = 0;
+
+	ret = call_function_by_hand (argvec[0], 3, argvec + 1);
+	if (gnu_runtime)
+	  {
+	    argvec[0] = ret;
+	    ret = call_function_by_hand (argvec[0], 3, argvec + 1);
+	  }
+
+	/* ret should now be the selector.  */
+
+	addr = value_as_long (ret);
+	if (addr)
+	  {
+	    struct symbol *sym = NULL;
+	    /* Is it a high_level symbol?  */
+
+	    sym = find_pc_function (addr);
+	    if (sym != NULL) 
+	      method = value_of_variable (sym, 0);
+	  }
+
+	/* If we found a method with symbol information, check to see
+           if it returns a struct.  Otherwise assume it doesn't.  */
+
+	if (method)
+	  {
+	    struct block *b;
+	    CORE_ADDR funaddr;
+	    struct type *value_type;
+
+	    funaddr = find_function_addr (method, &value_type);
+
+	    b = block_for_pc (funaddr);
+
+	    /* If compiled without -g, assume GCC 2.  */
+	    using_gcc = (b == NULL ? 2 : BLOCK_GCC_COMPILED (b));
+
+	    CHECK_TYPEDEF (value_type);
+	  
+	    if ((value_type == NULL) 
+		|| (TYPE_CODE(value_type) == TYPE_CODE_ERROR))
+	      {
+		if (expect_type != NULL)
+		  value_type = expect_type;
+	      }
+
+	    struct_return = using_struct_return (method, funaddr, value_type, using_gcc);
+	  }
+	else if (expect_type != NULL)
+	  {
+	    struct_return = using_struct_return (NULL, addr, check_typedef (expect_type), using_gcc);
+	  }
+	
+	/* Found a function symbol.  Now we will substitute its
+	   value in place of the message dispatcher (obj_msgSend),
+	   so that we call the method directly instead of thru
+	   the dispatcher.  The main reason for doing this is that
+	   we can now evaluate the return value and parameter values
+	   according to their known data types, in case we need to
+	   do things like promotion, dereferencing, special handling
+	   of structs and doubles, etc.
+	  
+	   We want to use the type signature of 'method', but still
+	   jump to objc_msgSend() or objc_msgSend_stret() to better
+	   mimic the behavior of the runtime.  */
+	
+	if (method)
+	  {
+	    if (TYPE_CODE (VALUE_TYPE (method)) != TYPE_CODE_FUNC)
+	      error ("method address has symbol information with non-function type; skipping");
+	    if (struct_return)
+	      VALUE_ADDRESS (method) = value_as_address (msg_send_stret);
+	    else
+	      VALUE_ADDRESS (method) = value_as_address (msg_send);
+	    called_method = method;
+	  }
+	else
+	  {
+	    if (struct_return)
+	      called_method = msg_send_stret;
+	    else
+	      called_method = msg_send;
+	  }
+
+	if (noside == EVAL_SKIP)
+	  goto nosideret;
+
+	if (noside == EVAL_AVOID_SIDE_EFFECTS)
+	  {
+	    /* If the return type doesn't look like a function type,
+	       call an error.  This can happen if somebody tries to
+	       turn a variable into a function call. This is here
+	       because people often want to call, eg, strcmp, which
+	       gdb doesn't know is a function.  If gdb isn't asked for
+	       it's opinion (ie. through "whatis"), it won't offer
+	       it. */
+
+	    struct type *type = VALUE_TYPE (called_method);
+	    if (type && TYPE_CODE (type) == TYPE_CODE_PTR)
+	      type = TYPE_TARGET_TYPE (type);
+	    type = TYPE_TARGET_TYPE (type);
+
+	    if (type)
+	    {
+	      if ((TYPE_CODE (type) == TYPE_CODE_ERROR) && expect_type)
+		return allocate_value (expect_type);
+	      else
+		return allocate_value (type);
+	    }
+	    else
+	      error ("Expression of type other than \"method returning ...\" used as a method");
+	  }
+
+	/* Now depending on whether we found a symbol for the method,
+	   we will either call the runtime dispatcher or the method
+	   directly.  */
+
+	argvec[0] = called_method;
+	argvec[1] = target;
+	argvec[2] = value_from_longest (builtin_type_long, selector);
+	/* User-supplied arguments.  */
+	for (tem = 0; tem < nargs; tem++)
+	  argvec[tem + 3] = evaluate_subexp_with_coercion (exp, pos, noside);
+	argvec[tem + 3] = 0;
+
+	if (gnu_runtime && (method != NULL))
+	  {
+	    ret = call_function_by_hand (argvec[0], nargs + 2, argvec + 1);
+	    /* Function objc_msg_lookup returns a pointer.  */
+	    argvec[0] = ret;
+	    ret = call_function_by_hand (argvec[0], nargs + 2, argvec + 1);
+	  }
+	else
+	  ret = call_function_by_hand (argvec[0], nargs + 2, argvec + 1);
+
+	return ret;
+      }
+      break;
+
     case OP_FUNCALL:
       (*pos) += 2;
       op = exp->elts[*pos].opcode;
@@ -1749,6 +2030,10 @@ evaluate_subexp_standard (struct type *expect_type,
       (*pos) += 1;
       return value_of_this (1);
 
+    case OP_OBJC_SELF:
+      (*pos) += 1;
+      return value_of_local ("self", 1);
+
     case OP_TYPE:
       error ("Attempt to use a type name as an expression");
 
diff --git a/gdb/findvar.c b/gdb/findvar.c
index beab9fb8fe5..ca371d21e03 100644
--- a/gdb/findvar.c
+++ b/gdb/findvar.c
@@ -300,7 +300,7 @@ value_of_register (int regnum, struct frame_info *frame)
   int optim;
   struct value *reg_val;
   int realnum;
-  char *raw_buffer = (char*) alloca (MAX_REGISTER_RAW_SIZE);
+  char raw_buffer[MAX_REGISTER_SIZE];
   enum lval_type lval;
 
   /* Builtin registers lie completly outside of the range of normal
@@ -664,7 +664,7 @@ addresses have not been bound by the dynamic loader. Try again when executable i
 struct value *
 value_from_register (struct type *type, int regnum, struct frame_info *frame)
 {
-  char *raw_buffer = (char*) alloca (MAX_REGISTER_RAW_SIZE);
+  char raw_buffer[MAX_REGISTER_SIZE];
   CORE_ADDR addr;
   int optim;
   struct value *v = allocate_value (type);
@@ -699,7 +699,7 @@ value_from_register (struct type *type, int regnum, struct frame_info *frame)
       CORE_ADDR last_addr = 0;
       CORE_ADDR first_addr = 0;
 
-      value_bytes = (char *) alloca (len + MAX_REGISTER_RAW_SIZE);
+      value_bytes = (char *) alloca (len + MAX_REGISTER_SIZE);
 
       /* Copy all of the data out, whereever it may be.  */
 
diff --git a/gdb/fork-child.c b/gdb/fork-child.c
index 1dc28e822d4..e1d32b06452 100644
--- a/gdb/fork-child.c
+++ b/gdb/fork-child.c
@@ -88,6 +88,29 @@ breakup_args (char *scratch, char **argv)
 
 }
 
+/* When executing a command under the given shell, return non-zero
+   if the '!' character should be escaped when embedded in a quoted
+   command-line argument.  */
+
+static int
+escape_bang_in_quoted_argument (const char *shell_file)
+{
+  const int shell_file_len = strlen (shell_file);
+  
+  /* Bang should be escaped only in C Shells.  For now, simply check
+     that the shell name ends with 'csh', which covers at least csh
+     and tcsh.  This should be good enough for now.  */
+
+  if (shell_file_len < 3)
+    return 0;
+
+  if (shell_file[shell_file_len - 3] == 'c'
+      && shell_file[shell_file_len - 2] == 's'
+      && shell_file[shell_file_len - 1] == 'h')
+    return 1;
+
+  return 0;
+}
 
 /* Start an inferior Unix child process and sets inferior_ptid to its pid.
    EXEC_FILE is the file to run.
@@ -171,6 +194,7 @@ fork_inferior (char *exec_file_arg, char *allargs, char **env,
 
       char *p;
       int need_to_quote;
+      const int escape_bang = escape_bang_in_quoted_argument (shell_file);
 
       strcat (shell_command, "exec ");
 
@@ -215,7 +239,7 @@ fork_inferior (char *exec_file_arg, char *allargs, char **env,
 	    {
 	      if (*p == '\'')
 		strcat (shell_command, "'\\''");
-	      else if (*p == '!')
+	      else if (*p == '!' && escape_bang)
 		strcat (shell_command, "\\!");
 	      else
 		strncat (shell_command, p, 1);
@@ -404,9 +428,6 @@ startup_inferior (int ntraps)
   inferior_ignoring_leading_exec_events =
     target_reported_exec_events_per_exec_call () - 1;
 
-#ifdef STARTUP_INFERIOR
-  STARTUP_INFERIOR (pending_execs);
-#else
   while (1)
     {
       /* Make wait_for_inferior be quiet */
@@ -444,6 +465,5 @@ startup_inferior (int ntraps)
 	  resume (0, TARGET_SIGNAL_0);	/* Just make it go on */
 	}
     }
-#endif /* STARTUP_INFERIOR */
   stop_soon = NO_STOP_QUIETLY;
 }
diff --git a/gdb/frame.c b/gdb/frame.c
index 3871aa1d5fc..a664b97999b 100644
--- a/gdb/frame.c
+++ b/gdb/frame.c
@@ -139,7 +139,7 @@ static int frame_debug;
 
 static int backtrace_below_main;
 
-static void
+void
 fprint_frame_id (struct ui_file *file, struct frame_id id)
 {
   fprintf_unfiltered (file, "{stack=0x%s,code=0x%s}",
@@ -295,10 +295,8 @@ frame_id_eq (struct frame_id l, struct frame_id r)
     /* The .stack and .code are identical, the ID's are identical.  */
     eq = 1;
   else
-    /* FIXME: cagney/2003-04-06: This should be zero.  Can't yet do
-       this because most frame ID's are not being initialized
-       correctly.  */
-    eq = 1;
+    /* No luck.  */
+    eq = 0;
   if (frame_debug)
     {
       fprintf_unfiltered (gdb_stdlog, "{ frame_id_eq (l=");
@@ -620,7 +618,7 @@ void
 frame_unwind_signed_register (struct frame_info *frame, int regnum,
 			      LONGEST *val)
 {
-  void *buf = alloca (MAX_REGISTER_RAW_SIZE);
+  char buf[MAX_REGISTER_SIZE];
   frame_unwind_register (frame, regnum, buf);
   (*val) = extract_signed_integer (buf, REGISTER_VIRTUAL_SIZE (regnum));
 }
@@ -629,7 +627,7 @@ void
 frame_unwind_unsigned_register (struct frame_info *frame, int regnum,
 				ULONGEST *val)
 {
-  void *buf = alloca (MAX_REGISTER_RAW_SIZE);
+  char buf[MAX_REGISTER_SIZE];
   frame_unwind_register (frame, regnum, buf);
   (*val) = extract_unsigned_integer (buf, REGISTER_VIRTUAL_SIZE (regnum));
 }
@@ -1388,7 +1386,8 @@ legacy_get_prev_frame (struct frame_info *this_frame)
 	     using the same sequence as is found a traditional
 	     unwinder.  Once all architectures supply the
 	     unwind_dummy_id method, this code can go away.  */
-	  prev->this_id.value = frame_id_build (read_fp (), read_pc ());
+	  prev->this_id.value = frame_id_build (deprecated_read_fp (),
+						read_pc ());
 	}
 
       /* Check that the unwound ID is valid.  */
@@ -1543,8 +1542,9 @@ legacy_get_prev_frame (struct frame_info *this_frame)
      DEPRECATED_INIT_EXTRA_FRAME_INFO, one possible scheme:
 
      SETUP_INNERMOST_FRAME(): Default version is just create_new_frame
-     (read_fp ()), read_pc ()).  Machines with extra frame info would
-     do that (or the local equivalent) and then set the extra fields.
+     (deprecated_read_fp ()), read_pc ()).  Machines with extra frame
+     info would do that (or the local equivalent) and then set the
+     extra fields.
 
      SETUP_ARBITRARY_FRAME(argc, argv): Only change here is that
      create_new_frame would no longer init extra frame info;
@@ -2069,7 +2069,12 @@ get_frame_type (struct frame_info *frame)
   if (!DEPRECATED_USE_GENERIC_DUMMY_FRAMES
       && deprecated_frame_in_dummy (frame))
     return DUMMY_FRAME;
-  if (frame->unwind == NULL)
+
+  /* Some legacy code, e.g, mips_init_extra_frame_info() wants
+     to determine the frame's type prior to it being completely
+     initialized.  Don't attempt to lazily initialize ->unwind for
+     legacy code.  It will be initialized in legacy_get_prev_frame().  */
+  if (frame->unwind == NULL && !legacy_frame_p (current_gdbarch))
     {
       /* Initialize the frame's unwinder because it is that which
          provides the frame's type.  */
diff --git a/gdb/frame.h b/gdb/frame.h
index f33755a99ca..a8f05f35f8b 100644
--- a/gdb/frame.h
+++ b/gdb/frame.h
@@ -95,6 +95,10 @@ extern int frame_id_eq (struct frame_id l, struct frame_id r);
    above about frameless functions.  */
 extern int frame_id_inner (struct frame_id l, struct frame_id r);
 
+/* Write the internal representation of a frame ID on the specified
+   stream.  */
+extern void fprint_frame_id (struct ui_file *file, struct frame_id id);
+
 
 /* For every stopped thread, GDB tracks two frames: current and
    selected.  Current frame is the inner most frame of the selected
@@ -369,6 +373,7 @@ enum print_what
 
 extern void *frame_obstack_zalloc (unsigned long size);
 #define FRAME_OBSTACK_ZALLOC(TYPE) ((TYPE *) frame_obstack_zalloc (sizeof (TYPE)))
+#define FRAME_OBSTACK_CALLOC(NUMBER,TYPE) ((TYPE *) frame_obstack_zalloc ((NUMBER) * sizeof (TYPE)))
 
 /* If legacy_frame_chain_valid() returns zero it means that the given
    frame is the outermost one and has no caller.
@@ -556,9 +561,9 @@ extern void deprecated_update_frame_pc_hack (struct frame_info *frame,
 
 /* FIXME: cagney/2002-12-18: Has the frame's base changed?  Or to be
    more exact, whas that initial guess at the frame's base as returned
-   by read_fp() wrong.  If it was, fix it.  This shouldn't be
-   necessary since the code should be getting the frame's base correct
-   from the outset.
+   by deprecated_read_fp() wrong.  If it was, fix it.  This shouldn't
+   be necessary since the code should be getting the frame's base
+   correct from the outset.
 
    This replaced: frame->frame = ....; */
 extern void deprecated_update_frame_base_hack (struct frame_info *frame,
diff --git a/gdb/frv-tdep.c b/gdb/frv-tdep.c
index bab37760ad0..ce02b7fc6a8 100644
--- a/gdb/frv-tdep.c
+++ b/gdb/frv-tdep.c
@@ -1053,11 +1053,11 @@ frv_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
 
   set_gdbarch_num_regs (gdbarch, frv_num_regs);
   set_gdbarch_sp_regnum (gdbarch, sp_regnum);
-  set_gdbarch_fp_regnum (gdbarch, fp_regnum);
+  set_gdbarch_deprecated_fp_regnum (gdbarch, fp_regnum);
   set_gdbarch_pc_regnum (gdbarch, pc_regnum);
 
   set_gdbarch_register_name (gdbarch, frv_register_name);
-  set_gdbarch_register_size (gdbarch, 4);
+  set_gdbarch_deprecated_register_size (gdbarch, 4);
   set_gdbarch_register_bytes (gdbarch, frv_num_regs * 4);
   set_gdbarch_register_byte (gdbarch, frv_register_byte);
   set_gdbarch_register_raw_size (gdbarch, frv_register_raw_size);
@@ -1092,8 +1092,8 @@ frv_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
   set_gdbarch_deprecated_push_return_address (gdbarch, frv_push_return_address);
   set_gdbarch_deprecated_pop_frame (gdbarch, frv_pop_frame);
 
-  set_gdbarch_call_dummy_words (gdbarch, frv_call_dummy_words);
-  set_gdbarch_sizeof_call_dummy_words (gdbarch, sizeof (frv_call_dummy_words));
+  set_gdbarch_deprecated_call_dummy_words (gdbarch, frv_call_dummy_words);
+  set_gdbarch_deprecated_sizeof_call_dummy_words (gdbarch, sizeof (frv_call_dummy_words));
   set_gdbarch_deprecated_init_extra_frame_info (gdbarch, frv_init_extra_frame_info);
 
   /* Settings that should be unnecessary.  */
@@ -1101,7 +1101,6 @@ frv_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
 
   set_gdbarch_read_pc (gdbarch, generic_target_read_pc);
   set_gdbarch_write_pc (gdbarch, generic_target_write_pc);
-  set_gdbarch_read_fp (gdbarch, generic_target_read_fp);
   set_gdbarch_read_sp (gdbarch, generic_target_read_sp);
   set_gdbarch_deprecated_dummy_write_sp (gdbarch, generic_target_write_sp);
 
@@ -1147,7 +1146,7 @@ _initialize_frv_tdep (void)
 {
   register_gdbarch_init (bfd_arch_frv, frv_gdbarch_init);
 
-  tm_print_insn = print_insn_frv;
+  deprecated_tm_print_insn = print_insn_frv;
 }
 
 
diff --git a/gdb/gcore.c b/gdb/gcore.c
index 5ad17e83f83..6a0edbf51e1 100644
--- a/gdb/gcore.c
+++ b/gdb/gcore.c
@@ -26,6 +26,7 @@
 #include "elf-bfd.h"
 #include "symfile.h"
 #include "objfiles.h"
+#include "infcall.h"
 
 static char                  *default_gcore_target (void);
 static enum bfd_architecture  default_gcore_arch (void);
diff --git a/gdb/gdbarch.c b/gdb/gdbarch.c
index 3b5a80762c3..db9e76e9671 100644
--- a/gdb/gdbarch.c
+++ b/gdb/gdbarch.c
@@ -147,7 +147,7 @@ struct gdbarch
   int char_signed;
   gdbarch_read_pc_ftype *read_pc;
   gdbarch_write_pc_ftype *write_pc;
-  gdbarch_read_fp_ftype *read_fp;
+  gdbarch_deprecated_target_read_fp_ftype *deprecated_target_read_fp;
   gdbarch_read_sp_ftype *read_sp;
   gdbarch_deprecated_dummy_write_sp_ftype *deprecated_dummy_write_sp;
   gdbarch_virtual_frame_pointer_ftype *virtual_frame_pointer;
@@ -156,7 +156,7 @@ struct gdbarch
   int num_regs;
   int num_pseudo_regs;
   int sp_regnum;
-  int fp_regnum;
+  int deprecated_fp_regnum;
   int pc_regnum;
   int ps_regnum;
   int fp0_regnum;
@@ -167,7 +167,7 @@ struct gdbarch
   gdbarch_sdb_reg_to_regnum_ftype *sdb_reg_to_regnum;
   gdbarch_dwarf2_reg_to_regnum_ftype *dwarf2_reg_to_regnum;
   gdbarch_register_name_ftype *register_name;
-  int register_size;
+  int deprecated_register_size;
   int register_bytes;
   gdbarch_register_byte_ftype *register_byte;
   gdbarch_register_raw_size_ftype *register_raw_size;
@@ -188,14 +188,15 @@ struct gdbarch
   int deprecated_use_generic_dummy_frames;
   int call_dummy_location;
   gdbarch_call_dummy_address_ftype *call_dummy_address;
-  CORE_ADDR call_dummy_start_offset;
-  CORE_ADDR call_dummy_breakpoint_offset;
-  int call_dummy_length;
+  CORE_ADDR deprecated_call_dummy_start_offset;
+  CORE_ADDR deprecated_call_dummy_breakpoint_offset;
+  int deprecated_call_dummy_length;
   gdbarch_deprecated_pc_in_call_dummy_ftype *deprecated_pc_in_call_dummy;
-  LONGEST * call_dummy_words;
-  int sizeof_call_dummy_words;
+  LONGEST * deprecated_call_dummy_words;
+  int deprecated_sizeof_call_dummy_words;
   int deprecated_call_dummy_stack_adjust;
-  gdbarch_fix_call_dummy_ftype *fix_call_dummy;
+  gdbarch_deprecated_fix_call_dummy_ftype *deprecated_fix_call_dummy;
+  gdbarch_push_dummy_code_ftype *push_dummy_code;
   gdbarch_deprecated_init_frame_pc_first_ftype *deprecated_init_frame_pc_first;
   gdbarch_deprecated_init_frame_pc_ftype *deprecated_init_frame_pc;
   int believe_pcc_promotion;
@@ -401,6 +402,7 @@ struct gdbarch startup_gdbarch =
   0,
   0,
   0,
+  generic_remote_translate_xfer_address,
   0,
   0,
   0,
@@ -499,12 +501,11 @@ gdbarch_alloc (const struct gdbarch_info *info,
   current_gdbarch->char_signed = -1;
   current_gdbarch->read_pc = generic_target_read_pc;
   current_gdbarch->write_pc = generic_target_write_pc;
-  current_gdbarch->read_fp = generic_target_read_fp;
   current_gdbarch->read_sp = generic_target_read_sp;
   current_gdbarch->virtual_frame_pointer = legacy_virtual_frame_pointer;
   current_gdbarch->num_regs = -1;
   current_gdbarch->sp_regnum = -1;
-  current_gdbarch->fp_regnum = -1;
+  current_gdbarch->deprecated_fp_regnum = -1;
   current_gdbarch->pc_regnum = -1;
   current_gdbarch->ps_regnum = -1;
   current_gdbarch->fp0_regnum = -1;
@@ -515,8 +516,6 @@ gdbarch_alloc (const struct gdbarch_info *info,
   current_gdbarch->sdb_reg_to_regnum = no_op_reg_to_regnum;
   current_gdbarch->dwarf2_reg_to_regnum = no_op_reg_to_regnum;
   current_gdbarch->register_name = legacy_register_name;
-  current_gdbarch->register_size = -1;
-  current_gdbarch->register_bytes = -1;
   current_gdbarch->register_byte = generic_register_byte;
   current_gdbarch->register_raw_size = generic_register_size;
   current_gdbarch->register_virtual_size = generic_register_size;
@@ -528,8 +527,8 @@ gdbarch_alloc (const struct gdbarch_info *info,
   current_gdbarch->call_dummy_location = AT_ENTRY_POINT;
   current_gdbarch->call_dummy_address = entry_point_address;
   current_gdbarch->deprecated_pc_in_call_dummy = generic_pc_in_call_dummy;
-  current_gdbarch->call_dummy_words = legacy_call_dummy_words;
-  current_gdbarch->sizeof_call_dummy_words = legacy_sizeof_call_dummy_words;
+  current_gdbarch->deprecated_call_dummy_words = legacy_call_dummy_words;
+  current_gdbarch->deprecated_sizeof_call_dummy_words = legacy_sizeof_call_dummy_words;
   current_gdbarch->register_convertible = generic_register_convertible_not;
   current_gdbarch->convert_register_p = legacy_convert_register_p;
   current_gdbarch->register_to_value = legacy_register_to_value;
@@ -622,7 +621,7 @@ verify_gdbarch (struct gdbarch *gdbarch)
     gdbarch->char_signed = 1;
   /* Skip verify of read_pc, invalid_p == 0 */
   /* Skip verify of write_pc, invalid_p == 0 */
-  /* Skip verify of read_fp, invalid_p == 0 */
+  /* Skip verify of deprecated_target_read_fp, has predicate */
   /* Skip verify of read_sp, invalid_p == 0 */
   /* Skip verify of deprecated_dummy_write_sp, has predicate */
   /* Skip verify of virtual_frame_pointer, invalid_p == 0 */
@@ -633,7 +632,7 @@ verify_gdbarch (struct gdbarch *gdbarch)
     fprintf_unfiltered (log, "\n\tnum_regs");
   /* Skip verify of num_pseudo_regs, invalid_p == 0 */
   /* Skip verify of sp_regnum, invalid_p == 0 */
-  /* Skip verify of fp_regnum, invalid_p == 0 */
+  /* Skip verify of deprecated_fp_regnum, invalid_p == 0 */
   /* Skip verify of pc_regnum, invalid_p == 0 */
   /* Skip verify of ps_regnum, invalid_p == 0 */
   /* Skip verify of fp0_regnum, invalid_p == 0 */
@@ -644,13 +643,7 @@ verify_gdbarch (struct gdbarch *gdbarch)
   /* Skip verify of sdb_reg_to_regnum, invalid_p == 0 */
   /* Skip verify of dwarf2_reg_to_regnum, invalid_p == 0 */
   /* Skip verify of register_name, invalid_p == 0 */
-  if ((GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL)
-      && (gdbarch->register_size == -1))
-    fprintf_unfiltered (log, "\n\tregister_size");
-  if ((GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL)
-      && (gdbarch->register_bytes == -1))
-    fprintf_unfiltered (log, "\n\tregister_bytes");
-  /* Skip verify of register_byte, invalid_p == 0 */
+  /* Skip verify of register_byte, has predicate */
   /* Skip verify of register_raw_size, invalid_p == 0 */
   /* Skip verify of deprecated_max_register_raw_size, has predicate */
   /* Skip verify of register_virtual_size, invalid_p == 0 */
@@ -670,10 +663,11 @@ verify_gdbarch (struct gdbarch *gdbarch)
   /* Skip verify of call_dummy_location, invalid_p == 0 */
   /* Skip verify of call_dummy_address, invalid_p == 0 */
   /* Skip verify of deprecated_pc_in_call_dummy, has predicate */
-  /* Skip verify of call_dummy_words, invalid_p == 0 */
-  /* Skip verify of sizeof_call_dummy_words, invalid_p == 0 */
+  /* Skip verify of deprecated_call_dummy_words, invalid_p == 0 */
+  /* Skip verify of deprecated_sizeof_call_dummy_words, invalid_p == 0 */
   /* Skip verify of deprecated_call_dummy_stack_adjust, has predicate */
-  /* Skip verify of fix_call_dummy, has predicate */
+  /* Skip verify of deprecated_fix_call_dummy, has predicate */
+  /* Skip verify of push_dummy_code, has predicate */
   /* Skip verify of deprecated_init_frame_pc_first, has predicate */
   /* Skip verify of deprecated_init_frame_pc, has predicate */
   /* Skip verify of deprecated_get_saved_register, has predicate */
@@ -922,22 +916,6 @@ gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file)
                         (long) current_gdbarch->call_dummy_address
                         /*CALL_DUMMY_ADDRESS ()*/);
 #endif
-#ifdef CALL_DUMMY_BREAKPOINT_OFFSET
-  fprintf_unfiltered (file,
-                      "gdbarch_dump: CALL_DUMMY_BREAKPOINT_OFFSET # %s\n",
-                      XSTRING (CALL_DUMMY_BREAKPOINT_OFFSET));
-  fprintf_unfiltered (file,
-                      "gdbarch_dump: CALL_DUMMY_BREAKPOINT_OFFSET = %ld\n",
-                      (long) CALL_DUMMY_BREAKPOINT_OFFSET);
-#endif
-#ifdef CALL_DUMMY_LENGTH
-  fprintf_unfiltered (file,
-                      "gdbarch_dump: CALL_DUMMY_LENGTH # %s\n",
-                      XSTRING (CALL_DUMMY_LENGTH));
-  fprintf_unfiltered (file,
-                      "gdbarch_dump: CALL_DUMMY_LENGTH = %d\n",
-                      CALL_DUMMY_LENGTH);
-#endif
 #ifdef CALL_DUMMY_LOCATION
   fprintf_unfiltered (file,
                       "gdbarch_dump: CALL_DUMMY_LOCATION # %s\n",
@@ -946,22 +924,6 @@ gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file)
                       "gdbarch_dump: CALL_DUMMY_LOCATION = %d\n",
                       CALL_DUMMY_LOCATION);
 #endif
-#ifdef CALL_DUMMY_START_OFFSET
-  fprintf_unfiltered (file,
-                      "gdbarch_dump: CALL_DUMMY_START_OFFSET # %s\n",
-                      XSTRING (CALL_DUMMY_START_OFFSET));
-  fprintf_unfiltered (file,
-                      "gdbarch_dump: CALL_DUMMY_START_OFFSET = %ld\n",
-                      (long) CALL_DUMMY_START_OFFSET);
-#endif
-#ifdef CALL_DUMMY_WORDS
-  fprintf_unfiltered (file,
-                      "gdbarch_dump: CALL_DUMMY_WORDS # %s\n",
-                      XSTRING (CALL_DUMMY_WORDS));
-  fprintf_unfiltered (file,
-                      "gdbarch_dump: CALL_DUMMY_WORDS = 0x%08lx\n",
-                      (long) CALL_DUMMY_WORDS);
-#endif
 #ifdef CANNOT_FETCH_REGISTER
   fprintf_unfiltered (file,
                       "gdbarch_dump: %s # %s\n",
@@ -1040,6 +1002,22 @@ gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file)
                       "gdbarch_dump: DECR_PC_AFTER_BREAK = %ld\n",
                       (long) DECR_PC_AFTER_BREAK);
 #endif
+#ifdef DEPRECATED_CALL_DUMMY_BREAKPOINT_OFFSET
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: DEPRECATED_CALL_DUMMY_BREAKPOINT_OFFSET # %s\n",
+                      XSTRING (DEPRECATED_CALL_DUMMY_BREAKPOINT_OFFSET));
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: DEPRECATED_CALL_DUMMY_BREAKPOINT_OFFSET = %ld\n",
+                      (long) DEPRECATED_CALL_DUMMY_BREAKPOINT_OFFSET);
+#endif
+#ifdef DEPRECATED_CALL_DUMMY_LENGTH
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: DEPRECATED_CALL_DUMMY_LENGTH # %s\n",
+                      XSTRING (DEPRECATED_CALL_DUMMY_LENGTH));
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: DEPRECATED_CALL_DUMMY_LENGTH = %d\n",
+                      DEPRECATED_CALL_DUMMY_LENGTH);
+#endif
 #ifdef DEPRECATED_CALL_DUMMY_STACK_ADJUST_P
   fprintf_unfiltered (file,
                       "gdbarch_dump: %s # %s\n",
@@ -1057,6 +1035,22 @@ gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file)
                       "gdbarch_dump: DEPRECATED_CALL_DUMMY_STACK_ADJUST = %d\n",
                       DEPRECATED_CALL_DUMMY_STACK_ADJUST);
 #endif
+#ifdef DEPRECATED_CALL_DUMMY_START_OFFSET
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: DEPRECATED_CALL_DUMMY_START_OFFSET # %s\n",
+                      XSTRING (DEPRECATED_CALL_DUMMY_START_OFFSET));
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: DEPRECATED_CALL_DUMMY_START_OFFSET = %ld\n",
+                      (long) DEPRECATED_CALL_DUMMY_START_OFFSET);
+#endif
+#ifdef DEPRECATED_CALL_DUMMY_WORDS
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: DEPRECATED_CALL_DUMMY_WORDS # %s\n",
+                      XSTRING (DEPRECATED_CALL_DUMMY_WORDS));
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: DEPRECATED_CALL_DUMMY_WORDS = 0x%08lx\n",
+                      (long) DEPRECATED_CALL_DUMMY_WORDS);
+#endif
 #ifdef DEPRECATED_DO_REGISTERS_INFO_P
   fprintf_unfiltered (file,
                       "gdbarch_dump: %s # %s\n",
@@ -1145,6 +1139,37 @@ gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file)
                       "gdbarch_dump: DEPRECATED_EXTRA_STACK_ALIGNMENT_NEEDED = %d\n",
                       DEPRECATED_EXTRA_STACK_ALIGNMENT_NEEDED);
 #endif
+#ifdef DEPRECATED_FIX_CALL_DUMMY_P
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: %s # %s\n",
+                      "DEPRECATED_FIX_CALL_DUMMY_P()",
+                      XSTRING (DEPRECATED_FIX_CALL_DUMMY_P ()));
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: DEPRECATED_FIX_CALL_DUMMY_P() = %d\n",
+                      DEPRECATED_FIX_CALL_DUMMY_P ());
+#endif
+#ifdef DEPRECATED_FIX_CALL_DUMMY
+#if GDB_MULTI_ARCH
+  /* Macro might contain `[{}]' when not multi-arch */
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: %s # %s\n",
+                      "DEPRECATED_FIX_CALL_DUMMY(dummy, pc, fun, nargs, args, type, gcc_p)",
+                      XSTRING (DEPRECATED_FIX_CALL_DUMMY (dummy, pc, fun, nargs, args, type, gcc_p)));
+#endif
+  if (GDB_MULTI_ARCH)
+    fprintf_unfiltered (file,
+                        "gdbarch_dump: DEPRECATED_FIX_CALL_DUMMY = <0x%08lx>\n",
+                        (long) current_gdbarch->deprecated_fix_call_dummy
+                        /*DEPRECATED_FIX_CALL_DUMMY ()*/);
+#endif
+#ifdef DEPRECATED_FP_REGNUM
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: DEPRECATED_FP_REGNUM # %s\n",
+                      XSTRING (DEPRECATED_FP_REGNUM));
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: DEPRECATED_FP_REGNUM = %d\n",
+                      DEPRECATED_FP_REGNUM);
+#endif
 #ifdef DEPRECATED_FRAME_CHAIN_P
   fprintf_unfiltered (file,
                       "gdbarch_dump: %s # %s\n",
@@ -1454,6 +1479,14 @@ gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file)
                         (long) current_gdbarch->deprecated_push_return_address
                         /*DEPRECATED_PUSH_RETURN_ADDRESS ()*/);
 #endif
+#ifdef DEPRECATED_REGISTER_SIZE
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: DEPRECATED_REGISTER_SIZE # %s\n",
+                      XSTRING (DEPRECATED_REGISTER_SIZE));
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: DEPRECATED_REGISTER_SIZE = %d\n",
+                      DEPRECATED_REGISTER_SIZE);
+#endif
 #ifdef DEPRECATED_SAVED_PC_AFTER_CALL_P
   fprintf_unfiltered (file,
                       "gdbarch_dump: %s # %s\n",
@@ -1474,6 +1507,14 @@ gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file)
                         (long) current_gdbarch->deprecated_saved_pc_after_call
                         /*DEPRECATED_SAVED_PC_AFTER_CALL ()*/);
 #endif
+#ifdef DEPRECATED_SIZEOF_CALL_DUMMY_WORDS
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: DEPRECATED_SIZEOF_CALL_DUMMY_WORDS # %s\n",
+                      XSTRING (DEPRECATED_SIZEOF_CALL_DUMMY_WORDS));
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: DEPRECATED_SIZEOF_CALL_DUMMY_WORDS = %d\n",
+                      DEPRECATED_SIZEOF_CALL_DUMMY_WORDS);
+#endif
 #ifdef DEPRECATED_STORE_RETURN_VALUE
 #if GDB_MULTI_ARCH
   /* Macro might contain `[{}]' when not multi-arch */
@@ -1511,6 +1552,26 @@ gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file)
                         (long) current_gdbarch->deprecated_store_struct_return
                         /*DEPRECATED_STORE_STRUCT_RETURN ()*/);
 #endif
+#ifdef DEPRECATED_TARGET_READ_FP_P
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: %s # %s\n",
+                      "DEPRECATED_TARGET_READ_FP_P()",
+                      XSTRING (DEPRECATED_TARGET_READ_FP_P ()));
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: DEPRECATED_TARGET_READ_FP_P() = %d\n",
+                      DEPRECATED_TARGET_READ_FP_P ());
+#endif
+#ifdef DEPRECATED_TARGET_READ_FP
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: %s # %s\n",
+                      "DEPRECATED_TARGET_READ_FP()",
+                      XSTRING (DEPRECATED_TARGET_READ_FP ()));
+  if (GDB_MULTI_ARCH)
+    fprintf_unfiltered (file,
+                        "gdbarch_dump: DEPRECATED_TARGET_READ_FP = <0x%08lx>\n",
+                        (long) current_gdbarch->deprecated_target_read_fp
+                        /*DEPRECATED_TARGET_READ_FP ()*/);
+#endif
 #ifdef DEPRECATED_USE_GENERIC_DUMMY_FRAMES
   fprintf_unfiltered (file,
                       "gdbarch_dump: DEPRECATED_USE_GENERIC_DUMMY_FRAMES # %s\n",
@@ -1623,29 +1684,6 @@ gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file)
                         (long) current_gdbarch->extract_struct_value_address
                         /*EXTRACT_STRUCT_VALUE_ADDRESS ()*/);
 #endif
-#ifdef FIX_CALL_DUMMY_P
-  fprintf_unfiltered (file,
-                      "gdbarch_dump: %s # %s\n",
-                      "FIX_CALL_DUMMY_P()",
-                      XSTRING (FIX_CALL_DUMMY_P ()));
-  fprintf_unfiltered (file,
-                      "gdbarch_dump: FIX_CALL_DUMMY_P() = %d\n",
-                      FIX_CALL_DUMMY_P ());
-#endif
-#ifdef FIX_CALL_DUMMY
-#if GDB_MULTI_ARCH
-  /* Macro might contain `[{}]' when not multi-arch */
-  fprintf_unfiltered (file,
-                      "gdbarch_dump: %s # %s\n",
-                      "FIX_CALL_DUMMY(dummy, pc, fun, nargs, args, type, gcc_p)",
-                      XSTRING (FIX_CALL_DUMMY (dummy, pc, fun, nargs, args, type, gcc_p)));
-#endif
-  if (GDB_MULTI_ARCH)
-    fprintf_unfiltered (file,
-                        "gdbarch_dump: FIX_CALL_DUMMY = <0x%08lx>\n",
-                        (long) current_gdbarch->fix_call_dummy
-                        /*FIX_CALL_DUMMY ()*/);
-#endif
 #ifdef FP0_REGNUM
   fprintf_unfiltered (file,
                       "gdbarch_dump: FP0_REGNUM # %s\n",
@@ -1654,14 +1692,6 @@ gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file)
                       "gdbarch_dump: FP0_REGNUM = %d\n",
                       FP0_REGNUM);
 #endif
-#ifdef FP_REGNUM
-  fprintf_unfiltered (file,
-                      "gdbarch_dump: FP_REGNUM # %s\n",
-                      XSTRING (FP_REGNUM));
-  fprintf_unfiltered (file,
-                      "gdbarch_dump: FP_REGNUM = %d\n",
-                      FP_REGNUM);
-#endif
 #ifdef FRAMELESS_FUNCTION_INVOCATION
   fprintf_unfiltered (file,
                       "gdbarch_dump: %s # %s\n",
@@ -1953,6 +1983,23 @@ gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file)
     fprintf_unfiltered (file,
                         "gdbarch_dump: push_dummy_call = 0x%08lx\n",
                         (long) current_gdbarch->push_dummy_call);
+  if (GDB_MULTI_ARCH)
+    fprintf_unfiltered (file,
+                        "gdbarch_dump: gdbarch_push_dummy_code_p() = %d\n",
+                        gdbarch_push_dummy_code_p (current_gdbarch));
+  if (GDB_MULTI_ARCH)
+    fprintf_unfiltered (file,
+                        "gdbarch_dump: push_dummy_code = 0x%08lx\n",
+                        (long) current_gdbarch->push_dummy_code);
+#ifdef REGISTER_BYTE_P
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: %s # %s\n",
+                      "REGISTER_BYTE_P()",
+                      XSTRING (REGISTER_BYTE_P ()));
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: REGISTER_BYTE_P() = %d\n",
+                      REGISTER_BYTE_P ());
+#endif
 #ifdef REGISTER_BYTE
   fprintf_unfiltered (file,
                       "gdbarch_dump: %s # %s\n",
@@ -2064,14 +2111,6 @@ gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file)
                         (long) current_gdbarch->register_sim_regno
                         /*REGISTER_SIM_REGNO ()*/);
 #endif
-#ifdef REGISTER_SIZE
-  fprintf_unfiltered (file,
-                      "gdbarch_dump: REGISTER_SIZE # %s\n",
-                      XSTRING (REGISTER_SIZE));
-  fprintf_unfiltered (file,
-                      "gdbarch_dump: REGISTER_SIZE = %d\n",
-                      REGISTER_SIZE);
-#endif
 #ifdef REGISTER_TO_VALUE
 #if GDB_MULTI_ARCH
   /* Macro might contain `[{}]' when not multi-arch */
@@ -2145,20 +2184,10 @@ gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file)
                         (long) current_gdbarch->reg_struct_has_addr
                         /*REG_STRUCT_HAS_ADDR ()*/);
 #endif
-#ifdef REMOTE_TRANSLATE_XFER_ADDRESS
-#if GDB_MULTI_ARCH
-  /* Macro might contain `[{}]' when not multi-arch */
-  fprintf_unfiltered (file,
-                      "gdbarch_dump: %s # %s\n",
-                      "REMOTE_TRANSLATE_XFER_ADDRESS(gdb_addr, gdb_len, rem_addr, rem_len)",
-                      XSTRING (REMOTE_TRANSLATE_XFER_ADDRESS (gdb_addr, gdb_len, rem_addr, rem_len)));
-#endif
   if (GDB_MULTI_ARCH)
     fprintf_unfiltered (file,
-                        "gdbarch_dump: REMOTE_TRANSLATE_XFER_ADDRESS = <0x%08lx>\n",
-                        (long) current_gdbarch->remote_translate_xfer_address
-                        /*REMOTE_TRANSLATE_XFER_ADDRESS ()*/);
-#endif
+                        "gdbarch_dump: remote_translate_xfer_address = 0x%08lx\n",
+                        (long) current_gdbarch->remote_translate_xfer_address);
 #ifdef RETURN_VALUE_ON_STACK
   fprintf_unfiltered (file,
                       "gdbarch_dump: %s # %s\n",
@@ -2244,14 +2273,6 @@ gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file)
                         (long) current_gdbarch->sigtramp_start
                         /*SIGTRAMP_START ()*/);
 #endif
-#ifdef SIZEOF_CALL_DUMMY_WORDS
-  fprintf_unfiltered (file,
-                      "gdbarch_dump: SIZEOF_CALL_DUMMY_WORDS # %s\n",
-                      XSTRING (SIZEOF_CALL_DUMMY_WORDS));
-  fprintf_unfiltered (file,
-                      "gdbarch_dump: SIZEOF_CALL_DUMMY_WORDS = %d\n",
-                      SIZEOF_CALL_DUMMY_WORDS);
-#endif
 #ifdef SKIP_PROLOGUE
   fprintf_unfiltered (file,
                       "gdbarch_dump: %s # %s\n",
@@ -2501,17 +2522,6 @@ gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file)
                       "gdbarch_dump: TARGET_PTR_BIT = %d\n",
                       TARGET_PTR_BIT);
 #endif
-#ifdef TARGET_READ_FP
-  fprintf_unfiltered (file,
-                      "gdbarch_dump: %s # %s\n",
-                      "TARGET_READ_FP()",
-                      XSTRING (TARGET_READ_FP ()));
-  if (GDB_MULTI_ARCH)
-    fprintf_unfiltered (file,
-                        "gdbarch_dump: TARGET_READ_FP = <0x%08lx>\n",
-                        (long) current_gdbarch->read_fp
-                        /*TARGET_READ_FP ()*/);
-#endif
 #ifdef TARGET_READ_PC
   fprintf_unfiltered (file,
                       "gdbarch_dump: %s # %s\n",
@@ -2880,23 +2890,30 @@ set_gdbarch_write_pc (struct gdbarch *gdbarch,
   gdbarch->write_pc = write_pc;
 }
 
+int
+gdbarch_deprecated_target_read_fp_p (struct gdbarch *gdbarch)
+{
+  gdb_assert (gdbarch != NULL);
+  return gdbarch->deprecated_target_read_fp != 0;
+}
+
 CORE_ADDR
-gdbarch_read_fp (struct gdbarch *gdbarch)
+gdbarch_deprecated_target_read_fp (struct gdbarch *gdbarch)
 {
   gdb_assert (gdbarch != NULL);
-  if (gdbarch->read_fp == 0)
+  if (gdbarch->deprecated_target_read_fp == 0)
     internal_error (__FILE__, __LINE__,
-                    "gdbarch: gdbarch_read_fp invalid");
+                    "gdbarch: gdbarch_deprecated_target_read_fp invalid");
   if (gdbarch_debug >= 2)
-    fprintf_unfiltered (gdb_stdlog, "gdbarch_read_fp called\n");
-  return gdbarch->read_fp ();
+    fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_target_read_fp called\n");
+  return gdbarch->deprecated_target_read_fp ();
 }
 
 void
-set_gdbarch_read_fp (struct gdbarch *gdbarch,
-                     gdbarch_read_fp_ftype read_fp)
+set_gdbarch_deprecated_target_read_fp (struct gdbarch *gdbarch,
+                                       gdbarch_deprecated_target_read_fp_ftype deprecated_target_read_fp)
 {
-  gdbarch->read_fp = read_fp;
+  gdbarch->deprecated_target_read_fp = deprecated_target_read_fp;
 }
 
 CORE_ADDR
@@ -3069,20 +3086,20 @@ set_gdbarch_sp_regnum (struct gdbarch *gdbarch,
 }
 
 int
-gdbarch_fp_regnum (struct gdbarch *gdbarch)
+gdbarch_deprecated_fp_regnum (struct gdbarch *gdbarch)
 {
   gdb_assert (gdbarch != NULL);
-  /* Skip verify of fp_regnum, invalid_p == 0 */
+  /* Skip verify of deprecated_fp_regnum, invalid_p == 0 */
   if (gdbarch_debug >= 2)
-    fprintf_unfiltered (gdb_stdlog, "gdbarch_fp_regnum called\n");
-  return gdbarch->fp_regnum;
+    fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_fp_regnum called\n");
+  return gdbarch->deprecated_fp_regnum;
 }
 
 void
-set_gdbarch_fp_regnum (struct gdbarch *gdbarch,
-                       int fp_regnum)
+set_gdbarch_deprecated_fp_regnum (struct gdbarch *gdbarch,
+                                  int deprecated_fp_regnum)
 {
-  gdbarch->fp_regnum = fp_regnum;
+  gdbarch->deprecated_fp_regnum = deprecated_fp_regnum;
 }
 
 int
@@ -3268,31 +3285,25 @@ set_gdbarch_register_name (struct gdbarch *gdbarch,
 }
 
 int
-gdbarch_register_size (struct gdbarch *gdbarch)
+gdbarch_deprecated_register_size (struct gdbarch *gdbarch)
 {
   gdb_assert (gdbarch != NULL);
-  if (gdbarch->register_size == -1)
-    internal_error (__FILE__, __LINE__,
-                    "gdbarch: gdbarch_register_size invalid");
   if (gdbarch_debug >= 2)
-    fprintf_unfiltered (gdb_stdlog, "gdbarch_register_size called\n");
-  return gdbarch->register_size;
+    fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_register_size called\n");
+  return gdbarch->deprecated_register_size;
 }
 
 void
-set_gdbarch_register_size (struct gdbarch *gdbarch,
-                           int register_size)
+set_gdbarch_deprecated_register_size (struct gdbarch *gdbarch,
+                                      int deprecated_register_size)
 {
-  gdbarch->register_size = register_size;
+  gdbarch->deprecated_register_size = deprecated_register_size;
 }
 
 int
 gdbarch_register_bytes (struct gdbarch *gdbarch)
 {
   gdb_assert (gdbarch != NULL);
-  if (gdbarch->register_bytes == -1)
-    internal_error (__FILE__, __LINE__,
-                    "gdbarch: gdbarch_register_bytes invalid");
   if (gdbarch_debug >= 2)
     fprintf_unfiltered (gdb_stdlog, "gdbarch_register_bytes called\n");
   return gdbarch->register_bytes;
@@ -3306,12 +3317,20 @@ set_gdbarch_register_bytes (struct gdbarch *gdbarch,
 }
 
 int
+gdbarch_register_byte_p (struct gdbarch *gdbarch)
+{
+  gdb_assert (gdbarch != NULL);
+  return gdbarch->register_byte != generic_register_byte;
+}
+
+int
 gdbarch_register_byte (struct gdbarch *gdbarch, int reg_nr)
 {
   gdb_assert (gdbarch != NULL);
   if (gdbarch->register_byte == 0)
     internal_error (__FILE__, __LINE__,
                     "gdbarch: gdbarch_register_byte invalid");
+  /* Ignore predicate (gdbarch->register_byte != generic_register_byte).  */
   if (gdbarch_debug >= 2)
     fprintf_unfiltered (gdb_stdlog, "gdbarch_register_byte called\n");
   return gdbarch->register_byte (reg_nr);
@@ -3720,51 +3739,51 @@ set_gdbarch_call_dummy_address (struct gdbarch *gdbarch,
 }
 
 CORE_ADDR
-gdbarch_call_dummy_start_offset (struct gdbarch *gdbarch)
+gdbarch_deprecated_call_dummy_start_offset (struct gdbarch *gdbarch)
 {
   gdb_assert (gdbarch != NULL);
   if (gdbarch_debug >= 2)
-    fprintf_unfiltered (gdb_stdlog, "gdbarch_call_dummy_start_offset called\n");
-  return gdbarch->call_dummy_start_offset;
+    fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_call_dummy_start_offset called\n");
+  return gdbarch->deprecated_call_dummy_start_offset;
 }
 
 void
-set_gdbarch_call_dummy_start_offset (struct gdbarch *gdbarch,
-                                     CORE_ADDR call_dummy_start_offset)
+set_gdbarch_deprecated_call_dummy_start_offset (struct gdbarch *gdbarch,
+                                                CORE_ADDR deprecated_call_dummy_start_offset)
 {
-  gdbarch->call_dummy_start_offset = call_dummy_start_offset;
+  gdbarch->deprecated_call_dummy_start_offset = deprecated_call_dummy_start_offset;
 }
 
 CORE_ADDR
-gdbarch_call_dummy_breakpoint_offset (struct gdbarch *gdbarch)
+gdbarch_deprecated_call_dummy_breakpoint_offset (struct gdbarch *gdbarch)
 {
   gdb_assert (gdbarch != NULL);
   if (gdbarch_debug >= 2)
-    fprintf_unfiltered (gdb_stdlog, "gdbarch_call_dummy_breakpoint_offset called\n");
-  return gdbarch->call_dummy_breakpoint_offset;
+    fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_call_dummy_breakpoint_offset called\n");
+  return gdbarch->deprecated_call_dummy_breakpoint_offset;
 }
 
 void
-set_gdbarch_call_dummy_breakpoint_offset (struct gdbarch *gdbarch,
-                                          CORE_ADDR call_dummy_breakpoint_offset)
+set_gdbarch_deprecated_call_dummy_breakpoint_offset (struct gdbarch *gdbarch,
+                                                     CORE_ADDR deprecated_call_dummy_breakpoint_offset)
 {
-  gdbarch->call_dummy_breakpoint_offset = call_dummy_breakpoint_offset;
+  gdbarch->deprecated_call_dummy_breakpoint_offset = deprecated_call_dummy_breakpoint_offset;
 }
 
 int
-gdbarch_call_dummy_length (struct gdbarch *gdbarch)
+gdbarch_deprecated_call_dummy_length (struct gdbarch *gdbarch)
 {
   gdb_assert (gdbarch != NULL);
   if (gdbarch_debug >= 2)
-    fprintf_unfiltered (gdb_stdlog, "gdbarch_call_dummy_length called\n");
-  return gdbarch->call_dummy_length;
+    fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_call_dummy_length called\n");
+  return gdbarch->deprecated_call_dummy_length;
 }
 
 void
-set_gdbarch_call_dummy_length (struct gdbarch *gdbarch,
-                               int call_dummy_length)
+set_gdbarch_deprecated_call_dummy_length (struct gdbarch *gdbarch,
+                                          int deprecated_call_dummy_length)
 {
-  gdbarch->call_dummy_length = call_dummy_length;
+  gdbarch->deprecated_call_dummy_length = deprecated_call_dummy_length;
 }
 
 int
@@ -3795,37 +3814,37 @@ set_gdbarch_deprecated_pc_in_call_dummy (struct gdbarch *gdbarch,
 }
 
 LONGEST *
-gdbarch_call_dummy_words (struct gdbarch *gdbarch)
+gdbarch_deprecated_call_dummy_words (struct gdbarch *gdbarch)
 {
   gdb_assert (gdbarch != NULL);
-  /* Skip verify of call_dummy_words, invalid_p == 0 */
+  /* Skip verify of deprecated_call_dummy_words, invalid_p == 0 */
   if (gdbarch_debug >= 2)
-    fprintf_unfiltered (gdb_stdlog, "gdbarch_call_dummy_words called\n");
-  return gdbarch->call_dummy_words;
+    fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_call_dummy_words called\n");
+  return gdbarch->deprecated_call_dummy_words;
 }
 
 void
-set_gdbarch_call_dummy_words (struct gdbarch *gdbarch,
-                              LONGEST * call_dummy_words)
+set_gdbarch_deprecated_call_dummy_words (struct gdbarch *gdbarch,
+                                         LONGEST * deprecated_call_dummy_words)
 {
-  gdbarch->call_dummy_words = call_dummy_words;
+  gdbarch->deprecated_call_dummy_words = deprecated_call_dummy_words;
 }
 
 int
-gdbarch_sizeof_call_dummy_words (struct gdbarch *gdbarch)
+gdbarch_deprecated_sizeof_call_dummy_words (struct gdbarch *gdbarch)
 {
   gdb_assert (gdbarch != NULL);
-  /* Skip verify of sizeof_call_dummy_words, invalid_p == 0 */
+  /* Skip verify of deprecated_sizeof_call_dummy_words, invalid_p == 0 */
   if (gdbarch_debug >= 2)
-    fprintf_unfiltered (gdb_stdlog, "gdbarch_sizeof_call_dummy_words called\n");
-  return gdbarch->sizeof_call_dummy_words;
+    fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_sizeof_call_dummy_words called\n");
+  return gdbarch->deprecated_sizeof_call_dummy_words;
 }
 
 void
-set_gdbarch_sizeof_call_dummy_words (struct gdbarch *gdbarch,
-                                     int sizeof_call_dummy_words)
+set_gdbarch_deprecated_sizeof_call_dummy_words (struct gdbarch *gdbarch,
+                                                int deprecated_sizeof_call_dummy_words)
 {
-  gdbarch->sizeof_call_dummy_words = sizeof_call_dummy_words;
+  gdbarch->deprecated_sizeof_call_dummy_words = deprecated_sizeof_call_dummy_words;
 }
 
 int
@@ -3852,29 +3871,55 @@ set_gdbarch_deprecated_call_dummy_stack_adjust (struct gdbarch *gdbarch,
 }
 
 int
-gdbarch_fix_call_dummy_p (struct gdbarch *gdbarch)
+gdbarch_deprecated_fix_call_dummy_p (struct gdbarch *gdbarch)
 {
   gdb_assert (gdbarch != NULL);
-  return gdbarch->fix_call_dummy != 0;
+  return gdbarch->deprecated_fix_call_dummy != 0;
 }
 
 void
-gdbarch_fix_call_dummy (struct gdbarch *gdbarch, char *dummy, CORE_ADDR pc, CORE_ADDR fun, int nargs, struct value **args, struct type *type, int gcc_p)
+gdbarch_deprecated_fix_call_dummy (struct gdbarch *gdbarch, char *dummy, CORE_ADDR pc, CORE_ADDR fun, int nargs, struct value **args, struct type *type, int gcc_p)
 {
   gdb_assert (gdbarch != NULL);
-  if (gdbarch->fix_call_dummy == 0)
+  if (gdbarch->deprecated_fix_call_dummy == 0)
     internal_error (__FILE__, __LINE__,
-                    "gdbarch: gdbarch_fix_call_dummy invalid");
+                    "gdbarch: gdbarch_deprecated_fix_call_dummy invalid");
   if (gdbarch_debug >= 2)
-    fprintf_unfiltered (gdb_stdlog, "gdbarch_fix_call_dummy called\n");
-  gdbarch->fix_call_dummy (dummy, pc, fun, nargs, args, type, gcc_p);
+    fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_fix_call_dummy called\n");
+  gdbarch->deprecated_fix_call_dummy (dummy, pc, fun, nargs, args, type, gcc_p);
 }
 
 void
-set_gdbarch_fix_call_dummy (struct gdbarch *gdbarch,
-                            gdbarch_fix_call_dummy_ftype fix_call_dummy)
+set_gdbarch_deprecated_fix_call_dummy (struct gdbarch *gdbarch,
+                                       gdbarch_deprecated_fix_call_dummy_ftype deprecated_fix_call_dummy)
 {
-  gdbarch->fix_call_dummy = fix_call_dummy;
+  gdbarch->deprecated_fix_call_dummy = deprecated_fix_call_dummy;
+}
+
+int
+gdbarch_push_dummy_code_p (struct gdbarch *gdbarch)
+{
+  gdb_assert (gdbarch != NULL);
+  return gdbarch->push_dummy_code != 0;
+}
+
+CORE_ADDR
+gdbarch_push_dummy_code (struct gdbarch *gdbarch, CORE_ADDR sp, CORE_ADDR funaddr, int using_gcc, struct value **args, int nargs, struct type *value_type, CORE_ADDR *real_pc, CORE_ADDR *bp_addr)
+{
+  gdb_assert (gdbarch != NULL);
+  if (gdbarch->push_dummy_code == 0)
+    internal_error (__FILE__, __LINE__,
+                    "gdbarch: gdbarch_push_dummy_code invalid");
+  if (gdbarch_debug >= 2)
+    fprintf_unfiltered (gdb_stdlog, "gdbarch_push_dummy_code called\n");
+  return gdbarch->push_dummy_code (gdbarch, sp, funaddr, using_gcc, args, nargs, value_type, real_pc, bp_addr);
+}
+
+void
+set_gdbarch_push_dummy_code (struct gdbarch *gdbarch,
+                             gdbarch_push_dummy_code_ftype push_dummy_code)
+{
+  gdbarch->push_dummy_code = push_dummy_code;
 }
 
 int
@@ -4711,7 +4756,7 @@ set_gdbarch_function_start_offset (struct gdbarch *gdbarch,
 }
 
 void
-gdbarch_remote_translate_xfer_address (struct gdbarch *gdbarch, CORE_ADDR gdb_addr, int gdb_len, CORE_ADDR *rem_addr, int *rem_len)
+gdbarch_remote_translate_xfer_address (struct gdbarch *gdbarch, struct regcache *regcache, CORE_ADDR gdb_addr, int gdb_len, CORE_ADDR *rem_addr, int *rem_len)
 {
   gdb_assert (gdbarch != NULL);
   if (gdbarch->remote_translate_xfer_address == 0)
@@ -4719,7 +4764,7 @@ gdbarch_remote_translate_xfer_address (struct gdbarch *gdbarch, CORE_ADDR gdb_ad
                     "gdbarch: gdbarch_remote_translate_xfer_address invalid");
   if (gdbarch_debug >= 2)
     fprintf_unfiltered (gdb_stdlog, "gdbarch_remote_translate_xfer_address called\n");
-  gdbarch->remote_translate_xfer_address (gdb_addr, gdb_len, rem_addr, rem_len);
+  gdbarch->remote_translate_xfer_address (gdbarch, regcache, gdb_addr, gdb_len, rem_addr, rem_len);
 }
 
 void
@@ -6203,9 +6248,7 @@ gdbarch_update_p (struct gdbarch_info info)
 /* Disassembler */
 
 /* Pointer to the target-dependent disassembly function.  */
-int (*tm_print_insn) (bfd_vma, disassemble_info *);
-disassemble_info tm_print_insn_info;
-
+int (*deprecated_tm_print_insn) (bfd_vma, disassemble_info *);
 
 extern void _initialize_gdbarch (void);
 
@@ -6214,12 +6257,6 @@ _initialize_gdbarch (void)
 {
   struct cmd_list_element *c;
 
-  INIT_DISASSEMBLE_INFO_NO_ARCH (tm_print_insn_info, gdb_stdout, (fprintf_ftype)fprintf_filtered);
-  tm_print_insn_info.flavour = bfd_target_unknown_flavour;
-  tm_print_insn_info.read_memory_func = dis_asm_read_memory;
-  tm_print_insn_info.memory_error_func = dis_asm_memory_error;
-  tm_print_insn_info.print_address_func = dis_asm_print_address;
-
   add_show_from_set (add_set_cmd ("arch",
 				  class_maintenance,
 				  var_zinteger,
diff --git a/gdb/gdbarch.h b/gdb/gdbarch.h
index 7b2641b4c1e..1a8e386e1a0 100644
--- a/gdb/gdbarch.h
+++ b/gdb/gdbarch.h
@@ -345,20 +345,43 @@ extern void set_gdbarch_write_pc (struct gdbarch *gdbarch, gdbarch_write_pc_ftyp
 #endif
 #endif
 
+/* This is simply not needed.  See value_of_builtin_frame_fp_reg and
+   call_function_by_hand. */
+
+#if defined (DEPRECATED_TARGET_READ_FP)
+/* Legacy for systems yet to multi-arch DEPRECATED_TARGET_READ_FP */
+#if !defined (DEPRECATED_TARGET_READ_FP_P)
+#define DEPRECATED_TARGET_READ_FP_P() (1)
+#endif
+#endif
+
+/* Default predicate for non- multi-arch targets. */
+#if (!GDB_MULTI_ARCH) && !defined (DEPRECATED_TARGET_READ_FP_P)
+#define DEPRECATED_TARGET_READ_FP_P() (0)
+#endif
+
+extern int gdbarch_deprecated_target_read_fp_p (struct gdbarch *gdbarch);
+#if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (DEPRECATED_TARGET_READ_FP_P)
+#error "Non multi-arch definition of DEPRECATED_TARGET_READ_FP"
+#endif
+#if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (DEPRECATED_TARGET_READ_FP_P)
+#define DEPRECATED_TARGET_READ_FP_P() (gdbarch_deprecated_target_read_fp_p (current_gdbarch))
+#endif
+
 /* Default (function) for non- multi-arch platforms. */
-#if (!GDB_MULTI_ARCH) && !defined (TARGET_READ_FP)
-#define TARGET_READ_FP() (generic_target_read_fp ())
+#if (!GDB_MULTI_ARCH) && !defined (DEPRECATED_TARGET_READ_FP)
+#define DEPRECATED_TARGET_READ_FP() (internal_error (__FILE__, __LINE__, "DEPRECATED_TARGET_READ_FP"), 0)
 #endif
 
-typedef CORE_ADDR (gdbarch_read_fp_ftype) (void);
-extern CORE_ADDR gdbarch_read_fp (struct gdbarch *gdbarch);
-extern void set_gdbarch_read_fp (struct gdbarch *gdbarch, gdbarch_read_fp_ftype *read_fp);
-#if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (TARGET_READ_FP)
-#error "Non multi-arch definition of TARGET_READ_FP"
+typedef CORE_ADDR (gdbarch_deprecated_target_read_fp_ftype) (void);
+extern CORE_ADDR gdbarch_deprecated_target_read_fp (struct gdbarch *gdbarch);
+extern void set_gdbarch_deprecated_target_read_fp (struct gdbarch *gdbarch, gdbarch_deprecated_target_read_fp_ftype *deprecated_target_read_fp);
+#if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (DEPRECATED_TARGET_READ_FP)
+#error "Non multi-arch definition of DEPRECATED_TARGET_READ_FP"
 #endif
 #if GDB_MULTI_ARCH
-#if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (TARGET_READ_FP)
-#define TARGET_READ_FP() (gdbarch_read_fp (current_gdbarch))
+#if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (DEPRECATED_TARGET_READ_FP)
+#define DEPRECATED_TARGET_READ_FP() (gdbarch_deprecated_target_read_fp (current_gdbarch))
 #endif
 #endif
 
@@ -503,19 +526,22 @@ extern void set_gdbarch_sp_regnum (struct gdbarch *gdbarch, int sp_regnum);
 #endif
 #endif
 
+/* This is simply not needed.  See value_of_builtin_frame_fp_reg and
+   call_function_by_hand. */
+
 /* Default (value) for non- multi-arch platforms. */
-#if (!GDB_MULTI_ARCH) && !defined (FP_REGNUM)
-#define FP_REGNUM (-1)
+#if (!GDB_MULTI_ARCH) && !defined (DEPRECATED_FP_REGNUM)
+#define DEPRECATED_FP_REGNUM (-1)
 #endif
 
-extern int gdbarch_fp_regnum (struct gdbarch *gdbarch);
-extern void set_gdbarch_fp_regnum (struct gdbarch *gdbarch, int fp_regnum);
-#if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (FP_REGNUM)
-#error "Non multi-arch definition of FP_REGNUM"
+extern int gdbarch_deprecated_fp_regnum (struct gdbarch *gdbarch);
+extern void set_gdbarch_deprecated_fp_regnum (struct gdbarch *gdbarch, int deprecated_fp_regnum);
+#if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (DEPRECATED_FP_REGNUM)
+#error "Non multi-arch definition of DEPRECATED_FP_REGNUM"
 #endif
 #if GDB_MULTI_ARCH
-#if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (FP_REGNUM)
-#define FP_REGNUM (gdbarch_fp_regnum (current_gdbarch))
+#if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (DEPRECATED_FP_REGNUM)
+#define DEPRECATED_FP_REGNUM (gdbarch_deprecated_fp_regnum (current_gdbarch))
 #endif
 #endif
 
@@ -695,15 +721,13 @@ extern void set_gdbarch_register_name (struct gdbarch *gdbarch, gdbarch_register
 #endif
 #endif
 
-extern int gdbarch_register_size (struct gdbarch *gdbarch);
-extern void set_gdbarch_register_size (struct gdbarch *gdbarch, int register_size);
-#if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (REGISTER_SIZE)
-#error "Non multi-arch definition of REGISTER_SIZE"
-#endif
-#if GDB_MULTI_ARCH
-#if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (REGISTER_SIZE)
-#define REGISTER_SIZE (gdbarch_register_size (current_gdbarch))
+extern int gdbarch_deprecated_register_size (struct gdbarch *gdbarch);
+extern void set_gdbarch_deprecated_register_size (struct gdbarch *gdbarch, int deprecated_register_size);
+#if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (DEPRECATED_REGISTER_SIZE)
+#error "Non multi-arch definition of DEPRECATED_REGISTER_SIZE"
 #endif
+#if !defined (DEPRECATED_REGISTER_SIZE)
+#define DEPRECATED_REGISTER_SIZE (gdbarch_deprecated_register_size (current_gdbarch))
 #endif
 
 extern int gdbarch_register_bytes (struct gdbarch *gdbarch);
@@ -711,10 +735,34 @@ extern void set_gdbarch_register_bytes (struct gdbarch *gdbarch, int register_by
 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (REGISTER_BYTES)
 #error "Non multi-arch definition of REGISTER_BYTES"
 #endif
-#if GDB_MULTI_ARCH
-#if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (REGISTER_BYTES)
+#if !defined (REGISTER_BYTES)
 #define REGISTER_BYTES (gdbarch_register_bytes (current_gdbarch))
 #endif
+
+/* NOTE: cagney/2002-05-02: This function with predicate has a valid
+   (callable) initial value.  As a consequence, even when the predicate
+   is false, the corresponding function works.  This simplifies the
+   migration process - old code, calling REGISTER_BYTE, doesn't need to
+   be modified. */
+
+#if defined (REGISTER_BYTE)
+/* Legacy for systems yet to multi-arch REGISTER_BYTE */
+#if !defined (REGISTER_BYTE_P)
+#define REGISTER_BYTE_P() (1)
+#endif
+#endif
+
+/* Default predicate for non- multi-arch targets. */
+#if (!GDB_MULTI_ARCH) && !defined (REGISTER_BYTE_P)
+#define REGISTER_BYTE_P() (0)
+#endif
+
+extern int gdbarch_register_byte_p (struct gdbarch *gdbarch);
+#if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (REGISTER_BYTE_P)
+#error "Non multi-arch definition of REGISTER_BYTE"
+#endif
+#if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (REGISTER_BYTE_P)
+#define REGISTER_BYTE_P() (gdbarch_register_byte_p (current_gdbarch))
 #endif
 
 /* Default (function) for non- multi-arch platforms. */
@@ -734,10 +782,8 @@ extern void set_gdbarch_register_byte (struct gdbarch *gdbarch, gdbarch_register
 #endif
 #endif
 
-/* The methods REGISTER_VIRTUAL_TYPE, MAX_REGISTER_RAW_SIZE,
-   MAX_REGISTER_VIRTUAL_SIZE, MAX_REGISTER_RAW_SIZE,
-   REGISTER_VIRTUAL_SIZE and REGISTER_RAW_SIZE are all being replaced
-   by REGISTER_TYPE. */
+/* The methods REGISTER_VIRTUAL_TYPE, REGISTER_VIRTUAL_SIZE and
+   REGISTER_RAW_SIZE are all being replaced by REGISTER_TYPE. */
 
 /* Default (function) for non- multi-arch platforms. */
 #if (!GDB_MULTI_ARCH) && !defined (REGISTER_RAW_SIZE)
@@ -756,10 +802,9 @@ extern void set_gdbarch_register_raw_size (struct gdbarch *gdbarch, gdbarch_regi
 #endif
 #endif
 
-/* The methods REGISTER_VIRTUAL_TYPE, MAX_REGISTER_RAW_SIZE,
-   MAX_REGISTER_VIRTUAL_SIZE, MAX_REGISTER_RAW_SIZE,
-   REGISTER_VIRTUAL_SIZE and REGISTER_RAW_SIZE are all being replaced
-   by REGISTER_TYPE. */
+/* The methods DEPRECATED_MAX_REGISTER_RAW_SIZE and
+   DEPRECATED_MAX_REGISTER_VIRTUAL_SIZE are all being replaced by
+   MAX_REGISTER_SIZE (a constant). */
 
 #if defined (DEPRECATED_MAX_REGISTER_RAW_SIZE)
 /* Legacy for systems yet to multi-arch DEPRECATED_MAX_REGISTER_RAW_SIZE */
@@ -797,10 +842,8 @@ extern void set_gdbarch_deprecated_max_register_raw_size (struct gdbarch *gdbarc
 #endif
 #endif
 
-/* The methods REGISTER_VIRTUAL_TYPE, MAX_REGISTER_RAW_SIZE,
-   MAX_REGISTER_VIRTUAL_SIZE, MAX_REGISTER_RAW_SIZE,
-   REGISTER_VIRTUAL_SIZE and REGISTER_RAW_SIZE are all being replaced
-   by REGISTER_TYPE. */
+/* The methods REGISTER_VIRTUAL_TYPE, REGISTER_VIRTUAL_SIZE and
+   REGISTER_RAW_SIZE are all being replaced by REGISTER_TYPE. */
 
 /* Default (function) for non- multi-arch platforms. */
 #if (!GDB_MULTI_ARCH) && !defined (REGISTER_VIRTUAL_SIZE)
@@ -819,10 +862,9 @@ extern void set_gdbarch_register_virtual_size (struct gdbarch *gdbarch, gdbarch_
 #endif
 #endif
 
-/* The methods REGISTER_VIRTUAL_TYPE, MAX_REGISTER_RAW_SIZE,
-   MAX_REGISTER_VIRTUAL_SIZE, MAX_REGISTER_RAW_SIZE,
-   REGISTER_VIRTUAL_SIZE and REGISTER_RAW_SIZE are all being replaced
-   by REGISTER_TYPE. */
+/* The methods DEPRECATED_MAX_REGISTER_RAW_SIZE and
+   DEPRECATED_MAX_REGISTER_VIRTUAL_SIZE are all being replaced by
+   MAX_REGISTER_SIZE (a constant). */
 
 #if defined (DEPRECATED_MAX_REGISTER_VIRTUAL_SIZE)
 /* Legacy for systems yet to multi-arch DEPRECATED_MAX_REGISTER_VIRTUAL_SIZE */
@@ -860,10 +902,8 @@ extern void set_gdbarch_deprecated_max_register_virtual_size (struct gdbarch *gd
 #endif
 #endif
 
-/* The methods REGISTER_VIRTUAL_TYPE, MAX_REGISTER_RAW_SIZE,
-   MAX_REGISTER_VIRTUAL_SIZE, MAX_REGISTER_RAW_SIZE,
-   REGISTER_VIRTUAL_SIZE and REGISTER_RAW_SIZE have all being replaced
-   by REGISTER_TYPE. */
+/* The methods REGISTER_VIRTUAL_TYPE, REGISTER_VIRTUAL_SIZE and
+   REGISTER_RAW_SIZE are all being replaced by REGISTER_TYPE. */
 
 #if defined (REGISTER_VIRTUAL_TYPE)
 /* Legacy for systems yet to multi-arch REGISTER_VIRTUAL_TYPE */
@@ -1113,6 +1153,8 @@ extern void set_gdbarch_deprecated_use_generic_dummy_frames (struct gdbarch *gdb
 #define DEPRECATED_USE_GENERIC_DUMMY_FRAMES (gdbarch_deprecated_use_generic_dummy_frames (current_gdbarch))
 #endif
 
+/* Replaced by push_dummy_code. */
+
 /* Default (value) for non- multi-arch platforms. */
 #if (!GDB_MULTI_ARCH) && !defined (CALL_DUMMY_LOCATION)
 #define CALL_DUMMY_LOCATION (AT_ENTRY_POINT)
@@ -1127,6 +1169,8 @@ extern void set_gdbarch_call_dummy_location (struct gdbarch *gdbarch, int call_d
 #define CALL_DUMMY_LOCATION (gdbarch_call_dummy_location (current_gdbarch))
 #endif
 
+/* Replaced by push_dummy_code. */
+
 /* Default (function) for non- multi-arch platforms. */
 #if (!GDB_MULTI_ARCH) && !defined (CALL_DUMMY_ADDRESS)
 #define CALL_DUMMY_ADDRESS() (entry_point_address ())
@@ -1144,31 +1188,37 @@ extern void set_gdbarch_call_dummy_address (struct gdbarch *gdbarch, gdbarch_cal
 #endif
 #endif
 
-extern CORE_ADDR gdbarch_call_dummy_start_offset (struct gdbarch *gdbarch);
-extern void set_gdbarch_call_dummy_start_offset (struct gdbarch *gdbarch, CORE_ADDR call_dummy_start_offset);
-#if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (CALL_DUMMY_START_OFFSET)
-#error "Non multi-arch definition of CALL_DUMMY_START_OFFSET"
+/* Replaced by push_dummy_code. */
+
+extern CORE_ADDR gdbarch_deprecated_call_dummy_start_offset (struct gdbarch *gdbarch);
+extern void set_gdbarch_deprecated_call_dummy_start_offset (struct gdbarch *gdbarch, CORE_ADDR deprecated_call_dummy_start_offset);
+#if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (DEPRECATED_CALL_DUMMY_START_OFFSET)
+#error "Non multi-arch definition of DEPRECATED_CALL_DUMMY_START_OFFSET"
 #endif
-#if !defined (CALL_DUMMY_START_OFFSET)
-#define CALL_DUMMY_START_OFFSET (gdbarch_call_dummy_start_offset (current_gdbarch))
+#if !defined (DEPRECATED_CALL_DUMMY_START_OFFSET)
+#define DEPRECATED_CALL_DUMMY_START_OFFSET (gdbarch_deprecated_call_dummy_start_offset (current_gdbarch))
 #endif
 
-extern CORE_ADDR gdbarch_call_dummy_breakpoint_offset (struct gdbarch *gdbarch);
-extern void set_gdbarch_call_dummy_breakpoint_offset (struct gdbarch *gdbarch, CORE_ADDR call_dummy_breakpoint_offset);
-#if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (CALL_DUMMY_BREAKPOINT_OFFSET)
-#error "Non multi-arch definition of CALL_DUMMY_BREAKPOINT_OFFSET"
+/* Replaced by push_dummy_code. */
+
+extern CORE_ADDR gdbarch_deprecated_call_dummy_breakpoint_offset (struct gdbarch *gdbarch);
+extern void set_gdbarch_deprecated_call_dummy_breakpoint_offset (struct gdbarch *gdbarch, CORE_ADDR deprecated_call_dummy_breakpoint_offset);
+#if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (DEPRECATED_CALL_DUMMY_BREAKPOINT_OFFSET)
+#error "Non multi-arch definition of DEPRECATED_CALL_DUMMY_BREAKPOINT_OFFSET"
 #endif
-#if !defined (CALL_DUMMY_BREAKPOINT_OFFSET)
-#define CALL_DUMMY_BREAKPOINT_OFFSET (gdbarch_call_dummy_breakpoint_offset (current_gdbarch))
+#if !defined (DEPRECATED_CALL_DUMMY_BREAKPOINT_OFFSET)
+#define DEPRECATED_CALL_DUMMY_BREAKPOINT_OFFSET (gdbarch_deprecated_call_dummy_breakpoint_offset (current_gdbarch))
 #endif
 
-extern int gdbarch_call_dummy_length (struct gdbarch *gdbarch);
-extern void set_gdbarch_call_dummy_length (struct gdbarch *gdbarch, int call_dummy_length);
-#if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (CALL_DUMMY_LENGTH)
-#error "Non multi-arch definition of CALL_DUMMY_LENGTH"
+/* Replaced by push_dummy_code. */
+
+extern int gdbarch_deprecated_call_dummy_length (struct gdbarch *gdbarch);
+extern void set_gdbarch_deprecated_call_dummy_length (struct gdbarch *gdbarch, int deprecated_call_dummy_length);
+#if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (DEPRECATED_CALL_DUMMY_LENGTH)
+#error "Non multi-arch definition of DEPRECATED_CALL_DUMMY_LENGTH"
 #endif
-#if !defined (CALL_DUMMY_LENGTH)
-#define CALL_DUMMY_LENGTH (gdbarch_call_dummy_length (current_gdbarch))
+#if !defined (DEPRECATED_CALL_DUMMY_LENGTH)
+#define DEPRECATED_CALL_DUMMY_LENGTH (gdbarch_deprecated_call_dummy_length (current_gdbarch))
 #endif
 
 /* NOTE: cagney/2002-11-24: This function with predicate has a valid
@@ -1214,34 +1264,40 @@ extern void set_gdbarch_deprecated_pc_in_call_dummy (struct gdbarch *gdbarch, gd
 #endif
 #endif
 
+/* Replaced by push_dummy_code. */
+
 /* Default (value) for non- multi-arch platforms. */
-#if (!GDB_MULTI_ARCH) && !defined (CALL_DUMMY_WORDS)
-#define CALL_DUMMY_WORDS (legacy_call_dummy_words)
+#if (!GDB_MULTI_ARCH) && !defined (DEPRECATED_CALL_DUMMY_WORDS)
+#define DEPRECATED_CALL_DUMMY_WORDS (legacy_call_dummy_words)
 #endif
 
-extern LONGEST * gdbarch_call_dummy_words (struct gdbarch *gdbarch);
-extern void set_gdbarch_call_dummy_words (struct gdbarch *gdbarch, LONGEST * call_dummy_words);
-#if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (CALL_DUMMY_WORDS)
-#error "Non multi-arch definition of CALL_DUMMY_WORDS"
+extern LONGEST * gdbarch_deprecated_call_dummy_words (struct gdbarch *gdbarch);
+extern void set_gdbarch_deprecated_call_dummy_words (struct gdbarch *gdbarch, LONGEST * deprecated_call_dummy_words);
+#if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (DEPRECATED_CALL_DUMMY_WORDS)
+#error "Non multi-arch definition of DEPRECATED_CALL_DUMMY_WORDS"
 #endif
-#if !defined (CALL_DUMMY_WORDS)
-#define CALL_DUMMY_WORDS (gdbarch_call_dummy_words (current_gdbarch))
+#if !defined (DEPRECATED_CALL_DUMMY_WORDS)
+#define DEPRECATED_CALL_DUMMY_WORDS (gdbarch_deprecated_call_dummy_words (current_gdbarch))
 #endif
 
+/* Replaced by push_dummy_code. */
+
 /* Default (value) for non- multi-arch platforms. */
-#if (!GDB_MULTI_ARCH) && !defined (SIZEOF_CALL_DUMMY_WORDS)
-#define SIZEOF_CALL_DUMMY_WORDS (legacy_sizeof_call_dummy_words)
+#if (!GDB_MULTI_ARCH) && !defined (DEPRECATED_SIZEOF_CALL_DUMMY_WORDS)
+#define DEPRECATED_SIZEOF_CALL_DUMMY_WORDS (legacy_sizeof_call_dummy_words)
 #endif
 
-extern int gdbarch_sizeof_call_dummy_words (struct gdbarch *gdbarch);
-extern void set_gdbarch_sizeof_call_dummy_words (struct gdbarch *gdbarch, int sizeof_call_dummy_words);
-#if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (SIZEOF_CALL_DUMMY_WORDS)
-#error "Non multi-arch definition of SIZEOF_CALL_DUMMY_WORDS"
+extern int gdbarch_deprecated_sizeof_call_dummy_words (struct gdbarch *gdbarch);
+extern void set_gdbarch_deprecated_sizeof_call_dummy_words (struct gdbarch *gdbarch, int deprecated_sizeof_call_dummy_words);
+#if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (DEPRECATED_SIZEOF_CALL_DUMMY_WORDS)
+#error "Non multi-arch definition of DEPRECATED_SIZEOF_CALL_DUMMY_WORDS"
 #endif
-#if !defined (SIZEOF_CALL_DUMMY_WORDS)
-#define SIZEOF_CALL_DUMMY_WORDS (gdbarch_sizeof_call_dummy_words (current_gdbarch))
+#if !defined (DEPRECATED_SIZEOF_CALL_DUMMY_WORDS)
+#define DEPRECATED_SIZEOF_CALL_DUMMY_WORDS (gdbarch_deprecated_sizeof_call_dummy_words (current_gdbarch))
 #endif
 
+/* Replaced by push_dummy_code. */
+
 #if defined (DEPRECATED_CALL_DUMMY_STACK_ADJUST)
 /* Legacy for systems yet to multi-arch DEPRECATED_CALL_DUMMY_STACK_ADJUST */
 #if !defined (DEPRECATED_CALL_DUMMY_STACK_ADJUST_P)
@@ -1278,43 +1334,53 @@ extern void set_gdbarch_deprecated_call_dummy_stack_adjust (struct gdbarch *gdba
 #endif
 #endif
 
-#if defined (FIX_CALL_DUMMY)
-/* Legacy for systems yet to multi-arch FIX_CALL_DUMMY */
-#if !defined (FIX_CALL_DUMMY_P)
-#define FIX_CALL_DUMMY_P() (1)
+/* Replaced by push_dummy_code. */
+
+#if defined (DEPRECATED_FIX_CALL_DUMMY)
+/* Legacy for systems yet to multi-arch DEPRECATED_FIX_CALL_DUMMY */
+#if !defined (DEPRECATED_FIX_CALL_DUMMY_P)
+#define DEPRECATED_FIX_CALL_DUMMY_P() (1)
 #endif
 #endif
 
 /* Default predicate for non- multi-arch targets. */
-#if (!GDB_MULTI_ARCH) && !defined (FIX_CALL_DUMMY_P)
-#define FIX_CALL_DUMMY_P() (0)
+#if (!GDB_MULTI_ARCH) && !defined (DEPRECATED_FIX_CALL_DUMMY_P)
+#define DEPRECATED_FIX_CALL_DUMMY_P() (0)
 #endif
 
-extern int gdbarch_fix_call_dummy_p (struct gdbarch *gdbarch);
-#if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (FIX_CALL_DUMMY_P)
-#error "Non multi-arch definition of FIX_CALL_DUMMY"
+extern int gdbarch_deprecated_fix_call_dummy_p (struct gdbarch *gdbarch);
+#if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (DEPRECATED_FIX_CALL_DUMMY_P)
+#error "Non multi-arch definition of DEPRECATED_FIX_CALL_DUMMY"
 #endif
-#if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (FIX_CALL_DUMMY_P)
-#define FIX_CALL_DUMMY_P() (gdbarch_fix_call_dummy_p (current_gdbarch))
+#if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (DEPRECATED_FIX_CALL_DUMMY_P)
+#define DEPRECATED_FIX_CALL_DUMMY_P() (gdbarch_deprecated_fix_call_dummy_p (current_gdbarch))
 #endif
 
 /* Default (function) for non- multi-arch platforms. */
-#if (!GDB_MULTI_ARCH) && !defined (FIX_CALL_DUMMY)
-#define FIX_CALL_DUMMY(dummy, pc, fun, nargs, args, type, gcc_p) (internal_error (__FILE__, __LINE__, "FIX_CALL_DUMMY"), 0)
+#if (!GDB_MULTI_ARCH) && !defined (DEPRECATED_FIX_CALL_DUMMY)
+#define DEPRECATED_FIX_CALL_DUMMY(dummy, pc, fun, nargs, args, type, gcc_p) (internal_error (__FILE__, __LINE__, "DEPRECATED_FIX_CALL_DUMMY"), 0)
 #endif
 
-typedef void (gdbarch_fix_call_dummy_ftype) (char *dummy, CORE_ADDR pc, CORE_ADDR fun, int nargs, struct value **args, struct type *type, int gcc_p);
-extern void gdbarch_fix_call_dummy (struct gdbarch *gdbarch, char *dummy, CORE_ADDR pc, CORE_ADDR fun, int nargs, struct value **args, struct type *type, int gcc_p);
-extern void set_gdbarch_fix_call_dummy (struct gdbarch *gdbarch, gdbarch_fix_call_dummy_ftype *fix_call_dummy);
-#if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (FIX_CALL_DUMMY)
-#error "Non multi-arch definition of FIX_CALL_DUMMY"
+typedef void (gdbarch_deprecated_fix_call_dummy_ftype) (char *dummy, CORE_ADDR pc, CORE_ADDR fun, int nargs, struct value **args, struct type *type, int gcc_p);
+extern void gdbarch_deprecated_fix_call_dummy (struct gdbarch *gdbarch, char *dummy, CORE_ADDR pc, CORE_ADDR fun, int nargs, struct value **args, struct type *type, int gcc_p);
+extern void set_gdbarch_deprecated_fix_call_dummy (struct gdbarch *gdbarch, gdbarch_deprecated_fix_call_dummy_ftype *deprecated_fix_call_dummy);
+#if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (DEPRECATED_FIX_CALL_DUMMY)
+#error "Non multi-arch definition of DEPRECATED_FIX_CALL_DUMMY"
 #endif
 #if GDB_MULTI_ARCH
-#if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (FIX_CALL_DUMMY)
-#define FIX_CALL_DUMMY(dummy, pc, fun, nargs, args, type, gcc_p) (gdbarch_fix_call_dummy (current_gdbarch, dummy, pc, fun, nargs, args, type, gcc_p))
+#if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (DEPRECATED_FIX_CALL_DUMMY)
+#define DEPRECATED_FIX_CALL_DUMMY(dummy, pc, fun, nargs, args, type, gcc_p) (gdbarch_deprecated_fix_call_dummy (current_gdbarch, dummy, pc, fun, nargs, args, type, gcc_p))
 #endif
 #endif
 
+/* This is a replacement for DEPRECATED_FIX_CALL_DUMMY et.al. */
+
+extern int gdbarch_push_dummy_code_p (struct gdbarch *gdbarch);
+
+typedef CORE_ADDR (gdbarch_push_dummy_code_ftype) (struct gdbarch *gdbarch, CORE_ADDR sp, CORE_ADDR funaddr, int using_gcc, struct value **args, int nargs, struct type *value_type, CORE_ADDR *real_pc, CORE_ADDR *bp_addr);
+extern CORE_ADDR gdbarch_push_dummy_code (struct gdbarch *gdbarch, CORE_ADDR sp, CORE_ADDR funaddr, int using_gcc, struct value **args, int nargs, struct type *value_type, CORE_ADDR *real_pc, CORE_ADDR *bp_addr);
+extern void set_gdbarch_push_dummy_code (struct gdbarch *gdbarch, gdbarch_push_dummy_code_ftype *push_dummy_code);
+
 #if defined (DEPRECATED_INIT_FRAME_PC_FIRST)
 /* Legacy for systems yet to multi-arch DEPRECATED_INIT_FRAME_PC_FIRST */
 #if !defined (DEPRECATED_INIT_FRAME_PC_FIRST_P)
@@ -2187,22 +2253,9 @@ extern void set_gdbarch_function_start_offset (struct gdbarch *gdbarch, CORE_ADD
 #endif
 #endif
 
-/* Default (function) for non- multi-arch platforms. */
-#if (!GDB_MULTI_ARCH) && !defined (REMOTE_TRANSLATE_XFER_ADDRESS)
-#define REMOTE_TRANSLATE_XFER_ADDRESS(gdb_addr, gdb_len, rem_addr, rem_len) (generic_remote_translate_xfer_address (gdb_addr, gdb_len, rem_addr, rem_len))
-#endif
-
-typedef void (gdbarch_remote_translate_xfer_address_ftype) (CORE_ADDR gdb_addr, int gdb_len, CORE_ADDR *rem_addr, int *rem_len);
-extern void gdbarch_remote_translate_xfer_address (struct gdbarch *gdbarch, CORE_ADDR gdb_addr, int gdb_len, CORE_ADDR *rem_addr, int *rem_len);
+typedef void (gdbarch_remote_translate_xfer_address_ftype) (struct gdbarch *gdbarch, struct regcache *regcache, CORE_ADDR gdb_addr, int gdb_len, CORE_ADDR *rem_addr, int *rem_len);
+extern void gdbarch_remote_translate_xfer_address (struct gdbarch *gdbarch, struct regcache *regcache, CORE_ADDR gdb_addr, int gdb_len, CORE_ADDR *rem_addr, int *rem_len);
 extern void set_gdbarch_remote_translate_xfer_address (struct gdbarch *gdbarch, gdbarch_remote_translate_xfer_address_ftype *remote_translate_xfer_address);
-#if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (REMOTE_TRANSLATE_XFER_ADDRESS)
-#error "Non multi-arch definition of REMOTE_TRANSLATE_XFER_ADDRESS"
-#endif
-#if GDB_MULTI_ARCH
-#if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (REMOTE_TRANSLATE_XFER_ADDRESS)
-#define REMOTE_TRANSLATE_XFER_ADDRESS(gdb_addr, gdb_len, rem_addr, rem_len) (gdbarch_remote_translate_xfer_address (current_gdbarch, gdb_addr, gdb_len, rem_addr, rem_len))
-#endif
-#endif
 
 extern CORE_ADDR gdbarch_frame_args_skip (struct gdbarch *gdbarch);
 extern void set_gdbarch_frame_args_skip (struct gdbarch *gdbarch, CORE_ADDR frame_args_skip);
@@ -3355,22 +3408,11 @@ extern const struct bfd_arch_info *target_architecture;
 
 /* The target-system-dependent disassembler is semi-dynamic */
 
-extern int dis_asm_read_memory (bfd_vma memaddr, bfd_byte *myaddr,
-				unsigned int len, disassemble_info *info);
-
-extern void dis_asm_memory_error (int status, bfd_vma memaddr,
-				  disassemble_info *info);
-
-extern void dis_asm_print_address (bfd_vma addr,
-				   disassemble_info *info);
-
-extern int (*tm_print_insn) (bfd_vma, disassemble_info*);
-extern disassemble_info tm_print_insn_info;
-#ifndef TARGET_PRINT_INSN_INFO
-#define TARGET_PRINT_INSN_INFO (&tm_print_insn_info)
-#endif
-
+/* Use gdb_disassemble, and gdbarch_print_insn instead.  */
+extern int (*deprecated_tm_print_insn) (bfd_vma, disassemble_info*);
 
+/* Use set_gdbarch_print_insn instead.  */
+extern disassemble_info deprecated_tm_print_insn_info;
 
 /* Set the dynamic target-system-dependent parameters (architecture,
    byte-order, ...) using information found in the BFD */
diff --git a/gdb/gdbarch.sh b/gdb/gdbarch.sh
index 7a17b63c3d9..16165a9858a 100755
--- a/gdb/gdbarch.sh
+++ b/gdb/gdbarch.sh
@@ -428,7 +428,9 @@ v:2:TARGET_CHAR_SIGNED:int:char_signed::::1:-1:1::::
 #
 f:2:TARGET_READ_PC:CORE_ADDR:read_pc:ptid_t ptid:ptid::0:generic_target_read_pc::0
 f:2:TARGET_WRITE_PC:void:write_pc:CORE_ADDR val, ptid_t ptid:val, ptid::0:generic_target_write_pc::0
-f:2:TARGET_READ_FP:CORE_ADDR:read_fp:void:::0:generic_target_read_fp::0
+# This is simply not needed.  See value_of_builtin_frame_fp_reg and
+# call_function_by_hand.
+F::DEPRECATED_TARGET_READ_FP:CORE_ADDR:deprecated_target_read_fp:void
 f:2:TARGET_READ_SP:CORE_ADDR:read_sp:void:::0:generic_target_read_sp::0
 # The dummy call frame SP should be set by push_dummy_call.
 F:2:DEPRECATED_DUMMY_WRITE_SP:void:deprecated_dummy_write_sp:CORE_ADDR val:val
@@ -451,7 +453,9 @@ v:2:NUM_PSEUDO_REGS:int:num_pseudo_regs::::0:0::0:::
 # a real register or a pseudo (computed) register or not be defined at
 # all (-1).
 v:2:SP_REGNUM:int:sp_regnum::::-1:-1::0
-v:2:FP_REGNUM:int:fp_regnum::::-1:-1::0
+# This is simply not needed.  See value_of_builtin_frame_fp_reg and
+# call_function_by_hand.
+v:2:DEPRECATED_FP_REGNUM:int:deprecated_fp_regnum::::-1:-1::0
 v:2:PC_REGNUM:int:pc_regnum::::-1:-1::0
 v:2:PS_REGNUM:int:ps_regnum::::-1:-1::0
 v:2:FP0_REGNUM:int:fp0_regnum::::0:-1::0
@@ -468,33 +472,30 @@ f:2:DWARF_REG_TO_REGNUM:int:dwarf_reg_to_regnum:int dwarf_regnr:dwarf_regnr:::no
 f:2:SDB_REG_TO_REGNUM:int:sdb_reg_to_regnum:int sdb_regnr:sdb_regnr:::no_op_reg_to_regnum::0
 f:2:DWARF2_REG_TO_REGNUM:int:dwarf2_reg_to_regnum:int dwarf2_regnr:dwarf2_regnr:::no_op_reg_to_regnum::0
 f:2:REGISTER_NAME:const char *:register_name:int regnr:regnr:::legacy_register_name::0
-v:2:REGISTER_SIZE:int:register_size::::0:-1
-v:2:REGISTER_BYTES:int:register_bytes::::0:-1
-f:2:REGISTER_BYTE:int:register_byte:int reg_nr:reg_nr::generic_register_byte:generic_register_byte::0
-# The methods REGISTER_VIRTUAL_TYPE, MAX_REGISTER_RAW_SIZE,
-# MAX_REGISTER_VIRTUAL_SIZE, MAX_REGISTER_RAW_SIZE,
-# REGISTER_VIRTUAL_SIZE and REGISTER_RAW_SIZE are all being replaced
-# by REGISTER_TYPE.
+v::DEPRECATED_REGISTER_SIZE:int:deprecated_register_size
+v::REGISTER_BYTES:int:register_bytes
+# NOTE: cagney/2002-05-02: This function with predicate has a valid
+# (callable) initial value.  As a consequence, even when the predicate
+# is false, the corresponding function works.  This simplifies the
+# migration process - old code, calling REGISTER_BYTE, doesn't need to
+# be modified.
+F::REGISTER_BYTE:int:register_byte:int reg_nr:reg_nr::generic_register_byte:generic_register_byte
+# The methods REGISTER_VIRTUAL_TYPE, REGISTER_VIRTUAL_SIZE and
+# REGISTER_RAW_SIZE are all being replaced by REGISTER_TYPE.
 f:2:REGISTER_RAW_SIZE:int:register_raw_size:int reg_nr:reg_nr::generic_register_size:generic_register_size::0
-# The methods REGISTER_VIRTUAL_TYPE, MAX_REGISTER_RAW_SIZE,
-# MAX_REGISTER_VIRTUAL_SIZE, MAX_REGISTER_RAW_SIZE,
-# REGISTER_VIRTUAL_SIZE and REGISTER_RAW_SIZE are all being replaced
-# by REGISTER_TYPE.
+# The methods DEPRECATED_MAX_REGISTER_RAW_SIZE and
+# DEPRECATED_MAX_REGISTER_VIRTUAL_SIZE are all being replaced by
+# MAX_REGISTER_SIZE (a constant).
 V:2:DEPRECATED_MAX_REGISTER_RAW_SIZE:int:deprecated_max_register_raw_size
-# The methods REGISTER_VIRTUAL_TYPE, MAX_REGISTER_RAW_SIZE,
-# MAX_REGISTER_VIRTUAL_SIZE, MAX_REGISTER_RAW_SIZE,
-# REGISTER_VIRTUAL_SIZE and REGISTER_RAW_SIZE are all being replaced
-# by REGISTER_TYPE.
+# The methods REGISTER_VIRTUAL_TYPE, REGISTER_VIRTUAL_SIZE and
+# REGISTER_RAW_SIZE are all being replaced by REGISTER_TYPE.
 f:2:REGISTER_VIRTUAL_SIZE:int:register_virtual_size:int reg_nr:reg_nr::generic_register_size:generic_register_size::0
-# The methods REGISTER_VIRTUAL_TYPE, MAX_REGISTER_RAW_SIZE,
-# MAX_REGISTER_VIRTUAL_SIZE, MAX_REGISTER_RAW_SIZE,
-# REGISTER_VIRTUAL_SIZE and REGISTER_RAW_SIZE are all being replaced
-# by REGISTER_TYPE.
+# The methods DEPRECATED_MAX_REGISTER_RAW_SIZE and
+# DEPRECATED_MAX_REGISTER_VIRTUAL_SIZE are all being replaced by
+# MAX_REGISTER_SIZE (a constant).
 V:2:DEPRECATED_MAX_REGISTER_VIRTUAL_SIZE:int:deprecated_max_register_virtual_size
-# The methods REGISTER_VIRTUAL_TYPE, MAX_REGISTER_RAW_SIZE,
-# MAX_REGISTER_VIRTUAL_SIZE, MAX_REGISTER_RAW_SIZE,
-# REGISTER_VIRTUAL_SIZE and REGISTER_RAW_SIZE have all being replaced
-# by REGISTER_TYPE.
+# The methods REGISTER_VIRTUAL_TYPE, REGISTER_VIRTUAL_SIZE and
+# REGISTER_RAW_SIZE are all being replaced by REGISTER_TYPE.
 F:2:REGISTER_VIRTUAL_TYPE:struct type *:register_virtual_type:int reg_nr:reg_nr::0:0
 M:2:REGISTER_TYPE:struct type *:register_type:int reg_nr:reg_nr::0:
 #
@@ -519,21 +520,32 @@ F:2:GET_LONGJMP_TARGET:int:get_longjmp_target:CORE_ADDR *pc:pc::0:0
 # reqires that these methods be set up from the word go.  This also
 # avoids any potential problems with moving beyond multi-arch partial.
 v::DEPRECATED_USE_GENERIC_DUMMY_FRAMES:int:deprecated_use_generic_dummy_frames:::::1::0
+# Replaced by push_dummy_code.
 v::CALL_DUMMY_LOCATION:int:call_dummy_location:::::AT_ENTRY_POINT::0
+# Replaced by push_dummy_code.
 f::CALL_DUMMY_ADDRESS:CORE_ADDR:call_dummy_address:void::::entry_point_address::0
-v::CALL_DUMMY_START_OFFSET:CORE_ADDR:call_dummy_start_offset
-v::CALL_DUMMY_BREAKPOINT_OFFSET:CORE_ADDR:call_dummy_breakpoint_offset
-v::CALL_DUMMY_LENGTH:int:call_dummy_length
+# Replaced by push_dummy_code.
+v::DEPRECATED_CALL_DUMMY_START_OFFSET:CORE_ADDR:deprecated_call_dummy_start_offset
+# Replaced by push_dummy_code.
+v::DEPRECATED_CALL_DUMMY_BREAKPOINT_OFFSET:CORE_ADDR:deprecated_call_dummy_breakpoint_offset
+# Replaced by push_dummy_code.
+v::DEPRECATED_CALL_DUMMY_LENGTH:int:deprecated_call_dummy_length
 # NOTE: cagney/2002-11-24: This function with predicate has a valid
 # (callable) initial value.  As a consequence, even when the predicate
 # is false, the corresponding function works.  This simplifies the
 # migration process - old code, calling DEPRECATED_PC_IN_CALL_DUMMY(),
 # doesn't need to be modified.
 F::DEPRECATED_PC_IN_CALL_DUMMY:int:deprecated_pc_in_call_dummy:CORE_ADDR pc, CORE_ADDR sp, CORE_ADDR frame_address:pc, sp, frame_address::generic_pc_in_call_dummy:generic_pc_in_call_dummy
-v::CALL_DUMMY_WORDS:LONGEST *:call_dummy_words::::0:legacy_call_dummy_words::0:0x%08lx
-v::SIZEOF_CALL_DUMMY_WORDS:int:sizeof_call_dummy_words::::0:legacy_sizeof_call_dummy_words::0
+# Replaced by push_dummy_code.
+v::DEPRECATED_CALL_DUMMY_WORDS:LONGEST *:deprecated_call_dummy_words::::0:legacy_call_dummy_words::0:0x%08lx
+# Replaced by push_dummy_code.
+v::DEPRECATED_SIZEOF_CALL_DUMMY_WORDS:int:deprecated_sizeof_call_dummy_words::::0:legacy_sizeof_call_dummy_words::0
+# Replaced by push_dummy_code.
 V:2:DEPRECATED_CALL_DUMMY_STACK_ADJUST:int:deprecated_call_dummy_stack_adjust::::0
-F::FIX_CALL_DUMMY:void:fix_call_dummy:char *dummy, CORE_ADDR pc, CORE_ADDR fun, int nargs, struct value **args, struct type *type, int gcc_p:dummy, pc, fun, nargs, args, type, gcc_p
+# Replaced by push_dummy_code.
+F::DEPRECATED_FIX_CALL_DUMMY:void:deprecated_fix_call_dummy:char *dummy, CORE_ADDR pc, CORE_ADDR fun, int nargs, struct value **args, struct type *type, int gcc_p:dummy, pc, fun, nargs, args, type, gcc_p
+# This is a replacement for DEPRECATED_FIX_CALL_DUMMY et.al.
+M::PUSH_DUMMY_CODE:CORE_ADDR:push_dummy_code:CORE_ADDR sp, CORE_ADDR funaddr, int using_gcc, struct value **args, int nargs, struct type *value_type, CORE_ADDR *real_pc, CORE_ADDR *bp_addr:sp, funaddr, using_gcc, args, nargs, value_type, real_pc, bp_addr:
 F:2:DEPRECATED_INIT_FRAME_PC_FIRST:CORE_ADDR:deprecated_init_frame_pc_first:int fromleaf, struct frame_info *prev:fromleaf, prev
 F:2:DEPRECATED_INIT_FRAME_PC:CORE_ADDR:deprecated_init_frame_pc:int fromleaf, struct frame_info *prev:fromleaf, prev
 #
@@ -586,7 +598,7 @@ v:2:DECR_PC_AFTER_BREAK:CORE_ADDR:decr_pc_after_break::::0:-1
 f:2:PREPARE_TO_PROCEED:int:prepare_to_proceed:int select_it:select_it::0:default_prepare_to_proceed::0
 v:2:FUNCTION_START_OFFSET:CORE_ADDR:function_start_offset::::0:-1
 #
-f:2:REMOTE_TRANSLATE_XFER_ADDRESS:void:remote_translate_xfer_address:CORE_ADDR gdb_addr, int gdb_len, CORE_ADDR *rem_addr, int *rem_len:gdb_addr, gdb_len, rem_addr, rem_len:::generic_remote_translate_xfer_address::0
+m::REMOTE_TRANSLATE_XFER_ADDRESS:void:remote_translate_xfer_address:struct regcache *regcache, CORE_ADDR gdb_addr, int gdb_len, CORE_ADDR *rem_addr, int *rem_len:regcache, gdb_addr, gdb_len, rem_addr, rem_len:::generic_remote_translate_xfer_address::0
 #
 v:2:FRAME_ARGS_SKIP:CORE_ADDR:frame_args_skip::::0:-1
 f:2:FRAMELESS_FUNCTION_INVOCATION:int:frameless_function_invocation:struct frame_info *fi:fi:::generic_frameless_function_invocation_not::0
@@ -1209,22 +1221,11 @@ extern const struct bfd_arch_info *target_architecture;
 
 /* The target-system-dependent disassembler is semi-dynamic */
 
-extern int dis_asm_read_memory (bfd_vma memaddr, bfd_byte *myaddr,
-				unsigned int len, disassemble_info *info);
-
-extern void dis_asm_memory_error (int status, bfd_vma memaddr,
-				  disassemble_info *info);
-
-extern void dis_asm_print_address (bfd_vma addr,
-				   disassemble_info *info);
-
-extern int (*tm_print_insn) (bfd_vma, disassemble_info*);
-extern disassemble_info tm_print_insn_info;
-#ifndef TARGET_PRINT_INSN_INFO
-#define TARGET_PRINT_INSN_INFO (&tm_print_insn_info)
-#endif
-
+/* Use gdb_disassemble, and gdbarch_print_insn instead.  */
+extern int (*deprecated_tm_print_insn) (bfd_vma, disassemble_info*);
 
+/* Use set_gdbarch_print_insn instead.  */
+extern disassemble_info deprecated_tm_print_insn_info;
 
 /* Set the dynamic target-system-dependent parameters (architecture,
    byte-order, ...) using information found in the BFD */
@@ -2377,9 +2378,7 @@ gdbarch_update_p (struct gdbarch_info info)
 /* Disassembler */
 
 /* Pointer to the target-dependent disassembly function.  */
-int (*tm_print_insn) (bfd_vma, disassemble_info *);
-disassemble_info tm_print_insn_info;
-
+int (*deprecated_tm_print_insn) (bfd_vma, disassemble_info *);
 
 extern void _initialize_gdbarch (void);
 
@@ -2388,12 +2387,6 @@ _initialize_gdbarch (void)
 {
   struct cmd_list_element *c;
 
-  INIT_DISASSEMBLE_INFO_NO_ARCH (tm_print_insn_info, gdb_stdout, (fprintf_ftype)fprintf_filtered);
-  tm_print_insn_info.flavour = bfd_target_unknown_flavour;
-  tm_print_insn_info.read_memory_func = dis_asm_read_memory;
-  tm_print_insn_info.memory_error_func = dis_asm_memory_error;
-  tm_print_insn_info.print_address_func = dis_asm_print_address;
-
   add_show_from_set (add_set_cmd ("arch",
 				  class_maintenance,
 				  var_zinteger,
diff --git a/gdb/gdbcmd.h b/gdb/gdbcmd.h
index e626eb5f9e4..8c4490ec940 100644
--- a/gdb/gdbcmd.h
+++ b/gdb/gdbcmd.h
@@ -98,10 +98,6 @@ extern struct cmd_list_element *maintenanceinfolist;
 
 extern struct cmd_list_element *maintenanceprintlist;
 
-/* Chain containing all defined "maintenance list" subcommands. */
-
-extern struct cmd_list_element *maintenancelistlist;
-
 extern struct cmd_list_element *setprintlist;
 
 extern struct cmd_list_element *showprintlist;
diff --git a/gdb/gdbserver/ChangeLog b/gdb/gdbserver/ChangeLog
index 63ec899245a..9df8a2a4807 100644
--- a/gdb/gdbserver/ChangeLog
+++ b/gdb/gdbserver/ChangeLog
@@ -1,3 +1,8 @@
+2003-04-24  Andrew Cagney  <cagney@redhat.com>
+
+	* low-nbsd.c (fetch_inferior_registers): 
+	(store_inferior_registers): 
+
 2003-03-26  Daniel Jacobowitz  <drow@mvista.com>
 
 	* linux-low.c (linux_create_inferior): Use __SIGRTMIN.
diff --git a/gdb/gdbserver/low-nbsd.c b/gdb/gdbserver/low-nbsd.c
index 9046d635604..8bec0d98e57 100644
--- a/gdb/gdbserver/low-nbsd.c
+++ b/gdb/gdbserver/low-nbsd.c
@@ -394,7 +394,7 @@ fetch_inferior_registers (int regno)
   RF (R0_REGNUM + 7, inferior_registers.r_r7);
 
   RF (SP_REGNUM, inferior_registers.r_sp);
-  RF (FP_REGNUM, inferior_registers.r_fp);
+  RF (DEPRECATED_FP_REGNUM, inferior_registers.r_fp);
   RF (PC_REGNUM, inferior_registers.r_pc);
   RF (PS_REGNUM, inferior_registers.r_psr);
 
@@ -429,7 +429,7 @@ store_inferior_registers (int regno)
   RS (R0_REGNUM + 7, inferior_registers.r_r7);
   
   RS (SP_REGNUM, inferior_registers.r_sp);
-  RS (FP_REGNUM, inferior_registers.r_fp);
+  RS (DEPRECATED_FP_REGNUM, inferior_registers.r_fp);
   RS (PC_REGNUM, inferior_registers.r_pc);
   RS (PS_REGNUM, inferior_registers.r_psr);
   
diff --git a/gdb/gdbthread.h b/gdb/gdbthread.h
index f336d91f48d..09dea26ca8c 100644
--- a/gdb/gdbthread.h
+++ b/gdb/gdbthread.h
@@ -44,7 +44,6 @@ struct thread_info
   int num;			/* Convenient handle (GDB thread id) */
   /* State from wait_for_inferior */
   CORE_ADDR prev_pc;
-  char *prev_func_name;
   struct breakpoint *step_resume_breakpoint;
   struct breakpoint *through_sigtramp_breakpoint;
   CORE_ADDR step_range_start;
@@ -117,7 +116,6 @@ extern struct thread_info *iterate_over_threads (thread_callback_func, void *);
 /* infrun context switch: save the debugger state for the given thread.  */
 extern void save_infrun_state (ptid_t ptid,
 			       CORE_ADDR prev_pc,
-			       char     *prev_func_name,
 			       int       trap_expected,
 			       struct breakpoint *step_resume_breakpoint,
 			       struct breakpoint *through_sigtramp_breakpoint,
@@ -137,7 +135,6 @@ extern void save_infrun_state (ptid_t ptid,
    for the given thread.  */
 extern void load_infrun_state (ptid_t ptid,
 			       CORE_ADDR *prev_pc,
-			       char     **prev_func_name,
 			       int       *trap_expected,
 			       struct breakpoint **step_resume_breakpoint,
 			       struct breakpoint **through_sigtramp_breakpoint,
diff --git a/gdb/h8300-tdep.c b/gdb/h8300-tdep.c
index 2423a9a40a5..3e12afdb7ff 100644
--- a/gdb/h8300-tdep.c
+++ b/gdb/h8300-tdep.c
@@ -1101,10 +1101,10 @@ h8300_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
   set_gdbarch_num_regs (gdbarch, E_NUM_REGS);
   set_gdbarch_num_pseudo_regs (gdbarch, 0);
   set_gdbarch_sp_regnum (gdbarch, E_SP_REGNUM);
-  set_gdbarch_fp_regnum (gdbarch, E_FP_REGNUM);
+  set_gdbarch_deprecated_fp_regnum (gdbarch, E_FP_REGNUM);
   set_gdbarch_pc_regnum (gdbarch, E_PC_REGNUM);
   set_gdbarch_register_name (gdbarch, h8300_register_name);
-  set_gdbarch_register_size (gdbarch, BINWORD);
+  set_gdbarch_deprecated_register_size (gdbarch, BINWORD);
   set_gdbarch_register_bytes (gdbarch, E_NUM_REGS * BINWORD);
   set_gdbarch_register_byte (gdbarch, h8300_register_byte);
   set_gdbarch_register_raw_size (gdbarch, h8300_register_raw_size);
@@ -1156,8 +1156,8 @@ h8300_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
   set_gdbarch_deprecated_store_return_value (gdbarch, h8300_store_return_value);
   set_gdbarch_deprecated_extract_struct_value_address (gdbarch, h8300_extract_struct_value_address);
   set_gdbarch_use_struct_convention (gdbarch, h8300_use_struct_convention);
-  set_gdbarch_call_dummy_words (gdbarch, call_dummy_words);
-  set_gdbarch_sizeof_call_dummy_words (gdbarch, 0);
+  set_gdbarch_deprecated_call_dummy_words (gdbarch, call_dummy_words);
+  set_gdbarch_deprecated_sizeof_call_dummy_words (gdbarch, 0);
   set_gdbarch_breakpoint_from_pc (gdbarch, h8300_breakpoint_from_pc);
 
   set_gdbarch_int_bit (gdbarch, 2 * TARGET_CHAR_BIT);
@@ -1177,6 +1177,6 @@ h8300_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
 void
 _initialize_h8300_tdep (void)
 {
-  tm_print_insn = gdb_print_insn_h8300;
+  deprecated_tm_print_insn = gdb_print_insn_h8300;
   register_gdbarch_init (bfd_arch_h8300, h8300_gdbarch_init);
 }
diff --git a/gdb/hppa-tdep.c b/gdb/hppa-tdep.c
index 27cfedfd648..d524bae33c1 100644
--- a/gdb/hppa-tdep.c
+++ b/gdb/hppa-tdep.c
@@ -36,6 +36,7 @@
 #include "infttrace.h"
 /* For argument passing to the inferior */
 #include "symtab.h"
+#include "infcall.h"
 
 #ifdef USG
 #include <sys/types.h>
@@ -199,7 +200,7 @@ extern int exception_catchpoints_are_fragile;
 int
 hppa_use_struct_convention (int gcc_p, struct type *type)
 {
-  return (TYPE_LENGTH (type) > 2 * REGISTER_SIZE);
+  return (TYPE_LENGTH (type) > 2 * DEPRECATED_REGISTER_SIZE);
 }
 
 
@@ -903,16 +904,16 @@ hppa_frame_saved_pc (struct frame_info *frame)
 	       /* A call dummy is sized in words, but it is actually a
 		  series of instructions.  Account for that scaling
 		  factor.  */
-	       + ((REGISTER_SIZE / INSTRUCTION_SIZE)
-		  * CALL_DUMMY_LENGTH)
+	       + ((DEPRECATED_REGISTER_SIZE / INSTRUCTION_SIZE)
+		  * DEPRECATED_CALL_DUMMY_LENGTH)
 	       /* Similarly we have to account for 64bit wide register
 		  saves.  */
-	       + (32 * REGISTER_SIZE)
+	       + (32 * DEPRECATED_REGISTER_SIZE)
 	       /* We always consider FP regs 8 bytes long.  */
 	       + (NUM_REGS - FP0_REGNUM) * 8
 	       /* Similarly we have to account for 64bit wide register
 		  saves.  */
-	       + (6 * REGISTER_SIZE)))))
+	       + (6 * DEPRECATED_REGISTER_SIZE)))))
     {
       return read_memory_integer ((get_frame_base (frame)
 				   + (TARGET_PTR_BIT == 64 ? -16 : -20)),
@@ -1084,7 +1085,7 @@ hppa_init_extra_frame_info (int fromleaf, struct frame_info *frame)
          frame.  (we always want frame->frame to point at the lowest address
          in the frame).  */
       if (framesize == -1)
-	deprecated_update_frame_base_hack (frame, TARGET_READ_FP ());
+	deprecated_update_frame_base_hack (frame, deprecated_read_fp ());
       else
 	deprecated_update_frame_base_hack (frame, get_frame_base (frame) - framesize);
       return;
@@ -1105,7 +1106,7 @@ hppa_init_extra_frame_info (int fromleaf, struct frame_info *frame)
      sorts, and its base is the high address in its parent's frame.  */
   framesize = find_proc_framesize (get_frame_pc (frame));
   if (framesize == -1)
-    deprecated_update_frame_base_hack (frame, TARGET_READ_FP ());
+    deprecated_update_frame_base_hack (frame, deprecated_read_fp ());
   else
     deprecated_update_frame_base_hack (frame, read_register (SP_REGNUM) - framesize);
 }
@@ -1263,7 +1264,7 @@ hppa_frame_chain (struct frame_info *frame)
 	  saved_regs_frame = tmp_frame;
 
 	  /* If we have an address for r3, that's good.  */
-	  if (saved_regs[FP_REGNUM])
+	  if (saved_regs[DEPRECATED_FP_REGNUM])
 	    break;
 	}
     }
@@ -1325,7 +1326,7 @@ hppa_frame_chain (struct frame_info *frame)
 	      u = find_unwind_entry (DEPRECATED_FRAME_SAVED_PC (frame));
 	      if (!u)
 		{
-		  return read_memory_integer (saved_regs[FP_REGNUM],
+		  return read_memory_integer (saved_regs[DEPRECATED_FP_REGNUM],
 					      TARGET_PTR_BIT / 8);
 		}
 	      else
@@ -1334,7 +1335,7 @@ hppa_frame_chain (struct frame_info *frame)
 		}
 	    }
 
-	  return read_memory_integer (saved_regs[FP_REGNUM],
+	  return read_memory_integer (saved_regs[DEPRECATED_FP_REGNUM],
 				      TARGET_PTR_BIT / 8);
 	}
     }
@@ -1363,7 +1364,7 @@ hppa_frame_chain (struct frame_info *frame)
 	  u = find_unwind_entry (DEPRECATED_FRAME_SAVED_PC (frame));
 	  if (!u)
 	    {
-	      return read_memory_integer (saved_regs[FP_REGNUM],
+	      return read_memory_integer (saved_regs[DEPRECATED_FP_REGNUM],
 					  TARGET_PTR_BIT / 8);
 	    }
 	  else
@@ -1374,7 +1375,7 @@ hppa_frame_chain (struct frame_info *frame)
 
       /* The value in %r3 was never saved into the stack (thus %r3 still
          holds the value of the previous frame pointer).  */
-      return TARGET_READ_FP ();
+      return deprecated_read_fp ();
     }
 }
 
@@ -1466,24 +1467,24 @@ hppa_push_dummy_frame (void)
 
   /* The 32bit and 64bit ABIs save the return pointer into different
      stack slots.  */
-  if (REGISTER_SIZE == 8)
-    write_memory (sp - 16, (char *) &int_buffer, REGISTER_SIZE);
+  if (DEPRECATED_REGISTER_SIZE == 8)
+    write_memory (sp - 16, (char *) &int_buffer, DEPRECATED_REGISTER_SIZE);
   else
-    write_memory (sp - 20, (char *) &int_buffer, REGISTER_SIZE);
+    write_memory (sp - 20, (char *) &int_buffer, DEPRECATED_REGISTER_SIZE);
 
-  int_buffer = TARGET_READ_FP ();
-  write_memory (sp, (char *) &int_buffer, REGISTER_SIZE);
+  int_buffer = deprecated_read_fp ();
+  write_memory (sp, (char *) &int_buffer, DEPRECATED_REGISTER_SIZE);
 
-  write_register (FP_REGNUM, sp);
+  write_register (DEPRECATED_FP_REGNUM, sp);
 
-  sp += 2 * REGISTER_SIZE;
+  sp += 2 * DEPRECATED_REGISTER_SIZE;
 
   for (regnum = 1; regnum < 32; regnum++)
-    if (regnum != RP_REGNUM && regnum != FP_REGNUM)
+    if (regnum != RP_REGNUM && regnum != DEPRECATED_FP_REGNUM)
       sp = push_word (sp, read_register (regnum));
 
   /* This is not necessary for the 64bit ABI.  In fact it is dangerous.  */
-  if (REGISTER_SIZE != 8)
+  if (DEPRECATED_REGISTER_SIZE != 8)
     sp += 4;
 
   for (regnum = FP0_REGNUM; regnum < NUM_REGS; regnum++)
@@ -1509,37 +1510,37 @@ find_dummy_frame_regs (struct frame_info *frame,
   int i;
 
   /* The 32bit and 64bit ABIs save RP into different locations.  */
-  if (REGISTER_SIZE == 8)
+  if (DEPRECATED_REGISTER_SIZE == 8)
     frame_saved_regs[RP_REGNUM] = (fp - 16) & ~0x3;
   else
     frame_saved_regs[RP_REGNUM] = (fp - 20) & ~0x3;
 
-  frame_saved_regs[FP_REGNUM] = fp;
+  frame_saved_regs[DEPRECATED_FP_REGNUM] = fp;
 
-  frame_saved_regs[1] = fp + (2 * REGISTER_SIZE);
+  frame_saved_regs[1] = fp + (2 * DEPRECATED_REGISTER_SIZE);
 
-  for (fp += 3 * REGISTER_SIZE, i = 3; i < 32; i++)
+  for (fp += 3 * DEPRECATED_REGISTER_SIZE, i = 3; i < 32; i++)
     {
-      if (i != FP_REGNUM)
+      if (i != DEPRECATED_FP_REGNUM)
 	{
 	  frame_saved_regs[i] = fp;
-	  fp += REGISTER_SIZE;
+	  fp += DEPRECATED_REGISTER_SIZE;
 	}
     }
 
   /* This is not necessary or desirable for the 64bit ABI.  */
-  if (REGISTER_SIZE != 8)
+  if (DEPRECATED_REGISTER_SIZE != 8)
     fp += 4;
 
   for (i = FP0_REGNUM; i < NUM_REGS; i++, fp += 8)
     frame_saved_regs[i] = fp;
 
   frame_saved_regs[IPSW_REGNUM] = fp;
-  frame_saved_regs[SAR_REGNUM] = fp + REGISTER_SIZE;
-  frame_saved_regs[PCOQ_HEAD_REGNUM] = fp + 2 * REGISTER_SIZE;
-  frame_saved_regs[PCSQ_HEAD_REGNUM] = fp + 3 * REGISTER_SIZE;
-  frame_saved_regs[PCOQ_TAIL_REGNUM] = fp + 4 * REGISTER_SIZE;
-  frame_saved_regs[PCSQ_TAIL_REGNUM] = fp + 5 * REGISTER_SIZE;
+  frame_saved_regs[SAR_REGNUM] = fp + DEPRECATED_REGISTER_SIZE;
+  frame_saved_regs[PCOQ_HEAD_REGNUM] = fp + 2 * DEPRECATED_REGISTER_SIZE;
+  frame_saved_regs[PCSQ_HEAD_REGNUM] = fp + 3 * DEPRECATED_REGISTER_SIZE;
+  frame_saved_regs[PCOQ_TAIL_REGNUM] = fp + 4 * DEPRECATED_REGISTER_SIZE;
+  frame_saved_regs[PCSQ_TAIL_REGNUM] = fp + 5 * DEPRECATED_REGISTER_SIZE;
 }
 
 void
@@ -1563,7 +1564,7 @@ hppa_pop_frame (void)
   for (regnum = 31; regnum > 0; regnum--)
     if (fsr[regnum])
       write_register (regnum, read_memory_integer (fsr[regnum],
-		      REGISTER_SIZE));
+						   DEPRECATED_REGISTER_SIZE));
 
   for (regnum = NUM_REGS - 1; regnum >= FP0_REGNUM; regnum--)
     if (fsr[regnum])
@@ -1576,18 +1577,18 @@ hppa_pop_frame (void)
   if (fsr[IPSW_REGNUM])
     write_register (IPSW_REGNUM,
 		    read_memory_integer (fsr[IPSW_REGNUM],
-					 REGISTER_SIZE));
+					 DEPRECATED_REGISTER_SIZE));
 
   if (fsr[SAR_REGNUM])
     write_register (SAR_REGNUM,
 		    read_memory_integer (fsr[SAR_REGNUM],
-					 REGISTER_SIZE));
+					 DEPRECATED_REGISTER_SIZE));
 
   /* If the PC was explicitly saved, then just restore it.  */
   if (fsr[PCOQ_TAIL_REGNUM])
     {
       npc = read_memory_integer (fsr[PCOQ_TAIL_REGNUM],
-				 REGISTER_SIZE);
+				 DEPRECATED_REGISTER_SIZE);
       write_register (PCOQ_TAIL_REGNUM, npc);
     }
   /* Else use the value in %rp to set the new PC.  */
@@ -1597,7 +1598,7 @@ hppa_pop_frame (void)
       write_pc (npc);
     }
 
-  write_register (FP_REGNUM, read_memory_integer (fp, REGISTER_SIZE));
+  write_register (DEPRECATED_FP_REGNUM, read_memory_integer (fp, DEPRECATED_REGISTER_SIZE));
 
   if (fsr[IPSW_REGNUM])	/* call dummy */
     write_register (SP_REGNUM, fp - 48);
@@ -1666,7 +1667,7 @@ restore_pc_queue (CORE_ADDR *fsr)
      right place. */
 
   write_register (21, read_memory_integer (fsr[PCSQ_HEAD_REGNUM],
-					   REGISTER_SIZE));
+					   DEPRECATED_REGISTER_SIZE));
   write_register (22, new_pc);
 
   for (insn_count = 0; insn_count < 3; insn_count++)
@@ -1746,7 +1747,7 @@ hppa_push_arguments (int nargs, struct value **args, CORE_ADDR sp,
          the left.  We do this by promoting them to full-width,
          although the ABI says to pad them with garbage.  */
       if (is_integral_type (arg_type)
-	  && TYPE_LENGTH (arg_type) < REGISTER_SIZE)
+	  && TYPE_LENGTH (arg_type) < DEPRECATED_REGISTER_SIZE)
 	{
 	  args[i] = value_cast ((TYPE_UNSIGNED (arg_type)
 				 ? builtin_type_unsigned_long
@@ -1759,7 +1760,7 @@ hppa_push_arguments (int nargs, struct value **args, CORE_ADDR sp,
 
       /* Align the size of the argument to the word size for this
 	 target.  */
-      bytes_reserved = (lengths[i] + REGISTER_SIZE - 1) & -REGISTER_SIZE;
+      bytes_reserved = (lengths[i] + DEPRECATED_REGISTER_SIZE - 1) & -DEPRECATED_REGISTER_SIZE;
 
       offset[i] = cum_bytes_reserved;
 
@@ -1771,8 +1772,8 @@ hppa_push_arguments (int nargs, struct value **args, CORE_ADDR sp,
       if (bytes_reserved > 8)
 	{
 	  /* Round up the offset to a multiple of two slots.  */
-	  int new_offset = ((offset[i] + 2*REGISTER_SIZE-1)
-			    & -(2*REGISTER_SIZE));
+	  int new_offset = ((offset[i] + 2*DEPRECATED_REGISTER_SIZE-1)
+			    & -(2*DEPRECATED_REGISTER_SIZE));
 
 	  /* Note the space we've wasted, if any.  */
 	  bytes_reserved += new_offset - offset[i];
@@ -1859,15 +1860,15 @@ hppa_push_arguments (int nargs, struct value **args, CORE_ADDR sp,
 
       /* Align the size of the argument to the word size for this
 	 target.  */
-      bytes_reserved = (lengths[i] + REGISTER_SIZE - 1) & -REGISTER_SIZE;
+      bytes_reserved = (lengths[i] + DEPRECATED_REGISTER_SIZE - 1) & -DEPRECATED_REGISTER_SIZE;
 
       offset[i] = (cum_bytes_reserved
 		   + (lengths[i] > 4 ? bytes_reserved : lengths[i]));
 
       /* If the argument is a double word argument, then it needs to be
 	 double word aligned.  */
-      if ((bytes_reserved == 2 * REGISTER_SIZE)
-	  && (offset[i] % 2 * REGISTER_SIZE))
+      if ((bytes_reserved == 2 * DEPRECATED_REGISTER_SIZE)
+	  && (offset[i] % 2 * DEPRECATED_REGISTER_SIZE))
 	{
 	  int new_offset = 0;
 	  /* BYTES_RESERVED is already aligned to the word, so we put
@@ -1875,13 +1876,13 @@ hppa_push_arguments (int nargs, struct value **args, CORE_ADDR sp,
 
 	     This will leave one empty word on the stack, and one unused
 	     register as mandated by the ABI.  */
-	  new_offset = ((offset[i] + 2 * REGISTER_SIZE - 1)
-			& -(2 * REGISTER_SIZE));
+	  new_offset = ((offset[i] + 2 * DEPRECATED_REGISTER_SIZE - 1)
+			& -(2 * DEPRECATED_REGISTER_SIZE));
 
-	  if ((new_offset - offset[i]) >= 2 * REGISTER_SIZE)
+	  if ((new_offset - offset[i]) >= 2 * DEPRECATED_REGISTER_SIZE)
 	    {
-	      bytes_reserved += REGISTER_SIZE;
-	      offset[i] += REGISTER_SIZE;
+	      bytes_reserved += DEPRECATED_REGISTER_SIZE;
+	      offset[i] += DEPRECATED_REGISTER_SIZE;
 	    }
 	}
 
@@ -2036,9 +2037,9 @@ cover_find_stub_with_shl_get (void *args_untyped)
    into a call sequence of the above form stored at DUMMYNAME.
 
    On the hppa we need to call the stack dummy through $$dyncall.
-   Therefore our version of FIX_CALL_DUMMY takes an extra argument,
-   real_pc, which is the location where gdb should start up the
-   inferior to do the function call. 
+   Therefore our version of DEPRECATED_FIX_CALL_DUMMY takes an extra
+   argument, real_pc, which is the location where gdb should start up
+   the inferior to do the function call.
 
    This has to work across several versions of hpux, bsd, osf1.  It has to
    work regardless of what compiler was used to build the inferior program.
@@ -2194,7 +2195,7 @@ hppa_fix_call_dummy (char *dummy, CORE_ADDR pc, CORE_ADDR fun, int nargs,
          at *(fun+4).  Note the call dummy is *NOT* allowed to
          trash %r19 before calling the target function.  */
       write_register (19, read_memory_integer ((fun & ~0x3) + 4,
-		      REGISTER_SIZE));
+					       DEPRECATED_REGISTER_SIZE));
 
       /* Now get the real address for the function we are calling, it's
          at *fun.  */
@@ -2441,8 +2442,8 @@ hppa_read_fp (int pid)
     }
 
   /* This is the only site that may directly read_register () the FP
-     register.  All others must use TARGET_READ_FP (). */
-  return read_register (FP_REGNUM);
+     register.  All others must use deprecated_read_fp (). */
+  return read_register (DEPRECATED_FP_REGNUM);
 }
 
 CORE_ADDR
@@ -2629,7 +2630,7 @@ pa_register_look_aside (char *raw_regs, int regnum, long *raw_val)
   int start;
 
 
-  char *buf = alloca (max_register_size (current_gdbarch));
+  char buf[MAX_REGISTER_SIZE];
   long long reg_val;
 
   if (!know_which)
@@ -2826,8 +2827,8 @@ pa_strcat_registers (char *raw_regs, int regnum, int fpregs,
 static void
 pa_print_fp_reg (int i)
 {
-  char *raw_buffer = alloca (max_register_size (current_gdbarch));
-  char *virtual_buffer = alloca (max_register_size (current_gdbarch));
+  char raw_buffer[MAX_REGISTER_SIZE];
+  char virtual_buffer[MAX_REGISTER_SIZE];
 
   /* Get 32bits of data.  */
   frame_register_read (deprecated_selected_frame, i, raw_buffer);
@@ -2869,8 +2870,8 @@ pa_print_fp_reg (int i)
 static void
 pa_strcat_fp_reg (int i, struct ui_file *stream, enum precision_type precision)
 {
-  char *raw_buffer = alloca (max_register_size (current_gdbarch));
-  char *virtual_buffer = alloca (max_register_size (current_gdbarch));
+  char raw_buffer[MAX_REGISTER_SIZE];
+  char virtual_buffer[MAX_REGISTER_SIZE];
 
   fputs_filtered (REGISTER_NAME (i), stream);
   print_spaces_filtered (8 - strlen (REGISTER_NAME (i)), stream);
@@ -2884,7 +2885,7 @@ pa_strcat_fp_reg (int i, struct ui_file *stream, enum precision_type precision)
   if (precision == double_precision && (i % 2) == 0)
     {
 
-      char *raw_buf = alloca (max_register_size (current_gdbarch));
+      char raw_buf[MAX_REGISTER_SIZE];
 
       /* Get the data in raw format for the 2nd half.  */
       frame_register_read (deprecated_selected_frame, i + 1, raw_buf);
@@ -3589,7 +3590,7 @@ restart:
   for (i = 3; i < u->Entry_GR + 3; i++)
     {
       /* Frame pointer gets saved into a special location.  */
-      if (u->Save_SP && i == FP_REGNUM)
+      if (u->Save_SP && i == DEPRECATED_FP_REGNUM)
 	continue;
 
       save_gr |= (1 << i);
@@ -3881,16 +3882,16 @@ hppa_frame_find_saved_regs (struct frame_info *frame_info,
 	       /* A call dummy is sized in words, but it is actually a
 		  series of instructions.  Account for that scaling
 		  factor.  */
-	       + ((REGISTER_SIZE / INSTRUCTION_SIZE)
-		  * CALL_DUMMY_LENGTH)
+	       + ((DEPRECATED_REGISTER_SIZE / INSTRUCTION_SIZE)
+		  * DEPRECATED_CALL_DUMMY_LENGTH)
 	       /* Similarly we have to account for 64bit wide register
 		  saves.  */
-	       + (32 * REGISTER_SIZE)
+	       + (32 * DEPRECATED_REGISTER_SIZE)
 	       /* We always consider FP regs 8 bytes long.  */
 	       + (NUM_REGS - FP0_REGNUM) * 8
 	       /* Similarly we have to account for 64bit wide register
 		  saves.  */
-	       + (6 * REGISTER_SIZE)))))
+	       + (6 * DEPRECATED_REGISTER_SIZE)))))
     find_dummy_frame_regs (frame_info, frame_saved_regs);
 
   /* Interrupt handlers are special too.  They lay out the register
@@ -3940,7 +3941,7 @@ hppa_frame_find_saved_regs (struct frame_info *frame_info,
   for (i = 3; i < u->Entry_GR + 3; i++)
     {
       /* Frame pointer gets saved into a special location.  */
-      if (u->Save_SP && i == FP_REGNUM)
+      if (u->Save_SP && i == DEPRECATED_FP_REGNUM)
 	continue;
 
       save_gr |= (1 << i);
@@ -4002,14 +4003,14 @@ hppa_frame_find_saved_regs (struct frame_info *frame_info,
       if (   (inst & 0xffffc000) == 0x6fc10000  /* stw,ma r1,N(sr0,sp) */
           || (inst & 0xffffc00c) == 0x73c10008) /* std,ma r1,N(sr0,sp) */
 	{
-	  frame_saved_regs[FP_REGNUM] = get_frame_base (frame_info);
+	  frame_saved_regs[DEPRECATED_FP_REGNUM] = get_frame_base (frame_info);
 	  save_sp = 0;
 	}
 
       /* Account for general and floating-point register saves.  */
       reg = inst_saves_gr (inst);
       if (reg >= 3 && reg <= 18
-	  && (!u->Save_SP || reg != FP_REGNUM))
+	  && (!u->Save_SP || reg != DEPRECATED_FP_REGNUM))
 	{
 	  save_gr &= ~(1 << reg);
 
@@ -4762,7 +4763,7 @@ hppa_store_return_value (struct type *type, char *valbuf)
 				      ? (8 - TYPE_LENGTH (type))
 				      : (4 - TYPE_LENGTH (type))),
 				   valbuf, TYPE_LENGTH (type));
-  if (! SOFT_FLOAT && TYPE_CODE (type) == TYPE_CODE_FLT)
+  if (TYPE_CODE (type) == TYPE_CODE_FLT)
     deprecated_write_register_bytes (REGISTER_BYTE (FP4_REGNUM),
 				     valbuf, TYPE_LENGTH (type));
 }
@@ -4777,7 +4778,7 @@ hppa_store_return_value (struct type *type, char *valbuf)
 void
 hppa_extract_return_value (struct type *type, char *regbuf, char *valbuf)
 {
-  if (! SOFT_FLOAT && TYPE_CODE (type) == TYPE_CODE_FLT)
+  if (TYPE_CODE (type) == TYPE_CODE_FLT)
     memcpy (valbuf,
 	    (char *)regbuf + REGISTER_BYTE (FP4_REGNUM),
 	    TYPE_LENGTH (type));
@@ -4859,7 +4860,7 @@ int
 hppa_register_raw_size (int reg_nr)
 {
   /* All registers have the same size.  */
-  return REGISTER_SIZE;
+  return DEPRECATED_REGISTER_SIZE;
 }
 
 /* Index within the register vector of the first byte of the space i
@@ -4988,9 +4989,9 @@ hppa_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
   set_gdbarch_inner_than (gdbarch, hppa_inner_than);
   set_gdbarch_stack_align (gdbarch, hppa_stack_align);
   set_gdbarch_decr_pc_after_break (gdbarch, 0);
-  set_gdbarch_register_size (gdbarch, 4);
+  set_gdbarch_deprecated_register_size (gdbarch, 4);
   set_gdbarch_num_regs (gdbarch, hppa_num_regs);
-  set_gdbarch_fp_regnum (gdbarch, 3);
+  set_gdbarch_deprecated_fp_regnum (gdbarch, 3);
   set_gdbarch_sp_regnum (gdbarch, 30);
   set_gdbarch_fp0_regnum (gdbarch, 64);
   set_gdbarch_pc_regnum (gdbarch, PCOQ_HEAD_REGNUM);
@@ -5022,14 +5023,14 @@ hppa_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
   set_gdbarch_frame_args_skip (gdbarch, 0);
   set_gdbarch_deprecated_push_dummy_frame (gdbarch, hppa_push_dummy_frame);
   set_gdbarch_deprecated_pop_frame (gdbarch, hppa_pop_frame);
-  set_gdbarch_call_dummy_length (gdbarch, INSTRUCTION_SIZE * 28);
-  /* set_gdbarch_fix_call_dummy (gdbarch, hppa_fix_call_dummy); */
+  set_gdbarch_deprecated_call_dummy_length (gdbarch, INSTRUCTION_SIZE * 28);
+  /* set_gdbarch_deprecated_fix_call_dummy (gdbarch, hppa_fix_call_dummy); */
   set_gdbarch_deprecated_push_arguments (gdbarch, hppa_push_arguments);
   set_gdbarch_smash_text_address (gdbarch, hppa_smash_text_address);
   set_gdbarch_believe_pcc_promotion (gdbarch, 1);
   set_gdbarch_read_pc (gdbarch, hppa_target_read_pc);
   set_gdbarch_write_pc (gdbarch, hppa_target_write_pc);
-  set_gdbarch_read_fp (gdbarch, hppa_target_read_fp);
+  set_gdbarch_deprecated_target_read_fp (gdbarch, hppa_target_read_fp);
 
   return gdbarch;
 }
@@ -5049,7 +5050,7 @@ _initialize_hppa_tdep (void)
   void break_at_finish_at_depth_command (char *arg, int from_tty);
 
   gdbarch_register (bfd_arch_hppa, hppa_gdbarch_init, hppa_dump_tdep);
-  tm_print_insn = print_insn_hppa;
+  deprecated_tm_print_insn = print_insn_hppa;
 
   add_cmd ("unwind", class_maintenance, unwind_command,
 	   "Print unwind table entry at given address.",
diff --git a/gdb/hppab-nat.c b/gdb/hppab-nat.c
index 3ec3a57e9ac..dc3e6b6fb9c 100644
--- a/gdb/hppab-nat.c
+++ b/gdb/hppab-nat.c
@@ -55,7 +55,7 @@ static void
 fetch_register (int regno)
 {
   register unsigned int regaddr;
-  char *buf = alloca (max_register_size (current_gdbarch));
+  char buf[MAX_REGISTER_SIZE];
   register int i;
 
   /* Offset of registers within the u area.  */
diff --git a/gdb/hppah-nat.c b/gdb/hppah-nat.c
index b953d2546f6..0b8b04f9778 100644
--- a/gdb/hppah-nat.c
+++ b/gdb/hppah-nat.c
@@ -190,7 +190,7 @@ store_inferior_registers (int regno)
 static void
 fetch_register (int regno)
 {
-  char *buf = alloca (max_register_size (current_gdbarch));
+  char buf[MAX_REGISTER_SIZE];
   unsigned int addr, len, offset;
   int i;
 
diff --git a/gdb/hpux-thread.c b/gdb/hpux-thread.c
index b585ca540ce..7a7b74174a1 100644
--- a/gdb/hpux-thread.c
+++ b/gdb/hpux-thread.c
@@ -285,7 +285,7 @@ hpux_thread_fetch_registers (int regno)
 	child_ops.to_fetch_registers (regno);
       else
 	{
-	  unsigned char *buf = alloca (max_register_size (current_gdbarch));
+	  unsigned char buf[MAX_REGISTER_SIZE];
 	  CORE_ADDR sp;
 
 	  sp = (CORE_ADDR) tcb_ptr->static_ctx.sp - 160;
@@ -347,7 +347,7 @@ hpux_thread_store_registers (int regno)
 	child_ops.to_store_registers (regno);
       else
 	{
-	  unsigned char *buf = alloca (max_register_size (current_gdbarch));
+	  unsigned char buf[MAX_REGISTER_SIZE];
 	  CORE_ADDR sp;
 
 	  sp = (CORE_ADDR) tcb_ptr->static_ctx.sp - 160;
diff --git a/gdb/i386-linux-nat.c b/gdb/i386-linux-nat.c
index 3744124ebc5..cf769d87edc 100644
--- a/gdb/i386-linux-nat.c
+++ b/gdb/i386-linux-nat.c
@@ -72,7 +72,6 @@
 
 /* Prototypes for local functions.  */
 static void dummy_sse_values (void);
-
 
 
 /* The register sets used in GNU/Linux ELF core-dumps are identical to
@@ -233,10 +232,10 @@ supply_gregset (elf_gregset_t *gregsetp)
   int i;
 
   for (i = 0; i < I386_NUM_GREGS; i++)
-    supply_register (i, (char *) (regp + regmap[i]));
+    supply_register (i, regp + regmap[i]);
 
   if (I386_LINUX_ORIG_EAX_REGNUM < NUM_REGS)
-    supply_register (I386_LINUX_ORIG_EAX_REGNUM, (char *) (regp + ORIG_EAX));
+    supply_register (I386_LINUX_ORIG_EAX_REGNUM, regp + ORIG_EAX);
 }
 
 /* Fill register REGNO (if it is a general-purpose register) in
diff --git a/gdb/i386-nto-tdep.c b/gdb/i386-nto-tdep.c
new file mode 100644
index 00000000000..b35dd2a13b7
--- /dev/null
+++ b/gdb/i386-nto-tdep.c
@@ -0,0 +1,298 @@
+/* i386-nto-tdep.c - i386 specific functionality for QNX Neutrino.
+
+   Copyright 2003 Free Software Foundation, Inc.
+
+   Contributed by QNX Software Systems Ltd.
+
+   This file is part of GDB.
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 59 Temple Place - Suite 330,
+   Boston, MA 02111-1307, USA.  */
+
+#include "gdb_string.h"
+#include "gdb_assert.h"
+#include "defs.h"
+#include "frame.h"
+#include "target.h"
+#include "regcache.h"
+#include "solib-svr4.h"
+#include "i386-tdep.h"
+#include "nto-tdep.h"
+#include "osabi.h"
+#include "i387-tdep.h"
+
+#ifndef X86_CPU_FXSR
+#define X86_CPU_FXSR (1L << 12)
+#endif
+
+/* Why 13?  Look in our /usr/include/x86/context.h header at the
+   x86_cpu_registers structure and you'll see an 'exx' junk register
+   that is just filler.  Don't ask me, ask the kernel guys.  */
+#define NUM_GPREGS 13
+
+/* Map a GDB register number to an offset in the reg structure.  */
+static int regmap[] = {
+  (7 * 4),			/* eax */
+  (6 * 4),			/* ecx */
+  (5 * 4),			/* edx */
+  (4 * 4),			/* ebx */
+  (11 * 4),			/* esp */
+  (2 * 4),			/* epb */
+  (1 * 4),			/* esi */
+  (0 * 4),			/* edi */
+  (8 * 4),			/* eip */
+  (10 * 4),			/* eflags */
+  (9 * 4),			/* cs */
+  (12 * 4),			/* ss */
+  (-1 * 4)			/* filler */
+};
+
+/* Given a gdb regno, return the offset into Neutrino's register structure
+   or -1 if register is unknown.  */
+static int
+nto_reg_offset (int regno)
+{
+  return (regno >= 0 && regno < NUM_GPREGS) ? regmap[regno] : -1;
+}
+
+static void
+i386nto_supply_gregset (char *gpregs)
+{
+  unsigned regno;
+  int empty = 0;
+
+  for (regno = 0; regno < FP0_REGNUM; regno++)
+    {
+      int offset = nto_reg_offset (regno);
+      if (offset == -1)
+	supply_register (regno, (char *) &empty);
+      else
+	supply_register (regno, gpregs + offset);
+    }
+}
+
+static void
+i386nto_supply_fpregset (char *fpregs)
+{
+  if (nto_cpuinfo_valid && nto_cpuinfo_flags | X86_CPU_FXSR)
+    i387_supply_fxsave (fpregs);
+  else
+    i387_supply_fsave (fpregs);
+}
+
+static void
+i386nto_supply_regset (int regset, char *data)
+{
+  switch (regset)
+    {
+    case NTO_REG_GENERAL:	/* QNX has different ordering of GP regs than GDB.  */
+      i386nto_supply_gregset (data);
+      break;
+    case NTO_REG_FLOAT:
+      i386nto_supply_fpregset (data);
+      break;
+    }
+}
+
+static int
+i386nto_regset_id (int regno)
+{
+  if (regno == -1)
+    return NTO_REG_END;
+  else if (regno < FP0_REGNUM)
+    return NTO_REG_GENERAL;
+  else if (regno < FPC_REGNUM)
+    return NTO_REG_FLOAT;
+
+  return -1;			/* Error.  */
+}
+
+static int
+i386nto_register_area (int regno, int regset, unsigned *off)
+{
+  int len;
+
+  *off = 0;
+  if (regset == NTO_REG_GENERAL)
+    {
+      if (regno == -1)
+	return NUM_GPREGS * 4;
+
+      *off = nto_reg_offset (regno);
+      if (*off == -1)
+	return 0;
+      return 4;
+    }
+  else if (regset == NTO_REG_FLOAT)
+    {
+      unsigned off_adjust, regsize, regset_size;
+
+      if (nto_cpuinfo_valid && nto_cpuinfo_flags | X86_CPU_FXSR)
+	{
+	  off_adjust = 32;
+	  regsize = 16;
+	  regset_size = 512;
+	}
+      else
+	{
+	  off_adjust = 28;
+	  regsize = 10;
+	  regset_size = 128;
+	}
+
+      if (regno == -1)
+	return regset_size;
+
+      *off = (regno - FP0_REGNUM) * regsize + off_adjust;
+      return 10;
+      /* Why 10 instead of regsize?  GDB only stores 10 bytes per FP
+         register so if we're sending a register back to the target,
+         we only want pdebug to write 10 bytes so as not to clobber
+         the reserved 6 bytes in the fxsave structure.  */
+    }
+  return -1;
+}
+
+static int
+i386nto_regset_fill (int regset, char *data)
+{
+  if (regset == NTO_REG_GENERAL)
+    {
+      int regno;
+
+      for (regno = 0; regno < NUM_GPREGS; regno++)
+	{
+	  int offset = nto_reg_offset (regno);
+	  if (offset != -1)
+	    regcache_collect (regno, data + offset);
+	}
+    }
+  else if (regset == NTO_REG_FLOAT)
+    {
+      if (nto_cpuinfo_valid && nto_cpuinfo_flags | X86_CPU_FXSR)
+	i387_fill_fxsave (data, -1);
+      else
+	i387_fill_fsave (data, -1);
+    }
+  else
+    return -1;
+
+  return 0;
+}
+
+static struct link_map_offsets *
+i386nto_svr4_fetch_link_map_offsets (void)
+{
+  static struct link_map_offsets lmo;
+  static struct link_map_offsets *lmp = NULL;
+
+  if (lmp == NULL)
+    {
+      lmp = &lmo;
+
+      lmo.r_debug_size = 8;	/* The actual size is 20 bytes, but
+				   only 8 bytes are used.  */
+      lmo.r_map_offset = 4;
+      lmo.r_map_size = 4;
+
+      lmo.link_map_size = 20;	/* The actual size is 552 bytes, but
+				   only 20 bytes are used.  */
+      lmo.l_addr_offset = 0;
+      lmo.l_addr_size = 4;
+
+      lmo.l_name_offset = 4;
+      lmo.l_name_size = 4;
+
+      lmo.l_next_offset = 12;
+      lmo.l_next_size = 4;
+
+      lmo.l_prev_offset = 16;
+      lmo.l_prev_size = 4;
+    }
+
+  return lmp;
+}
+
+static int
+i386nto_pc_in_sigtramp (CORE_ADDR pc, char *name)
+{
+  return name && strcmp ("__signalstub", name) == 0;
+}
+
+#define SIGCONTEXT_OFFSET 136
+static CORE_ADDR
+i386nto_sigcontext_addr (struct frame_info *frame)
+{
+  if (get_next_frame (frame))
+    return get_frame_base (get_next_frame (frame)) + SIGCONTEXT_OFFSET;
+
+  return read_register (SP_REGNUM) + SIGCONTEXT_OFFSET;
+}
+
+static void
+init_i386nto_ops (void)
+{
+  current_nto_target.nto_regset_id = i386nto_regset_id;
+  current_nto_target.nto_supply_gregset = i386nto_supply_gregset;
+  current_nto_target.nto_supply_fpregset = i386nto_supply_fpregset;
+  current_nto_target.nto_supply_altregset = nto_dummy_supply_regset;
+  current_nto_target.nto_supply_regset = i386nto_supply_regset;
+  current_nto_target.nto_register_area = i386nto_register_area;
+  current_nto_target.nto_regset_fill = i386nto_regset_fill;
+  current_nto_target.nto_fetch_link_map_offsets =
+    i386nto_svr4_fetch_link_map_offsets;
+}
+
+static void
+i386nto_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
+{
+  struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
+
+  /* NTO uses ELF.  */
+  i386_elf_init_abi (info, gdbarch);
+
+  /* Neutrino rewinds to look more normal.  */
+  set_gdbarch_decr_pc_after_break (gdbarch, 0);
+
+  /* NTO has shared libraries.  */
+  set_gdbarch_in_solib_call_trampoline (gdbarch, in_plt_section);
+  set_gdbarch_skip_trampoline_code (gdbarch, find_solib_trampoline_target);
+
+  set_gdbarch_pc_in_sigtramp (gdbarch, i386nto_pc_in_sigtramp);
+  tdep->sigcontext_addr = i386nto_sigcontext_addr;
+  tdep->sc_pc_offset = 56;
+  tdep->sc_sp_offset = 68;
+
+  /* Setjmp()'s return PC saved in EDX (5).  */
+  tdep->jb_pc_offset = 20;	/* 5x32 bit ints in.  */
+
+  set_solib_svr4_fetch_link_map_offsets (gdbarch,
+					 i386nto_svr4_fetch_link_map_offsets);
+
+  /* Our loader handles solib relocations slightly differently than svr4.  */
+  TARGET_SO_RELOCATE_SECTION_ADDRESSES = nto_relocate_section_addresses;
+
+  /* Supply a nice function to find our solibs.  */
+  TARGET_SO_FIND_AND_OPEN_SOLIB = nto_find_and_open_solib;
+
+  init_i386nto_ops ();
+}
+
+void
+_initialize_i386nto_tdep (void)
+{
+  gdbarch_register_osabi (bfd_arch_i386, 0, GDB_OSABI_QNXNTO,
+			  i386nto_init_abi);
+}
diff --git a/gdb/i386-tdep.c b/gdb/i386-tdep.c
index 2406e3ffefc..5cf63b46f86 100644
--- a/gdb/i386-tdep.c
+++ b/gdb/i386-tdep.c
@@ -669,7 +669,7 @@ i386_frame_init_saved_regs (struct frame_info *fip)
     }
 
   get_frame_saved_regs (fip)[PC_REGNUM] = get_frame_base (fip) + 4;
-  get_frame_saved_regs (fip)[FP_REGNUM] = get_frame_base (fip);
+  get_frame_saved_regs (fip)[DEPRECATED_FP_REGNUM] = get_frame_base (fip);
 }
 
 /* Return PC of first real instruction.  */
@@ -808,7 +808,7 @@ i386_do_pop_frame (struct frame_info *frame)
 	  deprecated_write_register_gen (regnum, regbuf);
 	}
     }
-  write_register (FP_REGNUM, read_memory_integer (fp, 4));
+  write_register (DEPRECATED_FP_REGNUM, read_memory_integer (fp, 4));
   write_register (PC_REGNUM, read_memory_integer (fp + 4, 4));
   write_register (SP_REGNUM, fp + 8);
   flush_cached_frames ();
@@ -1057,7 +1057,7 @@ i386_use_struct_convention (int gcc_p, struct type *type)
 static struct type *
 i386_register_type (struct gdbarch *gdbarch, int regnum)
 {
-  if (regnum == PC_REGNUM || regnum == FP_REGNUM || regnum == SP_REGNUM)
+  if (regnum == PC_REGNUM || regnum == DEPRECATED_FP_REGNUM || regnum == SP_REGNUM)
     return lookup_pointer_type (builtin_type_void);
 
   if (i386_fp_regnum_p (regnum))
@@ -1097,7 +1097,7 @@ i386_pseudo_register_read (struct gdbarch *gdbarch, struct regcache *regcache,
 {
   if (i386_mmx_regnum_p (regnum))
     {
-      char *mmx_buf = alloca (MAX_REGISTER_RAW_SIZE);
+      char mmx_buf[MAX_REGISTER_SIZE];
       int fpnum = i386_mmx_regnum_to_fp_regnum (regcache, regnum);
 
       /* Extract (always little endian).  */
@@ -1114,7 +1114,7 @@ i386_pseudo_register_write (struct gdbarch *gdbarch, struct regcache *regcache,
 {
   if (i386_mmx_regnum_p (regnum))
     {
-      char *mmx_buf = alloca (MAX_REGISTER_RAW_SIZE);
+      char mmx_buf[MAX_REGISTER_SIZE];
       int fpnum = i386_mmx_regnum_to_fp_regnum (regcache, regnum);
 
       /* Read ...  */
@@ -1469,7 +1469,7 @@ i386_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
   set_gdbarch_num_regs (gdbarch, I386_NUM_GREGS + I386_NUM_FREGS);
 
   set_gdbarch_sp_regnum (gdbarch, 4); /* %esp */
-  set_gdbarch_fp_regnum (gdbarch, 5); /* %ebp */
+  set_gdbarch_deprecated_fp_regnum (gdbarch, 5); /* %ebp */
   set_gdbarch_pc_regnum (gdbarch, 8); /* %eip */
   set_gdbarch_ps_regnum (gdbarch, 9); /* %eflags */
   set_gdbarch_fp0_regnum (gdbarch, 16);	/* %st(0) */
@@ -1486,7 +1486,7 @@ i386_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
      be in use on any of the supported i386 targets.  */
 
   set_gdbarch_register_name (gdbarch, i386_register_name);
-  set_gdbarch_register_size (gdbarch, 4);
+  set_gdbarch_deprecated_register_size (gdbarch, 4);
   set_gdbarch_register_bytes (gdbarch, I386_SIZEOF_GREGS + I386_SIZEOF_FREGS);
   set_gdbarch_register_type (gdbarch, i386_register_type);
 
@@ -1495,8 +1495,8 @@ i386_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
   set_gdbarch_get_longjmp_target (gdbarch, i386_get_longjmp_target);
 
   /* Call dummy code.  */
-  set_gdbarch_call_dummy_words (gdbarch, NULL);
-  set_gdbarch_sizeof_call_dummy_words (gdbarch, 0);
+  set_gdbarch_deprecated_call_dummy_words (gdbarch, NULL);
+  set_gdbarch_deprecated_sizeof_call_dummy_words (gdbarch, 0);
 
   set_gdbarch_register_convertible (gdbarch, i386_register_convertible);
   set_gdbarch_register_convert_to_virtual (gdbarch,
@@ -1542,7 +1542,7 @@ i386_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
   set_gdbarch_pc_in_sigtramp (gdbarch, i386_pc_in_sigtramp);
 
   /* Wire in the MMX registers.  */
-  set_gdbarch_num_pseudo_regs (gdbarch, mmx_num_regs);
+  set_gdbarch_num_pseudo_regs (gdbarch, i386_num_mmx_regs);
   set_gdbarch_pseudo_register_read (gdbarch, i386_pseudo_register_read);
   set_gdbarch_pseudo_register_write (gdbarch, i386_pseudo_register_write);
 
diff --git a/gdb/i387-tdep.c b/gdb/i387-tdep.c
index 045357ea3fe..c6a2d5dac84 100644
--- a/gdb/i387-tdep.c
+++ b/gdb/i387-tdep.c
@@ -522,19 +522,34 @@ static int fxsave_offset[] =
   20,				/* FOSEG_REGNUM (16 bits).  */
   16,				/* FOOFF_REGNUM.  */
   6,				/* FOP_REGNUM (bottom 11 bits).  */
-  160,				/* XMM0_REGNUM through ...  */
-  176,
-  192,
-  208,
-  224,
-  240,
-  256,
-  272,				/* ... XMM7_REGNUM (128 bits each).  */
-  24,				/* MXCSR_REGNUM.  */
+  160 + 0 * 16,			/* XMM0_REGNUM through ...  */
+  160 + 1 * 16,
+  160 + 2 * 16,
+  160 + 3 * 16,
+  160 + 4 * 16,
+  160 + 5 * 16,
+  160 + 6 * 16,
+  160 + 7 * 16,
+  160 + 8 * 16,
+  160 + 9 * 16,
+  160 + 10 * 16,
+  160 + 11 * 16,
+  160 + 12 * 16,
+  160 + 13 * 16,
+  160 + 14 * 16,
+  160 + 15 * 16,		/* ... XMM15_REGNUM (128 bits each).  */
+  24				/* MXCSR_REGNUM.  */
 };
 
+/* FIXME: kettenis/20030430: We made an unfortunate choice in putting
+   %mxcsr after the SSE registers %xmm0-%xmm7 instead of before, since
+   it makes supporting the registers %xmm8-%xmm15 on x86-64 a bit
+   involved.  Hack around it by explicitly overriding the offset for
+   %mxcsr here.  */
+
 #define FXSAVE_ADDR(fxsave, regnum) \
-  (fxsave + fxsave_offset[regnum - FP0_REGNUM])
+  ((regnum == MXCSR_REGNUM) ? (fxsave + 24) : \
+   (fxsave + fxsave_offset[regnum - FP0_REGNUM]))
 
 static int i387_tag (unsigned char *raw);
 
diff --git a/gdb/ia64-tdep.c b/gdb/ia64-tdep.c
index 86638fb37ba..ce9b26c8e2e 100644
--- a/gdb/ia64-tdep.c
+++ b/gdb/ia64-tdep.c
@@ -678,8 +678,8 @@ rse_address_add(CORE_ADDR addr, int nslots)
    computationally expensive.  So, instead of making life difficult
    (and slow), we pick a more convenient representation of the frame
    chain, knowing that we'll have to make some small adjustments in
-   other places.  (E.g, note that read_fp() is actually read_sp() in
-   ia64_gdbarch_init() below.)
+   other places.  (E.g, note that deprecated_read_fp() is actually
+   read_sp() in ia64_gdbarch_init() below.)
 
    Okay, so what is the frame chain exactly?  It'll be the SP value
    at the time that the function in question was entered.
@@ -1259,7 +1259,7 @@ ia64_get_saved_register (char *raw_buffer,
     }
   else if (IA64_PR0_REGNUM <= regnum && regnum <= IA64_PR63_REGNUM)
     {
-      char *pr_raw_buffer = alloca (MAX_REGISTER_RAW_SIZE);
+      char pr_raw_buffer[MAX_REGISTER_SIZE];
       int  pr_optim;
       enum lval_type pr_lval;
       CORE_ADDR pr_addr;
@@ -1282,7 +1282,7 @@ ia64_get_saved_register (char *raw_buffer,
     }
   else if (IA64_NAT0_REGNUM <= regnum && regnum <= IA64_NAT31_REGNUM)
     {
-      char *unat_raw_buffer = alloca (MAX_REGISTER_RAW_SIZE);
+      char unat_raw_buffer[MAX_REGISTER_SIZE];
       int  unat_optim;
       enum lval_type unat_lval;
       CORE_ADDR unat_addr;
@@ -2033,7 +2033,9 @@ ia64_pop_frame_regular (struct frame_info *frame)
 }
 
 static void
-ia64_remote_translate_xfer_address (CORE_ADDR memaddr, int nr_bytes,
+ia64_remote_translate_xfer_address (struct gdbarch *gdbarch,
+				    struct regcache *regcache,
+				    CORE_ADDR memaddr, int nr_bytes,
 				    CORE_ADDR *targ_addr, int *targ_len)
 {
   *targ_addr = memaddr;
@@ -2168,12 +2170,12 @@ ia64_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
 
   set_gdbarch_num_regs (gdbarch, ia64_num_regs);
   set_gdbarch_sp_regnum (gdbarch, sp_regnum);
-  set_gdbarch_fp_regnum (gdbarch, fp_regnum);
+  set_gdbarch_deprecated_fp_regnum (gdbarch, fp_regnum);
   set_gdbarch_pc_regnum (gdbarch, pc_regnum);
   set_gdbarch_fp0_regnum (gdbarch, IA64_FR0_REGNUM);
 
   set_gdbarch_register_name (gdbarch, ia64_register_name);
-  set_gdbarch_register_size (gdbarch, 8);
+  set_gdbarch_deprecated_register_size (gdbarch, 8);
   set_gdbarch_register_bytes (gdbarch, ia64_num_regs * 8 + 128*8);
   set_gdbarch_register_byte (gdbarch, ia64_register_byte);
   set_gdbarch_register_raw_size (gdbarch, ia64_register_raw_size);
@@ -2217,18 +2219,18 @@ ia64_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
   set_gdbarch_deprecated_push_return_address (gdbarch, ia64_push_return_address);
   set_gdbarch_deprecated_pop_frame (gdbarch, ia64_pop_frame);
 
-  set_gdbarch_call_dummy_words (gdbarch, ia64_call_dummy_words);
-  set_gdbarch_sizeof_call_dummy_words (gdbarch, sizeof (ia64_call_dummy_words));
+  set_gdbarch_deprecated_call_dummy_words (gdbarch, ia64_call_dummy_words);
+  set_gdbarch_deprecated_sizeof_call_dummy_words (gdbarch, sizeof (ia64_call_dummy_words));
   set_gdbarch_deprecated_init_extra_frame_info (gdbarch, ia64_init_extra_frame_info);
   set_gdbarch_frame_args_address (gdbarch, ia64_frame_args_address);
   set_gdbarch_frame_locals_address (gdbarch, ia64_frame_locals_address);
 
-  /* We won't necessarily have a frame pointer and even if we do,
-     it winds up being extraordinarly messy when attempting to find
-     the frame chain.  So for the purposes of creating frames (which
-     is all read_fp() is used for), simply use the stack pointer value
-     instead.  */
-  set_gdbarch_read_fp (gdbarch, generic_target_read_sp);
+  /* We won't necessarily have a frame pointer and even if we do, it
+     winds up being extraordinarly messy when attempting to find the
+     frame chain.  So for the purposes of creating frames (which is
+     all deprecated_read_fp() is used for), simply use the stack
+     pointer value instead.  */
+  set_gdbarch_deprecated_target_read_fp (gdbarch, generic_target_read_sp);
 
   /* Settings that should be unnecessary.  */
   set_gdbarch_inner_than (gdbarch, core_addr_lessthan);
@@ -2251,6 +2253,6 @@ _initialize_ia64_tdep (void)
 {
   register_gdbarch_init (bfd_arch_ia64, ia64_gdbarch_init);
 
-  tm_print_insn = print_insn_ia64;
-  tm_print_insn_info.bytes_per_line = SLOT_MULTIPLIER;
+  deprecated_tm_print_insn = print_insn_ia64;
+  deprecated_tm_print_insn_info.bytes_per_line = SLOT_MULTIPLIER;
 }
diff --git a/gdb/infcall.c b/gdb/infcall.c
new file mode 100644
index 00000000000..5f80e896bbc
--- /dev/null
+++ b/gdb/infcall.c
@@ -0,0 +1,1072 @@
+/* Perform an inferior function call, for GDB, the GNU debugger.
+
+   Copyright 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994,
+   1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003 Free Software
+   Foundation, Inc.
+
+   This file is part of GDB.
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 59 Temple Place - Suite 330,
+   Boston, MA 02111-1307, USA.  */
+
+#include "defs.h"
+#include "breakpoint.h"
+#include "target.h"
+#include "regcache.h"
+#include "inferior.h"
+#include "gdb_assert.h"
+#include "block.h"
+#include "gdbcore.h"
+#include "language.h"
+#include "symfile.h"
+#include "gdbcmd.h"
+#include "command.h"
+#include "gdb_string.h"
+
+/* NOTE: cagney/2003-04-16: What's the future of this code?
+
+   GDB needs an asynchronous expression evaluator, that means an
+   asynchronous inferior function call implementation, and that in
+   turn means restructuring the code so that it is event driven.  */
+
+/* How you should pass arguments to a function depends on whether it
+   was defined in K&R style or prototype style.  If you define a
+   function using the K&R syntax that takes a `float' argument, then
+   callers must pass that argument as a `double'.  If you define the
+   function using the prototype syntax, then you must pass the
+   argument as a `float', with no promotion.
+
+   Unfortunately, on certain older platforms, the debug info doesn't
+   indicate reliably how each function was defined.  A function type's
+   TYPE_FLAG_PROTOTYPED flag may be clear, even if the function was
+   defined in prototype style.  When calling a function whose
+   TYPE_FLAG_PROTOTYPED flag is clear, GDB consults this flag to
+   decide what to do.
+
+   For modern targets, it is proper to assume that, if the prototype
+   flag is clear, that can be trusted: `float' arguments should be
+   promoted to `double'.  For some older targets, if the prototype
+   flag is clear, that doesn't tell us anything.  The default is to
+   trust the debug information; the user can override this behavior
+   with "set coerce-float-to-double 0".  */
+
+static int coerce_float_to_double_p = 1;
+
+/* This boolean tells what gdb should do if a signal is received while
+   in a function called from gdb (call dummy).  If set, gdb unwinds
+   the stack and restore the context to what as it was before the
+   call.
+
+   The default is to stop in the frame where the signal was received. */
+
+int unwind_on_signal_p = 0;
+
+/* Perform the standard coercions that are specified
+   for arguments to be passed to C functions.
+
+   If PARAM_TYPE is non-NULL, it is the expected parameter type.
+   IS_PROTOTYPED is non-zero if the function declaration is prototyped.  */
+
+static struct value *
+value_arg_coerce (struct value *arg, struct type *param_type,
+		  int is_prototyped)
+{
+  register struct type *arg_type = check_typedef (VALUE_TYPE (arg));
+  register struct type *type
+    = param_type ? check_typedef (param_type) : arg_type;
+
+  switch (TYPE_CODE (type))
+    {
+    case TYPE_CODE_REF:
+      if (TYPE_CODE (arg_type) != TYPE_CODE_REF
+	  && TYPE_CODE (arg_type) != TYPE_CODE_PTR)
+	{
+	  arg = value_addr (arg);
+	  VALUE_TYPE (arg) = param_type;
+	  return arg;
+	}
+      break;
+    case TYPE_CODE_INT:
+    case TYPE_CODE_CHAR:
+    case TYPE_CODE_BOOL:
+    case TYPE_CODE_ENUM:
+      /* If we don't have a prototype, coerce to integer type if necessary.  */
+      if (!is_prototyped)
+	{
+	  if (TYPE_LENGTH (type) < TYPE_LENGTH (builtin_type_int))
+	    type = builtin_type_int;
+	}
+      /* Currently all target ABIs require at least the width of an integer
+         type for an argument.  We may have to conditionalize the following
+         type coercion for future targets.  */
+      if (TYPE_LENGTH (type) < TYPE_LENGTH (builtin_type_int))
+	type = builtin_type_int;
+      break;
+    case TYPE_CODE_FLT:
+      if (!is_prototyped && coerce_float_to_double_p)
+	{
+	  if (TYPE_LENGTH (type) < TYPE_LENGTH (builtin_type_double))
+	    type = builtin_type_double;
+	  else if (TYPE_LENGTH (type) > TYPE_LENGTH (builtin_type_double))
+	    type = builtin_type_long_double;
+	}
+      break;
+    case TYPE_CODE_FUNC:
+      type = lookup_pointer_type (type);
+      break;
+    case TYPE_CODE_ARRAY:
+      /* Arrays are coerced to pointers to their first element, unless
+         they are vectors, in which case we want to leave them alone,
+         because they are passed by value.  */
+      if (current_language->c_style_arrays)
+	if (!TYPE_VECTOR (type))
+	  type = lookup_pointer_type (TYPE_TARGET_TYPE (type));
+      break;
+    case TYPE_CODE_UNDEF:
+    case TYPE_CODE_PTR:
+    case TYPE_CODE_STRUCT:
+    case TYPE_CODE_UNION:
+    case TYPE_CODE_VOID:
+    case TYPE_CODE_SET:
+    case TYPE_CODE_RANGE:
+    case TYPE_CODE_STRING:
+    case TYPE_CODE_BITSTRING:
+    case TYPE_CODE_ERROR:
+    case TYPE_CODE_MEMBER:
+    case TYPE_CODE_METHOD:
+    case TYPE_CODE_COMPLEX:
+    default:
+      break;
+    }
+
+  return value_cast (type, arg);
+}
+
+/* Determine a function's address and its return type from its value.
+   Calls error() if the function is not valid for calling.  */
+
+CORE_ADDR
+find_function_addr (struct value *function, struct type **retval_type)
+{
+  register struct type *ftype = check_typedef (VALUE_TYPE (function));
+  register enum type_code code = TYPE_CODE (ftype);
+  struct type *value_type;
+  CORE_ADDR funaddr;
+
+  /* If it's a member function, just look at the function
+     part of it.  */
+
+  /* Determine address to call.  */
+  if (code == TYPE_CODE_FUNC || code == TYPE_CODE_METHOD)
+    {
+      funaddr = VALUE_ADDRESS (function);
+      value_type = TYPE_TARGET_TYPE (ftype);
+    }
+  else if (code == TYPE_CODE_PTR)
+    {
+      funaddr = value_as_address (function);
+      ftype = check_typedef (TYPE_TARGET_TYPE (ftype));
+      if (TYPE_CODE (ftype) == TYPE_CODE_FUNC
+	  || TYPE_CODE (ftype) == TYPE_CODE_METHOD)
+	{
+	  funaddr = CONVERT_FROM_FUNC_PTR_ADDR (funaddr);
+	  value_type = TYPE_TARGET_TYPE (ftype);
+	}
+      else
+	value_type = builtin_type_int;
+    }
+  else if (code == TYPE_CODE_INT)
+    {
+      /* Handle the case of functions lacking debugging info.
+         Their values are characters since their addresses are char */
+      if (TYPE_LENGTH (ftype) == 1)
+	funaddr = value_as_address (value_addr (function));
+      else
+	/* Handle integer used as address of a function.  */
+	funaddr = (CORE_ADDR) value_as_long (function);
+
+      value_type = builtin_type_int;
+    }
+  else
+    error ("Invalid data type for function to be called.");
+
+  *retval_type = value_type;
+  return funaddr;
+}
+
+/* Call breakpoint_auto_delete on the current contents of the bpstat
+   pointed to by arg (which is really a bpstat *).  */
+
+static void
+breakpoint_auto_delete_contents (void *arg)
+{
+  breakpoint_auto_delete (*(bpstat *) arg);
+}
+
+static CORE_ADDR
+legacy_push_dummy_code (struct gdbarch *gdbarch,
+			CORE_ADDR sp, CORE_ADDR funaddr, int using_gcc,
+			struct value **args, int nargs,
+			struct type *value_type,
+			CORE_ADDR *real_pc, CORE_ADDR *bp_addr)
+{
+  /* CALL_DUMMY is an array of words (DEPRECATED_REGISTER_SIZE), but
+     each word is in host byte order.  Before calling
+     DEPRECATED_FIX_CALL_DUMMY, we byteswap it and remove any extra
+     bytes which might exist because ULONGEST is bigger than
+     DEPRECATED_REGISTER_SIZE.  */
+  /* NOTE: This is pretty wierd, as the call dummy is actually a
+     sequence of instructions.  But CISC machines will have to pack
+     the instructions into DEPRECATED_REGISTER_SIZE units (and so will
+     RISC machines for which INSTRUCTION_SIZE is not
+     DEPRECATED_REGISTER_SIZE).  */
+  /* NOTE: This is pretty stupid.  CALL_DUMMY should be in strict
+     target byte order. */
+  CORE_ADDR start_sp;
+  ULONGEST *dummy = alloca (DEPRECATED_SIZEOF_CALL_DUMMY_WORDS);
+  int sizeof_dummy1 = (DEPRECATED_REGISTER_SIZE
+		       * DEPRECATED_SIZEOF_CALL_DUMMY_WORDS
+		       / sizeof (ULONGEST));
+  char *dummy1 = alloca (sizeof_dummy1);
+  memcpy (dummy, DEPRECATED_CALL_DUMMY_WORDS,
+	  DEPRECATED_SIZEOF_CALL_DUMMY_WORDS);
+  if (INNER_THAN (1, 2))
+    {
+      /* Stack grows down */
+      sp -= sizeof_dummy1;
+      start_sp = sp;
+    }
+  else
+    {
+      /* Stack grows up */
+      start_sp = sp;
+      sp += sizeof_dummy1;
+    }
+  /* NOTE: cagney/2002-09-10: Don't bother re-adjusting the stack
+     after allocating space for the call dummy.  A target can specify
+     a SIZEOF_DUMMY1 (via DEPRECATED_SIZEOF_CALL_DUMMY_WORDS) such
+     that all local alignment requirements are met.  */
+  /* Create a call sequence customized for this function and the
+     number of arguments for it.  */
+  {
+    int i;
+    for (i = 0; i < (int) (DEPRECATED_SIZEOF_CALL_DUMMY_WORDS / sizeof (dummy[0]));
+	 i++)
+      store_unsigned_integer (&dummy1[i * DEPRECATED_REGISTER_SIZE],
+			      DEPRECATED_REGISTER_SIZE,
+			      (ULONGEST) dummy[i]);
+  }
+  /* NOTE: cagney/2003-04-22: This computation of REAL_PC, BP_ADDR and
+     DUMMY_ADDR is pretty messed up.  It comes from constant tinkering
+     with the values.  Instead a DEPRECATED_FIX_CALL_DUMMY replacement
+     (PUSH_DUMMY_BREAKPOINT?) should just do everything.  */
+#ifdef GDB_TARGET_IS_HPPA
+  real_pc = DEPRECATED_FIX_CALL_DUMMY (dummy1, start_sp, funaddr, nargs, args,
+				       value_type, using_gcc);
+#else
+  if (DEPRECATED_FIX_CALL_DUMMY_P ())
+    {
+      /* gdb_assert (CALL_DUMMY_LOCATION == ON_STACK) true?  */
+      DEPRECATED_FIX_CALL_DUMMY (dummy1, start_sp, funaddr, nargs, args,
+				 value_type, using_gcc);
+    }
+  (*real_pc) = start_sp;
+#endif
+  /* Yes, the offset is applied to the real_pc and not the dummy addr.
+     Ulgh!  Blame the HP/UX target.  */
+  (*bp_addr) = (*real_pc) + DEPRECATED_CALL_DUMMY_BREAKPOINT_OFFSET;
+  /* Yes, the offset is applied to the real_pc and not the
+     dummy_addr.  Ulgh!  Blame the HP/UX target.  */
+  (*real_pc) += DEPRECATED_CALL_DUMMY_START_OFFSET;
+  write_memory (start_sp, (char *) dummy1, sizeof_dummy1);
+  if (DEPRECATED_USE_GENERIC_DUMMY_FRAMES)
+    generic_save_call_dummy_addr (start_sp, start_sp + sizeof_dummy1);
+  return sp;
+}
+
+static CORE_ADDR
+generic_push_dummy_code (struct gdbarch *gdbarch,
+			 CORE_ADDR sp, CORE_ADDR funaddr, int using_gcc,
+			 struct value **args, int nargs,
+			 struct type *value_type,
+			 CORE_ADDR *real_pc, CORE_ADDR *bp_addr)
+{
+  /* Something here to findout the size of a breakpoint and then
+     allocate space for it on the stack.  */
+  int bplen;
+  /* This code assumes frame align.  */
+  gdb_assert (gdbarch_frame_align_p (gdbarch));
+  /* Force the stack's alignment.  The intent is to ensure that the SP
+     is aligned to at least a breakpoint instruction's boundary.  */
+  sp = gdbarch_frame_align (gdbarch, sp);
+  /* Allocate space for, and then position the breakpoint on the
+     stack.  */
+  if (gdbarch_inner_than (gdbarch, 1, 2))
+    {
+      CORE_ADDR bppc = sp;
+      gdbarch_breakpoint_from_pc (gdbarch, &bppc, &bplen);
+      sp = gdbarch_frame_align (gdbarch, sp - bplen);
+      (*bp_addr) = sp;
+      /* Should the breakpoint size/location be re-computed here?  */
+    }      
+  else
+    {
+      (*bp_addr) = sp;
+      gdbarch_breakpoint_from_pc (gdbarch, bp_addr, &bplen);
+      sp = gdbarch_frame_align (gdbarch, sp + bplen);
+    }
+  /* Inferior resumes at the function entry point.  */
+  (*real_pc) = funaddr;
+  return sp;
+}
+
+/* Provide backward compatibility.  Once DEPRECATED_FIX_CALL_DUMMY is
+   eliminated, this can be simplified.  */
+
+static CORE_ADDR
+push_dummy_code (struct gdbarch *gdbarch,
+		 CORE_ADDR sp, CORE_ADDR funaddr, int using_gcc,
+		 struct value **args, int nargs,
+		 struct type *value_type,
+		 CORE_ADDR *real_pc, CORE_ADDR *bp_addr)
+{
+  if (gdbarch_push_dummy_code_p (gdbarch))
+    return gdbarch_push_dummy_code (gdbarch, sp, funaddr, using_gcc,
+				    args, nargs, value_type, real_pc, bp_addr);
+  else if (DEPRECATED_FIX_CALL_DUMMY_P ())
+    return legacy_push_dummy_code (gdbarch, sp, funaddr, using_gcc,
+				   args, nargs, value_type, real_pc, bp_addr);
+  else    
+    return generic_push_dummy_code (gdbarch, sp, funaddr, using_gcc,
+				    args, nargs, value_type, real_pc, bp_addr);
+}
+
+/* All this stuff with a dummy frame may seem unnecessarily complicated
+   (why not just save registers in GDB?).  The purpose of pushing a dummy
+   frame which looks just like a real frame is so that if you call a
+   function and then hit a breakpoint (get a signal, etc), "backtrace"
+   will look right.  Whether the backtrace needs to actually show the
+   stack at the time the inferior function was called is debatable, but
+   it certainly needs to not display garbage.  So if you are contemplating
+   making dummy frames be different from normal frames, consider that.  */
+
+/* Perform a function call in the inferior.
+   ARGS is a vector of values of arguments (NARGS of them).
+   FUNCTION is a value, the function to be called.
+   Returns a value representing what the function returned.
+   May fail to return, if a breakpoint or signal is hit
+   during the execution of the function.
+
+   ARGS is modified to contain coerced values. */
+
+struct value *
+call_function_by_hand (struct value *function, int nargs, struct value **args)
+{
+  register CORE_ADDR sp;
+  CORE_ADDR dummy_addr;
+  struct type *value_type;
+  unsigned char struct_return;
+  CORE_ADDR struct_addr = 0;
+  struct regcache *retbuf;
+  struct cleanup *retbuf_cleanup;
+  struct inferior_status *inf_status;
+  struct cleanup *inf_status_cleanup;
+  CORE_ADDR funaddr;
+  int using_gcc;		/* Set to version of gcc in use, or zero if not gcc */
+  CORE_ADDR real_pc;
+  struct type *ftype = check_typedef (SYMBOL_TYPE (function));
+  CORE_ADDR bp_addr;
+
+  if (!target_has_execution)
+    noprocess ();
+
+  /* Create a cleanup chain that contains the retbuf (buffer
+     containing the register values).  This chain is create BEFORE the
+     inf_status chain so that the inferior status can cleaned up
+     (restored or discarded) without having the retbuf freed.  */
+  retbuf = regcache_xmalloc (current_gdbarch);
+  retbuf_cleanup = make_cleanup_regcache_xfree (retbuf);
+
+  /* A cleanup for the inferior status.  Create this AFTER the retbuf
+     so that this can be discarded or applied without interfering with
+     the regbuf.  */
+  inf_status = save_inferior_status (1);
+  inf_status_cleanup = make_cleanup_restore_inferior_status (inf_status);
+
+  if (DEPRECATED_PUSH_DUMMY_FRAME_P ())
+    {
+      /* DEPRECATED_PUSH_DUMMY_FRAME is responsible for saving the
+	 inferior registers (and frame_pop() for restoring them).  (At
+	 least on most machines) they are saved on the stack in the
+	 inferior.  */
+      DEPRECATED_PUSH_DUMMY_FRAME;
+    }
+  else
+    {
+      /* FIXME: cagney/2003-02-26: Step zero of this little tinker is
+      to extract the generic dummy frame code from the architecture
+      vector.  Hence this direct call.
+
+      A follow-on change is to modify this interface so that it takes
+      thread OR frame OR tpid as a parameter, and returns a dummy
+      frame handle.  The handle can then be used further down as a
+      parameter SAVE_DUMMY_FRAME_TOS.  Hmm, thinking about it, since
+      everything is ment to be using generic dummy frames, why not
+      even use some of the dummy frame code to here - do a regcache
+      dup and then pass the duped regcache, along with all the other
+      stuff, at one single point.
+
+      In fact, you can even save the structure's return address in the
+      dummy frame and fix one of those nasty lost struct return edge
+      conditions.  */
+      generic_push_dummy_frame ();
+    }
+
+  /* Ensure that the initial SP is correctly aligned.  */
+  {
+    CORE_ADDR old_sp = read_sp ();
+    if (gdbarch_frame_align_p (current_gdbarch))
+      {
+	/* NOTE: cagney/2002-09-18:
+	   
+	   On a RISC architecture, a void parameterless generic dummy
+	   frame (i.e., no parameters, no result) typically does not
+	   need to push anything the stack and hence can leave SP and
+	   FP.  Similarly, a framelss (possibly leaf) function does
+	   not push anything on the stack and, hence, that too can
+	   leave FP and SP unchanged.  As a consequence, a sequence of
+	   void parameterless generic dummy frame calls to frameless
+	   functions will create a sequence of effectively identical
+	   frames (SP, FP and TOS and PC the same).  This, not
+	   suprisingly, results in what appears to be a stack in an
+	   infinite loop --- when GDB tries to find a generic dummy
+	   frame on the internal dummy frame stack, it will always
+	   find the first one.
+
+	   To avoid this problem, the code below always grows the
+	   stack.  That way, two dummy frames can never be identical.
+	   It does burn a few bytes of stack but that is a small price
+	   to pay :-).  */
+	sp = gdbarch_frame_align (current_gdbarch, old_sp);
+	if (sp == old_sp)
+	  {
+	    if (INNER_THAN (1, 2))
+	      /* Stack grows down.  */
+	      sp = gdbarch_frame_align (current_gdbarch, old_sp - 1);
+	    else
+	      /* Stack grows up.  */
+	      sp = gdbarch_frame_align (current_gdbarch, old_sp + 1);
+	  }
+	gdb_assert ((INNER_THAN (1, 2) && sp <= old_sp)
+		    || (INNER_THAN (2, 1) && sp >= old_sp));
+      }
+    else
+      /* FIXME: cagney/2002-09-18: Hey, you loose!  Who knows how
+	 badly aligned the SP is!  Further, per comment above, if the
+	 generic dummy frame ends up empty (because nothing is pushed)
+	 GDB won't be able to correctly perform back traces.  If a
+	 target is having trouble with backtraces, first thing to do
+	 is add FRAME_ALIGN() to its architecture vector.  After that,
+	 try adding SAVE_DUMMY_FRAME_TOS() and modifying
+	 DEPRECATED_FRAME_CHAIN so that when the next outer frame is a
+	 generic dummy, it returns the current frame's base.  */
+      sp = old_sp;
+  }
+
+  funaddr = find_function_addr (function, &value_type);
+  CHECK_TYPEDEF (value_type);
+
+  {
+    struct block *b = block_for_pc (funaddr);
+    /* If compiled without -g, assume GCC 2.  */
+    using_gcc = (b == NULL ? 2 : BLOCK_GCC_COMPILED (b));
+  }
+
+  /* Are we returning a value using a structure return or a normal
+     value return? */
+
+  struct_return = using_struct_return (function, funaddr, value_type,
+				       using_gcc);
+
+  /* Determine the location of the breakpoint (and possibly other
+     stuff) that the called function will return to.  The SPARC, for a
+     function returning a structure or union, needs to make space for
+     not just the breakpoint but also an extra word containing the
+     size (?) of the structure being passed.  */
+
+  /* The actual breakpoint (at BP_ADDR) is inserted separatly so there
+     is no need to write that out.  */
+
+  switch (CALL_DUMMY_LOCATION)
+    {
+    case ON_STACK:
+      /* "dummy_addr" is here just to keep old targets happy.  New
+	 targets return that same information via "sp" and "bp_addr".  */
+      if (INNER_THAN (1, 2))
+	{
+	  sp = push_dummy_code (current_gdbarch, sp, funaddr,
+				using_gcc, args, nargs, value_type,
+				&real_pc, &bp_addr);
+	  dummy_addr = sp;
+	}
+      else
+	{
+	  dummy_addr = sp;
+	  sp = push_dummy_code (current_gdbarch, sp, funaddr,
+				using_gcc, args, nargs, value_type,
+				&real_pc, &bp_addr);
+	}
+      break;
+    case AT_ENTRY_POINT:
+      real_pc = funaddr;
+      dummy_addr = CALL_DUMMY_ADDRESS ();
+      /* A call dummy always consists of just a single breakpoint, so
+         it's address is the same as the address of the dummy.  */
+      bp_addr = dummy_addr;
+      break;
+    default:
+      internal_error (__FILE__, __LINE__, "bad switch");
+    }
+
+  if (DEPRECATED_USE_GENERIC_DUMMY_FRAMES)
+    /* Save where the breakpoint is going to be inserted so that the
+       dummy-frame code is later able to re-identify it.  */
+    generic_save_call_dummy_addr (bp_addr, bp_addr + 1);
+
+  if (nargs < TYPE_NFIELDS (ftype))
+    error ("too few arguments in function call");
+
+  {
+    int i;
+    for (i = nargs - 1; i >= 0; i--)
+      {
+	int prototyped;
+	struct type *param_type;
+	
+	/* FIXME drow/2002-05-31: Should just always mark methods as
+	   prototyped.  Can we respect TYPE_VARARGS?  Probably not.  */
+	if (TYPE_CODE (ftype) == TYPE_CODE_METHOD)
+	  prototyped = 1;
+	else if (i < TYPE_NFIELDS (ftype))
+	  prototyped = TYPE_PROTOTYPED (ftype);
+	else
+	  prototyped = 0;
+
+	if (i < TYPE_NFIELDS (ftype))
+	  param_type = TYPE_FIELD_TYPE (ftype, i);
+	else
+	  param_type = NULL;
+	
+	args[i] = value_arg_coerce (args[i], param_type, prototyped);
+
+	/* elz: this code is to handle the case in which the function
+	   to be called has a pointer to function as parameter and the
+	   corresponding actual argument is the address of a function
+	   and not a pointer to function variable.  In aCC compiled
+	   code, the calls through pointers to functions (in the body
+	   of the function called by hand) are made via
+	   $$dyncall_external which requires some registers setting,
+	   this is taken care of if we call via a function pointer
+	   variable, but not via a function address.  In cc this is
+	   not a problem. */
+
+	if (using_gcc == 0)
+	  {
+	    if (param_type != NULL && TYPE_CODE (ftype) != TYPE_CODE_METHOD)
+	      {
+		/* if this parameter is a pointer to function.  */
+		if (TYPE_CODE (param_type) == TYPE_CODE_PTR)
+		  if (TYPE_CODE (TYPE_TARGET_TYPE (param_type)) == TYPE_CODE_FUNC)
+		    /* elz: FIXME here should go the test about the
+		       compiler used to compile the target. We want to
+		       issue the error message only if the compiler
+		       used was HP's aCC.  If we used HP's cc, then
+		       there is no problem and no need to return at
+		       this point.  */
+		    /* Go see if the actual parameter is a variable of
+		       type pointer to function or just a function.  */
+		    if (args[i]->lval == not_lval)
+		      {
+			char *arg_name;
+			if (find_pc_partial_function ((CORE_ADDR) args[i]->aligner.contents[0], &arg_name, NULL, NULL))
+			  error ("\
+You cannot use function <%s> as argument. \n\
+You must use a pointer to function type variable. Command ignored.", arg_name);
+		      }
+	      }
+	  }
+      }
+  }
+
+  if (REG_STRUCT_HAS_ADDR_P ())
+    {
+      int i;
+      /* This is a machine like the sparc, where we may need to pass a
+	 pointer to the structure, not the structure itself.  */
+      for (i = nargs - 1; i >= 0; i--)
+	{
+	  struct type *arg_type = check_typedef (VALUE_TYPE (args[i]));
+	  if ((TYPE_CODE (arg_type) == TYPE_CODE_STRUCT
+	       || TYPE_CODE (arg_type) == TYPE_CODE_UNION
+	       || TYPE_CODE (arg_type) == TYPE_CODE_ARRAY
+	       || TYPE_CODE (arg_type) == TYPE_CODE_STRING
+	       || TYPE_CODE (arg_type) == TYPE_CODE_BITSTRING
+	       || TYPE_CODE (arg_type) == TYPE_CODE_SET
+	       || (TYPE_CODE (arg_type) == TYPE_CODE_FLT
+		   && TYPE_LENGTH (arg_type) > 8)
+	       )
+	      && REG_STRUCT_HAS_ADDR (using_gcc, arg_type))
+	    {
+	      CORE_ADDR addr;
+	      int len;		/*  = TYPE_LENGTH (arg_type); */
+	      int aligned_len;
+	      arg_type = check_typedef (VALUE_ENCLOSING_TYPE (args[i]));
+	      len = TYPE_LENGTH (arg_type);
+
+	      if (STACK_ALIGN_P ())
+		/* MVS 11/22/96: I think at least some of this
+		   stack_align code is really broken.  Better to let
+		   PUSH_ARGUMENTS adjust the stack in a target-defined
+		   manner.  */
+		aligned_len = STACK_ALIGN (len);
+	      else
+		aligned_len = len;
+	      if (INNER_THAN (1, 2))
+		{
+		  /* stack grows downward */
+		  sp -= aligned_len;
+		  /* ... so the address of the thing we push is the
+		     stack pointer after we push it.  */
+		  addr = sp;
+		}
+	      else
+		{
+		  /* The stack grows up, so the address of the thing
+		     we push is the stack pointer before we push it.  */
+		  addr = sp;
+		  sp += aligned_len;
+		}
+	      /* Push the structure.  */
+	      write_memory (addr, VALUE_CONTENTS_ALL (args[i]), len);
+	      /* The value we're going to pass is the address of the
+		 thing we just pushed.  */
+	      /*args[i] = value_from_longest (lookup_pointer_type (value_type),
+		(LONGEST) addr); */
+	      args[i] = value_from_pointer (lookup_pointer_type (arg_type),
+					    addr);
+	    }
+	}
+    }
+
+
+  /* Reserve space for the return structure to be written on the
+     stack, if necessary.  Make certain that the value is correctly
+     aligned. */
+
+  if (struct_return)
+    {
+      int len = TYPE_LENGTH (value_type);
+      if (STACK_ALIGN_P ())
+	/* NOTE: cagney/2003-03-22: Should rely on frame align, rather
+           than stack align to force the alignment of the stack.  */
+	len = STACK_ALIGN (len);
+      if (INNER_THAN (1, 2))
+	{
+	  /* Stack grows downward.  Align STRUCT_ADDR and SP after
+             making space for the return value.  */
+	  sp -= len;
+	  if (gdbarch_frame_align_p (current_gdbarch))
+	    sp = gdbarch_frame_align (current_gdbarch, sp);
+	  struct_addr = sp;
+	}
+      else
+	{
+	  /* Stack grows upward.  Align the frame, allocate space, and
+             then again, re-align the frame??? */
+	  if (gdbarch_frame_align_p (current_gdbarch))
+	    sp = gdbarch_frame_align (current_gdbarch, sp);
+	  struct_addr = sp;
+	  sp += len;
+	  if (gdbarch_frame_align_p (current_gdbarch))
+	    sp = gdbarch_frame_align (current_gdbarch, sp);
+	}
+    }
+
+  /* elz: on HPPA no need for this extra alignment, maybe it is needed
+     on other architectures. This is because all the alignment is
+     taken care of in the above code (ifdef REG_STRUCT_HAS_ADDR) and
+     in hppa_push_arguments */
+  /* NOTE: cagney/2003-03-24: The below code is very broken.  Given an
+     odd sized parameter the below will mis-align the stack.  As was
+     suggested back in '96, better to let PUSH_ARGUMENTS handle it.  */
+  if (DEPRECATED_EXTRA_STACK_ALIGNMENT_NEEDED)
+    {
+      /* MVS 11/22/96: I think at least some of this stack_align code
+	 is really broken.  Better to let push_dummy_call() adjust the
+	 stack in a target-defined manner.  */
+      if (STACK_ALIGN_P () && INNER_THAN (1, 2))
+	{
+	  /* If stack grows down, we must leave a hole at the top. */
+	  int len = 0;
+	  int i;
+	  for (i = nargs - 1; i >= 0; i--)
+	    len += TYPE_LENGTH (VALUE_ENCLOSING_TYPE (args[i]));
+	  if (DEPRECATED_CALL_DUMMY_STACK_ADJUST_P ())
+	    len += DEPRECATED_CALL_DUMMY_STACK_ADJUST;
+	  sp -= STACK_ALIGN (len) - len;
+	}
+    }
+
+  /* Create the dummy stack frame.  Pass in the call dummy address as,
+     presumably, the ABI code knows where, in the call dummy, the
+     return address should be pointed.  */
+  if (gdbarch_push_dummy_call_p (current_gdbarch))
+    /* When there is no push_dummy_call method, should this code
+       simply error out.  That would the implementation of this method
+       for all ABIs (which is probably a good thing).  */
+    sp = gdbarch_push_dummy_call (current_gdbarch, current_regcache,
+				  bp_addr, nargs, args, sp, struct_return,
+				  struct_addr);
+  else  if (DEPRECATED_PUSH_ARGUMENTS_P ())
+    /* Keep old targets working.  */
+    sp = DEPRECATED_PUSH_ARGUMENTS (nargs, args, sp, struct_return,
+				    struct_addr);
+  else
+    sp = legacy_push_arguments (nargs, args, sp, struct_return, struct_addr);
+
+  if (DEPRECATED_PUSH_RETURN_ADDRESS_P ())
+    /* for targets that use no CALL_DUMMY */
+    /* There are a number of targets now which actually don't write
+       any CALL_DUMMY instructions into the target, but instead just
+       save the machine state, push the arguments, and jump directly
+       to the callee function.  Since this doesn't actually involve
+       executing a JSR/BSR instruction, the return address must be set
+       up by hand, either by pushing onto the stack or copying into a
+       return-address register as appropriate.  Formerly this has been
+       done in PUSH_ARGUMENTS, but that's overloading its
+       functionality a bit, so I'm making it explicit to do it here.  */
+    /* NOTE: cagney/2003-04-22: The first parameter ("real_pc") has
+       been replaced with zero, it turns out that no implementation
+       used that parameter.  This occured because the value being
+       supplied - the address of the called function's entry point
+       instead of the address of the breakpoint that the called
+       function should return to - wasn't useful.  */
+    sp = DEPRECATED_PUSH_RETURN_ADDRESS (0, sp);
+
+  /* NOTE: cagney/2003-03-23: Diable this code when there is a
+     push_dummy_call() method.  Since that method will have already
+     handled any alignment issues, the code below is entirely
+     redundant.  */
+  if (!gdbarch_push_dummy_call_p (current_gdbarch)
+      && STACK_ALIGN_P () && !INNER_THAN (1, 2))
+    {
+      /* If stack grows up, we must leave a hole at the bottom, note
+         that sp already has been advanced for the arguments!  */
+      if (DEPRECATED_CALL_DUMMY_STACK_ADJUST_P ())
+	sp += DEPRECATED_CALL_DUMMY_STACK_ADJUST;
+      sp = STACK_ALIGN (sp);
+    }
+
+/* XXX This seems wrong.  For stacks that grow down we shouldn't do
+   anything here!  */
+  /* MVS 11/22/96: I think at least some of this stack_align code is
+     really broken.  Better to let PUSH_ARGUMENTS adjust the stack in
+     a target-defined manner.  */
+  if (DEPRECATED_CALL_DUMMY_STACK_ADJUST_P ())
+    if (INNER_THAN (1, 2))
+      {
+	/* stack grows downward */
+	sp -= DEPRECATED_CALL_DUMMY_STACK_ADJUST;
+      }
+
+  /* Store the address at which the structure is supposed to be
+     written.  */
+  /* NOTE: 2003-03-24: Since PUSH_ARGUMENTS can (and typically does)
+     store the struct return address, this call is entirely redundant.  */
+  if (struct_return && DEPRECATED_STORE_STRUCT_RETURN_P ())
+    DEPRECATED_STORE_STRUCT_RETURN (struct_addr, sp);
+
+  /* Write the stack pointer.  This is here because the statements above
+     might fool with it.  On SPARC, this write also stores the register
+     window into the right place in the new stack frame, which otherwise
+     wouldn't happen.  (See store_inferior_registers in sparc-nat.c.)  */
+  /* NOTE: cagney/2003-03-23: Disable this code when there is a
+     push_dummy_call() method.  Since that method will have already
+     stored the stack pointer (as part of creating the fake call
+     frame), and none of the code following that code adjusts the
+     stack-pointer value, the below call is entirely redundant.  */
+  if (DEPRECATED_DUMMY_WRITE_SP_P ())
+    DEPRECATED_DUMMY_WRITE_SP (sp);
+
+  if (SAVE_DUMMY_FRAME_TOS_P ())
+    SAVE_DUMMY_FRAME_TOS (sp);
+
+  /* Now proceed, having reached the desired place.  */
+  clear_proceed_status ();
+    
+  /* Create a momentary breakpoint at the return address of the
+     inferior.  That way it breaks when it returns.  */
+
+  {
+    struct breakpoint *bpt;
+    struct symtab_and_line sal;
+    struct frame_id frame;
+    init_sal (&sal);		/* initialize to zeroes */
+    sal.pc = bp_addr;
+    sal.section = find_pc_overlay (sal.pc);
+    /* Set up a frame ID for the dummy frame so we can pass it to
+       set_momentary_breakpoint.  We need to give the breakpoint a
+       frame ID so that the breakpoint code can correctly re-identify
+       the dummy breakpoint.  */
+    /* The assumption here is that push_dummy_call() returned the
+       stack part of the frame ID.  Unfortunatly, many older
+       architectures were, via a convoluted mess, relying on the
+       poorly defined and greatly overloaded DEPRECATED_TARGET_READ_FP
+       or DEPRECATED_FP_REGNUM to supply the value.  */
+    if (DEPRECATED_TARGET_READ_FP_P ())
+      frame = frame_id_build (DEPRECATED_TARGET_READ_FP (), sal.pc);
+    else if (DEPRECATED_FP_REGNUM >= 0)
+      frame = frame_id_build (read_register (DEPRECATED_FP_REGNUM), sal.pc);
+    else
+      frame = frame_id_build (sp, sal.pc);
+    bpt = set_momentary_breakpoint (sal, frame, bp_call_dummy);
+    bpt->disposition = disp_del;
+  }
+
+  /* Execute a "stack dummy", a piece of code stored in the stack by
+     the debugger to be executed in the inferior.
+
+     The dummy's frame is automatically popped whenever that break is
+     hit.  If that is the first time the program stops,
+     call_function_by_hand returns to its caller with that frame
+     already gone and sets RC to 0.
+   
+     Otherwise, set RC to a non-zero value.  If the called function
+     receives a random signal, we do not allow the user to continue
+     executing it as this may not work.  The dummy frame is poped and
+     we return 1.  If we hit a breakpoint, we leave the frame in place
+     and return 2 (the frame will eventually be popped when we do hit
+     the dummy end breakpoint).  */
+
+  {
+    struct cleanup *old_cleanups = make_cleanup (null_cleanup, 0);
+    int saved_async = 0;
+
+    /* If all error()s out of proceed ended up calling normal_stop
+       (and perhaps they should; it already does in the special case
+       of error out of resume()), then we wouldn't need this.  */
+    make_cleanup (breakpoint_auto_delete_contents, &stop_bpstat);
+
+    disable_watchpoints_before_interactive_call_start ();
+    proceed_to_finish = 1;	/* We want stop_registers, please... */
+
+    if (target_can_async_p ())
+      saved_async = target_async_mask (0);
+    
+    proceed (real_pc, TARGET_SIGNAL_0, 0);
+    
+    if (saved_async)
+      target_async_mask (saved_async);
+    
+    enable_watchpoints_after_interactive_call_stop ();
+      
+    discard_cleanups (old_cleanups);
+  }
+
+  if (stopped_by_random_signal || !stop_stack_dummy)
+    {
+      /* Find the name of the function we're about to complain about.  */
+      char *name = NULL;
+      {
+	struct symbol *symbol = find_pc_function (funaddr);
+	if (symbol)
+	  name = SYMBOL_PRINT_NAME (symbol);
+	else
+	  {
+	    /* Try the minimal symbols.  */
+	    struct minimal_symbol *msymbol = lookup_minimal_symbol_by_pc (funaddr);
+	    if (msymbol)
+	      name = SYMBOL_PRINT_NAME (msymbol);
+	  }
+      }
+      if (name == NULL)
+	{
+	  /* NOTE: cagney/2003-04-23: Don't blame me.  This code dates
+             back to 1993-07-08, I simply moved it.  */
+	  char format[80];
+	  sprintf (format, "at %s", local_hex_format ());
+	  name = alloca (80);
+	  /* FIXME-32x64: assumes funaddr fits in a long.  */
+	  sprintf (name, format, (unsigned long) funaddr);
+	}
+      if (stopped_by_random_signal)
+	{
+	  /* We stopped inside the FUNCTION because of a random
+	     signal.  Further execution of the FUNCTION is not
+	     allowed. */
+
+	  if (unwind_on_signal_p)
+	    {
+	      /* The user wants the context restored. */
+
+	      /* We must get back to the frame we were before the
+		 dummy call. */
+	      frame_pop (get_current_frame ());
+
+	      /* FIXME: Insert a bunch of wrap_here; name can be very
+		 long if it's a C++ name with arguments and stuff.  */
+	      error ("\
+The program being debugged was signaled while in a function called from GDB.\n\
+GDB has restored the context to what it was before the call.\n\
+To change this behavior use \"set unwindonsignal off\"\n\
+Evaluation of the expression containing the function (%s) will be abandoned.",
+		     name);
+	    }
+	  else
+	    {
+	      /* The user wants to stay in the frame where we stopped
+                 (default).*/
+	      /* If we restored the inferior status (via the cleanup),
+		 we would print a spurious error message (Unable to
+		 restore previously selected frame), would write the
+		 registers from the inf_status (which is wrong), and
+		 would do other wrong things.  */
+	      discard_cleanups (inf_status_cleanup);
+	      discard_inferior_status (inf_status);
+	      /* FIXME: Insert a bunch of wrap_here; name can be very
+		 long if it's a C++ name with arguments and stuff.  */
+	      error ("\
+The program being debugged was signaled while in a function called from GDB.\n\
+GDB remains in the frame where the signal was received.\n\
+To change this behavior use \"set unwindonsignal on\"\n\
+Evaluation of the expression containing the function (%s) will be abandoned.",
+		     name);
+	    }
+	}
+
+      if (!stop_stack_dummy)
+	{
+	  /* We hit a breakpoint inside the FUNCTION. */
+	  /* If we restored the inferior status (via the cleanup), we
+	     would print a spurious error message (Unable to restore
+	     previously selected frame), would write the registers
+	     from the inf_status (which is wrong), and would do other
+	     wrong things.  */
+	  discard_cleanups (inf_status_cleanup);
+	  discard_inferior_status (inf_status);
+	  /* The following error message used to say "The expression
+	     which contained the function call has been discarded."
+	     It is a hard concept to explain in a few words.  Ideally,
+	     GDB would be able to resume evaluation of the expression
+	     when the function finally is done executing.  Perhaps
+	     someday this will be implemented (it would not be easy).  */
+	  /* FIXME: Insert a bunch of wrap_here; name can be very long if it's
+	     a C++ name with arguments and stuff.  */
+	  error ("\
+The program being debugged stopped while in a function called from GDB.\n\
+When the function (%s) is done executing, GDB will silently\n\
+stop (instead of continuing to evaluate the expression containing\n\
+the function call).", name);
+	}
+
+      /* The above code errors out, so ...  */
+      internal_error (__FILE__, __LINE__, "... should not be here");
+    }
+
+  /* If we get here the called FUNCTION run to completion. */
+
+  /* On normal return, the stack dummy has been popped already.  */
+  regcache_cpy_no_passthrough (retbuf, stop_registers);
+
+  /* Restore the inferior status, via its cleanup.  At this stage,
+     leave the RETBUF alone.  */
+  do_cleanups (inf_status_cleanup);
+
+  /* Figure out the value returned by the function.  */
+  /* elz: I defined this new macro for the hppa architecture only.
+     this gives us a way to get the value returned by the function
+     from the stack, at the same address we told the function to put
+     it.  We cannot assume on the pa that r28 still contains the
+     address of the returned structure. Usually this will be
+     overwritten by the callee.  I don't know about other
+     architectures, so I defined this macro */
+#ifdef VALUE_RETURNED_FROM_STACK
+  if (struct_return)
+    {
+      do_cleanups (retbuf_cleanup);
+      return VALUE_RETURNED_FROM_STACK (value_type, struct_addr);
+    }
+#endif
+  /* NOTE: cagney/2002-09-10: Only when the stack has been correctly
+     aligned (using frame_align()) do we can trust STRUCT_ADDR and
+     fetch the return value direct from the stack.  This lack of trust
+     comes about because legacy targets have a nasty habit of
+     silently, and local to PUSH_ARGUMENTS(), moving STRUCT_ADDR.  For
+     such targets, just hope that value_being_returned() can find the
+     adjusted value.  */
+  if (struct_return && gdbarch_frame_align_p (current_gdbarch))
+    {
+      struct value *retval = value_at (value_type, struct_addr, NULL);
+      do_cleanups (retbuf_cleanup);
+      return retval;
+    }
+  else
+    {
+      struct value *retval = value_being_returned (value_type, retbuf,
+						   struct_return);
+      do_cleanups (retbuf_cleanup);
+      return retval;
+    }
+}
+
+void _initialize_infcall (void);
+
+void
+_initialize_infcall (void)
+{
+  add_setshow_boolean_cmd ("coerce-float-to-double", class_obscure,
+			   &coerce_float_to_double_p, "\
+Set coercion of floats to doubles when calling functions\n\
+Variables of type float should generally be converted to doubles before\n\
+calling an unprototyped function, and left alone when calling a prototyped\n\
+function.  However, some older debug info formats do not provide enough\n\
+information to determine that a function is prototyped.  If this flag is\n\
+set, GDB will perform the conversion for a function it considers\n\
+unprototyped.\n\
+The default is to perform the conversion.\n", "\
+Show coercion of floats to doubles when calling functions\n\
+Variables of type float should generally be converted to doubles before\n\
+calling an unprototyped function, and left alone when calling a prototyped\n\
+function.  However, some older debug info formats do not provide enough\n\
+information to determine that a function is prototyped.  If this flag is\n\
+set, GDB will perform the conversion for a function it considers\n\
+unprototyped.\n\
+The default is to perform the conversion.\n",
+			   NULL, NULL, &setlist, &showlist);
+
+  add_setshow_boolean_cmd ("unwindonsignal", no_class,
+			   &unwind_on_signal_p, "\
+Set unwinding of stack if a signal is received while in a call dummy.\n\
+The unwindonsignal lets the user determine what gdb should do if a signal\n\
+is received while in a function called from gdb (call dummy).  If set, gdb\n\
+unwinds the stack and restore the context to what as it was before the call.\n\
+The default is to stop in the frame where the signal was received.", "\
+Set unwinding of stack if a signal is received while in a call dummy.\n\
+The unwindonsignal lets the user determine what gdb should do if a signal\n\
+is received while in a function called from gdb (call dummy).  If set, gdb\n\
+unwinds the stack and restore the context to what as it was before the call.\n\
+The default is to stop in the frame where the signal was received.",
+			   NULL, NULL, &setlist, &showlist);
+}
diff --git a/gdb/infcall.h b/gdb/infcall.h
new file mode 100644
index 00000000000..05d06e034bf
--- /dev/null
+++ b/gdb/infcall.h
@@ -0,0 +1,43 @@
+/* Perform an inferior function call, for GDB, the GNU debugger.
+
+   Copyright 2003 Free Software Foundation, Inc.
+
+   This file is part of GDB.
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 59 Temple Place - Suite 330,
+   Boston, MA 02111-1307, USA.  */
+
+#ifndef INFCALL_H
+#define INFCALL_H
+
+struct value;
+struct type;
+
+extern CORE_ADDR find_function_addr (struct value *function, 
+				     struct type **retval_type);
+
+/* Perform a function call in the inferior.
+
+   ARGS is a vector of values of arguments (NARGS of them).  FUNCTION
+   is a value, the function to be called.  Returns a value
+   representing what the function returned.  May fail to return, if a
+   breakpoint or signal is hit during the execution of the function.
+
+   ARGS is modified to contain coerced values. */
+
+extern struct value *call_function_by_hand (struct value *function, int nargs,
+					    struct value **args);
+
+#endif
diff --git a/gdb/infcmd.c b/gdb/infcmd.c
index 01ab3d7b0de..de6c319608d 100644
--- a/gdb/infcmd.c
+++ b/gdb/infcmd.c
@@ -115,8 +115,6 @@ void _initialize_infcmd (void);
 
 #define GO_USAGE   "Usage: go <location>\n"
 
-static void breakpoint_auto_delete_contents (void *);
-
 #define ERROR_NO_INFERIOR \
    if (!target_has_execution) error ("The program is not being run.");
 
@@ -950,112 +948,6 @@ signal_command (char *signum_exp, int from_tty)
   proceed (oursig == TARGET_SIGNAL_0 ? (CORE_ADDR) -1 : stop_pc, oursig, 0);
 }
 
-/* Call breakpoint_auto_delete on the current contents of the bpstat
-   pointed to by arg (which is really a bpstat *).  */
-
-static void
-breakpoint_auto_delete_contents (void *arg)
-{
-  breakpoint_auto_delete (*(bpstat *) arg);
-}
-
-
-/* Execute a "stack dummy", a piece of code stored in the stack
-   by the debugger to be executed in the inferior.
-
-   To call: first, do PUSH_DUMMY_FRAME.
-   Then push the contents of the dummy.  It should end with a breakpoint insn.
-   Then call here, passing address at which to start the dummy.
-
-   The contents of all registers are saved before the dummy frame is popped
-   and copied into the buffer BUFFER.
-
-   The dummy's frame is automatically popped whenever that break is hit.
-   If that is the first time the program stops, run_stack_dummy
-   returns to its caller with that frame already gone and returns 0.
-   
-   Otherwise, run_stack-dummy returns a non-zero value.
-   If the called function receives a random signal, we do not allow the user
-   to continue executing it as this may not work.  The dummy frame is poped
-   and we return 1.
-   If we hit a breakpoint, we leave the frame in place and return 2 (the frame
-   will eventually be popped when we do hit the dummy end breakpoint).  */
-
-int
-run_stack_dummy (CORE_ADDR addr, struct regcache *buffer)
-{
-  struct cleanup *old_cleanups = make_cleanup (null_cleanup, 0);
-  int saved_async = 0;
-  struct breakpoint *bpt;
-  struct symtab_and_line sal;
-
-  /* Now proceed, having reached the desired place.  */
-  clear_proceed_status ();
-
-  init_sal (&sal);		/* initialize to zeroes */
-  if (CALL_DUMMY_LOCATION == AT_ENTRY_POINT)
-    {
-      sal.pc = CALL_DUMMY_ADDRESS ();
-    }
-  else
-    {
-      /* If defined, CALL_DUMMY_BREAKPOINT_OFFSET is where we need to
-	 put a breakpoint instruction.  If not, the call dummy already
-	 has the breakpoint instruction in it.
-
-	 ADDR IS THE ADDRESS of the call dummy plus the
-	 CALL_DUMMY_START_OFFSET, so we need to subtract the
-	 CALL_DUMMY_START_OFFSET.  */
-      sal.pc = addr - CALL_DUMMY_START_OFFSET + CALL_DUMMY_BREAKPOINT_OFFSET;
-    }
-  sal.section = find_pc_overlay (sal.pc);
-  
-  {
-    /* Set up a frame ID for the dummy frame so we can pass it to
-       set_momentary_breakpoint.  We need to give the breakpoint a
-       frame ID so that the breakpoint code can correctly re-identify
-       the dummy breakpoint.  */
-    struct frame_id frame = frame_id_build (read_fp (), sal.pc);
-    /* Create a momentary breakpoint at the return address of the
-       inferior.  That way it breaks when it returns.  */
-    bpt = set_momentary_breakpoint (sal, frame, bp_call_dummy);
-    bpt->disposition = disp_del;
-  }
-
-  /* If all error()s out of proceed ended up calling normal_stop (and
-     perhaps they should; it already does in the special case of error
-     out of resume()), then we wouldn't need this.  */
-  make_cleanup (breakpoint_auto_delete_contents, &stop_bpstat);
-
-  disable_watchpoints_before_interactive_call_start ();
-  proceed_to_finish = 1;	/* We want stop_registers, please... */
-
-  if (target_can_async_p ())
-    saved_async = target_async_mask (0);
-
-  proceed (addr, TARGET_SIGNAL_0, 0);
-
-  if (saved_async)
-    target_async_mask (saved_async);
-
-  enable_watchpoints_after_interactive_call_stop ();
-
-  discard_cleanups (old_cleanups);
-
-  /* We can stop during an inferior call because a signal is received. */
-  if (stopped_by_random_signal)
-    return 1;
-    
-  /* We may also stop prematurely because we hit a breakpoint in the
-     called routine. */
-  if (!stop_stack_dummy)
-    return 2;
-
-  /* On normal return, the stack dummy has been popped already.  */
-  regcache_cpy_no_passthrough (buffer, stop_registers);
-  return 0;
-}
-
 /* Proceed until we reach a different source line with pc greater than
    our current one or exit the function.  We skip calls in both cases.
 
@@ -1608,8 +1500,8 @@ default_print_registers_info (struct gdbarch *gdbarch,
 {
   int i;
   const int numregs = NUM_REGS + NUM_PSEUDO_REGS;
-  char *raw_buffer = alloca (MAX_REGISTER_RAW_SIZE);
-  char *virtual_buffer = alloca (MAX_REGISTER_VIRTUAL_SIZE);
+  char raw_buffer[MAX_REGISTER_SIZE];
+  char virtual_buffer[MAX_REGISTER_SIZE];
 
   if (DEPRECATED_DO_REGISTERS_INFO_P ())
     {
diff --git a/gdb/inferior.h b/gdb/inferior.h
index 62034492915..1de3b25e39b 100644
--- a/gdb/inferior.h
+++ b/gdb/inferior.h
@@ -164,8 +164,6 @@ extern void terminal_save_ours (void);
 
 extern void terminal_ours (void);
 
-extern int run_stack_dummy (CORE_ADDR , struct regcache *);
-
 extern CORE_ADDR read_pc (void);
 
 extern CORE_ADDR read_pc_pid (ptid_t);
@@ -184,9 +182,7 @@ extern CORE_ADDR generic_target_read_sp (void);
 
 extern void generic_target_write_sp (CORE_ADDR);
 
-extern CORE_ADDR read_fp (void);
-
-extern CORE_ADDR generic_target_read_fp (void);
+extern CORE_ADDR deprecated_read_fp (void);
 
 extern CORE_ADDR unsigned_pointer_to_address (struct type *type, const void *buf);
 
@@ -489,13 +485,14 @@ extern int deprecated_pc_in_call_dummy_at_entry_point (CORE_ADDR pc,
 
    Note that this macro is intended for targets (like HP-UX) which
    require more than a single breakpoint in their call dummies, and
-   therefore cannot use the CALL_DUMMY_BREAKPOINT_OFFSET mechanism.
-
-   If a target does define CALL_DUMMY_BREAKPOINT_OFFSET, then this
-   default implementation of CALL_DUMMY_HAS_COMPLETED is sufficient.
-   Else, a target may wish to supply an implementation that works in
-   the presense of multiple breakpoints in its call dummy.
- */
+   therefore cannot use the DEPRECATED_CALL_DUMMY_BREAKPOINT_OFFSET
+   mechanism.
+
+   If a target does define DEPRECATED_CALL_DUMMY_BREAKPOINT_OFFSET,
+   then this default implementation of CALL_DUMMY_HAS_COMPLETED is
+   sufficient.  Else, a target may wish to supply an implementation
+   that works in the presense of multiple breakpoints in its call
+   dummy.  */
 #if !defined(CALL_DUMMY_HAS_COMPLETED)
 #define CALL_DUMMY_HAS_COMPLETED(pc, sp, frame_address) \
   DEPRECATED_PC_IN_CALL_DUMMY((pc), (sp), (frame_address))
diff --git a/gdb/infptrace.c b/gdb/infptrace.c
index a142080cf8c..1225dd8a62c 100644
--- a/gdb/infptrace.c
+++ b/gdb/infptrace.c
@@ -359,7 +359,7 @@ fetch_register (int regno)
   char mess[128];		/* For messages */
   register int i;
   unsigned int offset;		/* Offset of registers within the u area.  */
-  char *buf = alloca (MAX_REGISTER_RAW_SIZE);
+  char buf[MAX_REGISTER_SIZE];
   int tid;
 
   if (CANNOT_FETCH_REGISTER (regno))
@@ -424,7 +424,7 @@ store_register (int regno)
   register int i;
   unsigned int offset;		/* Offset of registers within the u area.  */
   int tid;
-  char *buf = alloca (MAX_REGISTER_RAW_SIZE);
+  char buf[MAX_REGISTER_SIZE];
 
   if (CANNOT_STORE_REGISTER (regno))
     {
diff --git a/gdb/infrun.c b/gdb/infrun.c
index 9503b106faf..df179682109 100644
--- a/gdb/infrun.c
+++ b/gdb/infrun.c
@@ -667,6 +667,12 @@ clear_proceed_status (void)
   bpstat_clear (&stop_bpstat);
 }
 
+
+/* Record the pc of the program the last time it stopped.  This is
+   just used internally by wait_for_inferior, but need to be preserved
+   over calls to it and cleared when the inferior is started.  */
+static CORE_ADDR prev_pc;
+
 /* Basic routine for continuing the program in various fashions.
 
    ADDR is the address to resume at, or -1 for resume where stopped.
@@ -772,6 +778,30 @@ proceed (CORE_ADDR addr, enum target_signal siggnal, int step)
      inferior.  */
   gdb_flush (gdb_stdout);
 
+  /* Refresh prev_pc value just prior to resuming.  This used to be
+     done in stop_stepping, however, setting prev_pc there did not handle
+     scenarios such as inferior function calls or returning from
+     a function via the return command.  In those cases, the prev_pc
+     value was not set properly for subsequent commands.  The prev_pc value 
+     is used to initialize the starting line number in the ecs.  With an 
+     invalid value, the gdb next command ends up stopping at the position
+     represented by the next line table entry past our start position.
+     On platforms that generate one line table entry per line, this
+     is not a problem.  However, on the ia64, the compiler generates
+     extraneous line table entries that do not increase the line number.
+     When we issue the gdb next command on the ia64 after an inferior call
+     or a return command, we often end up a few instructions forward, still 
+     within the original line we started.
+
+     An attempt was made to have init_execution_control_state () refresh
+     the prev_pc value before calculating the line number.  This approach
+     did not work because on platforms that use ptrace, the pc register
+     cannot be read unless the inferior is stopped.  At that point, we
+     are not guaranteed the inferior is stopped and so the read_pc ()
+     call can fail.  Setting the prev_pc value here ensures the value is 
+     updated correctly when the inferior is stopped.  */  
+  prev_pc = read_pc ();
+
   /* Resume inferior.  */
   resume (oneproc || step || bpstat_should_step (), stop_signal);
 
@@ -785,13 +815,6 @@ proceed (CORE_ADDR addr, enum target_signal siggnal, int step)
       normal_stop ();
     }
 }
-
-/* Record the pc and sp of the program the last time it stopped.
-   These are just used internally by wait_for_inferior, but need
-   to be preserved over calls to it and cleared when the inferior
-   is started.  */
-static CORE_ADDR prev_pc;
-static char *prev_func_name;
 
 
 /* Start remote-debugging of a machine over a serial link.  */
@@ -829,7 +852,6 @@ init_wait_for_inferior (void)
 {
   /* These are meaningless until the first time through wait_for_inferior.  */
   prev_pc = 0;
-  prev_func_name = NULL;
 
 #ifdef HP_OS_BUG
   trap_expected_after_continue = 0;
@@ -1116,7 +1138,7 @@ context_switch (struct execution_control_state *ecs)
   if (in_thread_list (inferior_ptid) && in_thread_list (ecs->ptid))
     {				/* Perform infrun state context switch: */
       /* Save infrun state for the old thread.  */
-      save_infrun_state (inferior_ptid, prev_pc, prev_func_name,
+      save_infrun_state (inferior_ptid, prev_pc,
 			 trap_expected, step_resume_breakpoint,
 			 through_sigtramp_breakpoint, step_range_start,
 			 step_range_end, &step_frame_id,
@@ -1127,7 +1149,7 @@ context_switch (struct execution_control_state *ecs)
 			 ecs->current_line, ecs->current_symtab, step_sp);
 
       /* Load infrun state for the new thread.  */
-      load_infrun_state (ecs->ptid, &prev_pc, &prev_func_name,
+      load_infrun_state (ecs->ptid, &prev_pc,
 			 &trap_expected, &step_resume_breakpoint,
 			 &through_sigtramp_breakpoint, &step_range_start,
 			 &step_range_end, &step_frame_id,
@@ -1140,6 +1162,39 @@ context_switch (struct execution_control_state *ecs)
   inferior_ptid = ecs->ptid;
 }
 
+/* Wrapper for PC_IN_SIGTRAMP that takes care of the need to find the
+   function's name.
+
+   In a classic example of "left hand VS right hand", "infrun.c" was
+   trying to improve GDB's performance by caching the result of calls
+   to calls to find_pc_partial_funtion, while at the same time
+   find_pc_partial_function was also trying to ramp up performance by
+   caching its most recent return value.  The below makes the the
+   function find_pc_partial_function solely responsibile for
+   performance issues (the local cache that relied on a global
+   variable - arrrggg - deleted).
+
+   Using the testsuite and gcov, it was found that dropping the local
+   "infrun.c" cache and instead relying on find_pc_partial_function
+   increased the number of calls to 12000 (from 10000), but the number
+   of times find_pc_partial_function's cache missed (this is what
+   matters) was only increased by only 4 (to 3569).  (A quick back of
+   envelope caculation suggests that the extra 2000 function calls
+   @1000 extra instructions per call make the 1 MIP VAX testsuite run
+   take two extra seconds, oops :-)
+
+   Long term, this function can be eliminated, replaced by the code:
+   get_frame_type(current_frame()) == SIGTRAMP_FRAME (for new
+   architectures this is very cheap).  */
+
+static int
+pc_in_sigtramp (CORE_ADDR pc)
+{
+  char *name;
+  find_pc_partial_function (pc, &name, NULL, NULL);
+  return PC_IN_SIGTRAMP (pc, name);
+}
+
 
 /* Given an execution control state that has been freshly filled in
    by an event from the inferior, figure out what it means and take
@@ -2262,8 +2317,8 @@ process_event_stop_test:
   ecs->update_step_sp = 1;
 
   /* Did we just take a signal?  */
-  if (PC_IN_SIGTRAMP (stop_pc, ecs->stop_func_name)
-      && !PC_IN_SIGTRAMP (prev_pc, prev_func_name)
+  if (pc_in_sigtramp (stop_pc)
+      && !pc_in_sigtramp (prev_pc)
       && INNER_THAN (read_sp (), step_sp))
     {
       /* We've just taken a signal; go until we are back to
@@ -2373,7 +2428,7 @@ process_event_stop_test:
 	{
 	  /* We're doing a "next".  */
 
-	  if (PC_IN_SIGTRAMP (stop_pc, ecs->stop_func_name)
+	  if (pc_in_sigtramp (stop_pc)
 	      && frame_id_inner (step_frame_id,
 				 frame_id_build (read_sp (), 0)))
 	    /* We stepped out of a signal handler, and into its
@@ -2562,8 +2617,8 @@ static void
 check_sigtramp2 (struct execution_control_state *ecs)
 {
   if (trap_expected
-      && PC_IN_SIGTRAMP (stop_pc, ecs->stop_func_name)
-      && !PC_IN_SIGTRAMP (prev_pc, prev_func_name)
+      && pc_in_sigtramp (stop_pc)
+      && !pc_in_sigtramp (prev_pc)
       && INNER_THAN (read_sp (), step_sp))
     {
       /* What has happened here is that we have just stepped the
@@ -2727,15 +2782,6 @@ step_over_function (struct execution_control_state *ecs)
 static void
 stop_stepping (struct execution_control_state *ecs)
 {
-  if (target_has_execution)
-    {
-      /* Assuming the inferior still exists, set these up for next
-         time, just like we did above if we didn't break out of the
-         loop.  */
-      prev_pc = read_pc ();
-      prev_func_name = ecs->stop_func_name;
-    }
-
   /* Let callers know we don't want to wait for the inferior anymore.  */
   ecs->wait_some_more = 0;
 }
@@ -2749,7 +2795,6 @@ keep_going (struct execution_control_state *ecs)
 {
   /* Save the pc before execution, to compare with pc after stop.  */
   prev_pc = read_pc ();		/* Might have been DECR_AFTER_BREAK */
-  prev_func_name = ecs->stop_func_name;
 
   if (ecs->update_step_sp)
     step_sp = read_sp ();
diff --git a/gdb/irix4-nat.c b/gdb/irix4-nat.c
index b44c5bbba49..63ca71e6bc6 100644
--- a/gdb/irix4-nat.c
+++ b/gdb/irix4-nat.c
@@ -51,8 +51,8 @@ supply_gregset (gregset_t *gregsetp)
 {
   register int regi;
   register greg_t *regp = (greg_t *) (gregsetp->gp_regs);
-  char *zerobuf = alloca (max_register_size (current_gdbarch));
-  memset (zerobuf, 0, max_register_size (current_gdbarch));
+  char zerobuf[MAX_REGISTER_SIZE];
+  memset (zerobuf, 0, MAX_REGISTER_SIZE);
 
   /* FIXME: somewhere, there should be a #define for the meaning
      of this magic number 32; we should use that. */
@@ -104,8 +104,8 @@ void
 supply_fpregset (fpregset_t *fpregsetp)
 {
   register int regi;
-  char *zerobuf = alloca (max_register_size (current_gdbarch));
-  memset (zerobuf, 0, max_register_size (current_gdbarch));
+  char zerobuf[MAX_REGISTER_SIZE];
+  memset (zerobuf, 0, MAX_REGISTER_SIZE);
 
   for (regi = 0; regi < 32; regi++)
     supply_register (FP0_REGNUM + regi,
diff --git a/gdb/linespec.c b/gdb/linespec.c
index 2738b1e1dec..ea52a803620 100644
--- a/gdb/linespec.c
+++ b/gdb/linespec.c
@@ -33,6 +33,7 @@
 #include "cp-abi.h"
 #include "parser-defs.h"
 #include "block.h"
+#include "objc-lang.h"
 
 /* We share this one with symtab.c, but it is not exported widely. */
 
@@ -49,6 +50,12 @@ static struct symtabs_and_lines decode_indirect (char **argptr);
 
 static char *locate_first_half (char **argptr, int *is_quote_enclosed);
 
+static struct symtabs_and_lines decode_objc (char **argptr,
+					     int funfirstline,
+					     struct symtab *file_symtab,
+					     char ***canonical,
+					     char *saved_arg);
+
 static struct symtabs_and_lines decode_compound (char **argptr,
 						 int funfirstline,
 						 char ***canonical,
@@ -589,6 +596,7 @@ decode_line_1 (char **argptr, int funfirstline, struct symtab *default_symtab,
   int is_quoted;
   /* Is part of *ARGPTR is enclosed in double quotes?  */
   int is_quote_enclosed;
+  int is_objc_method = 0;
   char *saved_arg = *argptr;
 
   /* Defaults have defaults.  */
@@ -614,6 +622,25 @@ decode_line_1 (char **argptr, int funfirstline, struct symtab *default_symtab,
 
   p = locate_first_half (argptr, &is_quote_enclosed);
 
+  /* Check if this is an Objective-C method (anything that starts with
+     a '+' or '-' and a '[').  */
+  if (*p && (p[0] == ':') && (strchr ("+-", p[1]) != NULL) 
+      && (p[2] == '['))
+    {
+      is_objc_method = 1;
+      paren_pointer  = NULL; /* Just a category name.  Ignore it.  */
+    }
+
+  /* Check if the symbol could be an Objective-C selector.  */
+
+  {
+    struct symtabs_and_lines values;
+    values = decode_objc (argptr, funfirstline, NULL,
+			  canonical, saved_arg);
+    if (values.sals != NULL)
+      return values;
+  }
+
   /* Does it look like there actually were two parts?  */
 
   if ((p[0] == ':' || p[0] == '.') && paren_pointer == NULL)
@@ -695,6 +722,11 @@ decode_line_1 (char **argptr, int funfirstline, struct symtab *default_symtab,
       if (p[-1] != '\'')
 	error ("Unmatched single quote.");
     }
+  else if (is_objc_method)
+    {
+      /* allow word separators in method names for Obj-C */
+      p = skip_quoted_chars (*argptr, NULL, "");
+    }
   else if (paren_pointer != NULL)
     {
       p = paren_pointer + 1;
@@ -893,6 +925,13 @@ locate_first_half (char **argptr, int *is_quote_enclosed)
 	    error ("malformed template specification in command");
 	  p = temp_end;
 	}
+      /* Check for a colon and a plus or minus and a [ (which
+         indicates an Objective-C method) */
+      if (*p && (p[0] == ':') && (strchr ("+-", p[1]) != NULL) 
+	  && (p[2] == '['))
+	{
+	  break;
+	}
       /* Check for the end of the first half of the linespec.  End of
          line, a tab, a double colon or the last single colon, or a
          space.  But if enclosed in double quotes we do not break on
@@ -936,6 +975,95 @@ locate_first_half (char **argptr, int *is_quote_enclosed)
 
 
 
+/* Here's where we recognise an Objective-C Selector.  An Objective C
+   selector may be implemented by more than one class, therefore it
+   may represent more than one method/function.  This gives us a
+   situation somewhat analogous to C++ overloading.  If there's more
+   than one method that could represent the selector, then use some of
+   the existing C++ code to let the user choose one.  */
+
+struct symtabs_and_lines
+decode_objc (char **argptr, int funfirstline, struct symtab *file_symtab,
+	     char ***canonical, char *saved_arg)
+{
+  struct symtabs_and_lines values;
+  struct symbol **sym_arr = NULL;
+  struct symbol *sym = NULL;
+  char *copy = NULL;
+  struct block *block = NULL;
+  int i1 = 0;
+  int i2 = 0;
+
+  values.sals = NULL;
+  values.nelts = 0;
+
+  if (file_symtab != NULL)
+    block = BLOCKVECTOR_BLOCK (BLOCKVECTOR (file_symtab), STATIC_BLOCK);
+  else
+    block = get_selected_block (0);
+    
+  copy = find_imps (file_symtab, block, *argptr, NULL, &i1, &i2); 
+    
+  if (i1 > 0)
+    {
+      sym_arr = (struct symbol **) alloca ((i1 + 1) * sizeof (struct symbol *));
+      sym_arr[i1] = 0;
+
+      copy = find_imps (file_symtab, block, *argptr, sym_arr, &i1, &i2); 
+      *argptr = copy;
+    }
+
+  /* i1 now represents the TOTAL number of matches found.
+     i2 represents how many HIGH-LEVEL (struct symbol) matches,
+     which will come first in the sym_arr array.  Any low-level
+     (minimal_symbol) matches will follow those.  */
+      
+  if (i1 == 1)
+    {
+      if (i2 > 0)
+	{
+	  /* Already a struct symbol.  */
+	  sym = sym_arr[0];
+	}
+      else
+	{
+	  sym = find_pc_function (SYMBOL_VALUE_ADDRESS (sym_arr[0]));
+	  if ((sym != NULL) && strcmp (SYMBOL_LINKAGE_NAME (sym_arr[0]), SYMBOL_LINKAGE_NAME (sym)) != 0)
+	    {
+	      warning ("debugging symbol \"%s\" does not match selector; ignoring", SYMBOL_LINKAGE_NAME (sym));
+	      sym = NULL;
+	    }
+	}
+	      
+      values.sals = (struct symtab_and_line *) xmalloc (sizeof (struct symtab_and_line));
+      values.nelts = 1;
+	      
+      if (sym && SYMBOL_CLASS (sym) == LOC_BLOCK)
+	{
+	  /* Canonicalize this, so it remains resolved for dylib loads.  */
+	  values.sals[0] = find_function_start_sal (sym, funfirstline);
+	  build_canonical_line_spec (values.sals, SYMBOL_NATURAL_NAME (sym), canonical);
+	}
+      else
+	{
+	  /* The only match was a non-debuggable symbol.  */
+	  values.sals[0].symtab = 0;
+	  values.sals[0].line = 0;
+	  values.sals[0].end = 0;
+	  values.sals[0].pc = SYMBOL_VALUE_ADDRESS (sym_arr[0]);
+	}
+      return values;
+    }
+
+  if (i1 > 1)
+    {
+      /* More than one match. The user must choose one or more.  */
+      return decode_line_2 (sym_arr, i2, funfirstline, canonical);
+    }
+
+  return values;
+}
+
 /* This handles C++ and Java compound data structures.  P should point
    at the first component separator, i.e. double-colon or period.  */
 
diff --git a/gdb/lynx-nat.c b/gdb/lynx-nat.c
index 4be7fb8e1ab..f425cb9c37a 100644
--- a/gdb/lynx-nat.c
+++ b/gdb/lynx-nat.c
@@ -283,7 +283,7 @@ fetch_inferior_registers (int regno)
   if (whatregs & WHATREGS_GEN)
     {
       struct econtext ec;	/* general regs */
-      char *buf = alloca (max_register_size (current_gdbarch));
+      char buf[MAX_REGISTER_SIZE];
       int retval;
       int i;
 
@@ -512,7 +512,7 @@ fetch_inferior_registers (int regno)
   ecp = registers_addr (PIDGET (inferior_ptid));
 
   {
-    char *buf = alloca (max_register_size (current_gdbarch));
+    char buf[MAX_REGISTER_SIZE];
     for (regno = reglo; regno <= reghi; regno++)
       {
 	int ptrace_fun = PTRACE_PEEKTHREAD;
diff --git a/gdb/m68hc11-tdep.c b/gdb/m68hc11-tdep.c
index 37d27a544be..fb174206e2c 100644
--- a/gdb/m68hc11-tdep.c
+++ b/gdb/m68hc11-tdep.c
@@ -1367,23 +1367,21 @@ m68hc11_gdbarch_init (struct gdbarch_info info,
 
   set_gdbarch_read_pc (gdbarch, generic_target_read_pc);
   set_gdbarch_write_pc (gdbarch, generic_target_write_pc);
-  set_gdbarch_read_fp (gdbarch, generic_target_read_fp);
   set_gdbarch_read_sp (gdbarch, generic_target_read_sp);
   set_gdbarch_deprecated_dummy_write_sp (gdbarch, generic_target_write_sp);
 
   set_gdbarch_sp_regnum (gdbarch, HARD_SP_REGNUM);
-  set_gdbarch_fp_regnum (gdbarch, SOFT_FP_REGNUM);
+  set_gdbarch_deprecated_fp_regnum (gdbarch, SOFT_FP_REGNUM);
   set_gdbarch_register_name (gdbarch, m68hc11_register_name);
-  set_gdbarch_register_size (gdbarch, 2);
+  set_gdbarch_deprecated_register_size (gdbarch, 2);
   set_gdbarch_register_bytes (gdbarch, M68HC11_ALL_REGS * 2);
   set_gdbarch_register_virtual_type (gdbarch, m68hc11_register_virtual_type);
   set_gdbarch_pseudo_register_read (gdbarch, m68hc11_pseudo_register_read);
   set_gdbarch_pseudo_register_write (gdbarch, m68hc11_pseudo_register_write);
 
   set_gdbarch_call_dummy_address (gdbarch, m68hc11_call_dummy_address);
-  set_gdbarch_call_dummy_words (gdbarch, m68hc11_call_dummy_words);
-  set_gdbarch_sizeof_call_dummy_words (gdbarch,
-                                       sizeof (m68hc11_call_dummy_words));
+  set_gdbarch_deprecated_call_dummy_words (gdbarch, m68hc11_call_dummy_words);
+  set_gdbarch_deprecated_sizeof_call_dummy_words (gdbarch, sizeof (m68hc11_call_dummy_words));
   set_gdbarch_deprecated_get_saved_register (gdbarch, deprecated_generic_get_saved_register);
   set_gdbarch_deprecated_extract_return_value (gdbarch, m68hc11_extract_return_value);
   set_gdbarch_deprecated_push_arguments (gdbarch, m68hc11_push_arguments);
diff --git a/gdb/m68k-tdep.c b/gdb/m68k-tdep.c
index 1ad176e3ad0..aabb13ab597 100644
--- a/gdb/m68k-tdep.c
+++ b/gdb/m68k-tdep.c
@@ -429,9 +429,9 @@ void
 m68k_fix_call_dummy (char *dummy, CORE_ADDR pc, CORE_ADDR fun, int nargs,
 		     struct value **args, struct type *type, int gcc_p)
 {
-  bfd_putb32 (fun, (unsigned char *) dummy + CALL_DUMMY_START_OFFSET + 2);
+  bfd_putb32 (fun, (unsigned char *) dummy + DEPRECATED_CALL_DUMMY_START_OFFSET + 2);
   bfd_putb32 (nargs * 4,
-	      (unsigned char *) dummy + CALL_DUMMY_START_OFFSET + 8);
+	      (unsigned char *) dummy + DEPRECATED_CALL_DUMMY_START_OFFSET + 8);
 }
 
 
@@ -445,8 +445,8 @@ m68k_push_dummy_frame (void)
   char raw_buffer[12];
 
   sp = push_word (sp, read_register (PC_REGNUM));
-  sp = push_word (sp, read_register (FP_REGNUM));
-  write_register (FP_REGNUM, sp);
+  sp = push_word (sp, read_register (DEPRECATED_FP_REGNUM));
+  write_register (DEPRECATED_FP_REGNUM, sp);
 
   /* Always save the floating-point registers, whether they exist on
      this target or not.  */
@@ -456,7 +456,7 @@ m68k_push_dummy_frame (void)
       sp = push_bytes (sp, raw_buffer, 12);
     }
 
-  for (regnum = FP_REGNUM - 1; regnum >= 0; regnum--)
+  for (regnum = DEPRECATED_FP_REGNUM - 1; regnum >= 0; regnum--)
     {
       sp = push_word (sp, read_register (regnum));
     }
@@ -486,7 +486,7 @@ m68k_pop_frame (void)
 					   12);
 	}
     }
-  for (regnum = FP_REGNUM - 1; regnum >= 0; regnum--)
+  for (regnum = DEPRECATED_FP_REGNUM - 1; regnum >= 0; regnum--)
     {
       if (get_frame_saved_regs (frame)[regnum])
 	{
@@ -499,7 +499,7 @@ m68k_pop_frame (void)
       write_register (PS_REGNUM,
 		      read_memory_integer (get_frame_saved_regs (frame)[PS_REGNUM], 4));
     }
-  write_register (FP_REGNUM, read_memory_integer (fp, 4));
+  write_register (DEPRECATED_FP_REGNUM, read_memory_integer (fp, 4));
   write_register (PC_REGNUM, read_memory_integer (fp + 4, 4));
   write_register (SP_REGNUM, fp + 8);
   flush_cached_frames ();
@@ -589,7 +589,7 @@ m68k_frame_init_saved_regs (struct frame_info *frame_info)
 
   /* First possible address for a pc in a call dummy for this frame.  */
   CORE_ADDR possible_call_dummy_start =
-    get_frame_base (frame_info) - 28 - FP_REGNUM * 4 - 4 - 8 * 12;
+    get_frame_base (frame_info) - 28 - DEPRECATED_FP_REGNUM * 4 - 4 - 8 * 12;
 
   int nextinsn;
 
@@ -743,7 +743,7 @@ m68k_frame_init_saved_regs (struct frame_info *frame_info)
     }
 lose:;
   get_frame_saved_regs (frame_info)[SP_REGNUM] = get_frame_base (frame_info) + 8;
-  get_frame_saved_regs (frame_info)[FP_REGNUM] = get_frame_base (frame_info);
+  get_frame_saved_regs (frame_info)[DEPRECATED_FP_REGNUM] = get_frame_base (frame_info);
   get_frame_saved_regs (frame_info)[PC_REGNUM] = get_frame_base (frame_info) + 4;
 #ifdef SIG_SP_FP_OFFSET
   /* Adjust saved SP_REGNUM for fake _sigtramp frames.  */
@@ -1025,27 +1025,27 @@ m68k_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
   set_gdbarch_deprecated_max_register_virtual_size (gdbarch, 12);
   set_gdbarch_register_virtual_type (gdbarch, m68k_register_virtual_type);
   set_gdbarch_register_name (gdbarch, m68k_register_name);
-  set_gdbarch_register_size (gdbarch, 4);
+  set_gdbarch_deprecated_register_size (gdbarch, 4);
   set_gdbarch_register_byte (gdbarch, m68k_register_byte);
   set_gdbarch_num_regs (gdbarch, 29);
   set_gdbarch_register_bytes_ok (gdbarch, m68k_register_bytes_ok);
   set_gdbarch_register_bytes (gdbarch, (16 * 4 + 8 + 8 * 12 + 3 * 4));
   set_gdbarch_sp_regnum (gdbarch, M68K_SP_REGNUM);
-  set_gdbarch_fp_regnum (gdbarch, M68K_FP_REGNUM);
+  set_gdbarch_deprecated_fp_regnum (gdbarch, M68K_FP_REGNUM);
   set_gdbarch_pc_regnum (gdbarch, M68K_PC_REGNUM);
   set_gdbarch_ps_regnum (gdbarch, M68K_PS_REGNUM);
   set_gdbarch_fp0_regnum (gdbarch, M68K_FP0_REGNUM);
 
   set_gdbarch_deprecated_use_generic_dummy_frames (gdbarch, 0);
   set_gdbarch_call_dummy_location (gdbarch, ON_STACK);
-  set_gdbarch_call_dummy_breakpoint_offset (gdbarch, 24);
+  set_gdbarch_deprecated_call_dummy_breakpoint_offset (gdbarch, 24);
   set_gdbarch_deprecated_pc_in_call_dummy (gdbarch, deprecated_pc_in_call_dummy_on_stack);
-  set_gdbarch_call_dummy_length (gdbarch, 28);
-  set_gdbarch_call_dummy_start_offset (gdbarch, 12);
+  set_gdbarch_deprecated_call_dummy_length (gdbarch, 28);
+  set_gdbarch_deprecated_call_dummy_start_offset (gdbarch, 12);
 
-  set_gdbarch_call_dummy_words (gdbarch, call_dummy_words);
-  set_gdbarch_sizeof_call_dummy_words (gdbarch, sizeof (call_dummy_words));
-  set_gdbarch_fix_call_dummy (gdbarch, m68k_fix_call_dummy);
+  set_gdbarch_deprecated_call_dummy_words (gdbarch, call_dummy_words);
+  set_gdbarch_deprecated_sizeof_call_dummy_words (gdbarch, sizeof (call_dummy_words));
+  set_gdbarch_deprecated_fix_call_dummy (gdbarch, m68k_fix_call_dummy);
   set_gdbarch_deprecated_push_dummy_frame (gdbarch, m68k_push_dummy_frame);
   set_gdbarch_deprecated_pop_frame (gdbarch, m68k_pop_frame);
 
@@ -1066,5 +1066,5 @@ void
 _initialize_m68k_tdep (void)
 {
   gdbarch_register (bfd_arch_m68k, m68k_gdbarch_init, m68k_dump_tdep);
-  tm_print_insn = print_insn_m68k;
+  deprecated_tm_print_insn = print_insn_m68k;
 }
diff --git a/gdb/m68klinux-nat.c b/gdb/m68klinux-nat.c
index 0f0a7d10241..e077deadc27 100644
--- a/gdb/m68klinux-nat.c
+++ b/gdb/m68klinux-nat.c
@@ -135,7 +135,7 @@ fetch_register (int regno)
   char mess[128];		/* For messages */
   register int i;
   unsigned int offset;		/* Offset of registers within the u area.  */
-  char *buf = alloca (max_register_size (current_gdbarch));
+  char buf[MAX_REGISTER_SIZE];
   int tid;
 
   if (CANNOT_FETCH_REGISTER (regno))
@@ -199,7 +199,7 @@ store_register (int regno)
   register int i;
   unsigned int offset;		/* Offset of registers within the u area.  */
   int tid;
-  char *buf = alloca (MAX_REGISTER_RAW_SIZE);
+  char buf[MAX_REGISTER_SIZE];
 
   if (CANNOT_STORE_REGISTER (regno))
     {
diff --git a/gdb/maint.c b/gdb/maint.c
index 2eb59ee5e3a..aa342390765 100644
--- a/gdb/maint.c
+++ b/gdb/maint.c
@@ -434,18 +434,6 @@ maintenance_print_command (char *arg, int from_tty)
   help_list (maintenanceprintlist, "maintenance print ", -1, gdb_stdout);
 }
 
-/* The "maintenance list" command is defined as a prefix, with
-   allow_unknown 0.  Therefore, its own definition is called only for
-   "maintenance list" with no args.  */
-
-/* ARGSUSED */
-static void
-maintenance_list_command (char *arg, int from_tty)
-{
-  printf_unfiltered ("\"maintenance list\" must be followed by the name of a list command.\n");
-  help_list (maintenancelistlist, "maintenance list ", -1, gdb_stdout);
-}
-
 /* The "maintenance translate-address" command converts a section and address
    to a symbol.  This can be called in two ways:
    maintenance translate-address <secname> <addr>
@@ -744,11 +732,6 @@ lists all sections from all object files, including shared libraries.",
 		  &maintenanceprintlist, "maintenance print ", 0,
 		  &maintenancelist);
 
-  add_prefix_cmd ("list", class_maintenance, maintenance_list_command,
-		  "Maintenance command for listing GDB internal state.",
-		  &maintenancelistlist, "maintenance list ", 0,
-		  &maintenancelist);
-
   add_prefix_cmd ("set", class_maintenance, maintenance_set_cmd, "\
 Set GDB internal variables used by the GDB maintainer.\n\
 Configure variables internal to GDB that aid in GDB's maintenance",
@@ -827,18 +810,18 @@ If a SOURCE file is specified, dump only that file's partial symbols.",
 	   "Print dump of current object file definitions.",
 	   &maintenanceprintlist);
 
-  add_cmd ("symtabs", class_maintenance, maintenance_list_symtabs,
+  add_cmd ("symtabs", class_maintenance, maintenance_info_symtabs,
 	   "List the full symbol tables for all object files.\n\
 This does not include information about individual symbols, blocks, or\n\
 linetables --- just the symbol table structures themselves.\n\
 With an argument REGEXP, list the symbol tables whose names that match that.",
-	   &maintenancelistlist);
+	   &maintenanceinfolist);
 
-  add_cmd ("psymtabs", class_maintenance, maintenance_list_psymtabs,
+  add_cmd ("psymtabs", class_maintenance, maintenance_info_psymtabs,
 	   "List the partial symbol tables for all object files.\n\
 This does not include information about individual partial symbols,\n\
 just the symbol table structures themselves.",
-	   &maintenancelistlist);
+	   &maintenanceinfolist);
 
   add_cmd ("statistics", class_maintenance, maintenance_print_statistics,
 	   "Print statistics about internal gdb state.",
diff --git a/gdb/mcore-tdep.c b/gdb/mcore-tdep.c
index ab03f3ad765..484c1ec9d22 100644
--- a/gdb/mcore-tdep.c
+++ b/gdb/mcore-tdep.c
@@ -28,6 +28,7 @@
 #include "inferior.h"
 #include "arch-utils.h"
 #include "gdb_string.h"
+#include "disasm.h"
 
 /* Functions declared and used only in this file */
 
@@ -163,7 +164,7 @@ mcore_dump_insn (char *commnt, CORE_ADDR pc, int insn)
     {
       printf_filtered ("MCORE:  %s %08x %08x ",
 		       commnt, (unsigned int) pc, (unsigned int) insn);
-      TARGET_PRINT_INSN (pc, &tm_print_insn_info);
+      gdb_print_insn (pc, gdb_stdout);
       printf_filtered ("\n");
     }
 }
@@ -682,7 +683,8 @@ mcore_frame_chain (struct frame_info * fi)
 	{
 	  /* The "FP" was saved on the stack.  Don't forget to adjust
 	     the "FP" with the framesize to get a real FP. */
-	  callers_addr = read_memory_integer (get_frame_saved_regs (fi)[fp], REGISTER_SIZE)
+	  callers_addr = read_memory_integer (get_frame_saved_regs (fi)[fp],
+					      DEPRECATED_REGISTER_SIZE)
 	    + get_frame_extra_info (dummy)->framesize;
 	}
       else
@@ -766,7 +768,7 @@ mcore_find_callers_reg (struct frame_info *fi, int regnum)
 					       get_frame_base (fi), regnum);
       else if (get_frame_saved_regs (fi)[regnum] != 0)
 	return read_memory_integer (get_frame_saved_regs (fi)[regnum],
-				    REGISTER_SIZE);
+				    DEPRECATED_REGISTER_SIZE);
     }
 
   return read_register (regnum);
@@ -813,7 +815,7 @@ mcore_pop_frame (void)
 	      ULONGEST value;
 
 	      value = read_memory_unsigned_integer (get_frame_saved_regs (fi)[rn],
-						    REGISTER_SIZE);
+						    DEPRECATED_REGISTER_SIZE);
 	      write_register (rn, value);
 	    }
 	}
@@ -829,9 +831,9 @@ mcore_pop_frame (void)
 /* Setup arguments and PR for a call to the target. First six arguments
    go in FIRST_ARGREG -> LAST_ARGREG, subsequent args go on to the stack.
 
-   * Types with lengths greater than REGISTER_SIZE may not be split
-   between registers and the stack, and they must start in an even-numbered
-   register. Subsequent args will go onto the stack.
+   - Types with lengths greater than DEPRECATED_REGISTER_SIZE may not
+   be split between registers and the stack, and they must start in an
+   even-numbered register. Subsequent args will go onto the stack.
 
    * Structs may be split between registers and stack, left-aligned.
 
@@ -883,21 +885,21 @@ mcore_push_arguments (int nargs, struct value **args, CORE_ADDR sp,
          numbered register. */
       olen = len;
 
-      if (TYPE_CODE (type) != TYPE_CODE_STRUCT && len > REGISTER_SIZE && argreg % 2)
+      if (TYPE_CODE (type) != TYPE_CODE_STRUCT && len > DEPRECATED_REGISTER_SIZE && argreg % 2)
 	{
-	  mcore_insn_debug (("MCORE PUSH: %d > REGISTER_SIZE: and %s is not even\n",
+	  mcore_insn_debug (("MCORE PUSH: %d > DEPRECATED_REGISTER_SIZE: and %s is not even\n",
 			     len, mcore_register_names[argreg]));
 	  argreg++;
 	}
 
-      if ((argreg <= LAST_ARGREG && len <= (LAST_ARGREG - argreg + 1) * REGISTER_SIZE)
+      if ((argreg <= LAST_ARGREG && len <= (LAST_ARGREG - argreg + 1) * DEPRECATED_REGISTER_SIZE)
 	  || (TYPE_CODE (type) == TYPE_CODE_STRUCT))
 	{
 	  /* Something that will fit entirely into registers (or a struct
 	     which may be split between registers and stack). */
 	  mcore_insn_debug (("MCORE PUSH: arg %d going into regs\n", argnum));
 
-	  if (TYPE_CODE (type) == TYPE_CODE_STRUCT && olen < REGISTER_SIZE)
+	  if (TYPE_CODE (type) == TYPE_CODE_STRUCT && olen < DEPRECATED_REGISTER_SIZE)
 	    {
 	      /* Small structs must be right aligned within the register,
 	         the most significant bits are undefined. */
@@ -908,16 +910,16 @@ mcore_push_arguments (int nargs, struct value **args, CORE_ADDR sp,
 
 	  while (len > 0 && argreg <= LAST_ARGREG)
 	    {
-	      write_register (argreg, extract_unsigned_integer (val, REGISTER_SIZE));
+	      write_register (argreg, extract_unsigned_integer (val, DEPRECATED_REGISTER_SIZE));
 	      argreg++;
-	      val += REGISTER_SIZE;
-	      len -= REGISTER_SIZE;
+	      val += DEPRECATED_REGISTER_SIZE;
+	      len -= DEPRECATED_REGISTER_SIZE;
 	    }
 
 	  /* Any remainder for the stack is noted below... */
 	}
       else if (TYPE_CODE (VALUE_TYPE (args[argnum])) != TYPE_CODE_STRUCT
-	       && len > REGISTER_SIZE)
+	       && len > DEPRECATED_REGISTER_SIZE)
 	{
 	  /* All subsequent args go onto the stack. */
 	  mcore_insn_debug (("MCORE PUSH: does not fit into regs, going onto stack\n"));
@@ -990,7 +992,7 @@ mcore_use_struct_convention (int gcc_p, struct type *type)
 CORE_ADDR
 mcore_extract_struct_value_address (char *regbuf)
 {
-  return extract_address (regbuf + REGISTER_BYTE (FIRST_ARGREG), REGISTER_SIZE);
+  return extract_address (regbuf + REGISTER_BYTE (FIRST_ARGREG), DEPRECATED_REGISTER_SIZE);
 }
 
 /* Given a function which returns a value of type TYPE, extract the
@@ -1028,7 +1030,7 @@ mcore_store_return_value (struct type *type, char *valbuf)
   value_size = TYPE_LENGTH (type);
 
   /* Return value fits into registers. */
-  return_size = (value_size + REGISTER_SIZE - 1) & ~(REGISTER_SIZE - 1);
+  return_size = (value_size + DEPRECATED_REGISTER_SIZE - 1) & ~(DEPRECATED_REGISTER_SIZE - 1);
   offset = REGISTER_BYTE (RETVAL_REGNUM) + (return_size - value_size);
   zeros = alloca (return_size);
   memset (zeros, 0, return_size);
@@ -1058,8 +1060,8 @@ mcore_init_extra_frame_info (int fromleaf, struct frame_info *fi)
   if (DEPRECATED_PC_IN_CALL_DUMMY (get_frame_pc (fi), get_frame_base (fi),
 				   get_frame_base (fi)))
     {
-      /* We need to setup fi->frame here because run_stack_dummy gets it wrong
-         by assuming it's always FP.  */
+      /* We need to setup fi->frame here because call_function_by_hand
+         gets it wrong by assuming it's always FP.  */
       deprecated_update_frame_base_hack (fi, deprecated_read_register_dummy (get_frame_pc (fi), get_frame_base (fi), SP_REGNUM));
     }
   else
@@ -1100,7 +1102,7 @@ mcore_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
   /* Registers: */
 
   /* All registers are 32 bits */
-  set_gdbarch_register_size (gdbarch, MCORE_REG_SIZE);
+  set_gdbarch_deprecated_register_size (gdbarch, MCORE_REG_SIZE);
   set_gdbarch_deprecated_max_register_raw_size (gdbarch, MCORE_REG_SIZE);
   set_gdbarch_deprecated_max_register_virtual_size (gdbarch, MCORE_REG_SIZE);
   set_gdbarch_register_name (gdbarch, mcore_register_name);
@@ -1112,12 +1114,12 @@ mcore_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
   set_gdbarch_num_regs (gdbarch, MCORE_NUM_REGS);
   set_gdbarch_pc_regnum (gdbarch, 64);
   set_gdbarch_sp_regnum (gdbarch, 0);
-  set_gdbarch_fp_regnum (gdbarch, 0);
+  set_gdbarch_deprecated_fp_regnum (gdbarch, 0);
 
   /* Call Dummies:  */
 
-  set_gdbarch_call_dummy_words (gdbarch, call_dummy_words);
-  set_gdbarch_sizeof_call_dummy_words (gdbarch, 0);
+  set_gdbarch_deprecated_call_dummy_words (gdbarch, call_dummy_words);
+  set_gdbarch_deprecated_sizeof_call_dummy_words (gdbarch, 0);
   set_gdbarch_save_dummy_frame_tos (gdbarch, generic_save_dummy_frame_tos);
   set_gdbarch_deprecated_saved_pc_after_call (gdbarch, mcore_saved_pc_after_call);
   set_gdbarch_function_start_offset (gdbarch, 0);
@@ -1173,7 +1175,7 @@ _initialize_mcore_tdep (void)
 {
   extern int print_insn_mcore (bfd_vma, disassemble_info *);
   gdbarch_register (bfd_arch_mcore, mcore_gdbarch_init, mcore_dump_tdep);
-  tm_print_insn = print_insn_mcore;
+  deprecated_tm_print_insn = print_insn_mcore;
 
 #ifdef MCORE_DEBUG
   add_show_from_set (add_set_cmd ("mcoredebug", no_class,
diff --git a/gdb/mi/ChangeLog b/gdb/mi/ChangeLog
index 73b4975534c..1580d1fc997 100644
--- a/gdb/mi/ChangeLog
+++ b/gdb/mi/ChangeLog
@@ -1,3 +1,25 @@
+2003-05-08  Andrew Cagney  <cagney@redhat.com>
+
+	* mi-main.c (register_changed_p): Use MAX_REGISTER_SIZE instead of
+	MAX_REGISTER_RAW_SIZE.
+
+2003-05-08  Andrew Cagney  <cagney@redhat.com>
+
+	* mi-main.c (get_register): Use MAX_REGISTER_SIZE.
+
+2003-05-05  Andrew Cagney  <cagney@redhat.com>
+
+	* mi-main.c (mi_cmd_data_write_register_values): Replace
+	REGISTER_SIZE with DEPRECATED_REGISTER_SIZE.
+
+2003-05-03  J. Brobecker  <brobecker@gnat.com>
+
+	From  Thierry Schneider  <tpschneider1@yahoo.com>:
+	* mi-cmds.h (mi_cmd_symbol_list_lines): Add declaration.
+	* mi-cmds.c (mi_cmds): Add entry for new MI command.
+	* mi-cmd-symbol.c (mi_cmd_symbol_list_lines): New source file
+	for all symbol-related commands.
+
 2003-04-02  Bob Rossi  <bob_rossi@cox.net>
 
 	* mi-cmd-file.c: New file to implement mi file commands.
diff --git a/gdb/mi/mi-cmd-symbol.c b/gdb/mi/mi-cmd-symbol.c
new file mode 100644
index 00000000000..1d86d21d517
--- /dev/null
+++ b/gdb/mi/mi-cmd-symbol.c
@@ -0,0 +1,67 @@
+/* MI Command Set - symbol commands.
+   Copyright 2003 Free Software Foundation, Inc.
+
+   This file is part of GDB.
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 59 Temple Place - Suite 330,
+   Boston, MA 02111-1307, USA.  */
+
+#include "defs.h"
+#include "mi-cmds.h"
+#include "symtab.h"
+#include "ui-out.h"
+
+/* SYMBOL-LIST-LINES:
+
+   Print the list of all pc addresses and lines of code for
+   the provided (full or base) source file name.  The entries
+   are sorted in ascending PC order. */
+
+enum mi_cmd_result
+mi_cmd_symbol_list_lines (char *command, char **argv, int argc)
+{
+  char *filename;
+  struct symtab *s;
+  int i;
+  struct cleanup *cleanup_stack, *cleanup_tuple;
+
+  if (argc != 1)
+    error ("mi_cmd_symbol_list_lines: Usage: SOURCE_FILENAME");
+
+  filename = argv[0];
+  s = lookup_symtab (filename);
+
+  if (s == NULL)
+    error ("mi_cmd_symbol_list_lines: Unknown source file name.");
+
+  /* Now, dump the associated line table.  The pc addresses are already
+     sorted by increasing values in the symbol table, so no need to
+     perform any other sorting. */
+
+  cleanup_stack = make_cleanup_ui_out_list_begin_end (uiout, "lines");
+
+  if (LINETABLE (s) != NULL && LINETABLE (s)->nitems > 0)
+    for (i = 0; i < LINETABLE (s)->nitems; i++)
+    {
+      cleanup_tuple = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
+      ui_out_field_core_addr (uiout, "pc", LINETABLE (s)->item[i].pc);
+      ui_out_field_int (uiout, "line", LINETABLE (s)->item[i].line);
+      do_cleanups (cleanup_tuple);
+    }
+
+  do_cleanups (cleanup_stack);
+
+  return MI_CMD_DONE;
+}
diff --git a/gdb/mi/mi-cmds.c b/gdb/mi/mi-cmds.c
index d6778421339..9ec174fd854 100644
--- a/gdb/mi/mi-cmds.c
+++ b/gdb/mi/mi-cmds.c
@@ -119,6 +119,7 @@ struct mi_cmd mi_cmds[] =
   {"symbol-info-line", 0, 0},
   {"symbol-info-symbol", 0, 0},
   {"symbol-list-functions", 0, 0},
+  {"symbol-list-lines", 0, 0, mi_cmd_symbol_list_lines},
   {"symbol-list-types", 0, 0},
   {"symbol-list-variables", 0, 0},
   {"symbol-locate", 0, 0},
diff --git a/gdb/mi/mi-cmds.h b/gdb/mi/mi-cmds.h
index 47e1bbf17a7..b0c8cb8db1f 100644
--- a/gdb/mi/mi-cmds.h
+++ b/gdb/mi/mi-cmds.h
@@ -88,6 +88,7 @@ extern mi_cmd_argv_ftype mi_cmd_stack_list_args;
 extern mi_cmd_argv_ftype mi_cmd_stack_list_frames;
 extern mi_cmd_argv_ftype mi_cmd_stack_list_locals;
 extern mi_cmd_argv_ftype mi_cmd_stack_select_frame;
+extern mi_cmd_argv_ftype mi_cmd_symbol_list_lines;
 extern mi_cmd_args_ftype mi_cmd_target_download;
 extern mi_cmd_args_ftype mi_cmd_target_select;
 extern mi_cmd_argv_ftype mi_cmd_thread_list_ids;
diff --git a/gdb/mi/mi-main.c b/gdb/mi/mi-main.c
index 6ba069821ea..6158c8ff439 100644
--- a/gdb/mi/mi-main.c
+++ b/gdb/mi/mi-main.c
@@ -398,7 +398,7 @@ mi_cmd_data_list_changed_registers (char *command, char **argv, int argc)
 static int
 register_changed_p (int regnum)
 {
-  char *raw_buffer = alloca (MAX_REGISTER_RAW_SIZE);
+  char raw_buffer[MAX_REGISTER_SIZE];
 
   if (! frame_register_read (deprecated_selected_frame, regnum, raw_buffer))
     return -1;
@@ -511,8 +511,8 @@ mi_cmd_data_list_register_values (char *command, char **argv, int argc)
 static int
 get_register (int regnum, int format)
 {
-  char *raw_buffer = alloca (MAX_REGISTER_RAW_SIZE);
-  char *virtual_buffer = alloca (MAX_REGISTER_VIRTUAL_SIZE);
+  char raw_buffer[MAX_REGISTER_SIZE];
+  char virtual_buffer[MAX_REGISTER_SIZE];
   int optim;
   int realnum;
   CORE_ADDR addr;
@@ -636,9 +636,9 @@ mi_cmd_data_write_register_values (char *command, char **argv, int argc)
 	  /* Get the value as a number */
 	  value = parse_and_eval_address (argv[i + 1]);
 	  /* Get the value into an array */
-	  buffer = xmalloc (REGISTER_SIZE);
+	  buffer = xmalloc (DEPRECATED_REGISTER_SIZE);
 	  old_chain = make_cleanup (xfree, buffer);
-	  store_signed_integer (buffer, REGISTER_SIZE, value);
+	  store_signed_integer (buffer, DEPRECATED_REGISTER_SIZE, value);
 	  /* Write it down */
 	  deprecated_write_register_bytes (REGISTER_BYTE (regnum), buffer, REGISTER_RAW_SIZE (regnum));
 	  /* Free the buffer.  */
diff --git a/gdb/mips-linux-tdep.c b/gdb/mips-linux-tdep.c
index ae4e6897949..b8072f1aba7 100644
--- a/gdb/mips-linux-tdep.c
+++ b/gdb/mips-linux-tdep.c
@@ -91,7 +91,7 @@ mips_linux_get_longjmp_target (CORE_ADDR *pc)
 static void
 supply_32bit_reg (int regnum, const void *addr)
 {
-  char *buf = alloca (MAX_REGISTER_RAW_SIZE);
+  char buf[MAX_REGISTER_SIZE];
   store_signed_integer (buf, REGISTER_RAW_SIZE (regnum),
                         extract_signed_integer (addr, 4));
   supply_register (regnum, buf);
@@ -104,9 +104,9 @@ supply_gregset (elf_gregset_t *gregsetp)
 {
   int regi;
   elf_greg_t *regp = *gregsetp;
-  char *zerobuf = alloca (MAX_REGISTER_RAW_SIZE);
+  char zerobuf[MAX_REGISTER_SIZE];
 
-  memset (zerobuf, 0, MAX_REGISTER_RAW_SIZE);
+  memset (zerobuf, 0, MAX_REGISTER_SIZE);
 
   for (regi = EF_REG0; regi <= EF_REG31; regi++)
     supply_32bit_reg ((regi - EF_REG0), (char *)(regp + regi));
@@ -192,9 +192,9 @@ void
 supply_fpregset (elf_fpregset_t *fpregsetp)
 {
   register int regi;
-  char *zerobuf = alloca (MAX_REGISTER_RAW_SIZE);
+  char zerobuf[MAX_REGISTER_SIZE];
 
-  memset (zerobuf, 0, MAX_REGISTER_RAW_SIZE);
+  memset (zerobuf, 0, MAX_REGISTER_SIZE);
 
   for (regi = 0; regi < 32; regi++)
     supply_register (FP0_REGNUM + regi,
@@ -379,9 +379,9 @@ mips64_supply_gregset (mips64_elf_gregset_t *gregsetp)
 {
   int regi;
   mips64_elf_greg_t *regp = *gregsetp;
-  char *zerobuf = alloca (MAX_REGISTER_RAW_SIZE);
+  char zerobuf[MAX_REGISTER_SIZE];
 
-  memset (zerobuf, 0, MAX_REGISTER_RAW_SIZE);
+  memset (zerobuf, 0, MAX_REGISTER_SIZE);
 
   for (regi = MIPS64_EF_REG0; regi <= MIPS64_EF_REG31; regi++)
     supply_register ((regi - MIPS64_EF_REG0), (char *)(regp + regi));
@@ -467,9 +467,9 @@ static void
 mips64_supply_fpregset (mips64_elf_fpregset_t *fpregsetp)
 {
   register int regi;
-  char *zerobuf = alloca (MAX_REGISTER_RAW_SIZE);
+  char zerobuf[MAX_REGISTER_SIZE];
 
-  memset (zerobuf, 0, MAX_REGISTER_RAW_SIZE);
+  memset (zerobuf, 0, MAX_REGISTER_SIZE);
 
   for (regi = 0; regi < 32; regi++)
     supply_register (FP0_REGNUM + regi,
diff --git a/gdb/mips-nat.c b/gdb/mips-nat.c
index f893e339c2e..1a29c3e317a 100644
--- a/gdb/mips-nat.c
+++ b/gdb/mips-nat.c
@@ -70,10 +70,10 @@ void
 fetch_inferior_registers (int regno)
 {
   register unsigned int regaddr;
-  char *buf = alloca (max_register_size (current_gdbarch));
+  char buf[MAX_REGISTER_SIZE];
   register int i;
-  char *zerobuf = alloca (max_register_size (current_gdbarch));
-  memset (zerobuf, 0, max_register_size (current_gdbarch));
+  char zerobuf[MAX_REGISTER_SIZE];
+  memset (zerobuf, 0, MAX_REGISTER_SIZE);
 
   deprecated_registers_fetched ();
 
@@ -91,7 +91,7 @@ fetch_inferior_registers (int regno)
 
   supply_register (ZERO_REGNUM, zerobuf);
   /* Frame ptr reg must appear to be 0; it is faked by stack handling code. */
-  supply_register (FP_REGNUM, zerobuf);
+  supply_register (DEPRECATED_FP_REGNUM, zerobuf);
 }
 
 /* Store our register values back into the inferior.
@@ -108,7 +108,7 @@ store_inferior_registers (int regno)
     {
       if (regno == ZERO_REGNUM || regno == PS_REGNUM
 	  || regno == BADVADDR_REGNUM || regno == CAUSE_REGNUM
-	  || regno == FCRIR_REGNUM || regno == FP_REGNUM
+	  || regno == FCRIR_REGNUM || regno == DEPRECATED_FP_REGNUM
 	  || (regno >= FIRST_EMBED_REGNUM && regno <= LAST_EMBED_REGNUM))
 	return;
       regaddr = REGISTER_PTRACE_ADDR (regno);
@@ -174,8 +174,8 @@ fetch_core_registers (char *core_reg_sect, unsigned core_reg_size, int which,
   int bad_reg = -1;
   register reg_ptr = -reg_addr;	/* Original u.u_ar0 is -reg_addr. */
 
-  char *zerobuf = alloca (max_register_size (current_gdbarch));
-  memset (zerobuf, 0, max_register_size (current_gdbarch));
+  char zerobuf[MAX_REGISTER_SIZE];
+  memset (zerobuf, 0, MAX_REGISTER_SIZE);
 
 
   /* If u.u_ar0 was an absolute address in the core file, relativize it now,
@@ -210,7 +210,7 @@ fetch_core_registers (char *core_reg_sect, unsigned core_reg_size, int which,
     }
   supply_register (ZERO_REGNUM, zerobuf);
   /* Frame ptr reg must appear to be 0; it is faked by stack handling code. */
-  supply_register (FP_REGNUM, zerobuf);
+  supply_register (DEPRECATED_FP_REGNUM, zerobuf);
 }
 
 /* Return the address in the core dump or inferior of register REGNO.
diff --git a/gdb/mips-tdep.c b/gdb/mips-tdep.c
index 7956be49249..bf19ed8d999 100644
--- a/gdb/mips-tdep.c
+++ b/gdb/mips-tdep.c
@@ -150,6 +150,36 @@ static const char *mips_saved_regsize_string = size_auto;
 
 #define MIPS_SAVED_REGSIZE (mips_saved_regsize())
 
+/* Return the contents of register REGNUM as a signed integer.  */
+
+static LONGEST
+read_signed_register (int regnum)
+{
+  void *buf = alloca (REGISTER_RAW_SIZE (regnum));
+  deprecated_read_register_gen (regnum, buf);
+  return (extract_signed_integer (buf, REGISTER_RAW_SIZE (regnum)));
+}
+
+static LONGEST
+read_signed_register_pid (int regnum, ptid_t ptid)
+{
+  ptid_t save_ptid;
+  LONGEST retval;
+
+  if (ptid_equal (ptid, inferior_ptid))
+    return read_signed_register (regnum);
+
+  save_ptid = inferior_ptid;
+
+  inferior_ptid = ptid;
+
+  retval = read_signed_register (regnum);
+
+  inferior_ptid = save_ptid;
+
+  return retval;
+}
+
 /* Return the MIPS ABI associated with GDBARCH.  */
 enum mips_abi
 mips_abi (struct gdbarch *gdbarch)
@@ -215,7 +245,7 @@ mips_xfer_register (struct regcache *regcache, int reg_num, int length,
 		    enum bfd_endian endian, bfd_byte *in, const bfd_byte *out,
 		    int buf_offset)
 {
-  bfd_byte *reg = alloca (MAX_REGISTER_RAW_SIZE);
+  bfd_byte reg[MAX_REGISTER_SIZE];
   int reg_offset = 0;
   /* Need to transfer the left or right part of the register, based on
      the targets byte order.  */
@@ -623,9 +653,9 @@ if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG
    
    Note: kevinb/2002-08-01: The definition below should faithfully
    reproduce the behavior of each of the REGISTER_VIRTUAL_TYPE
-   definitions found in config/mips/tm-*.h.  I'm concerned about
-   the ``FCRCS_REGNUM <= reg && reg <= LAST_EMBED_REGNUM'' clause
-   though.  In some cases FP_REGNUM is in this range, and I doubt
+   definitions found in config/mips/tm-*.h.  I'm concerned about the
+   ``FCRCS_REGNUM <= reg && reg <= LAST_EMBED_REGNUM'' clause though.
+   In some cases DEPRECATED_FP_REGNUM is in this range, and I doubt
    that this code is correct for the 64-bit case.  */
 
 static struct type *
@@ -1612,7 +1642,7 @@ read_next_frame_reg (struct frame_info *fi, int regno)
   CORE_ADDR addr;
   int realnum;
   enum lval_type lval;
-  void *raw_buffer = alloca (MAX_REGISTER_RAW_SIZE);
+  char raw_buffer[MAX_REGISTER_SIZE];
 
   if (fi == NULL)
     {
@@ -2721,7 +2751,7 @@ mips_eabi_push_arguments (int nargs,
   for (argnum = 0; argnum < nargs; argnum++)
     {
       char *val;
-      char *valbuf = alloca (MAX_REGISTER_RAW_SIZE);
+      char valbuf[MAX_REGISTER_SIZE];
       struct value *arg = args[argnum];
       struct type *arg_type = check_typedef (VALUE_TYPE (arg));
       int len = TYPE_LENGTH (arg_type);
@@ -2972,7 +3002,7 @@ mips_n32n64_push_arguments (int nargs,
   for (argnum = 0; argnum < nargs; argnum++)
     {
       char *val;
-      char *valbuf = alloca (MAX_REGISTER_RAW_SIZE);
+      char valbuf[MAX_REGISTER_SIZE];
       struct value *arg = args[argnum];
       struct type *arg_type = check_typedef (VALUE_TYPE (arg));
       int len = TYPE_LENGTH (arg_type);
@@ -3195,7 +3225,7 @@ mips_o32_push_arguments (int nargs,
   for (argnum = 0; argnum < nargs; argnum++)
     {
       char *val;
-      char *valbuf = alloca (MAX_REGISTER_RAW_SIZE);
+      char valbuf[MAX_REGISTER_SIZE];
       struct value *arg = args[argnum];
       struct type *arg_type = check_typedef (VALUE_TYPE (arg));
       int len = TYPE_LENGTH (arg_type);
@@ -3494,7 +3524,7 @@ mips_o64_push_arguments (int nargs,
   for (argnum = 0; argnum < nargs; argnum++)
     {
       char *val;
-      char *valbuf = alloca (MAX_REGISTER_RAW_SIZE);
+      char valbuf[MAX_REGISTER_SIZE];
       struct value *arg = args[argnum];
       struct type *arg_type = check_typedef (VALUE_TYPE (arg));
       int len = TYPE_LENGTH (arg_type);
@@ -4014,7 +4044,7 @@ mips_print_fp_register (int regnum)
 static void
 mips_print_register (int regnum, int all)
 {
-  char *raw_buffer = alloca (MAX_REGISTER_RAW_SIZE);
+  char raw_buffer[MAX_REGISTER_SIZE];
   int offset;
 
   if (TYPE_CODE (REGISTER_VIRTUAL_TYPE (regnum)) == TYPE_CODE_FLT)
@@ -4070,7 +4100,7 @@ static int
 do_gp_register_row (int regnum)
 {
   /* do values for GP (int) regs */
-  char *raw_buffer = alloca (MAX_REGISTER_RAW_SIZE);
+  char raw_buffer[MAX_REGISTER_SIZE];
   int ncols = (MIPS_REGSIZE == 8 ? 4 : 8);	/* display cols per row */
   int col, byte;
   int start_regnum = regnum;
@@ -4573,7 +4603,7 @@ mips_o64_extract_return_value (struct type *valtype,
 static void
 mips_eabi_store_return_value (struct type *valtype, char *valbuf)
 {
-  char *raw_buffer = alloca (MAX_REGISTER_RAW_SIZE);
+  char raw_buffer[MAX_REGISTER_SIZE];
   struct return_value_word lo;
   struct return_value_word hi;
   return_value_location (valtype, &hi, &lo);
@@ -4595,7 +4625,7 @@ mips_eabi_store_return_value (struct type *valtype, char *valbuf)
 static void
 mips_o64_store_return_value (struct type *valtype, char *valbuf)
 {
-  char *raw_buffer = alloca (MAX_REGISTER_RAW_SIZE);
+  char raw_buffer[MAX_REGISTER_SIZE];
   struct return_value_word lo;
   struct return_value_word hi;
   return_value_location (valtype, &hi, &lo);
@@ -4677,7 +4707,7 @@ mips_o32_xfer_return_value (struct type *type,
       /* A struct that contains one or two floats.  Each value is part
          in the least significant part of their floating point
          register..  */
-      bfd_byte *reg = alloca (MAX_REGISTER_RAW_SIZE);
+      bfd_byte reg[MAX_REGISTER_SIZE];
       int regnum;
       int field;
       for (field = 0, regnum = FP0_REGNUM;
@@ -4789,7 +4819,7 @@ mips_n32n64_xfer_return_value (struct type *type,
       /* A struct that contains one or two floats.  Each value is part
          in the least significant part of their floating point
          register..  */
-      bfd_byte *reg = alloca (MAX_REGISTER_RAW_SIZE);
+      bfd_byte reg[MAX_REGISTER_SIZE];
       int regnum;
       int field;
       for (field = 0, regnum = FP0_REGNUM;
@@ -5543,9 +5573,9 @@ mips_gdbarch_init (struct gdbarch_info info,
 
   /* Reset the disassembly info, in case it was set to something
      non-default.  */
-  tm_print_insn_info.flavour = bfd_target_unknown_flavour;
-  tm_print_insn_info.arch = bfd_arch_unknown;
-  tm_print_insn_info.mach = 0;
+  deprecated_tm_print_insn_info.flavour = bfd_target_unknown_flavour;
+  deprecated_tm_print_insn_info.arch = bfd_arch_unknown;
+  deprecated_tm_print_insn_info.mach = 0;
 
   elf_flags = 0;
 
@@ -5626,7 +5656,7 @@ mips_gdbarch_init (struct gdbarch_info info,
   if (wanted_abi != MIPS_ABI_UNKNOWN)
     mips_abi = wanted_abi;
 
-  /* We have to set tm_print_insn_info before looking for a
+  /* We have to set deprecated_tm_print_insn_info before looking for a
      pre-existing architecture, otherwise we may return before we get
      a chance to set it up.  */
   if (mips_abi == MIPS_ABI_N32 || mips_abi == MIPS_ABI_N64)
@@ -5634,17 +5664,17 @@ mips_gdbarch_init (struct gdbarch_info info,
       /* Set up the disassembler info, so that we get the right
 	 register names from libopcodes.  */
       if (mips_abi == MIPS_ABI_N32)
-	tm_print_insn_info.disassembler_options = "gpr-names=n32";
+	deprecated_tm_print_insn_info.disassembler_options = "gpr-names=n32";
       else
-	tm_print_insn_info.disassembler_options = "gpr-names=64";
-      tm_print_insn_info.flavour = bfd_target_elf_flavour;
-      tm_print_insn_info.arch = bfd_arch_mips;
+	deprecated_tm_print_insn_info.disassembler_options = "gpr-names=64";
+      deprecated_tm_print_insn_info.flavour = bfd_target_elf_flavour;
+      deprecated_tm_print_insn_info.arch = bfd_arch_mips;
       if (info.bfd_arch_info != NULL
 	  && info.bfd_arch_info->arch == bfd_arch_mips
 	  && info.bfd_arch_info->mach)
-	tm_print_insn_info.mach = info.bfd_arch_info->mach;
+	deprecated_tm_print_insn_info.mach = info.bfd_arch_info->mach;
       else
-	tm_print_insn_info.mach = bfd_mach_mips8000;
+	deprecated_tm_print_insn_info.mach = bfd_mach_mips8000;
     }
   else
     /* This string is not recognized explicitly by the disassembler,
@@ -5652,7 +5682,7 @@ mips_gdbarch_init (struct gdbarch_info info,
        the bfd elf headers, such that, if the user overrides the ABI
        of a program linked as NewABI, the disassembly will follow the
        register naming conventions specified by the user.  */
-    tm_print_insn_info.disassembler_options = "gpr-names=32";
+    deprecated_tm_print_insn_info.disassembler_options = "gpr-names=32";
 
   if (gdbarch_debug)
     {
@@ -5880,7 +5910,7 @@ mips_gdbarch_init (struct gdbarch_info info,
   set_gdbarch_register_name (gdbarch, mips_register_name);
   set_gdbarch_read_pc (gdbarch, mips_read_pc);
   set_gdbarch_write_pc (gdbarch, generic_target_write_pc);
-  set_gdbarch_read_fp (gdbarch, mips_read_sp); /* Draft FRAME base.  */
+  set_gdbarch_deprecated_target_read_fp (gdbarch, mips_read_sp); /* Draft FRAME base.  */
   set_gdbarch_read_sp (gdbarch, mips_read_sp);
   set_gdbarch_deprecated_dummy_write_sp (gdbarch, generic_target_write_sp);
 
@@ -5908,9 +5938,9 @@ mips_gdbarch_init (struct gdbarch_info info,
   set_gdbarch_call_dummy_address (gdbarch, mips_call_dummy_address);
   set_gdbarch_deprecated_push_return_address (gdbarch, mips_push_return_address);
   set_gdbarch_deprecated_pop_frame (gdbarch, mips_pop_frame);
-  set_gdbarch_fix_call_dummy (gdbarch, mips_fix_call_dummy);
-  set_gdbarch_call_dummy_words (gdbarch, mips_call_dummy_words);
-  set_gdbarch_sizeof_call_dummy_words (gdbarch, sizeof (mips_call_dummy_words));
+  set_gdbarch_deprecated_fix_call_dummy (gdbarch, mips_fix_call_dummy);
+  set_gdbarch_deprecated_call_dummy_words (gdbarch, mips_call_dummy_words);
+  set_gdbarch_deprecated_sizeof_call_dummy_words (gdbarch, sizeof (mips_call_dummy_words));
   set_gdbarch_deprecated_push_return_address (gdbarch, mips_push_return_address);
   set_gdbarch_frame_align (gdbarch, mips_frame_align);
   set_gdbarch_save_dummy_frame_tos (gdbarch, generic_save_dummy_frame_tos);
@@ -6396,8 +6426,8 @@ _initialize_mips_tdep (void)
     internal_error (__FILE__, __LINE__, "mips_abi_strings out of sync");
 
   gdbarch_register (bfd_arch_mips, mips_gdbarch_init, mips_dump_tdep);
-  if (!tm_print_insn)		/* Someone may have already set it */
-    tm_print_insn = gdb_print_insn_mips;
+  if (!deprecated_tm_print_insn)	 /* Someone may have already set it */
+    deprecated_tm_print_insn = gdb_print_insn_mips;
 
   /* Add root prefix command for all "set mips"/"show mips" commands */
   add_prefix_cmd ("mips", no_class, set_mips_command,
diff --git a/gdb/mipsv4-nat.c b/gdb/mipsv4-nat.c
index 2695f1f8dbf..65ffa0dc629 100644
--- a/gdb/mipsv4-nat.c
+++ b/gdb/mipsv4-nat.c
@@ -47,8 +47,8 @@ supply_gregset (gregset_t *gregsetp)
 {
   register int regi;
   register greg_t *regp = &(*gregsetp)[0];
-  char *zerobuf = alloca (max_register_size (current_gdbarch));
-  memset (zerobuf, 0, max_register_size (current_gdbarch));
+  char zerobuf[MAX_REGISTER_SIZE];
+  memset (zerobuf, 0, MAX_REGISTER_SIZE);
 
   for (regi = 0; regi <= CXT_RA; regi++)
     supply_register (regi, (char *) (regp + regi));
@@ -61,7 +61,7 @@ supply_gregset (gregset_t *gregsetp)
   /* Fill inaccessible registers with zero.  */
   supply_register (PS_REGNUM, zerobuf);
   supply_register (BADVADDR_REGNUM, zerobuf);
-  supply_register (FP_REGNUM, zerobuf);
+  supply_register (DEPRECATED_FP_REGNUM, zerobuf);
   supply_register (UNUSED_REGNUM, zerobuf);
   for (regi = FIRST_EMBED_REGNUM; regi <= LAST_EMBED_REGNUM; regi++)
     supply_register (regi, zerobuf);
@@ -102,8 +102,8 @@ void
 supply_fpregset (fpregset_t *fpregsetp)
 {
   register int regi;
-  char *zerobuf = alloca (max_register_size (current_gdbarch));
-  memset (zerobuf, 0, max_register_size (current_gdbarch));
+  char zerobuf[MAX_REGISTER_SIZE];
+  memset (zerobuf, 0, MAX_REGISTER_SIZE);
 
   for (regi = 0; regi < 32; regi++)
     supply_register (FP0_REGNUM + regi,
diff --git a/gdb/mn10300-tdep.c b/gdb/mn10300-tdep.c
index 22f3b67e7f1..1d580342758 100644
--- a/gdb/mn10300-tdep.c
+++ b/gdb/mn10300-tdep.c
@@ -695,7 +695,8 @@ mn10300_frame_chain (struct frame_info *fi)
       /* Our caller has a frame pointer.  So find the frame in $a3 or
          in the stack.  */
       if (get_frame_saved_regs (fi)[A3_REGNUM])
-	return (read_memory_integer (get_frame_saved_regs (fi)[A3_REGNUM], REGISTER_SIZE));
+	return (read_memory_integer (get_frame_saved_regs (fi)[A3_REGNUM],
+				     DEPRECATED_REGISTER_SIZE));
       else
 	return read_register (A3_REGNUM);
     }
@@ -879,7 +880,8 @@ mn10300_frame_saved_pc (struct frame_info *fi)
 {
   int adjust = saved_regs_size (fi);
 
-  return (read_memory_integer (get_frame_base (fi) + adjust, REGISTER_SIZE));
+  return (read_memory_integer (get_frame_base (fi) + adjust,
+			       DEPRECATED_REGISTER_SIZE));
 }
 
 /* Function: mn10300_init_extra_frame_info
@@ -892,9 +894,10 @@ mn10300_frame_saved_pc (struct frame_info *fi)
    always be correct.  mn10300_analyze_prologue will fix fi->frame if
    it's not valid.
 
-   We can be called with the PC in the call dummy under two circumstances.
-   First, during normal backtracing, second, while figuring out the frame
-   pointer just prior to calling the target function (see run_stack_dummy).  */
+   We can be called with the PC in the call dummy under two
+   circumstances.  First, during normal backtracing, second, while
+   figuring out the frame pointer just prior to calling the target
+   function (see call_function_by_hand).  */
 
 static void
 mn10300_init_extra_frame_info (int fromleaf, struct frame_info *fi)
@@ -1007,7 +1010,7 @@ mn10300_dwarf2_reg_to_regnum (int dwarf2)
 static void
 mn10300_print_register (const char *name, int regnum, int reg_width)
 {
-  char *raw_buffer = alloca (MAX_REGISTER_RAW_SIZE);
+  char raw_buffer[MAX_REGISTER_SIZE];
 
   if (reg_width)
     printf_filtered ("%*s: ", reg_width, name);
@@ -1143,9 +1146,8 @@ mn10300_gdbarch_init (struct gdbarch_info info,
   /* Registers.  */
   set_gdbarch_num_regs (gdbarch, num_regs);
   set_gdbarch_register_name (gdbarch, register_name);
-  set_gdbarch_register_size (gdbarch, 4);
-  set_gdbarch_register_bytes (gdbarch, 
-                              num_regs * gdbarch_register_size (gdbarch));
+  set_gdbarch_deprecated_register_size (gdbarch, 4);
+  set_gdbarch_register_bytes (gdbarch, num_regs * gdbarch_deprecated_register_size (gdbarch));
   set_gdbarch_deprecated_max_register_raw_size (gdbarch, 4);
   set_gdbarch_register_raw_size (gdbarch, mn10300_register_raw_size);
   set_gdbarch_register_byte (gdbarch, mn10300_register_byte);
@@ -1156,7 +1158,7 @@ mn10300_gdbarch_init (struct gdbarch_info info,
   set_gdbarch_deprecated_do_registers_info (gdbarch, mn10300_do_registers_info);
   set_gdbarch_sp_regnum (gdbarch, 8);
   set_gdbarch_pc_regnum (gdbarch, 9);
-  set_gdbarch_fp_regnum (gdbarch, 31);
+  set_gdbarch_deprecated_fp_regnum (gdbarch, 31);
   set_gdbarch_virtual_frame_pointer (gdbarch, mn10300_virtual_frame_pointer);
 
   /* Breakpoints.  */
@@ -1182,12 +1184,11 @@ mn10300_gdbarch_init (struct gdbarch_info info,
   set_gdbarch_frame_args_skip (gdbarch, 0);
   set_gdbarch_frame_num_args (gdbarch, frame_num_args_unknown);
   /* That's right, we're using the stack pointer as our frame pointer.  */
-  set_gdbarch_read_fp (gdbarch, generic_target_read_sp);
+  set_gdbarch_deprecated_target_read_fp (gdbarch, generic_target_read_sp);
 
   /* Calling functions in the inferior from GDB.  */
-  set_gdbarch_call_dummy_words (gdbarch, mn10300_call_dummy_words);
-  set_gdbarch_sizeof_call_dummy_words (gdbarch, 
-                                       sizeof (mn10300_call_dummy_words));
+  set_gdbarch_deprecated_call_dummy_words (gdbarch, mn10300_call_dummy_words);
+  set_gdbarch_deprecated_sizeof_call_dummy_words (gdbarch, sizeof (mn10300_call_dummy_words));
   set_gdbarch_deprecated_pc_in_call_dummy (gdbarch, deprecated_pc_in_call_dummy_at_entry_point);
   set_gdbarch_deprecated_push_arguments (gdbarch, mn10300_push_arguments);
   set_gdbarch_reg_struct_has_addr (gdbarch, mn10300_reg_struct_has_addr);
@@ -1208,7 +1209,7 @@ _initialize_mn10300_tdep (void)
 {
 /*  printf("_initialize_mn10300_tdep\n"); */
 
-  tm_print_insn = print_insn_mn10300;
+  deprecated_tm_print_insn = print_insn_mn10300;
 
   register_gdbarch_init (bfd_arch_mn10300, mn10300_gdbarch_init);
 }
diff --git a/gdb/monitor.c b/gdb/monitor.c
index f58ed2aa6ef..ede61bb6998 100644
--- a/gdb/monitor.c
+++ b/gdb/monitor.c
@@ -896,7 +896,7 @@ char *
 monitor_supply_register (int regno, char *valstr)
 {
   ULONGEST val;
-  unsigned char *regbuf = alloca (max_register_size (current_gdbarch));
+  unsigned char regbuf[MAX_REGISTER_SIZE];
   char *p;
 
   val = 0;
@@ -1181,9 +1181,9 @@ monitor_fetch_register (int regno)
   char *regbuf;
   int i;
 
-  regbuf  = alloca (MAX_REGISTER_RAW_SIZE * 2 + 1);
-  zerobuf = alloca (MAX_REGISTER_RAW_SIZE);
-  memset (zerobuf, 0, MAX_REGISTER_RAW_SIZE);
+  regbuf  = alloca (MAX_REGISTER_SIZE * 2 + 1);
+  zerobuf = alloca (MAX_REGISTER_SIZE);
+  memset (zerobuf, 0, MAX_REGISTER_SIZE);
 
   if (current_monitor->regname != NULL)
     name = current_monitor->regname (regno);
diff --git a/gdb/nlm/i386.c b/gdb/nlm/i386.c
index b8ab480b996..8fc6b1dd01b 100644
--- a/gdb/nlm/i386.c
+++ b/gdb/nlm/i386.c
@@ -92,7 +92,7 @@ do_status (char *ptr, struct StackFrame *frame)
   ptr = mem2hex (&frame->ExceptionESP, ptr + 3, 4, 0);
   *ptr++ = ';';
 
-  sprintf (ptr, "%02x:", FP_REGNUM);
+  sprintf (ptr, "%02x:", DEPRECATED_FP_REGNUM);
   ptr = mem2hex (&frame->ExceptionEBP, ptr + 3, 4, 0);
   *ptr++ = ';';
 
diff --git a/gdb/nlm/i386.h b/gdb/nlm/i386.h
index 155702bd503..ff97aed2e49 100644
--- a/gdb/nlm/i386.h
+++ b/gdb/nlm/i386.h
@@ -1,7 +1,7 @@
 /* Register values.  All of these values *MUST* agree with tm.h */
 #define SP_REGNUM 4		/* Contains address of top of stack */
 #define PC_REGNUM 8		/* Contains program counter */
-#define FP_REGNUM 5		/* Virtual frame pointer */
+#define DEPRECATED_FP_REGNUM 5		/* Virtual frame pointer */
 #define NUM_REGS 16		/* Number of machine registers */
 #define REGISTER_BYTES (NUM_REGS * 4) /* Total size of registers array */
 
diff --git a/gdb/ns32k-tdep.c b/gdb/ns32k-tdep.c
index 3a31ddbb8d9..ef2752d0b77 100644
--- a/gdb/ns32k-tdep.c
+++ b/gdb/ns32k-tdep.c
@@ -395,7 +395,7 @@ ns32k_frame_init_saved_regs (struct frame_info *frame)
 
       get_frame_saved_regs (frame)[SP_REGNUM] = get_frame_base (frame) + 4;
       get_frame_saved_regs (frame)[PC_REGNUM] = get_frame_base (frame) + 4;
-      get_frame_saved_regs (frame)[FP_REGNUM] = read_memory_integer (get_frame_base (frame), 4);
+      get_frame_saved_regs (frame)[DEPRECATED_FP_REGNUM] = read_memory_integer (get_frame_base (frame), 4);
     }
   else if (enter_addr == 1)
     {
@@ -412,8 +412,8 @@ ns32k_push_dummy_frame (void)
   int regnum;
 
   sp = push_word (sp, read_register (PC_REGNUM));
-  sp = push_word (sp, read_register (FP_REGNUM));
-  write_register (FP_REGNUM, sp);
+  sp = push_word (sp, read_register (DEPRECATED_FP_REGNUM));
+  write_register (DEPRECATED_FP_REGNUM, sp);
 
   for (regnum = 0; regnum < 8; regnum++)
     sp = push_word (sp, read_register (regnum));
@@ -436,7 +436,7 @@ ns32k_pop_frame (void)
       write_register (regnum,
 		      read_memory_integer (get_frame_saved_regs (frame)[regnum], 4));
 
-  write_register (FP_REGNUM, read_memory_integer (fp, 4));
+  write_register (DEPRECATED_FP_REGNUM, read_memory_integer (fp, 4));
   write_register (PC_REGNUM, read_memory_integer (fp + 4, 4));
   write_register (SP_REGNUM, fp + 8);
   flush_cached_frames ();
@@ -556,7 +556,7 @@ ns32k_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
   set_gdbarch_num_regs (gdbarch, NS32K_PC_REGNUM);
   set_gdbarch_num_regs (gdbarch, NS32K_PS_REGNUM);
 
-  set_gdbarch_register_size (gdbarch, NS32K_REGISTER_SIZE);
+  set_gdbarch_deprecated_register_size (gdbarch, NS32K_REGISTER_SIZE);
   set_gdbarch_register_raw_size (gdbarch, ns32k_register_raw_size);
   set_gdbarch_deprecated_max_register_raw_size (gdbarch, NS32K_MAX_REGISTER_RAW_SIZE);
   set_gdbarch_register_virtual_size (gdbarch, ns32k_register_virtual_size);
@@ -595,11 +595,11 @@ ns32k_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
   set_gdbarch_deprecated_push_dummy_frame (gdbarch, ns32k_push_dummy_frame);
   set_gdbarch_deprecated_pop_frame (gdbarch, ns32k_pop_frame);
   set_gdbarch_call_dummy_location (gdbarch, ON_STACK);
-  set_gdbarch_call_dummy_words (gdbarch, ns32k_call_dummy_words);
-  set_gdbarch_sizeof_call_dummy_words (gdbarch, sizeof_ns32k_call_dummy_words);
-  set_gdbarch_fix_call_dummy (gdbarch, ns32k_fix_call_dummy);
-  set_gdbarch_call_dummy_start_offset (gdbarch, 3);
-  set_gdbarch_call_dummy_breakpoint_offset (gdbarch, 15);
+  set_gdbarch_deprecated_call_dummy_words (gdbarch, ns32k_call_dummy_words);
+  set_gdbarch_deprecated_sizeof_call_dummy_words (gdbarch, sizeof_ns32k_call_dummy_words);
+  set_gdbarch_deprecated_fix_call_dummy (gdbarch, ns32k_fix_call_dummy);
+  set_gdbarch_deprecated_call_dummy_start_offset (gdbarch, 3);
+  set_gdbarch_deprecated_call_dummy_breakpoint_offset (gdbarch, 15);
   set_gdbarch_deprecated_use_generic_dummy_frames (gdbarch, 0);
   set_gdbarch_deprecated_pc_in_call_dummy (gdbarch, deprecated_pc_in_call_dummy_on_stack);
 
@@ -624,5 +624,5 @@ _initialize_ns32k_tdep (void)
 {
   gdbarch_register (bfd_arch_ns32k, ns32k_gdbarch_init, NULL);
 
-  tm_print_insn = print_insn_ns32k;
+  deprecated_tm_print_insn = print_insn_ns32k;
 }
diff --git a/gdb/ns32knbsd-nat.c b/gdb/ns32knbsd-nat.c
index 24e422db661..2fe6d10bb47 100644
--- a/gdb/ns32knbsd-nat.c
+++ b/gdb/ns32knbsd-nat.c
@@ -58,7 +58,7 @@ fetch_inferior_registers (int regno)
   RF (R0_REGNUM + 7, inferior_registers.r_r7);
 
   RF (SP_REGNUM, inferior_registers.r_sp);
-  RF (FP_REGNUM, inferior_registers.r_fp);
+  RF (DEPRECATED_FP_REGNUM, inferior_registers.r_fp);
   RF (PC_REGNUM, inferior_registers.r_pc);
   RF (PS_REGNUM, inferior_registers.r_psr);
 
@@ -90,7 +90,7 @@ store_inferior_registers (int regno)
   RS (R0_REGNUM + 7, inferior_registers.r_r7);
 
   RS (SP_REGNUM, inferior_registers.r_sp);
-  RS (FP_REGNUM, inferior_registers.r_fp);
+  RS (DEPRECATED_FP_REGNUM, inferior_registers.r_fp);
   RS (PC_REGNUM, inferior_registers.r_pc);
   RS (PS_REGNUM, inferior_registers.r_psr);
 
@@ -150,7 +150,7 @@ fetch_core_registers (char *core_reg_sect, unsigned core_reg_size, int which,
   RF (R0_REGNUM + 7, core_reg->intreg.r_r7);
 
   RF (SP_REGNUM, core_reg->intreg.r_sp);
-  RF (FP_REGNUM, core_reg->intreg.r_fp);
+  RF (DEPRECATED_FP_REGNUM, core_reg->intreg.r_fp);
   RF (PC_REGNUM, core_reg->intreg.r_pc);
   RF (PS_REGNUM, core_reg->intreg.r_psr);
 
@@ -223,7 +223,7 @@ fetch_kcore_registers (struct pcb *pcb)
 
   dummy = pcb->pcb_kfp + 8;
   RF (SP_REGNUM, dummy);
-  RF (FP_REGNUM, sf.sf_fp);
+  RF (DEPRECATED_FP_REGNUM, sf.sf_fp);
   RF (PC_REGNUM, sf.sf_pc);
   RF (PS_REGNUM, intreg.r_psr);
 
@@ -258,7 +258,7 @@ clear_regs (void)
   RF (R0_REGNUM + 7, null);
 
   RF (SP_REGNUM, null);
-  RF (FP_REGNUM, null);
+  RF (DEPRECATED_FP_REGNUM, null);
   RF (PC_REGNUM, null);
   RF (PS_REGNUM, null);
 
diff --git a/gdb/nto-tdep.c b/gdb/nto-tdep.c
new file mode 100644
index 00000000000..5003ea069eb
--- /dev/null
+++ b/gdb/nto-tdep.c
@@ -0,0 +1,342 @@
+/* nto-tdep.c - general QNX Neutrino target functionality.
+
+   Copyright 2003 Free Software Foundation, Inc.
+
+   Contributed by QNX Software Systems Ltd.
+
+   This file is part of GDB.
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 59 Temple Place - Suite 330,
+   Boston, MA 02111-1307, USA.  */
+
+#include "gdb_stat.h"
+#include "gdb_string.h"
+#include "nto-tdep.h"
+#include "top.h"
+#include "cli/cli-decode.h"
+#include "cli/cli-cmds.h"
+#include "inferior.h"
+#include "gdbarch.h"
+#include "bfd.h"
+#include "elf-bfd.h"
+#include "solib-svr4.h"
+#include "gdbcore.h"
+
+#ifdef __CYGWIN__
+#include <sys/cygwin.h>
+#endif
+
+#ifdef __CYGWIN__
+static char default_nto_target[] = "C:\\QNXsdk\\target\\qnx6";
+#elif defined(__sun__) || defined(linux)
+static char default_nto_target[] = "/opt/QNXsdk/target/qnx6";
+#else
+static char default_nto_target[] = "";
+#endif
+
+struct nto_target_ops current_nto_target;
+
+static char *
+nto_target (void)
+{
+  char *p = getenv ("QNX_TARGET");
+
+#ifdef __CYGWIN__
+  static char buf[PATH_MAX];
+  if (p)
+    cygwin_conv_to_posix_path (p, buf);
+  else
+    cygwin_conv_to_posix_path (default_nto_target, buf);
+  return buf;
+#else
+  return p ? p : default_nto_target;
+#endif
+}
+
+/* Take a string such as i386, rs6000, etc. and map it onto CPUTYPE_X86,
+   CPUTYPE_PPC, etc. as defined in nto-share/dsmsgs.h.  */
+int
+nto_map_arch_to_cputype (const char *arch)
+{
+  if (!strcmp (arch, "i386") || !strcmp (arch, "x86"))
+    return CPUTYPE_X86;
+  if (!strcmp (arch, "rs6000") || !strcmp (arch, "ppc"))
+    return CPUTYPE_PPC;
+  if (!strcmp (arch, "mips"))
+    return CPUTYPE_MIPS;
+  if (!strcmp (arch, "arm"))
+    return CPUTYPE_ARM;
+  if (!strcmp (arch, "sh"))
+    return CPUTYPE_SH;
+  return CPUTYPE_UNKNOWN;
+}
+
+int
+nto_find_and_open_solib (char *solib, unsigned o_flags, char **temp_pathname)
+{
+  char *buf, arch_path[PATH_MAX], *nto_root, *endian;
+  const char *arch;
+  char *path_fmt = "%s/lib:%s/usr/lib:%s/usr/photon/lib\
+:%s/usr/photon/dll:%s/lib/dll";
+
+  nto_root = nto_target ();
+  if (strcmp (TARGET_ARCHITECTURE->arch_name, "i386") == 0)
+    {
+      arch = "x86";
+      endian = "";
+    }
+  else if (strcmp (TARGET_ARCHITECTURE->arch_name, "rs6000") == 0)
+    {
+      arch = "ppc";
+      endian = "be";
+    }
+  else
+    {
+      arch = TARGET_ARCHITECTURE->arch_name;
+      endian = TARGET_BYTE_ORDER == BFD_ENDIAN_BIG ? "be" : "le";
+    }
+
+  sprintf (arch_path, "%s/%s%s", nto_root, arch, endian);
+
+  buf = alloca (strlen (path_fmt) + strlen (arch_path) * 5 + 1);
+  sprintf (buf, path_fmt, arch_path, arch_path, arch_path, arch_path,
+	   arch_path);
+
+  return openp (buf, 1, solib, o_flags, 0, temp_pathname);
+}
+
+void
+nto_init_solib_absolute_prefix (void)
+{
+  char buf[PATH_MAX * 2], arch_path[PATH_MAX];
+  char *nto_root, *endian;
+  const char *arch;
+
+  nto_root = nto_target ();
+  if (strcmp (TARGET_ARCHITECTURE->arch_name, "i386") == 0)
+    {
+      arch = "x86";
+      endian = "";
+    }
+  else if (strcmp (TARGET_ARCHITECTURE->arch_name, "rs6000") == 0)
+    {
+      arch = "ppc";
+      endian = "be";
+    }
+  else
+    {
+      arch = TARGET_ARCHITECTURE->arch_name;
+      endian = TARGET_BYTE_ORDER == BFD_ENDIAN_BIG ? "be" : "le";
+    }
+
+  sprintf (arch_path, "%s/%s%s", nto_root, arch, endian);
+
+  sprintf (buf, "set solib-absolute-prefix %s", arch_path);
+  execute_command (buf, 0);
+}
+
+char **
+nto_parse_redirection (char *pargv[], char **pin, char **pout, char **perr)
+{
+  char **argv;
+  char *in, *out, *err, *p;
+  int argc, i, n;
+
+  for (n = 0; pargv[n]; n++);
+  if (n == 0)
+    return NULL;
+  in = "";
+  out = "";
+  err = "";
+
+  argv = xcalloc (n + 1, sizeof argv[0]);
+  argc = n;
+  for (i = 0, n = 0; n < argc; n++)
+    {
+      p = pargv[n];
+      if (*p == '>')
+	{
+	  p++;
+	  if (*p)
+	    out = p;
+	  else
+	    out = pargv[++n];
+	}
+      else if (*p == '<')
+	{
+	  p++;
+	  if (*p)
+	    in = p;
+	  else
+	    in = pargv[++n];
+	}
+      else if (*p++ == '2' && *p++ == '>')
+	{
+	  if (*p == '&' && *(p + 1) == '1')
+	    err = out;
+	  else if (*p)
+	    err = p;
+	  else
+	    err = pargv[++n];
+	}
+      else
+	argv[i++] = pargv[n];
+    }
+  *pin = in;
+  *pout = out;
+  *perr = err;
+  return argv;
+}
+
+/* The struct lm_info, LM_ADDR, and nto_truncate_ptr are copied from
+   solib-svr4.c to support nto_relocate_section_addresses
+   which is different from the svr4 version.  */
+
+struct lm_info
+{
+  /* Pointer to copy of link map from inferior.  The type is char *
+     rather than void *, so that we may use byte offsets to find the
+     various fields without the need for a cast.  */
+  char *lm;
+};
+
+static CORE_ADDR
+LM_ADDR (struct so_list *so)
+{
+  struct link_map_offsets *lmo = nto_fetch_link_map_offsets ();
+
+  return (CORE_ADDR) extract_signed_integer (so->lm_info->lm +
+					     lmo->l_addr_offset,
+					     lmo->l_addr_size);
+}
+
+static CORE_ADDR
+nto_truncate_ptr (CORE_ADDR addr)
+{
+  if (TARGET_PTR_BIT == sizeof (CORE_ADDR) * 8)
+    /* We don't need to truncate anything, and the bit twiddling below
+       will fail due to overflow problems.  */
+    return addr;
+  else
+    return addr & (((CORE_ADDR) 1 << TARGET_PTR_BIT) - 1);
+}
+
+Elf_Internal_Phdr *
+find_load_phdr (bfd *abfd)
+{
+  Elf_Internal_Phdr *phdr;
+  unsigned int i;
+
+  if (!elf_tdata (abfd))
+    return NULL;
+
+  phdr = elf_tdata (abfd)->phdr;
+  for (i = 0; i < elf_elfheader (abfd)->e_phnum; i++, phdr++)
+    {
+      if (phdr->p_type == PT_LOAD && (phdr->p_flags & PF_X))
+	return phdr;
+    }
+  return NULL;
+}
+
+void
+nto_relocate_section_addresses (struct so_list *so, struct section_table *sec)
+{
+  /* Neutrino treats the l_addr base address field in link.h as different than
+     the base address in the System V ABI and so the offset needs to be
+     calculated and applied to relocations.  */
+  Elf_Internal_Phdr *phdr = find_load_phdr (sec->bfd);
+  unsigned vaddr = phdr ? phdr->p_vaddr : 0;
+
+  sec->addr = nto_truncate_ptr (sec->addr + LM_ADDR (so) - vaddr);
+  sec->endaddr = nto_truncate_ptr (sec->endaddr + LM_ADDR (so) - vaddr);
+}
+
+static void
+fetch_core_registers (char *core_reg_sect, unsigned core_reg_size,
+		      int which, CORE_ADDR reg_addr)
+{
+  nto_regset_t regset;
+
+  nto_init_solib_absolute_prefix ();
+
+  if (which == NTO_REG_GENERAL)
+    {
+      memcpy ((char *) &regset, core_reg_sect,
+	      min (core_reg_size, sizeof (regset)));
+      nto_supply_gregset ((char *) &regset);
+    }
+  else if (which == NTO_REG_FLOAT)
+    {
+      memcpy ((char *) &regset, core_reg_sect,
+	      min (core_reg_size, sizeof (regset)));
+      nto_supply_fpregset ((char *) &regset);
+    }
+  else if (which == NTO_REG_ALT)
+    {
+      memcpy ((char *) &regset, core_reg_sect,
+	      min (core_reg_size, sizeof (regset)));
+      nto_supply_altregset ((char *) &regset);
+    }
+}
+
+void
+nto_dummy_supply_regset (char *regs)
+{
+  /* Do nothing.  */
+}
+
+/* Register that we are able to handle ELF file formats using standard
+   procfs "regset" structures.  */
+static struct core_fns regset_core_fns = {
+  bfd_target_elf_flavour,	/* core_flavour */
+  default_check_format,		/* check_format */
+  default_core_sniffer,		/* core_sniffer */
+  fetch_core_registers,		/* core_read_registers */
+  NULL				/* next */
+};
+
+void
+_initialize_nto_tdep (void)
+{
+  add_setshow_cmd ("nto-debug", class_maintenance, var_zinteger,
+		  &nto_internal_debugging, "Set QNX NTO internal debugging.\n\
+When non-zero, nto specific debug info is\n\
+displayed. Different information is displayed\n\
+for different positive values.",  "Show QNX NTO internal debugging.\n",
+		  NULL, NULL, &setdebuglist, &showdebuglist);
+
+  /* We use SIG45 for pulses, or something, so nostop, noprint
+     and pass them.  */
+  signal_stop_update (target_signal_from_name ("SIG45"), 0);
+  signal_print_update (target_signal_from_name ("SIG45"), 0);
+  signal_pass_update (target_signal_from_name ("SIG45"), 1);
+
+  /* By default we don't want to stop on these two, but we do want to pass.  */
+#if defined(SIGSELECT)
+  signal_stop_update (SIGSELECT, 0);
+  signal_print_update (SIGSELECT, 0);
+  signal_pass_update (SIGSELECT, 1);
+#endif
+
+#if defined(SIGPHOTON)
+  signal_stop_update (SIGPHOTON, 0);
+  signal_print_update (SIGPHOTON, 0);
+  signal_pass_update (SIGPHOTON, 1);
+#endif
+
+  /* Register core file support.  */
+  add_core_fns (&regset_core_fns);
+}
diff --git a/gdb/nto-tdep.h b/gdb/nto-tdep.h
new file mode 100644
index 00000000000..e22e8fd525c
--- /dev/null
+++ b/gdb/nto-tdep.h
@@ -0,0 +1,156 @@
+/* nto-tdep.h - QNX Neutrino target header.
+
+   Copyright 2003 Free Software Foundation, Inc.
+
+   Contributed by QNX Software Systems Ltd.
+
+   This file is part of GDB.
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 59 Temple Place - Suite 330,
+   Boston, MA 02111-1307, USA.  */
+
+#ifndef _NTO_TDEP_H
+#define _NTO_TDEP_H
+
+#include "defs.h"
+#include "solist.h"
+
+/* Generic functions in nto-tdep.c.  */
+
+extern void nto_init_solib_absolute_prefix (void);
+
+char **nto_parse_redirection (char *start_argv[], char **in,
+			      char **out, char **err);
+
+int proc_iterate_over_mappings (int (*func) (int, CORE_ADDR));
+
+void nto_relocate_section_addresses (struct so_list *, struct section_table *);
+
+int nto_map_arch_to_cputype (const char *);
+
+int nto_find_and_open_solib (char *, unsigned, char **);
+
+/* Dummy function for initializing nto_target_ops on targets which do
+   not define a particular regset.  */
+void nto_dummy_supply_regset (char *regs);
+
+/* Target operations defined for Neutrino targets (<target>-nto-tdep.c).  */
+
+struct nto_target_ops
+{
+  int nto_internal_debugging;
+  unsigned nto_cpuinfo_flags;
+  int nto_cpuinfo_valid;
+
+  int (*nto_regset_id) (int);
+  void (*nto_supply_gregset) (char *);
+  void (*nto_supply_fpregset) (char *);
+  void (*nto_supply_altregset) (char *);
+  void (*nto_supply_regset) (int, char *);
+  int (*nto_register_area) (int, int, unsigned *);
+  int (*nto_regset_fill) (int, char *);
+  struct link_map_offsets *(*nto_fetch_link_map_offsets) (void);
+};
+
+extern struct nto_target_ops current_nto_target;
+
+/* For 'maintenance debug nto-debug' command.  */
+#define nto_internal_debugging \
+	(current_nto_target.nto_internal_debugging)
+
+/* The CPUINFO flags from the remote.  Currently used by
+   i386 for fxsave but future proofing other hosts.
+   This is initialized in procfs_attach or nto_start_remote
+   depending on our host/target.  It would only be invalid
+   if we were talking to an older pdebug which didn't support
+   the cpuinfo message.  */
+#define nto_cpuinfo_flags \
+	(current_nto_target.nto_cpuinfo_flags)
+
+/* True if successfully retrieved cpuinfo from remote.  */
+#define nto_cpuinfo_valid \
+	(current_nto_target.nto_cpuinfo_valid)
+
+/* Given a register, return an id that represents the Neutrino
+   regset it came from.  If reg == -1 update all regsets.  */
+#define nto_regset_id(reg) \
+	(*current_nto_target.nto_regset_id) (reg)
+
+#define nto_supply_gregset(regs) \
+	(*current_nto_target.nto_supply_gregset) (regs)
+
+#define nto_supply_fpregset(regs) \
+	(*current_nto_target.nto_supply_fpregset) (regs)
+
+#define nto_supply_altregset(regs) \
+	(*current_nto_target.nto_supply_altregset) (regs)
+
+/* Given a regset, tell gdb about registers stored in data.  */
+#define nto_supply_regset(regset, data) \
+	(*current_nto_target.nto_supply_regset) (regset, data)
+
+/* Given a register and regset, calculate the offset into the regset
+   and stuff it into the last argument.  If regno is -1, calculate the
+   size of the entire regset.  Returns length of data, -1 if unknown
+   regset, 0 if unknown register.  */
+#define nto_register_area(reg, regset, off) \
+	(*current_nto_target.nto_register_area) (reg, regset, off)
+
+/* Build the Neutrino register set info into the data buffer.  
+   Return -1 if unknown regset, 0 otherwise.  */
+#define nto_regset_fill(regset, data) \
+	(*current_nto_target.nto_regset_fill) (regset, data)
+
+/* Gives the fetch_link_map_offsets function exposure outside of
+   solib-svr4.c so that we can override relocate_section_addresses().  */
+#define nto_fetch_link_map_offsets() \
+	(*current_nto_target.nto_fetch_link_map_offsets) ()
+
+/* Keep this consistant with neutrino syspage.h.  */
+enum
+{
+  CPUTYPE_X86,
+  CPUTYPE_PPC,
+  CPUTYPE_MIPS,
+  CPUTYPE_SPARE,
+  CPUTYPE_ARM,
+  CPUTYPE_SH,
+  CPUTYPE_UNKNOWN
+};
+
+enum
+{
+  OSTYPE_QNX4,
+  OSTYPE_NTO
+};
+
+/* These correspond to the DSMSG_* versions in dsmsgs.h. */
+enum
+{
+  NTO_REG_GENERAL,
+  NTO_REG_FLOAT,
+  NTO_REG_SYSTEM,
+  NTO_REG_ALT,
+  NTO_REG_END
+};
+
+typedef char qnx_reg64[8];
+
+typedef struct _debug_regs
+{
+  qnx_reg64 padding[1024];
+} nto_regset_t;
+
+#endif
diff --git a/gdb/objc-lang.c b/gdb/objc-lang.c
index bc937ca7ea0..368e3366e0e 100644
--- a/gdb/objc-lang.c
+++ b/gdb/objc-lang.c
@@ -42,6 +42,8 @@
 #include "gdb_regex.h"
 #include "regcache.h"
 #include "block.h"
+#include "infcall.h"
+#include "valprint.h"
 
 #include <ctype.h>
 
@@ -1751,6 +1753,19 @@ _initialize_objc_language (void)
   add_com_alias ("po", "print-object", class_vars, 1);
 }
 
+#if 1
+/* Disable these functions until we put them in the gdbarch vector.  */
+static unsigned long FETCH_ARGUMENT (int i)
+{
+  internal_error (__FILE__, __LINE__, "FETCH_ARGUMENT not implemented");
+  return 0;
+}
+static CORE_ADDR CONVERT_FUNCPTR (CORE_ADDR pc)
+{
+  internal_error (__FILE__, __LINE__, "CONVERT_FUNCPTR not implemented");
+  return pc;
+}
+#else
 #if defined (__powerpc__) || defined (__ppc__)
 static unsigned long FETCH_ARGUMENT (int i)
 {
@@ -1790,6 +1805,7 @@ static CORE_ADDR CONVERT_FUNCPTR (CORE_ADDR pc)
   return pc;
 }
 #endif
+#endif
 
 static void 
 read_objc_method (CORE_ADDR addr, struct objc_method *method)
diff --git a/gdb/objfiles.c b/gdb/objfiles.c
index 32a57fab2ff..59e03b93e9b 100644
--- a/gdb/objfiles.c
+++ b/gdb/objfiles.c
@@ -325,7 +325,7 @@ allocate_objfile (bfd *abfd, int flags)
     }
   else
     {
-      objfile->name = "<<anonymous objfile>>";
+      objfile->name = mstrsave (objfile->md, "<<anonymous objfile>>");
     }
 
   /* Initialize the section indexes for this objfile, so that we can
diff --git a/gdb/ppc-linux-nat.c b/gdb/ppc-linux-nat.c
index 4561e4d648d..20c8adda44a 100644
--- a/gdb/ppc-linux-nat.c
+++ b/gdb/ppc-linux-nat.c
@@ -204,7 +204,7 @@ fetch_register (int tid, int regno)
   char mess[128];              /* For messages */
   register int i;
   unsigned int offset;         /* Offset of registers within the u area. */
-  char *buf = alloca (MAX_REGISTER_RAW_SIZE);
+  char buf[MAX_REGISTER_SIZE];
   CORE_ADDR regaddr = ppc_register_u_addr (regno);
 
   if (altivec_register_p (regno))
@@ -364,7 +364,7 @@ store_register (int tid, int regno)
   char mess[128];              /* For messages */
   register int i;
   unsigned int offset;         /* Offset of registers within the u area.  */
-  char *buf = alloca (MAX_REGISTER_RAW_SIZE);
+  char buf[MAX_REGISTER_SIZE];
 
   if (altivec_register_p (regno))
     {
diff --git a/gdb/printcmd.c b/gdb/printcmd.c
index ae87bd7fd43..018d7731548 100644
--- a/gdb/printcmd.c
+++ b/gdb/printcmd.c
@@ -42,6 +42,7 @@
 #include "ui-out.h"
 #include "gdb_assert.h"
 #include "block.h"
+#include "disasm.h"
 
 extern int asm_demangle;	/* Whether to demangle syms in asm printouts */
 extern int addressprint;	/* Whether to print hex addresses in HLL " */
@@ -175,8 +176,6 @@ static void print_formatted (struct value *, int, int, struct ui_file *);
 
 static struct format_data decode_format (char **, int, int);
 
-static int print_insn (CORE_ADDR, struct ui_file *);
-
 static void sym_info (char *, int);
 
 
@@ -310,7 +309,7 @@ print_formatted (struct value *val, register int format, int size,
       /* We often wrap here if there are long symbolic names.  */
       wrap_here ("    ");
       next_address = VALUE_ADDRESS (val)
-	+ print_insn (VALUE_ADDRESS (val), stream);
+	+ gdb_print_insn (VALUE_ADDRESS (val), stream);
       next_section = VALUE_BFD_SECTION (val);
       break;
 
@@ -2240,27 +2239,6 @@ printf_command (char *arg, int from_tty)
   do_cleanups (old_cleanups);
 }
 
-/* Print the instruction at address MEMADDR in debugged memory,
-   on STREAM.  Returns length of the instruction, in bytes.  */
-
-static int
-print_insn (CORE_ADDR memaddr, struct ui_file *stream)
-{
-  if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG)
-    TARGET_PRINT_INSN_INFO->endian = BFD_ENDIAN_BIG;
-  else
-    TARGET_PRINT_INSN_INFO->endian = BFD_ENDIAN_LITTLE;
-
-  if (TARGET_ARCHITECTURE != NULL)
-    TARGET_PRINT_INSN_INFO->mach = TARGET_ARCHITECTURE->mach;
-  /* else: should set .mach=0 but some disassemblers don't grok this */
-
-  TARGET_PRINT_INSN_INFO->stream = stream;
-
-  return TARGET_PRINT_INSN (memaddr, TARGET_PRINT_INSN_INFO);
-}
-
-
 void
 _initialize_printcmd (void)
 {
diff --git a/gdb/procfs.c b/gdb/procfs.c
index 2f14c5d2402..96cdaa9a37d 100644
--- a/gdb/procfs.c
+++ b/gdb/procfs.c
@@ -3706,7 +3706,7 @@ procfs_fetch_registers (int regno)
       if ((regno >= 0 && regno < FP0_REGNUM) ||
 	  regno == PC_REGNUM  ||
 	  (NPC_REGNUM >= 0 && regno == NPC_REGNUM) ||
-	  regno == FP_REGNUM  ||
+	  regno == DEPRECATED_FP_REGNUM  ||
 	  regno == SP_REGNUM)
 	return;			/* not a floating point register */
 
@@ -3780,7 +3780,7 @@ procfs_store_registers (int regno)
       if ((regno >= 0 && regno < FP0_REGNUM) ||
 	  regno == PC_REGNUM  ||
 	  (NPC_REGNUM >= 0 && regno == NPC_REGNUM) ||
-	  regno == FP_REGNUM  ||
+	  regno == DEPRECATED_FP_REGNUM  ||
 	  regno == SP_REGNUM)
 	return;			/* not a floating point register */
 
diff --git a/gdb/regcache.c b/gdb/regcache.c
index 70af06f2fab..acf3044fa3c 100644
--- a/gdb/regcache.c
+++ b/gdb/regcache.c
@@ -78,9 +78,6 @@ struct regcache_descr
   long *register_offset;
   long *sizeof_register;
 
-  /* Useful constant.  Largest of all the registers.  */
-  long max_register_size;
-
   /* Cached table containing the type of each register.  */
   struct type **register_type;
 };
@@ -109,7 +106,6 @@ init_legacy_regcache_descr (struct gdbarch *gdbarch,
      read_register_bytes() and write_register_bytes() registers.  */
   descr->sizeof_register = XCALLOC (descr->nr_cooked_registers, long);
   descr->register_offset = XCALLOC (descr->nr_cooked_registers, long);
-  descr->max_register_size = 0;
   for (i = 0; i < descr->nr_cooked_registers; i++)
     {
       /* FIXME: cagney/2001-12-04: This code shouldn't need to use
@@ -119,10 +115,8 @@ init_legacy_regcache_descr (struct gdbarch *gdbarch,
          entirely avoid this uglyness.  */
       descr->register_offset[i] = REGISTER_BYTE (i);
       descr->sizeof_register[i] = REGISTER_RAW_SIZE (i);
-      if (descr->max_register_size < REGISTER_RAW_SIZE (i))
-	descr->max_register_size = REGISTER_RAW_SIZE (i);
-      if (descr->max_register_size < REGISTER_VIRTUAL_SIZE (i))
-	descr->max_register_size = REGISTER_VIRTUAL_SIZE (i);
+      gdb_assert (MAX_REGISTER_SIZE >= REGISTER_RAW_SIZE (i));
+      gdb_assert (MAX_REGISTER_SIZE >= REGISTER_VIRTUAL_SIZE (i));
     }
 
   /* Compute the real size of the register buffer.  Start out by
@@ -187,6 +181,12 @@ init_regcache_descr (struct gdbarch *gdbarch)
       && !gdbarch_pseudo_register_write_p (gdbarch)
       && !gdbarch_register_type_p (gdbarch))
     {
+      /* NOTE: cagney/2003-05-02: Don't add a test for REGISTER_BYTE_P
+	 to the above.  Doing that would cause all the existing
+	 architectures to revert back to the legacy regcache
+	 mechanisms, and that is not a good thing.  Instead just,
+	 later, check that the register cache's layout is consistent
+	 with REGISTER_BYTE.  */
       descr->legacy_p = 1;
       init_legacy_regcache_descr (gdbarch, descr);
       return descr;
@@ -213,14 +213,12 @@ init_regcache_descr (struct gdbarch *gdbarch)
     long offset = 0;
     descr->sizeof_register = XCALLOC (descr->nr_cooked_registers, long);
     descr->register_offset = XCALLOC (descr->nr_cooked_registers, long);
-    descr->max_register_size = 0;
     for (i = 0; i < descr->nr_cooked_registers; i++)
       {
 	descr->sizeof_register[i] = TYPE_LENGTH (descr->register_type[i]);
 	descr->register_offset[i] = offset;
 	offset += descr->sizeof_register[i];
-	if (descr->max_register_size < descr->sizeof_register[i])
-	  descr->max_register_size = descr->sizeof_register[i];
+	gdb_assert (MAX_REGISTER_SIZE >= descr->sizeof_register[i]);
       }
     /* Set the real size of the register cache buffer.  */
     descr->sizeof_cooked_registers = offset;
@@ -233,21 +231,19 @@ init_regcache_descr (struct gdbarch *gdbarch)
      buffer.  Ulgh!  */
   descr->sizeof_raw_registers = descr->sizeof_cooked_registers;
 
-#if 0
-  /* Sanity check.  Confirm that the assumptions about gdbarch are
-     true.  The REGCACHE_DESCR_HANDLE is set before doing the checks
-     so that targets using the generic methods supplied by regcache
-     don't go into infinite recursion trying to, again, create the
-     regcache.  */
-  set_gdbarch_data (gdbarch, regcache_descr_handle, descr);
+  /* Sanity check.  Confirm that there is agreement between the
+     regcache and the target's redundant REGISTER_BYTE (new targets
+     should not even be defining it).  */
   for (i = 0; i < descr->nr_cooked_registers; i++)
     {
+      if (REGISTER_BYTE_P ())
+	gdb_assert (descr->register_offset[i] == REGISTER_BYTE (i));
+#if 0
       gdb_assert (descr->sizeof_register[i] == REGISTER_RAW_SIZE (i));
       gdb_assert (descr->sizeof_register[i] == REGISTER_VIRTUAL_SIZE (i));
-      gdb_assert (descr->register_offset[i] == REGISTER_BYTE (i));
+#endif
     }
   /* gdb_assert (descr->sizeof_raw_registers == REGISTER_BYTES (i));  */
-#endif
 
   return descr;
 }
@@ -286,31 +282,6 @@ register_type (struct gdbarch *gdbarch, int regnum)
    the regcache descr.  */
 
 int
-max_register_size (struct gdbarch *gdbarch)
-{
-  struct regcache_descr *descr = regcache_descr (gdbarch);
-  return descr->max_register_size;
-}
-
-int
-legacy_max_register_raw_size (void)
-{
-  if (DEPRECATED_MAX_REGISTER_RAW_SIZE_P ())
-    return DEPRECATED_MAX_REGISTER_RAW_SIZE;
-  else
-    return max_register_size (current_gdbarch);
-}
-
-int
-legacy_max_register_virtual_size (void)
-{
-  if (DEPRECATED_MAX_REGISTER_VIRTUAL_SIZE_P ())
-    return DEPRECATED_MAX_REGISTER_VIRTUAL_SIZE;
-  else
-    return max_register_size (current_gdbarch);
-}
-
-int
 register_size (struct gdbarch *gdbarch, int regnum)
 {
   struct regcache_descr *descr = regcache_descr (gdbarch);
@@ -393,7 +364,7 @@ regcache_save (struct regcache *dst, regcache_cooked_read_ftype *cooked_read,
 	       void *src)
 {
   struct gdbarch *gdbarch = dst->descr->gdbarch;
-  void *buf = alloca (max_register_size (gdbarch));
+  char buf[MAX_REGISTER_SIZE];
   int regnum;
   /* The DST should be `read-only', if it wasn't then the save would
      end up trying to write the register values back out to the
@@ -427,7 +398,7 @@ regcache_restore (struct regcache *dst,
 		  void *src)
 {
   struct gdbarch *gdbarch = dst->descr->gdbarch;
-  void *buf = alloca (max_register_size (gdbarch));
+  char buf[MAX_REGISTER_SIZE];
   int regnum;
   /* The dst had better not be read-only.  If it is, the `restore'
      doesn't make much sense.  */
@@ -681,7 +652,7 @@ deprecated_read_register_bytes (int in_start, char *in_buf, int in_len)
 {
   int in_end = in_start + in_len;
   int regnum;
-  char *reg_buf = alloca (MAX_REGISTER_RAW_SIZE);
+  char reg_buf[MAX_REGISTER_SIZE];
 
   /* See if we are trying to read bytes from out-of-date registers.  If so,
      update just those registers.  */
@@ -1071,7 +1042,7 @@ deprecated_write_register_bytes (int myregstart, char *myaddr, int inlen)
       /* The register partially overlaps the range being written.  */
       else
 	{
-	  char *regbuf = (char*) alloca (MAX_REGISTER_RAW_SIZE);
+	  char regbuf[MAX_REGISTER_SIZE];
 	  /* What's the overlap between this register's bytes and
              those the caller wants to write?  */
 	  int overlapstart = max (regstart, myregstart);
@@ -1104,7 +1075,7 @@ regcache_xfer_part (struct regcache *regcache, int regnum,
 		    regcache_read_ftype *read, regcache_write_ftype *write)
 {
   struct regcache_descr *descr = regcache->descr;
-  bfd_byte *reg = alloca (descr->max_register_size);
+  bfd_byte reg[MAX_REGISTER_SIZE];
   gdb_assert (offset >= 0 && offset <= descr->sizeof_register[regnum]);
   gdb_assert (len >= 0 && offset + len <= descr->sizeof_register[regnum]);
   /* Something to do?  */
@@ -1213,36 +1184,6 @@ read_register_pid (int regnum, ptid_t ptid)
   return retval;
 }
 
-/* Return the contents of register REGNUM as a signed integer.  */
-
-LONGEST
-read_signed_register (int regnum)
-{
-  void *buf = alloca (REGISTER_RAW_SIZE (regnum));
-  deprecated_read_register_gen (regnum, buf);
-  return (extract_signed_integer (buf, REGISTER_RAW_SIZE (regnum)));
-}
-
-LONGEST
-read_signed_register_pid (int regnum, ptid_t ptid)
-{
-  ptid_t save_ptid;
-  LONGEST retval;
-
-  if (ptid_equal (ptid, inferior_ptid))
-    return read_signed_register (regnum);
-
-  save_ptid = inferior_ptid;
-
-  inferior_ptid = ptid;
-
-  retval = read_signed_register (regnum);
-
-  inferior_ptid = save_ptid;
-
-  return retval;
-}
-
 /* Store VALUE into the raw contents of register number REGNUM.  */
 
 void
@@ -1328,16 +1269,16 @@ regcache_collect (int regnum, void *buf)
 }
 
 
-/* read_pc, write_pc, read_sp, read_fp, etc.  Special handling for
-   registers PC, SP, and FP.  */
+/* read_pc, write_pc, read_sp, deprecated_read_fp, etc.  Special
+   handling for registers PC, SP, and FP.  */
 
 /* NOTE: cagney/2001-02-18: The functions generic_target_read_pc(),
    read_pc_pid(), read_pc(), generic_target_write_pc(),
    write_pc_pid(), write_pc(), generic_target_read_sp(), read_sp(),
-   generic_target_write_sp(), generic_target_read_fp() and read_fp(),
-   will eventually be moved out of the reg-cache into either
-   frame.[hc] or to the multi-arch framework.  The are not part of the
-   raw register cache.  */
+   generic_target_write_sp(), and deprecated_read_fp(), will
+   eventually be moved out of the reg-cache into either frame.[hc] or
+   to the multi-arch framework.  The are not part of the raw register
+   cache.  */
 
 /* This routine is getting awfully cluttered with #if's.  It's probably
    time to turn this into READ_PC and define it in the tm.h file.
@@ -1457,20 +1398,14 @@ generic_target_write_sp (CORE_ADDR val)
 }
 
 CORE_ADDR
-generic_target_read_fp (void)
+deprecated_read_fp (void)
 {
-#ifdef FP_REGNUM
-  if (FP_REGNUM >= 0)
-    return read_register (FP_REGNUM);
-#endif
-  internal_error (__FILE__, __LINE__,
-		  "generic_target_read_fp");
-}
-
-CORE_ADDR
-read_fp (void)
-{
-  return TARGET_READ_FP ();
+  if (DEPRECATED_TARGET_READ_FP_P ())
+    return DEPRECATED_TARGET_READ_FP ();
+  else if (DEPRECATED_FP_REGNUM >= 0)
+    return read_register (DEPRECATED_FP_REGNUM);
+  else
+    internal_error (__FILE__, __LINE__, "deprecated_read_fp");
 }
 
 /* ARGSUSED */
@@ -1530,7 +1465,7 @@ regcache_dump (struct regcache *regcache, struct ui_file *file,
   int footnote_register_offset = 0;
   int footnote_register_type_name_null = 0;
   long register_offset = 0;
-  unsigned char *buf = alloca (regcache->descr->max_register_size);
+  unsigned char buf[MAX_REGISTER_SIZE];
 
 #if 0
   fprintf_unfiltered (file, "legacy_p %d\n", regcache->descr->legacy_p);
@@ -1542,8 +1477,6 @@ regcache_dump (struct regcache *regcache, struct ui_file *file,
 		      regcache->descr->sizeof_raw_registers);
   fprintf_unfiltered (file, "sizeof_raw_register_valid_p %ld\n",
 		      regcache->descr->sizeof_raw_register_valid_p);
-  fprintf_unfiltered (file, "max_register_size %ld\n",
-		      regcache->descr->max_register_size);
   fprintf_unfiltered (file, "NUM_REGS %d\n", NUM_REGS);
   fprintf_unfiltered (file, "NUM_PSEUDO_REGS %d\n", NUM_PSEUDO_REGS);
 #endif
diff --git a/gdb/regcache.h b/gdb/regcache.h
index 3fb43c437a4..5d77095810b 100644
--- a/gdb/regcache.h
+++ b/gdb/regcache.h
@@ -127,12 +127,6 @@ extern int register_offset_hack (struct gdbarch *gdbarch, int regnum);
 extern struct type *register_type (struct gdbarch *gdbarch, int regnum);
 
 
-/* Return the size of the largest register.  Used when allocating
-   space for an aribtrary register value.  */
-
-extern int max_register_size (struct gdbarch *gdbarch);
-
-
 /* Return the size of register REGNUM.  All registers should have only
    one size.
 
@@ -247,10 +241,6 @@ extern ULONGEST read_register (int regnum);
 /* Rename to read_unsigned_register_pid()? */
 extern ULONGEST read_register_pid (int regnum, ptid_t ptid);
 
-extern LONGEST read_signed_register (int regnum);
-
-extern LONGEST read_signed_register_pid (int regnum, ptid_t ptid);
-
 extern void write_register (int regnum, LONGEST val);
 
 extern void write_register_pid (int regnum, CORE_ADDR val, ptid_t ptid);
diff --git a/gdb/remote-array.c b/gdb/remote-array.c
index da9bfc70e68..8df964771a2 100644
--- a/gdb/remote-array.c
+++ b/gdb/remote-array.c
@@ -731,7 +731,7 @@ array_wait (ptid_t ptid, struct target_waitstatus *status)
 static void
 array_fetch_registers (int ignored)
 {
-  char *reg = alloca (MAX_REGISTER_RAW_SIZE);
+  char reg[MAX_REGISTER_SIZE];
   int regno;
   char *p;
   char *packet = alloca (PBUFSIZ);
diff --git a/gdb/remote-e7000.c b/gdb/remote-e7000.c
index 49c7fb99ae8..643c6b6fe1b 100644
--- a/gdb/remote-e7000.c
+++ b/gdb/remote-e7000.c
@@ -785,7 +785,7 @@ void
 fetch_regs_from_dump (int (*nextchar) (), char *want)
 {
   int regno;
-  char *buf = alloca (max_register_size (current_gdbarch));
+  char buf[MAX_REGISTER_SIZE];
 
   int thischar = nextchar ();
 
@@ -856,9 +856,9 @@ fetch_regs_from_dump (int (*nextchar) (), char *want)
 	      want++;
 	      break;
 #endif
-#ifdef FP_REGNUM
+#ifdef DEPRECATED_FP_REGNUM
 	    case 'f':
-	      regno = FP_REGNUM;
+	      regno = DEPRECATED_FP_REGNUM;
 	      want++;
 	      break;
 #endif
diff --git a/gdb/remote-mips.c b/gdb/remote-mips.c
index a23f72d4606..d1e3705a4c8 100644
--- a/gdb/remote-mips.c
+++ b/gdb/remote-mips.c
@@ -1791,7 +1791,7 @@ mips_wait (ptid_t ptid, struct target_waitstatus *status)
 		    &rpc, &rfp, &rsp, flags);
   if (nfields >= 3)
     {
-      char *buf = alloca (max_register_size (current_gdbarch));
+      char buf[MAX_REGISTER_SIZE];
 
       store_unsigned_integer (buf, REGISTER_RAW_SIZE (PC_REGNUM), rpc);
       supply_register (PC_REGNUM, buf);
@@ -1802,8 +1802,8 @@ mips_wait (ptid_t ptid, struct target_waitstatus *status)
       store_unsigned_integer (buf, REGISTER_RAW_SIZE (SP_REGNUM), rsp);
       supply_register (SP_REGNUM, buf);
 
-      store_unsigned_integer (buf, REGISTER_RAW_SIZE (FP_REGNUM), 0);
-      supply_register (FP_REGNUM, buf);
+      store_unsigned_integer (buf, REGISTER_RAW_SIZE (DEPRECATED_FP_REGNUM), 0);
+      supply_register (DEPRECATED_FP_REGNUM, buf);
 
       if (nfields == 9)
 	{
@@ -1943,9 +1943,9 @@ mips_fetch_registers (int regno)
       return;
     }
 
-  if (regno == FP_REGNUM || regno == ZERO_REGNUM)
-    /* FP_REGNUM on the mips is a hack which is just supposed to read
-       zero (see also mips-nat.c).  */
+  if (regno == DEPRECATED_FP_REGNUM || regno == ZERO_REGNUM)
+    /* DEPRECATED_FP_REGNUM on the mips is a hack which is just
+       supposed to read zero (see also mips-nat.c).  */
     val = 0;
   else
     {
@@ -1972,7 +1972,7 @@ mips_fetch_registers (int regno)
     }
 
   {
-    char *buf = alloca (max_register_size (current_gdbarch));
+    char buf[MAX_REGISTER_SIZE];
 
     /* We got the number the register holds, but gdb expects to see a
        value in the target byte ordering.  */
diff --git a/gdb/remote-rdp.c b/gdb/remote-rdp.c
index 3f956e7811b..a9dba9ab401 100644
--- a/gdb/remote-rdp.c
+++ b/gdb/remote-rdp.c
@@ -550,7 +550,7 @@ rdp_fetch_one_fpu_register (int mask, char *buf)
       send_rdp ("bbw-SWWWWZ", RDP_COPRO_READ, FPU_COPRO_NUMBER, mask, buf + 0, buf + 4, buf + 8, &dummy);
     }
 #endif
-  memset (buf, 0, MAX_REGISTER_RAW_SIZE);
+  memset (buf, 0, MAX_REGISTER_SIZE);
 }
 
 
diff --git a/gdb/remote-sim.c b/gdb/remote-sim.c
index f934bd40f03..f7b9e89b0ba 100644
--- a/gdb/remote-sim.c
+++ b/gdb/remote-sim.c
@@ -304,9 +304,9 @@ gdbsim_fetch_register (int regno)
       {
 	/* For moment treat a `does not exist' register the same way
            as an ``unavailable'' register.  */
-	char *buf = alloca (MAX_REGISTER_RAW_SIZE);
+	char buf[MAX_REGISTER_SIZE];
 	int nr_bytes;
-	memset (buf, 0, MAX_REGISTER_RAW_SIZE);
+	memset (buf, 0, MAX_REGISTER_SIZE);
 	supply_register (regno, buf);
 	set_register_cached (regno, -1);
 	break;
@@ -314,10 +314,10 @@ gdbsim_fetch_register (int regno)
     default:
       {
 	static int warn_user = 1;
-	char *buf = alloca (MAX_REGISTER_RAW_SIZE);
+	char buf[MAX_REGISTER_SIZE];
 	int nr_bytes;
 	gdb_assert (regno >= 0 && regno < NUM_REGS);
-	memset (buf, 0, MAX_REGISTER_RAW_SIZE);
+	memset (buf, 0, MAX_REGISTER_SIZE);
 	nr_bytes = sim_fetch_register (gdbsim_desc,
 				       REGISTER_SIM_REGNO (regno),
 				       buf, REGISTER_RAW_SIZE (regno));
@@ -359,7 +359,7 @@ gdbsim_store_register (int regno)
     }
   else if (REGISTER_SIM_REGNO (regno) >= 0)
     {
-      char *tmp = alloca (max_register_size (current_gdbarch));
+      char tmp[MAX_REGISTER_SIZE];
       int nr_bytes;
       deprecated_read_register_gen (regno, tmp);
       nr_bytes = sim_store_register (gdbsim_desc,
diff --git a/gdb/remote.c b/gdb/remote.c
index 902cb5fc62d..20becee27d6 100644
--- a/gdb/remote.c
+++ b/gdb/remote.c
@@ -2948,7 +2948,7 @@ remote_wait (ptid_t ptid, struct target_waitstatus *status)
 	case 'T':		/* Status with PC, SP, FP, ... */
 	  {
 	    int i;
-	    char* regs = (char*) alloca (MAX_REGISTER_RAW_SIZE);
+	    char regs[MAX_REGISTER_SIZE];
 
 	    /* Expedited reply, containing Signal, {regno, reg} repeat */
 	    /*  format is:  'Tssn...:r...;n...:r...;n...:r...;#cc', where
@@ -3199,7 +3199,7 @@ remote_async_wait (ptid_t ptid, struct target_waitstatus *status)
 	case 'T':		/* Status with PC, SP, FP, ... */
 	  {
 	    int i;
-	    char* regs = (char*) alloca (MAX_REGISTER_RAW_SIZE);
+	    char regs[MAX_REGISTER_SIZE];
 
 	    /* Expedited reply, containing Signal, {regno, reg} repeat */
 	    /*  format is:  'Tssn...:r...;n...:r...;n...:r...;#cc', where
@@ -3546,7 +3546,7 @@ store_register_using_P (int regnum)
   struct packet_reg *reg = packet_reg_from_regnum (rs, regnum);
   /* Try storing a single register.  */
   char *buf = alloca (rs->remote_packet_size);
-  char *regp = alloca (MAX_REGISTER_RAW_SIZE);
+  char regp[MAX_REGISTER_SIZE];
   char *p;
   int i;
 
@@ -3973,7 +3973,10 @@ remote_xfer_memory (CORE_ADDR mem_addr, char *buffer, int mem_len,
   int targ_len;
   int res;
 
-  REMOTE_TRANSLATE_XFER_ADDRESS (mem_addr, mem_len, &targ_addr, &targ_len);
+  /* Should this be the selected frame?  */
+  gdbarch_remote_translate_xfer_address (current_gdbarch, current_regcache,
+					 mem_addr, mem_len,
+					 &targ_addr, &targ_len);
   if (targ_len <= 0)
     return 0;
 
diff --git a/gdb/rom68k-rom.c b/gdb/rom68k-rom.c
index 57c0a182327..6b0926bf408 100644
--- a/gdb/rom68k-rom.c
+++ b/gdb/rom68k-rom.c
@@ -88,7 +88,7 @@ static char *
 rom68k_supply_one_register (int regno, unsigned char *hex)
 {
   ULONGEST value;
-  unsigned char *regbuf = alloca (max_register_size (current_gdbarch));
+  unsigned char regbuf[MAX_REGISTER_SIZE];
 
   value = 0;
   while (*hex != '\0')
diff --git a/gdb/rs6000-nat.c b/gdb/rs6000-nat.c
index 4aed8d8a939..c5a0ea73d8f 100644
--- a/gdb/rs6000-nat.c
+++ b/gdb/rs6000-nat.c
@@ -218,7 +218,7 @@ rs6000_ptrace64 (int req, int id, long long addr, int data, int *buf)
 static void
 fetch_register (int regno)
 {
-  int *addr = alloca (MAX_REGISTER_RAW_SIZE);
+  int addr[MAX_REGISTER_SIZE];
   int nr, isfloat;
 
   /* Retrieved values may be -1, so infer errors from errno. */
@@ -275,7 +275,7 @@ fetch_register (int regno)
 static void
 store_register (int regno)
 {
-  int *addr = alloca (MAX_REGISTER_RAW_SIZE);
+  int addr[MAX_REGISTER_SIZE];
   int nr, isfloat;
 
   /* Fetch the register's value from the register cache.  */
diff --git a/gdb/rs6000-tdep.c b/gdb/rs6000-tdep.c
index 9f553687ec4..0b239bd4180 100644
--- a/gdb/rs6000-tdep.c
+++ b/gdb/rs6000-tdep.c
@@ -1739,7 +1739,7 @@ frame_initial_stack_address (struct frame_info *fi)
   /* There is an alloca register, use its value, in the current frame,
      as the initial stack pointer.  */
   {
-    char *tmpbuf = alloca (MAX_REGISTER_RAW_SIZE);
+    char tmpbuf[MAX_REGISTER_SIZE];
     if (frame_register_read (fi, fdata.alloca_reg, tmpbuf))
       {
 	get_frame_extra_info (fi)->initial_sp
@@ -1921,7 +1921,7 @@ e500_pseudo_register_read (struct gdbarch *gdbarch, struct regcache *regcache,
 {
   int base_regnum;
   int offset = 0;
-  char *temp_buffer = (char*) alloca (MAX_REGISTER_RAW_SIZE);
+  char temp_buffer[MAX_REGISTER_SIZE];
   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); 
 
   if (reg_nr >= tdep->ppc_gp0_regnum 
@@ -1944,7 +1944,7 @@ e500_pseudo_register_write (struct gdbarch *gdbarch, struct regcache *regcache,
 {
   int base_regnum;
   int offset = 0;
-  char *temp_buffer = (char*) alloca (MAX_REGISTER_RAW_SIZE);
+  char temp_buffer[MAX_REGISTER_SIZE];
   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); 
 
   if (reg_nr >= tdep->ppc_gp0_regnum 
@@ -2797,7 +2797,7 @@ rs6000_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
 
   set_gdbarch_pc_regnum (gdbarch, 64);
   set_gdbarch_sp_regnum (gdbarch, 1);
-  set_gdbarch_fp_regnum (gdbarch, 1);
+  set_gdbarch_deprecated_fp_regnum (gdbarch, 1);
   set_gdbarch_deprecated_extract_return_value (gdbarch,
 					       rs6000_extract_return_value);
   set_gdbarch_deprecated_store_return_value (gdbarch, rs6000_store_return_value);
@@ -2830,7 +2830,7 @@ rs6000_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
 	tdep->ppc_ev31_regnum = 38;
         set_gdbarch_pc_regnum (gdbarch, 0);
         set_gdbarch_sp_regnum (gdbarch, tdep->ppc_gp0_regnum + 1);
-        set_gdbarch_fp_regnum (gdbarch, tdep->ppc_gp0_regnum + 1);
+        set_gdbarch_deprecated_fp_regnum (gdbarch, tdep->ppc_gp0_regnum + 1);
         set_gdbarch_dwarf2_reg_to_regnum (gdbarch, e500_dwarf2_reg_to_regnum);
         set_gdbarch_pseudo_register_read (gdbarch, e500_pseudo_register_read);
         set_gdbarch_pseudo_register_write (gdbarch, e500_pseudo_register_write);
@@ -2872,14 +2872,13 @@ rs6000_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
 
   set_gdbarch_read_pc (gdbarch, generic_target_read_pc);
   set_gdbarch_write_pc (gdbarch, generic_target_write_pc);
-  set_gdbarch_read_fp (gdbarch, generic_target_read_fp);
   set_gdbarch_read_sp (gdbarch, generic_target_read_sp);
   set_gdbarch_deprecated_dummy_write_sp (gdbarch, generic_target_write_sp);
 
   set_gdbarch_num_regs (gdbarch, v->nregs);
   set_gdbarch_num_pseudo_regs (gdbarch, v->npregs);
   set_gdbarch_register_name (gdbarch, rs6000_register_name);
-  set_gdbarch_register_size (gdbarch, wordsize);
+  set_gdbarch_deprecated_register_size (gdbarch, wordsize);
   set_gdbarch_register_bytes (gdbarch, off);
   set_gdbarch_register_byte (gdbarch, rs6000_register_byte);
   set_gdbarch_register_raw_size (gdbarch, rs6000_register_raw_size);
@@ -2901,7 +2900,7 @@ rs6000_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
     set_gdbarch_long_double_bit (gdbarch, 8 * TARGET_CHAR_BIT);
   set_gdbarch_char_signed (gdbarch, 0);
 
-  set_gdbarch_fix_call_dummy (gdbarch, rs6000_fix_call_dummy);
+  set_gdbarch_deprecated_fix_call_dummy (gdbarch, rs6000_fix_call_dummy);
   set_gdbarch_frame_align (gdbarch, rs6000_frame_align);
   set_gdbarch_save_dummy_frame_tos (gdbarch, generic_save_dummy_frame_tos);
   set_gdbarch_deprecated_push_return_address (gdbarch, ppc_push_return_address);
diff --git a/gdb/s390-tdep.c b/gdb/s390-tdep.c
index 415fde7b480..f836c1b0516 100644
--- a/gdb/s390-tdep.c
+++ b/gdb/s390-tdep.c
@@ -280,7 +280,7 @@ s390_get_frame_info (CORE_ADDR pc, struct frame_extra_info *fextra_info,
 
   memset (gprs_saved, 0, sizeof (gprs_saved));
   memset (fprs_saved, 0, sizeof (fprs_saved));
-  info.read_memory_func = dis_asm_read_memory;
+  info.read_memory_func = deprecated_tm_print_insn_info.read_memory_func;
 
   save_link_regidx = subtract_sp_regidx = 0;
   if (fextra_info)
@@ -682,7 +682,7 @@ s390_check_function_end (CORE_ADDR pc)
   disassemble_info info;
   int regidx, instrlen;
 
-  info.read_memory_func = dis_asm_read_memory;
+  info.read_memory_func = deprecated_tm_print_insn_info.read_memory_func;
   instrlen = s390_readinstruction (instr, pc, &info);
   if (instrlen < 0)
     return -1;
@@ -819,7 +819,7 @@ s390_is_sigreturn (CORE_ADDR pc, struct frame_info *sighandler_fi,
 
   scontext = temp_sregs = 0;
 
-  info.read_memory_func = dis_asm_read_memory;
+  info.read_memory_func = deprecated_tm_print_insn_info.read_memory_func;
   instrlen = s390_readinstruction (instr, pc, &info);
   if (sigcaller_pc)
     *sigcaller_pc = 0;
@@ -1150,7 +1150,7 @@ void
 s390_store_return_value (struct type *valtype, char *valbuf)
 {
   int arglen;
-  char *reg_buff = alloca (max (S390_FPR_SIZE, REGISTER_SIZE)), *value;
+  char *reg_buff = alloca (max (S390_FPR_SIZE, DEPRECATED_REGISTER_SIZE)), *value;
 
   if (TYPE_CODE (valtype) == TYPE_CODE_FLT)
     {
@@ -1658,7 +1658,7 @@ s390_push_arguments (int nargs, struct value **args, CORE_ADDR sp,
      frame.  This will help us get backtraces from within functions
      called from GDB.  */
   write_memory_unsigned_integer (sp, (TARGET_PTR_BIT / TARGET_CHAR_BIT),
-                                 read_fp ());
+                                 deprecated_read_fp ());
 
   return sp;
 }
@@ -1841,7 +1841,7 @@ s390_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
   set_gdbarch_skip_prologue (gdbarch, s390_skip_prologue);
   set_gdbarch_deprecated_init_extra_frame_info (gdbarch, s390_init_extra_frame_info);
   set_gdbarch_deprecated_init_frame_pc_first (gdbarch, s390_init_frame_pc_first);
-  set_gdbarch_read_fp (gdbarch, s390_read_fp);
+  set_gdbarch_deprecated_target_read_fp (gdbarch, s390_read_fp);
   /* This function that tells us whether the function invocation represented
      by FI does not have a frame on the stack associated with it.  If it
      does not, FRAMELESS is set to 1, else 0.  */
@@ -1856,7 +1856,7 @@ s390_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
   set_gdbarch_register_byte (gdbarch, s390_register_byte);
   set_gdbarch_pc_regnum (gdbarch, S390_PC_REGNUM);
   set_gdbarch_sp_regnum (gdbarch, S390_SP_REGNUM);
-  set_gdbarch_fp_regnum (gdbarch, S390_FP_REGNUM);
+  set_gdbarch_deprecated_fp_regnum (gdbarch, S390_FP_REGNUM);
   set_gdbarch_fp0_regnum (gdbarch, S390_FP0_REGNUM);
   set_gdbarch_num_regs (gdbarch, S390_NUM_REGS);
   set_gdbarch_cannot_fetch_register (gdbarch, s390_cannot_fetch_register);
@@ -1876,14 +1876,13 @@ s390_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
   set_gdbarch_save_dummy_frame_tos (gdbarch, generic_save_dummy_frame_tos);
   set_gdbarch_deprecated_push_return_address (gdbarch,
                                               s390_push_return_address);
-  set_gdbarch_sizeof_call_dummy_words (gdbarch,
-                                       sizeof (s390_call_dummy_words));
-  set_gdbarch_call_dummy_words (gdbarch, s390_call_dummy_words);
+  set_gdbarch_deprecated_sizeof_call_dummy_words (gdbarch, sizeof (s390_call_dummy_words));
+  set_gdbarch_deprecated_call_dummy_words (gdbarch, s390_call_dummy_words);
 
   switch (info.bfd_arch_info->mach)
     {
     case bfd_mach_s390_31:
-      set_gdbarch_register_size (gdbarch, 4);
+      set_gdbarch_deprecated_register_size (gdbarch, 4);
       set_gdbarch_register_raw_size (gdbarch, s390_register_raw_size);
       set_gdbarch_register_virtual_size (gdbarch, s390_register_raw_size);
       set_gdbarch_register_virtual_type (gdbarch, s390_register_virtual_type);
@@ -1892,7 +1891,7 @@ s390_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
       set_gdbarch_register_bytes (gdbarch, S390_REGISTER_BYTES);
       break;
     case bfd_mach_s390_64:
-      set_gdbarch_register_size (gdbarch, 8);
+      set_gdbarch_deprecated_register_size (gdbarch, 8);
       set_gdbarch_register_raw_size (gdbarch, s390x_register_raw_size);
       set_gdbarch_register_virtual_size (gdbarch, s390x_register_raw_size);
       set_gdbarch_register_virtual_type (gdbarch,
@@ -1925,8 +1924,8 @@ _initialize_s390_tdep (void)
 
   /* Hook us into the gdbarch mechanism.  */
   register_gdbarch_init (bfd_arch_s390, s390_gdbarch_init);
-  if (!tm_print_insn)		/* Someone may have already set it */
-    tm_print_insn = gdb_print_insn_s390;
+  if (!deprecated_tm_print_insn)	/* Someone may have already set it */
+    deprecated_tm_print_insn = gdb_print_insn_s390;
 }
 
 #endif /* GDBSERVER */
diff --git a/gdb/scm-lang.c b/gdb/scm-lang.c
index 99a1fd5ba96..1af501d5829 100644
--- a/gdb/scm-lang.c
+++ b/gdb/scm-lang.c
@@ -33,6 +33,7 @@
 #include "source.h"
 #include "gdb_string.h"
 #include "gdbcore.h"
+#include "infcall.h"
 
 extern void _initialize_scheme_language (void);
 static struct value *evaluate_subexp_scm (struct type *, struct expression *,
diff --git a/gdb/sentinel-frame.c b/gdb/sentinel-frame.c
index dab16478413..dcc583ec98e 100644
--- a/gdb/sentinel-frame.c
+++ b/gdb/sentinel-frame.c
@@ -56,7 +56,7 @@ sentinel_frame_prev_register (struct frame_info *next_frame,
      onto the corresponding hardware register.  */
   *optimized = 0;
   *lvalp = lval_register;
-  *addrp = REGISTER_BYTE (regnum);
+  *addrp = register_offset_hack (current_gdbarch, regnum);
   *realnum = regnum;
 
   /* If needed, find and return the value of the register.  */
diff --git a/gdb/sh-tdep.c b/gdb/sh-tdep.c
index 0390e95f84f..0ef65de2c02 100644
--- a/gdb/sh-tdep.c
+++ b/gdb/sh-tdep.c
@@ -1003,7 +1003,7 @@ sh64_frame_chain (struct frame_info *frame)
       if (gdbarch_tdep (current_gdbarch)->sh_abi == SH_ABI_32)
 	size = 4;
       else
-	size = REGISTER_RAW_SIZE (translate_insn_rn (FP_REGNUM, media_mode));
+	size = REGISTER_RAW_SIZE (translate_insn_rn (DEPRECATED_FP_REGNUM, media_mode));
       return read_memory_integer (get_frame_base (frame)
 				  + get_frame_extra_info (frame)->f_offset,
 				  size);
@@ -1172,7 +1172,7 @@ sh_nofp_frame_init_saved_regs (struct frame_info *fi)
     {
       if (where[rn] >= 0)
 	{
-	  if (rn == FP_REGNUM)
+	  if (rn == DEPRECATED_FP_REGNUM)
 	    have_fp = 1;
 
 	  get_frame_saved_regs (fi)[rn] = get_frame_base (fi) - where[rn] + depth - 4;
@@ -1185,14 +1185,14 @@ sh_nofp_frame_init_saved_regs (struct frame_info *fi)
 
   if (have_fp)
     {
-      get_frame_saved_regs (fi)[SP_REGNUM] = read_memory_integer (get_frame_saved_regs (fi)[FP_REGNUM], 4);
+      get_frame_saved_regs (fi)[SP_REGNUM] = read_memory_integer (get_frame_saved_regs (fi)[DEPRECATED_FP_REGNUM], 4);
     }
   else
     {
       get_frame_saved_regs (fi)[SP_REGNUM] = get_frame_base (fi) - 4;
     }
 
-  get_frame_extra_info (fi)->f_offset = depth - where[FP_REGNUM] - 4;
+  get_frame_extra_info (fi)->f_offset = depth - where[DEPRECATED_FP_REGNUM] - 4;
   /* Work out the return pc - either from the saved pr or the pr
      value */
 }
@@ -1477,7 +1477,7 @@ sh64_nofp_frame_init_saved_regs (struct frame_info *fi)
  /* The frame pointer register is general register 14 in shmedia and
     shcompact modes. In sh compact it is a pseudo register.  Same goes
     for the stack pointer register, which is register 15. */
-  fp_regnum = translate_insn_rn (FP_REGNUM, media_mode);
+  fp_regnum = translate_insn_rn (DEPRECATED_FP_REGNUM, media_mode);
   sp_regnum = translate_insn_rn (SP_REGNUM, media_mode);
 
   for (opc = pc + (insn_size * 28); pc < opc; pc += insn_size)
@@ -1602,8 +1602,8 @@ sh64_nofp_frame_init_saved_regs (struct frame_info *fi)
 	 register r15 which still is the SP register. */
       /* The place on the stack where fp is stored contains the sp of
          the caller. */
-      /* Again, saved_registers contains only space for the real registers,
-	 so we store in FP_REGNUM position. */
+      /* Again, saved_registers contains only space for the real
+	 registers, so we store in DEPRECATED_FP_REGNUM position.  */
       int size;
       if (tdep->sh_abi == SH_ABI_32)
 	size = 4;
@@ -1724,7 +1724,7 @@ sh_fp_frame_init_saved_regs (struct frame_info *fi)
     {
       if (where[rn] >= 0)
 	{
-	  if (rn == FP_REGNUM)
+	  if (rn == DEPRECATED_FP_REGNUM)
 	    have_fp = 1;
 
 	  get_frame_saved_regs (fi)[rn] = get_frame_base (fi) - where[rn] + depth - 4;
@@ -1738,14 +1738,14 @@ sh_fp_frame_init_saved_regs (struct frame_info *fi)
   if (have_fp)
     {
       get_frame_saved_regs (fi)[SP_REGNUM] =
-	read_memory_integer (get_frame_saved_regs (fi)[FP_REGNUM], 4);
+	read_memory_integer (get_frame_saved_regs (fi)[DEPRECATED_FP_REGNUM], 4);
     }
   else
     {
       get_frame_saved_regs (fi)[SP_REGNUM] = get_frame_base (fi) - 4;
     }
 
-  get_frame_extra_info (fi)->f_offset = depth - where[FP_REGNUM] - 4;
+  get_frame_extra_info (fi)->f_offset = depth - where[DEPRECATED_FP_REGNUM] - 4;
   /* Work out the return pc - either from the saved pr or the pr
      value */
 }
@@ -1763,14 +1763,14 @@ sh_init_extra_frame_info (int fromleaf, struct frame_info *fi)
   if (DEPRECATED_PC_IN_CALL_DUMMY (get_frame_pc (fi), get_frame_base (fi),
 				   get_frame_base (fi)))
     {
-      /* We need to setup fi->frame here because run_stack_dummy gets it wrong
-         by assuming it's always FP.  */
+      /* We need to setup fi->frame here because call_function_by_hand
+         gets it wrong by assuming it's always FP.  */
       deprecated_update_frame_base_hack (fi, deprecated_read_register_dummy (get_frame_pc (fi), get_frame_base (fi),
 									     SP_REGNUM));
       get_frame_extra_info (fi)->return_pc = deprecated_read_register_dummy (get_frame_pc (fi),
 								  get_frame_base (fi),
 								  PC_REGNUM);
-      get_frame_extra_info (fi)->f_offset = -(CALL_DUMMY_LENGTH + 4);
+      get_frame_extra_info (fi)->f_offset = -(DEPRECATED_CALL_DUMMY_LENGTH + 4);
       get_frame_extra_info (fi)->leaf_function = 0;
       return;
     }
@@ -1795,13 +1795,13 @@ sh64_init_extra_frame_info (int fromleaf, struct frame_info *fi)
   if (DEPRECATED_PC_IN_CALL_DUMMY (get_frame_pc (fi), get_frame_base (fi),
 				   get_frame_base (fi)))
     {
-      /* We need to setup fi->frame here because run_stack_dummy gets it wrong
-         by assuming it's always FP.  */
+      /* We need to setup fi->frame here because call_function_by_hand
+         gets it wrong by assuming it's always FP.  */
       deprecated_update_frame_base_hack (fi, deprecated_read_register_dummy (get_frame_pc (fi), get_frame_base (fi), SP_REGNUM));
       get_frame_extra_info (fi)->return_pc = 
 	deprecated_read_register_dummy (get_frame_pc (fi),
 					get_frame_base (fi), PC_REGNUM);
-      get_frame_extra_info (fi)->f_offset = -(CALL_DUMMY_LENGTH + 4);
+      get_frame_extra_info (fi)->f_offset = -(DEPRECATED_CALL_DUMMY_LENGTH + 4);
       get_frame_extra_info (fi)->leaf_function = 0;
       return;
     }
@@ -1885,7 +1885,7 @@ sh64_get_saved_register (char *raw_buffer, int *optimized, CORE_ADDR *addrp,
 		{
 		  int size;
 		  if (tdep->sh_abi == SH_ABI_32
-		      && (live_regnum == FP_REGNUM
+		      && (live_regnum == DEPRECATED_FP_REGNUM
 			  || live_regnum == tdep->PR_REGNUM))
 		    size = 4;
 		  else
@@ -1993,7 +1993,7 @@ sh64_pop_frame (void)
 	  {
 	    int size;
 	    if (tdep->sh_abi == SH_ABI_32
-		&& (regnum == FP_REGNUM
+		&& (regnum == DEPRECATED_FP_REGNUM
 		    || regnum ==  tdep->PR_REGNUM))
 	      size = 4;
 	    else
@@ -3481,7 +3481,7 @@ sh_pseudo_register_read (struct gdbarch *gdbarch, struct regcache *regcache,
 			 int reg_nr, void *buffer)
 {
   int base_regnum, portion;
-  char *temp_buffer = (char*) alloca (MAX_REGISTER_RAW_SIZE);
+  char temp_buffer[MAX_REGISTER_SIZE];
   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); 
 
   if (reg_nr >= tdep->DR0_REGNUM 
@@ -3520,7 +3520,7 @@ sh64_pseudo_register_read (struct gdbarch *gdbarch, struct regcache *regcache,
   int base_regnum;
   int portion;
   int offset = 0;
-  char *temp_buffer = (char*) alloca (MAX_REGISTER_RAW_SIZE);
+  char temp_buffer[MAX_REGISTER_SIZE];
   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); 
 
   if (reg_nr >= tdep->DR0_REGNUM 
@@ -3684,7 +3684,7 @@ sh_pseudo_register_write (struct gdbarch *gdbarch, struct regcache *regcache,
 			  int reg_nr, const void *buffer)
 {
   int base_regnum, portion;
-  char *temp_buffer = (char*) alloca (MAX_REGISTER_RAW_SIZE);
+  char temp_buffer[MAX_REGISTER_SIZE];
   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); 
 
   if (reg_nr >= tdep->DR0_REGNUM
@@ -3721,7 +3721,7 @@ sh64_pseudo_register_write (struct gdbarch *gdbarch, struct regcache *regcache,
 {
   int base_regnum, portion;
   int offset;
-  char *temp_buffer = (char*) alloca (MAX_REGISTER_RAW_SIZE);
+  char temp_buffer[MAX_REGISTER_SIZE];
   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
 
   if (reg_nr >= tdep->DR0_REGNUM
@@ -4087,7 +4087,7 @@ sh64_do_pseudo_register (int regnum)
 static void
 sh_do_register (int regnum)
 {
-  char *raw_buffer = alloca (max_register_size (current_gdbarch));
+  char raw_buffer[MAX_REGISTER_SIZE];
 
   fputs_filtered (REGISTER_NAME (regnum), gdb_stdout);
   print_spaces_filtered (15 - strlen (REGISTER_NAME (regnum)), gdb_stdout);
@@ -4365,9 +4365,9 @@ sh_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
   set_gdbarch_ptr_bit (gdbarch, 4 * TARGET_CHAR_BIT);
   set_gdbarch_num_regs (gdbarch, SH_DEFAULT_NUM_REGS);
   set_gdbarch_sp_regnum (gdbarch, 15);
-  set_gdbarch_fp_regnum (gdbarch, 14);
+  set_gdbarch_deprecated_fp_regnum (gdbarch, 14);
   set_gdbarch_pc_regnum (gdbarch, 16);
-  set_gdbarch_register_size (gdbarch, 4);
+  set_gdbarch_deprecated_register_size (gdbarch, 4);
   set_gdbarch_register_bytes (gdbarch, SH_DEFAULT_NUM_REGS * 4);
   set_gdbarch_deprecated_do_registers_info (gdbarch, sh_do_registers_info);
   set_gdbarch_breakpoint_from_pc (gdbarch, sh_breakpoint_from_pc);
@@ -4586,7 +4586,7 @@ sh_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
       /* the number of real registers is the same whether we are in 
 	 ISA16(compact) or ISA32(media). */
       set_gdbarch_num_regs (gdbarch, SIM_SH64_NR_REGS);
-      set_gdbarch_register_size (gdbarch, 8); /*????*/
+      set_gdbarch_deprecated_register_size (gdbarch, 8); /*????*/
       set_gdbarch_register_bytes (gdbarch, 
 				  ((SIM_SH64_NR_FP_REGS + 1) * 4)
 				  + (SIM_SH64_NR_REGS - SIM_SH64_NR_FP_REGS -1) * 8);
@@ -4639,7 +4639,6 @@ sh_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
 
   set_gdbarch_read_pc (gdbarch, generic_target_read_pc);
   set_gdbarch_write_pc (gdbarch, generic_target_write_pc);
-  set_gdbarch_read_fp (gdbarch, generic_target_read_fp);
   set_gdbarch_read_sp (gdbarch, generic_target_read_sp);
   set_gdbarch_deprecated_dummy_write_sp (gdbarch, generic_target_write_sp);
 
@@ -4653,8 +4652,8 @@ sh_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
   set_gdbarch_double_bit (gdbarch, 8 * TARGET_CHAR_BIT);
   set_gdbarch_long_double_bit (gdbarch, 8 * TARGET_CHAR_BIT);
 
-  set_gdbarch_call_dummy_words (gdbarch, sh_call_dummy_words);
-  set_gdbarch_sizeof_call_dummy_words (gdbarch, sizeof (sh_call_dummy_words));
+  set_gdbarch_deprecated_call_dummy_words (gdbarch, sh_call_dummy_words);
+  set_gdbarch_deprecated_sizeof_call_dummy_words (gdbarch, sizeof (sh_call_dummy_words));
 
   set_gdbarch_deprecated_push_return_address (gdbarch, sh_push_return_address);
 
diff --git a/gdb/sol-thread.c b/gdb/sol-thread.c
index 1d379e9ec19..8e2c4ad57a8 100644
--- a/gdb/sol-thread.c
+++ b/gdb/sol-thread.c
@@ -647,9 +647,9 @@ sol_thread_store_registers (int regno)
   if (regno != -1)
     {				/* Not writing all the regs */
       /* save new register value */
-      char* old_value = (char*) alloca (REGISTER_SIZE);
+      char* old_value = (char*) alloca (DEPRECATED_REGISTER_SIZE);
       memcpy (old_value, &deprecated_registers[REGISTER_BYTE (regno)],
-	      REGISTER_SIZE);
+	      DEPRECATED_REGISTER_SIZE);
 
       val = p_td_thr_getgregs (&thandle, gregset);
       if (val != TD_OK)
@@ -662,7 +662,7 @@ sol_thread_store_registers (int regno)
 
       /* restore new register value */
       memcpy (&deprecated_registers[REGISTER_BYTE (regno)], old_value,
-	      REGISTER_SIZE);
+	      DEPRECATED_REGISTER_SIZE);
 
 #if 0
 /* thread_db doesn't seem to handle this right */
diff --git a/gdb/sparc-tdep.c b/gdb/sparc-tdep.c
index e1a0089f3c0..7f0ae4b2046 100644
--- a/gdb/sparc-tdep.c
+++ b/gdb/sparc-tdep.c
@@ -51,8 +51,11 @@
 
 #if (GDB_MULTI_ARCH > 0)
 
-/* Does the target have Floating Point registers?  */
-#define SPARC_HAS_FPU     (gdbarch_tdep (current_gdbarch)->has_fpu)
+#if 0
+// OBSOLETE /* Does the target have Floating Point registers?  */
+// OBSOLETE #define SPARC_HAS_FPU     (gdbarch_tdep (current_gdbarch)->has_fpu)
+#endif
+#define SPARC_HAS_FPU 1
 /* Number of bytes devoted to Floating Point registers: */
 #define FP_REGISTER_BYTES (gdbarch_tdep (current_gdbarch)->fp_register_bytes)
 /* Highest numbered Floating Point register.  */
@@ -310,13 +313,11 @@ sparc_init_extra_frame_info (int fromleaf, struct frame_info *fi)
 	: get_frame_base (get_next_frame (fi)))
      : read_sp ());
 
-  /* If fi->next is NULL, then we already set ->frame by passing read_fp()
-     to create_new_frame.  */
+  /* If fi->next is NULL, then we already set ->frame by passing
+     deprecated_read_fp() to create_new_frame.  */
   if (get_next_frame (fi))
     {
-      char *buf;
-
-      buf = alloca (MAX_REGISTER_RAW_SIZE);
+      char buf[MAX_REGISTER_SIZE];
 
       /* Compute ->frame as if not flat.  If it is flat, we'll change
          it later.  */
@@ -335,7 +336,7 @@ sparc_init_extra_frame_info (int fromleaf, struct frame_info *fi)
 	{
 	  /* Should we adjust for stack bias here? */
 	  ULONGEST tmp;
-	  frame_read_unsigned_register (fi, FP_REGNUM, &tmp);
+	  frame_read_unsigned_register (fi, DEPRECATED_FP_REGNUM, &tmp);
 	  deprecated_update_frame_base_hack (fi, tmp);
 	  if (GDB_TARGET_IS_SPARC64 && (get_frame_base (fi) & 1))
 	    deprecated_update_frame_base_hack (fi, get_frame_base (fi) + 2047);
@@ -365,9 +366,7 @@ sparc_init_extra_frame_info (int fromleaf, struct frame_info *fi)
 	      && X_OP3 (insn) == 4
 	      && X_RS1 (insn) == 14)
 	    {
-	      char *buf;
-	      
-	      buf = alloca (MAX_REGISTER_RAW_SIZE);
+	      char buf[MAX_REGISTER_SIZE];
 
 	      /* We definitely have a flat frame now.  */
 	      get_frame_extra_info (fi)->flat = 1;
@@ -471,10 +470,9 @@ sparc_extract_struct_value_address (char *regbuf)
 CORE_ADDR
 sparc_frame_saved_pc (struct frame_info *frame)
 {
-  char *buf;
+  char buf[MAX_REGISTER_SIZE];
   CORE_ADDR addr;
 
-  buf = alloca (MAX_REGISTER_RAW_SIZE);
   if ((get_frame_type (frame) == SIGTRAMP_FRAME))
     {
       /* This is the signal trampoline frame.
@@ -1065,16 +1063,16 @@ sparc_push_dummy_frame (void)
       if (GDB_TARGET_IS_SPARC64)
 	{
 	  /* Target is a 64 bit SPARC.  */
-	  CORE_ADDR oldfp = read_register (FP_REGNUM);
+	  CORE_ADDR oldfp = read_register (DEPRECATED_FP_REGNUM);
 	  if (oldfp & 1)
-	    write_register (FP_REGNUM, old_sp - 2047);
+	    write_register (DEPRECATED_FP_REGNUM, old_sp - 2047);
 	  else
-	    write_register (FP_REGNUM, old_sp);
+	    write_register (DEPRECATED_FP_REGNUM, old_sp);
 	}
       else
 	{
 	  /* Target is a 32 bit SPARC.  */
-	  write_register (FP_REGNUM, old_sp);
+	  write_register (DEPRECATED_FP_REGNUM, old_sp);
 	}
       /* Set return address register for the call dummy to the current PC.  */
       write_register (I7_REGNUM, read_pc () - 8);
@@ -1084,7 +1082,7 @@ sparc_push_dummy_frame (void)
       /* The call dummy will write this value to FP before executing
          the 'save'.  This ensures that register window flushes work
          correctly in the simulator.  */
-      write_register (G0_REGNUM + 1, read_register (FP_REGNUM));
+      write_register (G0_REGNUM + 1, read_register (DEPRECATED_FP_REGNUM));
 
       /* The call dummy will write this value to FP after executing
          the 'save'. */
@@ -1096,7 +1094,7 @@ sparc_push_dummy_frame (void)
 
       /* Set the FP that the call dummy will be using after the 'save'.
          This makes backtraces from an inferior function call work properly.  */
-      write_register (FP_REGNUM, old_sp);
+      write_register (DEPRECATED_FP_REGNUM, old_sp);
     }
 }
 
@@ -2067,8 +2065,8 @@ sparc_print_registers (struct gdbarch *gdbarch,
 {
   int i;
   const int numregs = NUM_REGS + NUM_PSEUDO_REGS;
-  char *raw_buffer = alloca (MAX_REGISTER_RAW_SIZE);
-  char *virtual_buffer = alloca (MAX_REGISTER_VIRTUAL_SIZE);
+  char raw_buffer[MAX_REGISTER_SIZE];
+  char virtual_buffer[MAX_REGISTER_SIZE];
 
   for (i = 0; i < numregs; i++)
     {
@@ -2308,9 +2306,7 @@ void
 sparc_store_return_value (struct type *type, char *valbuf)
 {
   int regno;
-  char *buffer;
-
-  buffer = alloca (MAX_REGISTER_RAW_SIZE);
+  char buffer[MAX_REGISTER_SIZE];
 
   if (TYPE_CODE (type) == TYPE_CODE_FLT && SPARC_HAS_FPU)
     /* Floating-point values are returned in the register pair */
@@ -2354,9 +2350,10 @@ sparc_store_return_value (struct type *type, char *valbuf)
 
    For structs and unions, if the function was compiled with Sun cc,
    it expects 'unimp' after the call.  But gcc doesn't use that
-   (twisted) convention.  So leave a nop there for gcc (FIX_CALL_DUMMY
-   can assume it is operating on a pristine CALL_DUMMY, not one that
-   has already been customized for a different function).  */
+   (twisted) convention.  So leave a nop there for gcc
+   (DEPRECATED_FIX_CALL_DUMMY can assume it is operating on a pristine
+   CALL_DUMMY, not one that has already been customized for a
+   different function).  */
 
 void
 sparc_fix_call_dummy (char *dummy, CORE_ADDR pc, CORE_ADDR fun,
@@ -2379,19 +2376,20 @@ sparc_fix_call_dummy (char *dummy, CORE_ADDR pc, CORE_ADDR fun,
      Adjust the call_dummy_breakpoint_offset for the bp_call_dummy breakpoint
      to the proper address in the call dummy, so that `finish' after a stop
      in a call dummy works.
-     Tweeking current_gdbarch is not an optimal solution, but the call to
-     sparc_fix_call_dummy is immediately followed by a call to run_stack_dummy,
-     which is the only function where dummy_breakpoint_offset is actually
-     used, if it is non-zero.  */
+
+     Tweeking current_gdbarch is not an optimal solution, but the call
+     to sparc_fix_call_dummy is immediately followed by a call to
+     call_function_by_hand, which is the only function where
+     dummy_breakpoint_offset is actually used, if it is non-zero.  */
   if (TYPE_CODE (value_type) == TYPE_CODE_STRUCT
        || TYPE_CODE (value_type) == TYPE_CODE_UNION)
     {
       store_unsigned_integer (dummy + CALL_DUMMY_CALL_OFFSET + 8, 4,
 			      TYPE_LENGTH (value_type) & 0x1fff);
-      set_gdbarch_call_dummy_breakpoint_offset (current_gdbarch, 0x30);
+      set_gdbarch_deprecated_call_dummy_breakpoint_offset (current_gdbarch, 0x30);
     }
   else
-    set_gdbarch_call_dummy_breakpoint_offset (current_gdbarch, 0x2c);
+    set_gdbarch_deprecated_call_dummy_breakpoint_offset (current_gdbarch, 0x2c);
 
   if (!(GDB_TARGET_IS_SPARC64))
     {
@@ -2459,8 +2457,8 @@ _initialize_sparc_tdep (void)
   /* Hook us into the gdbarch mechanism.  */
   gdbarch_register (bfd_arch_sparc, sparc_gdbarch_init, sparc_dump_tdep);
 
-  tm_print_insn = gdb_print_insn_sparc;
-  tm_print_insn_info.mach = TM_PRINT_INSN_MACH;		/* Selects sparc/sparclite */
+  deprecated_tm_print_insn = gdb_print_insn_sparc;
+  deprecated_tm_print_insn_info.mach = TM_PRINT_INSN_MACH;		/* Selects sparc/sparclite */
   /* OBSOLETE target_architecture_hook = sparc_target_architecture_hook; */
 }
 
@@ -2480,7 +2478,7 @@ sparc64_read_sp (void)
 CORE_ADDR
 sparc64_read_fp (void)
 {
-  CORE_ADDR fp = read_register (FP_REGNUM);
+  CORE_ADDR fp = read_register (DEPRECATED_FP_REGNUM);
 
   if (fp & 1)
     fp += 2047;
@@ -2934,7 +2932,7 @@ static struct type *
 sparc32_register_virtual_type (int regno)
 {
   if (regno == PC_REGNUM ||
-      regno == FP_REGNUM ||
+      regno == DEPRECATED_FP_REGNUM ||
       regno == SP_REGNUM)
     return builtin_type_unsigned_int;
   if (regno < 32)
@@ -2948,7 +2946,7 @@ static struct type *
 sparc64_register_virtual_type (int regno)
 {
   if (regno == PC_REGNUM ||
-      regno == FP_REGNUM ||
+      regno == DEPRECATED_FP_REGNUM ||
       regno == SP_REGNUM)
     return builtin_type_unsigned_long_long;
   if (regno < 32)
@@ -3050,7 +3048,7 @@ sparc_gdbarch_fix_call_dummy (char *dummy,
 static CORE_ADDR
 sparc_call_dummy_address (void)
 {
-  return (CALL_DUMMY_START_OFFSET) + CALL_DUMMY_BREAKPOINT_OFFSET;
+  return (DEPRECATED_CALL_DUMMY_START_OFFSET) + DEPRECATED_CALL_DUMMY_BREAKPOINT_OFFSET;
 }
 
 /* Supply the Y register number to those that need it.  */
@@ -3159,9 +3157,9 @@ sparc_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
   set_gdbarch_decr_pc_after_break (gdbarch, 0);
   set_gdbarch_double_bit (gdbarch, 8 * TARGET_CHAR_BIT);
   set_gdbarch_deprecated_extract_struct_value_address (gdbarch, sparc_extract_struct_value_address);
-  set_gdbarch_fix_call_dummy (gdbarch, sparc_gdbarch_fix_call_dummy);
+  set_gdbarch_deprecated_fix_call_dummy (gdbarch, sparc_gdbarch_fix_call_dummy);
   set_gdbarch_float_bit (gdbarch, 4 * TARGET_CHAR_BIT);
-  set_gdbarch_fp_regnum (gdbarch, SPARC_FP_REGNUM);
+  set_gdbarch_deprecated_fp_regnum (gdbarch, SPARC_FP_REGNUM);
   set_gdbarch_fp0_regnum (gdbarch, SPARC_FP0_REGNUM);
   set_gdbarch_deprecated_frame_chain (gdbarch, sparc_frame_chain);
   set_gdbarch_deprecated_frame_init_saved_regs (gdbarch, sparc_frame_init_saved_regs);
@@ -3217,10 +3215,18 @@ sparc_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
 #ifdef SPARC32_CALL_DUMMY_ON_STACK
       set_gdbarch_deprecated_pc_in_call_dummy (gdbarch, deprecated_pc_in_call_dummy_on_stack);
       set_gdbarch_call_dummy_address (gdbarch, sparc_call_dummy_address);
-      set_gdbarch_call_dummy_breakpoint_offset (gdbarch, 0x30);
-      set_gdbarch_call_dummy_length (gdbarch, 0x38);
-
-      /* NOTE: cagney/2002-04-26: Based from info posted by Peter
+      set_gdbarch_deprecated_call_dummy_breakpoint_offset (gdbarch, 0x30);
+      set_gdbarch_deprecated_call_dummy_length (gdbarch, 0x38);
+
+      /* NOTE: cagney/2003-05-01: Using the just added push_dummy_code
+	 architecture method, it is now possible to implement a
+	 generic dummy frames based inferior function call that stores
+	 the breakpoint (and struct info) on the stack.  Further, by
+	 treating a SIGSEG at a breakpoint as equivalent to a SIGTRAP
+	 it is even possible to make this work when the stack is
+	 no-execute.
+
+	 NOTE: cagney/2002-04-26: Based from info posted by Peter
 	 Schauer around Oct '99.  Briefly, due to aspects of the SPARC
 	 ABI, it isn't possible to use ON_STACK with a strictly
 	 compliant compiler.
@@ -3264,10 +3270,10 @@ sparc_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
 	 are explained in Appendix D.3.  */
 
       set_gdbarch_call_dummy_location (gdbarch, ON_STACK);
-      set_gdbarch_call_dummy_words (gdbarch, call_dummy_32);
+      set_gdbarch_deprecated_call_dummy_words (gdbarch, call_dummy_32);
 #else
       set_gdbarch_deprecated_pc_in_call_dummy (gdbarch, deprecated_pc_in_call_dummy_at_entry_point);
-      set_gdbarch_call_dummy_words (gdbarch, call_dummy_nil);
+      set_gdbarch_deprecated_call_dummy_words (gdbarch, call_dummy_nil);
 #endif
       set_gdbarch_deprecated_call_dummy_stack_adjust (gdbarch, 68);
       set_gdbarch_frame_args_skip (gdbarch, 68);
@@ -3277,19 +3283,18 @@ sparc_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
       set_gdbarch_pc_regnum (gdbarch, SPARC32_PC_REGNUM);
       set_gdbarch_ptr_bit (gdbarch, 4 * TARGET_CHAR_BIT);
       set_gdbarch_deprecated_push_arguments (gdbarch, sparc32_push_arguments);
-      set_gdbarch_read_fp (gdbarch, generic_target_read_fp);
       set_gdbarch_read_sp (gdbarch, generic_target_read_sp);
 
       set_gdbarch_register_byte (gdbarch, sparc32_register_byte);
       set_gdbarch_register_raw_size (gdbarch, sparc32_register_size);
-      set_gdbarch_register_size (gdbarch, 4);
+      set_gdbarch_deprecated_register_size (gdbarch, 4);
       set_gdbarch_register_virtual_size (gdbarch, sparc32_register_size);
       set_gdbarch_register_virtual_type (gdbarch, 
 					 sparc32_register_virtual_type);
 #ifdef SPARC32_CALL_DUMMY_ON_STACK
-      set_gdbarch_sizeof_call_dummy_words (gdbarch, sizeof (call_dummy_32));
+      set_gdbarch_deprecated_sizeof_call_dummy_words (gdbarch, sizeof (call_dummy_32));
 #else
-      set_gdbarch_sizeof_call_dummy_words (gdbarch, 0);
+      set_gdbarch_deprecated_sizeof_call_dummy_words (gdbarch, 0);
 #endif
       set_gdbarch_stack_align (gdbarch, sparc32_stack_align);
       set_gdbarch_deprecated_extra_stack_alignment_needed (gdbarch, 1);
@@ -3312,14 +3317,14 @@ sparc_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
 #ifdef SPARC64_CALL_DUMMY_ON_STACK
       set_gdbarch_deprecated_pc_in_call_dummy (gdbarch, deprecated_pc_in_call_dummy_on_stack);
       set_gdbarch_call_dummy_address (gdbarch, sparc_call_dummy_address);
-      set_gdbarch_call_dummy_breakpoint_offset (gdbarch, 8 * 4);
-      set_gdbarch_call_dummy_length (gdbarch, 192);
+      set_gdbarch_deprecated_call_dummy_breakpoint_offset (gdbarch, 8 * 4);
+      set_gdbarch_deprecated_call_dummy_length (gdbarch, 192);
       set_gdbarch_call_dummy_location (gdbarch, ON_STACK);
-      set_gdbarch_call_dummy_start_offset (gdbarch, 148);
-      set_gdbarch_call_dummy_words (gdbarch, call_dummy_64);
+      set_gdbarch_deprecated_call_dummy_start_offset (gdbarch, 148);
+      set_gdbarch_deprecated_call_dummy_words (gdbarch, call_dummy_64);
 #else
       set_gdbarch_deprecated_pc_in_call_dummy (gdbarch, deprecated_pc_in_call_dummy_at_entry_point);
-      set_gdbarch_call_dummy_words (gdbarch, call_dummy_nil);
+      set_gdbarch_deprecated_call_dummy_words (gdbarch, call_dummy_nil);
 #endif
       set_gdbarch_deprecated_call_dummy_stack_adjust (gdbarch, 128);
       set_gdbarch_frame_args_skip (gdbarch, 136);
@@ -3330,20 +3335,20 @@ sparc_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
       set_gdbarch_ptr_bit (gdbarch, 8 * TARGET_CHAR_BIT);
       set_gdbarch_deprecated_push_arguments (gdbarch, sparc64_push_arguments);
       /* NOTE different for at_entry */
-      set_gdbarch_read_fp (gdbarch, sparc64_read_fp);
+      set_gdbarch_deprecated_target_read_fp (gdbarch, sparc64_read_fp);
       set_gdbarch_read_sp (gdbarch, sparc64_read_sp);
       /* Some of the registers aren't 64 bits, but it's a lot simpler just
 	 to assume they all are (since most of them are).  */
       set_gdbarch_register_byte (gdbarch, sparc64_register_byte);
       set_gdbarch_register_raw_size (gdbarch, sparc64_register_size);
-      set_gdbarch_register_size (gdbarch, 8);
+      set_gdbarch_deprecated_register_size (gdbarch, 8);
       set_gdbarch_register_virtual_size (gdbarch, sparc64_register_size);
       set_gdbarch_register_virtual_type (gdbarch, 
 					 sparc64_register_virtual_type);
 #ifdef SPARC64_CALL_DUMMY_ON_STACK
-      set_gdbarch_sizeof_call_dummy_words (gdbarch, sizeof (call_dummy_64));
+      set_gdbarch_deprecated_sizeof_call_dummy_words (gdbarch, sizeof (call_dummy_64));
 #else
-      set_gdbarch_sizeof_call_dummy_words (gdbarch, 0);
+      set_gdbarch_deprecated_sizeof_call_dummy_words (gdbarch, 0);
 #endif
       set_gdbarch_stack_align (gdbarch, sparc64_stack_align);
       set_gdbarch_deprecated_extra_stack_alignment_needed (gdbarch, 1);
diff --git a/gdb/stack.c b/gdb/stack.c
index 2cb9a95dc3d..0a0aaac2a75 100644
--- a/gdb/stack.c
+++ b/gdb/stack.c
@@ -614,10 +614,25 @@ frame_info (char *addr_exp, int from_tty)
   int i, count, numregs;
   char *funname = 0;
   enum language funlang = language_unknown;
+  const char *pc_regname;
 
   if (!target_has_stack)
     error ("No stack.");
 
+  /* Name of the value returned by get_frame_pc().  Per comments, "pc"
+     is not a good name.  */
+  if (PC_REGNUM >= 0)
+    /* OK, this is weird.  The PC_REGNUM hardware register's value can
+       easily not match that of the internal value returned by
+       get_frame_pc().  */
+    pc_regname = REGISTER_NAME (PC_REGNUM);
+  else
+    /* But then, this is weird to.  Even without PC_REGNUM, an
+       architectures will often have a hardware register called "pc",
+       and that register's value, again, can easily not match
+       get_frame_pc().  */
+    pc_regname = "pc";
+
   fi = parse_frame_specification (addr_exp);
   if (fi == NULL)
     error ("Invalid frame specified.");
@@ -680,7 +695,7 @@ frame_info (char *addr_exp, int from_tty)
       print_address_numeric (get_frame_base (fi), 1, gdb_stdout);
       printf_filtered (":\n");
     }
-  printf_filtered (" %s = ", REGISTER_NAME (PC_REGNUM));
+  printf_filtered (" %s = ", pc_regname);
   print_address_numeric (get_frame_pc (fi), 1, gdb_stdout);
 
   wrap_here ("   ");
@@ -695,7 +710,7 @@ frame_info (char *addr_exp, int from_tty)
     printf_filtered (" (%s:%d)", sal.symtab->filename, sal.line);
   puts_filtered ("; ");
   wrap_here ("    ");
-  printf_filtered ("saved %s ", REGISTER_NAME (PC_REGNUM));
+  printf_filtered ("saved %s ", pc_regname);
   print_address_numeric (frame_pc_unwind (fi), 1, gdb_stdout);
   printf_filtered ("\n");
 
@@ -799,7 +814,7 @@ frame_info (char *addr_exp, int from_tty)
 			       &realnum, NULL);
 	if (!optimized && lval == not_lval)
 	  {
-	    void *value = alloca (MAX_REGISTER_RAW_SIZE);
+	    char value[MAX_REGISTER_SIZE];
 	    CORE_ADDR sp;
 	    frame_register_unwind (fi, SP_REGNUM, &optimized, &lval, &addr,
 				   &realnum, value);
diff --git a/gdb/std-regs.c b/gdb/std-regs.c
index 6078d1ab2b8..93d5102661c 100644
--- a/gdb/std-regs.c
+++ b/gdb/std-regs.c
@@ -74,39 +74,43 @@ value_of_builtin_frame_reg (struct frame_info *frame)
 static struct value *
 value_of_builtin_frame_fp_reg (struct frame_info *frame)
 {
-#ifdef FP_REGNUM
-  if (FP_REGNUM >= 0)
-    return value_of_register (FP_REGNUM, frame);
-#endif
-  {
-    struct value *val = allocate_value (builtin_type_void_data_ptr);
-    char *buf = VALUE_CONTENTS_RAW (val);
-    if (frame == NULL)
-      memset (buf, TYPE_LENGTH (VALUE_TYPE (val)), 0);
-    else
-      ADDRESS_TO_POINTER (builtin_type_void_data_ptr, buf,
-			  get_frame_base (frame));
-    return val;
-  }
+  if (DEPRECATED_FP_REGNUM >= 0)
+    /* NOTE: cagney/2003-04-24: Since the mere presence of "fp" in the
+       register name table overrides this built-in $fp register, there
+       is no real reason for this DEPRECATED_FP_REGNUM trickery here.
+       An architecture wanting to implement "$fp" as alias for a raw
+       register can do so by adding "fp" to register name table (mind
+       you, doing this is probably a dangerous thing).  */
+    return value_of_register (DEPRECATED_FP_REGNUM, frame);
+  else
+    {
+      struct value *val = allocate_value (builtin_type_void_data_ptr);
+      char *buf = VALUE_CONTENTS_RAW (val);
+      if (frame == NULL)
+	memset (buf, TYPE_LENGTH (VALUE_TYPE (val)), 0);
+      else
+	ADDRESS_TO_POINTER (builtin_type_void_data_ptr, buf,
+			    get_frame_base (frame));
+      return val;
+    }
 }
 
 static struct value *
 value_of_builtin_frame_pc_reg (struct frame_info *frame)
 {
-#ifdef PC_REGNUM
   if (PC_REGNUM >= 0)
     return value_of_register (PC_REGNUM, frame);
-#endif
-  {
-    struct value *val = allocate_value (builtin_type_void_data_ptr);
-    char *buf = VALUE_CONTENTS_RAW (val);
-    if (frame == NULL)
-      memset (buf, TYPE_LENGTH (VALUE_TYPE (val)), 0);
-    else
-      ADDRESS_TO_POINTER (builtin_type_void_data_ptr, buf,
-			  get_frame_pc (frame));
-    return val;
-  }
+  else
+    {
+      struct value *val = allocate_value (builtin_type_void_data_ptr);
+      char *buf = VALUE_CONTENTS_RAW (val);
+      if (frame == NULL)
+	memset (buf, TYPE_LENGTH (VALUE_TYPE (val)), 0);
+      else
+	ADDRESS_TO_POINTER (builtin_type_void_data_ptr, buf,
+			    get_frame_pc (frame));
+      return val;
+    }
 }
 
 static struct value *
diff --git a/gdb/symmisc.c b/gdb/symmisc.c
index 70eb125c1ba..636b1d9c1ba 100644
--- a/gdb/symmisc.c
+++ b/gdb/symmisc.c
@@ -987,9 +987,9 @@ maintenance_print_objfiles (char *ignore, int from_tty)
 }
 
 
-/* List all the symbol tables.  */
+/* List all the symbol tables whose names match REGEXP (optional).  */
 void
-maintenance_list_symtabs (char *regexp, int from_tty)
+maintenance_info_symtabs (char *regexp, int from_tty)
 {
   struct objfile *objfile;
 
@@ -1036,9 +1036,9 @@ maintenance_list_symtabs (char *regexp, int from_tty)
 }
 
 
-/* List all the partial symbol tables.  */
+/* List all the partial symbol tables whose names match REGEXP (optional).  */
 void
-maintenance_list_psymtabs (char *regexp, int from_tty)
+maintenance_info_psymtabs (char *regexp, int from_tty)
 {
   struct objfile *objfile;
 
diff --git a/gdb/symtab.c b/gdb/symtab.c
index e144197d606..2c46f9d6751 100644
--- a/gdb/symtab.c
+++ b/gdb/symtab.c
@@ -40,6 +40,7 @@
 #include "linespec.h"
 #include "source.h"
 #include "filenames.h"		/* for FILENAME_CMP */
+#include "objc-lang.h"
 
 #include "hashtab.h"
 
@@ -459,6 +460,18 @@ symbol_find_demangled_name (struct general_symbol_info *gsymbol,
 
   if (gsymbol->language == language_unknown)
     gsymbol->language = language_auto;
+
+  if (gsymbol->language == language_objc
+      || gsymbol->language == language_auto)
+    {
+      demangled =
+	objc_demangle (mangled, 0);
+      if (demangled != NULL)
+	{
+	  gsymbol->language = language_objc;
+	  return demangled;
+	}
+    }
   if (gsymbol->language == language_cplus
       || gsymbol->language == language_auto)
     {
@@ -607,7 +620,8 @@ symbol_init_demangled_name (struct general_symbol_info *gsymbol,
 
   demangled = symbol_find_demangled_name (gsymbol, mangled);
   if (gsymbol->language == language_cplus
-      || gsymbol->language == language_java)
+      || gsymbol->language == language_java
+      || gsymbol->language == language_objc)
     {
       if (demangled)
 	{
@@ -993,7 +1007,7 @@ lookup_symbol_aux (const char *name, const char *mangled_name,
     }
 #endif /* 0 */
 
-  /* C++: If requested to do so by the caller, 
+  /* C++/Java/Objective-C: If requested to do so by the caller, 
      check to see if NAME is a field of `this'. */
   if (is_a_field_of_this)
     {
@@ -1653,9 +1667,9 @@ find_main_psymtab (void)
    for now we don't worry about the slight inefficiency of looking for
    a match we'll never find, since it will go pretty quick.  Once the
    binary search terminates, we drop through and do a straight linear
-   search on the symbols.  Each symbol which is marked as being a C++
-   symbol (language_cplus set) has both the encoded and non-encoded names
-   tested for a match.
+   search on the symbols.  Each symbol which is marked as being a ObjC/C++
+   symbol (language_cplus or language_objc set) has both the encoded and 
+   non-encoded names tested for a match.
 
    If MANGLED_NAME is non-NULL, verify that any symbol we find has this
    particular mangled name.
diff --git a/gdb/symtab.h b/gdb/symtab.h
index 05275363936..4330b962257 100644
--- a/gdb/symtab.h
+++ b/gdb/symtab.h
@@ -1233,9 +1233,9 @@ void maintenance_print_msymbols (char *, int);
 
 void maintenance_print_objfiles (char *, int);
 
-void maintenance_list_symtabs (char *, int);
+void maintenance_info_symtabs (char *, int);
 
-void maintenance_list_psymtabs (char *, int);
+void maintenance_info_psymtabs (char *, int);
 
 void maintenance_check_symtabs (char *, int);
 
diff --git a/gdb/target.c b/gdb/target.c
index 4de246cc174..fd0165a19ba 100644
--- a/gdb/target.c
+++ b/gdb/target.c
@@ -1215,7 +1215,7 @@ find_default_create_inferior (char *exec_file, char *allargs, char **env)
 static int
 default_region_size_ok_for_hw_watchpoint (int byte_count)
 {
-  return (byte_count <= REGISTER_SIZE);
+  return (byte_count <= DEPRECATED_REGISTER_SIZE);
 }
 
 static int
@@ -1640,7 +1640,7 @@ debug_print_register (const char * func, int regno)
   if (regno >= 0)
     {
       int i;
-      unsigned char *buf = alloca (MAX_REGISTER_RAW_SIZE);
+      unsigned char buf[MAX_REGISTER_SIZE];
       deprecated_read_register_gen (regno, buf);
       fprintf_unfiltered (gdb_stdlog, " = ");
       for (i = 0; i < REGISTER_RAW_SIZE (regno); i++)
diff --git a/gdb/target.h b/gdb/target.h
index b3f43fce577..e757b6701d9 100644
--- a/gdb/target.h
+++ b/gdb/target.h
@@ -836,15 +836,15 @@ extern void target_load (char *arg, int from_tty);
 #define target_async(CALLBACK,CONTEXT) \
      (current_target.to_async((CALLBACK), (CONTEXT)))
 
-/* This is to be used ONLY within run_stack_dummy(). It
-   provides a workaround, to have inferior function calls done in
-   sychronous mode, even though the target is asynchronous. After
+/* This is to be used ONLY within call_function_by_hand(). It provides
+   a workaround, to have inferior function calls done in sychronous
+   mode, even though the target is asynchronous. After
    target_async_mask(0) is called, calls to target_can_async_p() will
    return FALSE , so that target_resume() will not try to start the
    target asynchronously. After the inferior stops, we IMMEDIATELY
    restore the previous nature of the target, by calling
    target_async_mask(1). After that, target_can_async_p() will return
-   TRUE. ANY OTHER USE OF THIS FEATURE IS DEPRECATED. 
+   TRUE. ANY OTHER USE OF THIS FEATURE IS DEPRECATED.
 
    FIXME ezannoni 1999-12-13: we won't need this once we move
    the turning async on and off to the single execution commands,
diff --git a/gdb/testsuite/ChangeLog b/gdb/testsuite/ChangeLog
index 7ace1507cf4..22ac56a3c1c 100644
--- a/gdb/testsuite/ChangeLog
+++ b/gdb/testsuite/ChangeLog
@@ -1,3 +1,56 @@
+2003-05-08  Jeff Johnston  <jjohnstn@redhat.com>
+
+	* gdb.threads/schedlock.exp: Remove assumption that all threads 
+	will run in a particular small time slice.  Also ensure we break 
+	in one of the child threads rather than the main thread.
+
+2003-05-07  Jim Blandy  <jimb@redhat.com>
+
+	Add support for assembly source testing on the s390x.
+	* gdb.asm/asm-source.exp: Add a case for the s390x-*-*
+	architecture.
+	* gdb.asm/s390x.inc: New file.
+
+	* gdb.asm/asm-source.exp: Use a 'switch -glob' statement, not a
+	succession of 'if' statements.
+
+2003-05-05  Andrew Cagney  <cagney@redhat.com>
+
+	* gdb.base/maint.exp: Add tests for "maint print dummy-frames".
+
+2003-05-05  Andrew Cagney  <cagney@redhat.com>
+
+	* gdb.base/watchpoint.exp: Rename CALL_DUMMY_BREAKPOINT_OFFSET to
+	DEPRECATED_CALL_DUMMY_BREAKPOINT_OFFSET in comments.
+
+2003-05-02  Elena Zannoni  <ezannoni@redhat.com>
+
+	* gdb.base/charset.exp: Update based on new behavior of set/show
+	charset commands.
+
+2003-05-01  Andrew Cagney  <cagney@redhat.com>
+
+	* gdb.asm/asm-source.exp: Check that "disassm" and "x/i" of a
+	variable do not give memory errors.
+
+2003-04-30  Adam Fedor  <fedor@gnu.org>
+
+	* Makefile.in (ALL_SUBDIRS): Add gdb.objc
+	* configure.in (AC_OUTPUT): Add gdb.objc/Makefile
+	* gdb.objc/Makefile.in, gdb.objc/basicclass.exp,
+	gdb.objc/basicclass.m: : New files
+
+	* lib/gdb.exp (gdb_compile_objc): New procedure.
+
+2003-04-27  Daniel Jacobowitz  <drow@mvista.com>
+
+	* gdb.base/signals.exp: Make backtrace tests more specific.
+
+2003-04-23  David Carlton  <carlton@bactrian.org>
+
+	* gdb.c++/maint.exp (test_first_component): Add tests for
+	'operator' in more locations.
+
 2003-04-16  Kevin Buettner  <kevinb@redhat.com>
 
 	* gdb.base/args.exp: Invoke gdb_load for simulator targets.
diff --git a/gdb/testsuite/Makefile.in b/gdb/testsuite/Makefile.in
index c0ba9ab79c2..898e6ed28b4 100644
--- a/gdb/testsuite/Makefile.in
+++ b/gdb/testsuite/Makefile.in
@@ -36,7 +36,7 @@ EXEEXT = @EXEEXT@
 SUBDIRS = @subdirs@
 RPATH_ENVVAR = @RPATH_ENVVAR@
 ALL_SUBDIRS = gdb.arch gdb.asm gdb.base gdb.c++ gdb.disasm gdb.java gdb.mi \
-	gdb.threads gdb.trace $(SUBDIRS)
+	gdb.objc gdb.threads gdb.trace $(SUBDIRS)
 
 EXPECT = `if [ -f $${rootme}/../../expect/expect ] ; then \
           echo $${rootme}/../../expect/expect ; \
diff --git a/gdb/testsuite/configure b/gdb/testsuite/configure
index 2a2494e886a..31e3a079f95 100755
--- a/gdb/testsuite/configure
+++ b/gdb/testsuite/configure
@@ -34,7 +34,6 @@ program_suffix=NONE
 program_transform_name=s,x,x,
 silent=
 site=
-sitefile=
 srcdir=
 target=NONE
 verbose=
@@ -149,7 +148,6 @@ Configuration:
   --help                  print this message
   --no-create             do not create output files
   --quiet, --silent       do not print \`checking...' messages
-  --site-file=FILE        use FILE as the site file
   --version               print the version of autoconf that created configure
 Directory and file names:
   --prefix=PREFIX         install architecture-independent files in PREFIX
@@ -320,11 +318,6 @@ EOF
   -site=* | --site=* | --sit=*)
     site="$ac_optarg" ;;
 
-  -site-file | --site-file | --site-fil | --site-fi | --site-f)
-    ac_prev=sitefile ;;
-  -site-file=* | --site-file=* | --site-fil=* | --site-fi=* | --site-f=*)
-    sitefile="$ac_optarg" ;;
-
   -srcdir | --srcdir | --srcdi | --srcd | --src | --sr)
     ac_prev=srcdir ;;
   -srcdir=* | --srcdir=* | --srcdi=* | --srcd=* | --src=* | --sr=*)
@@ -490,16 +483,12 @@ fi
 srcdir=`echo "${srcdir}" | sed 's%\([^/]\)/*$%\1%'`
 
 # Prefer explicitly selected file to automatically selected ones.
-if test -z "$sitefile"; then
-  if test -z "$CONFIG_SITE"; then
-    if test "x$prefix" != xNONE; then
-      CONFIG_SITE="$prefix/share/config.site $prefix/etc/config.site"
-    else
-      CONFIG_SITE="$ac_default_prefix/share/config.site $ac_default_prefix/etc/config.site"
-    fi
+if test -z "$CONFIG_SITE"; then
+  if test "x$prefix" != xNONE; then
+    CONFIG_SITE="$prefix/share/config.site $prefix/etc/config.site"
+  else
+    CONFIG_SITE="$ac_default_prefix/share/config.site $ac_default_prefix/etc/config.site"
   fi
-else
-  CONFIG_SITE="$sitefile"
 fi
 for ac_site_file in $CONFIG_SITE; do
   if test -r "$ac_site_file"; then
@@ -560,7 +549,7 @@ ac_config_sub=$ac_aux_dir/config.sub
 ac_configure=$ac_aux_dir/configure # This should be Cygnus configure.
 
 echo $ac_n "checking build system type""... $ac_c" 1>&6
-echo "configure:564: checking build system type" >&5
+echo "configure:553: checking build system type" >&5
 
 build_alias=$build
 case "$build_alias" in
@@ -584,7 +573,7 @@ else { echo "configure: error: can not run $ac_config_sub" 1>&2; exit 1; }
 fi
 
 echo $ac_n "checking host system type""... $ac_c" 1>&6
-echo "configure:588: checking host system type" >&5
+echo "configure:577: checking host system type" >&5
 
 host_alias=$host
 case "$host_alias" in
@@ -605,7 +594,7 @@ host_os=`echo $host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
 echo "$ac_t""$host" 1>&6
 
 echo $ac_n "checking target system type""... $ac_c" 1>&6
-echo "configure:609: checking target system type" >&5
+echo "configure:598: checking target system type" >&5
 
 target_alias=$target
 case "$target_alias" in
@@ -720,7 +709,7 @@ fi
 
 
 echo $ac_n "checking how to run the C preprocessor""... $ac_c" 1>&6
-echo "configure:724: checking how to run the C preprocessor" >&5
+echo "configure:713: checking how to run the C preprocessor" >&5
 # On Suns, sometimes $CPP names a directory.
 if test -n "$CPP" && test -d "$CPP"; then
   CPP=
@@ -735,13 +724,13 @@ else
   # On the NeXT, cc -E runs the code through the compiler's parser,
   # not just through cpp.
   cat > conftest.$ac_ext <<EOF
-#line 739 "configure"
+#line 728 "configure"
 #include "confdefs.h"
 #include <assert.h>
 Syntax Error
 EOF
 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
-{ (eval echo configure:745: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
+{ (eval echo configure:734: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
 if test -z "$ac_err"; then
   :
@@ -752,13 +741,13 @@ else
   rm -rf conftest*
   CPP="${CC-cc} -E -traditional-cpp"
   cat > conftest.$ac_ext <<EOF
-#line 756 "configure"
+#line 745 "configure"
 #include "confdefs.h"
 #include <assert.h>
 Syntax Error
 EOF
 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
-{ (eval echo configure:762: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
+{ (eval echo configure:751: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
 if test -z "$ac_err"; then
   :
@@ -769,13 +758,13 @@ else
   rm -rf conftest*
   CPP="${CC-cc} -nologo -E"
   cat > conftest.$ac_ext <<EOF
-#line 773 "configure"
+#line 762 "configure"
 #include "confdefs.h"
 #include <assert.h>
 Syntax Error
 EOF
 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
-{ (eval echo configure:779: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
+{ (eval echo configure:768: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
 if test -z "$ac_err"; then
   :
@@ -803,17 +792,17 @@ for ac_hdr in pthread.h
 do
 ac_safe=`echo "$ac_hdr" | sed 'y%./+-%__p_%'`
 echo $ac_n "checking for $ac_hdr""... $ac_c" 1>&6
-echo "configure:807: checking for $ac_hdr" >&5
+echo "configure:796: checking for $ac_hdr" >&5
 if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
   cat > conftest.$ac_ext <<EOF
-#line 812 "configure"
+#line 801 "configure"
 #include "confdefs.h"
 #include <$ac_hdr>
 EOF
 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
-{ (eval echo configure:817: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
+{ (eval echo configure:806: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
 if test -z "$ac_err"; then
   rm -rf conftest*
@@ -841,12 +830,12 @@ done
 
 
 echo $ac_n "checking for Cygwin environment""... $ac_c" 1>&6
-echo "configure:845: checking for Cygwin environment" >&5
+echo "configure:834: checking for Cygwin environment" >&5
 if eval "test \"`echo '$''{'ac_cv_cygwin'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
   cat > conftest.$ac_ext <<EOF
-#line 850 "configure"
+#line 839 "configure"
 #include "confdefs.h"
 
 int main() {
@@ -857,7 +846,7 @@ int main() {
 return __CYGWIN__;
 ; return 0; }
 EOF
-if { (eval echo configure:861: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
+if { (eval echo configure:850: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
   rm -rf conftest*
   ac_cv_cygwin=yes
 else
@@ -874,19 +863,19 @@ echo "$ac_t""$ac_cv_cygwin" 1>&6
 CYGWIN=
 test "$ac_cv_cygwin" = yes && CYGWIN=yes
 echo $ac_n "checking for mingw32 environment""... $ac_c" 1>&6
-echo "configure:878: checking for mingw32 environment" >&5
+echo "configure:867: checking for mingw32 environment" >&5
 if eval "test \"`echo '$''{'ac_cv_mingw32'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
   cat > conftest.$ac_ext <<EOF
-#line 883 "configure"
+#line 872 "configure"
 #include "confdefs.h"
 
 int main() {
 return __MINGW32__;
 ; return 0; }
 EOF
-if { (eval echo configure:890: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
+if { (eval echo configure:879: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
   rm -rf conftest*
   ac_cv_mingw32=yes
 else
@@ -905,7 +894,7 @@ test "$ac_cv_mingw32" = yes && MINGW32=yes
 
 
 echo $ac_n "checking for executable suffix""... $ac_c" 1>&6
-echo "configure:909: checking for executable suffix" >&5
+echo "configure:898: checking for executable suffix" >&5
 if eval "test \"`echo '$''{'ac_cv_exeext'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
@@ -915,10 +904,10 @@ else
   rm -f conftest*
   echo 'int main () { return 0; }' > conftest.$ac_ext
   ac_cv_exeext=
-  if { (eval echo configure:919: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; }; then
+  if { (eval echo configure:908: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; }; then
     for file in conftest.*; do
       case $file in
-      *.c | *.C | *.o | *.obj | *.ilk | *.pdb) ;;
+      *.c | *.o | *.obj) ;;
       *) ac_cv_exeext=`echo $file | sed -e s/conftest//` ;;
       esac
     done
@@ -1040,7 +1029,7 @@ ac_given_srcdir=$srcdir
 
 trap 'rm -fr `echo "Makefile gdb.arch/Makefile gdb.asm/Makefile gdb.base/Makefile \
   gdb.c++/Makefile gdb.disasm/Makefile gdb.java/Makefile gdb.mi/Makefile \
-  gdb.threads/Makefile gdb.trace/Makefile config.h:config.hin" | sed "s/:[^ ]*//g"` conftest*; exit 1' 1 2 15
+  gdb.objc/Makefile gdb.threads/Makefile gdb.trace/Makefile config.h:config.hin" | sed "s/:[^ ]*//g"` conftest*; exit 1' 1 2 15
 EOF
 cat >> $CONFIG_STATUS <<EOF
 
@@ -1134,7 +1123,7 @@ cat >> $CONFIG_STATUS <<EOF
 
 CONFIG_FILES=\${CONFIG_FILES-"Makefile gdb.arch/Makefile gdb.asm/Makefile gdb.base/Makefile \
   gdb.c++/Makefile gdb.disasm/Makefile gdb.java/Makefile gdb.mi/Makefile \
-  gdb.threads/Makefile gdb.trace/Makefile"}
+  gdb.objc/Makefile gdb.threads/Makefile gdb.trace/Makefile"}
 EOF
 cat >> $CONFIG_STATUS <<\EOF
 for ac_file in .. $CONFIG_FILES; do if test "x$ac_file" != x..; then
diff --git a/gdb/testsuite/configure.in b/gdb/testsuite/configure.in
index 8ba930f1600..f80b623cd36 100644
--- a/gdb/testsuite/configure.in
+++ b/gdb/testsuite/configure.in
@@ -115,4 +115,4 @@ AC_EXEEXT
 AC_CONFIG_SUBDIRS($configdirs)
 AC_OUTPUT([Makefile gdb.arch/Makefile gdb.asm/Makefile gdb.base/Makefile \
   gdb.c++/Makefile gdb.disasm/Makefile gdb.java/Makefile gdb.mi/Makefile \
-  gdb.threads/Makefile gdb.trace/Makefile])
+  gdb.objc/Makefile gdb.threads/Makefile gdb.trace/Makefile])
diff --git a/gdb/testsuite/gdb.asm/asm-source.exp b/gdb/testsuite/gdb.asm/asm-source.exp
index ac1bcd28fe0..e4aa7be4fd9 100644
--- a/gdb/testsuite/gdb.asm/asm-source.exp
+++ b/gdb/testsuite/gdb.asm/asm-source.exp
@@ -35,60 +35,66 @@ set asm-arch ""
 set asm-flags ""
 set link-flags ""
 
-if [istarget "*arm-*-*"] then {
-    set asm-arch arm
-}
-if [istarget "xscale-*-*"] then {
-    set asm-arch arm
-}
-if [istarget "d10v-*-*"] then {
-    set asm-arch d10v
-}
-if [istarget "s390-*-*"] then {
-    set asm-arch s390
-}
-if [istarget "x86_64-*-*"] then {
-    set asm-arch x86_64
-    set asm-flags "-gdwarf2 -I${srcdir}/${subdir} -I${objdir}/${subdir}"
-}
-if [istarget "i\[3456\]86-*-*"] then {
-    set asm-arch i386
-    if [istarget "*-*-cygwin*"] then {
-        set link-flags "--entry _start"
+switch -glob -- [istarget] {
+    "*arm-*-*" {
+        set asm-arch arm
+    }
+    "xscale-*-*" {
+        set asm-arch arm
+    }
+    "d10v-*-*" {
+        set asm-arch d10v
+    }
+    "s390-*-*" {
+        set asm-arch s390
+    }
+    "s390x-*-*" {
+        set asm-arch s390x
+    }
+    "x86_64-*-*" {
+        set asm-arch x86_64
+        set asm-flags "-gdwarf2 -I${srcdir}/${subdir} -I${objdir}/${subdir}"
+    }
+    "i\[3456\]86-*-*" {
+        set asm-arch i386
+        if [istarget "*-*-cygwin*"] then {
+            set link-flags "--entry _start"
+        }
+    }
+    "m32r*-*" {
+        set asm-arch m32r
+    }
+    "m6811-*-*" {
+        set asm-arch m68hc11
+        set asm-flags "-mshort-double -m68hc11 -gdwarf2 --no-warn -I${srcdir}/${subdir} -I${objdir}/${subdir}"
+    }
+    "m6812-*-*" {
+        set asm-arch m68hc11
+        set asm-flags "-mshort-double -m68hc12 -gdwarf2 --no-warn -I${srcdir}/${subdir} -I${objdir}/${subdir}"
+    }
+    "mips*-*" {
+        set asm-arch mips
+    }
+    "powerpc*-*" {
+        set asm-arch powerpc
+    }
+    "sparc-*-*" {
+        set asm-arch sparc
+    }
+    "sparc64-*-*" {
+        set asm-arch sparc64
+        set asm-flags "-xarch=v9 -gstabs -I${srcdir}/${subdir} -I${objdir}/${subdir}"
+    }
+    "xstormy16-*-*" {
+        set asm-arch xstormy16
+        set asm-flags "-gdwarf2 -I${srcdir}/${subdir} -I${objdir}/${subdir}"
+    }
+    "v850-*-*" {
+        set asm-arch v850
+        set gdb_wrapper_initialized 1
     }
 }
-if [istarget "m32r*-*"] then {
-    set asm-arch m32r
-}
-if [istarget "m6811-*-*"] then {
-    set asm-arch m68hc11
-    set asm-flags "-mshort-double -m68hc11 -gdwarf2 --no-warn -I${srcdir}/${subdir} -I${objdir}/${subdir}"
-}
-if [istarget "m6812-*-*"] then {
-    set asm-arch m68hc11
-    set asm-flags "-mshort-double -m68hc12 -gdwarf2 --no-warn -I${srcdir}/${subdir} -I${objdir}/${subdir}"
-}
-if [istarget "mips*-*"] then {
-    set asm-arch mips
-}
-if [istarget "powerpc*-*"] then {
-    set asm-arch powerpc
-}
-if [istarget "sparc-*-*"] then {
-    set asm-arch sparc
-}
-if [istarget "sparc64-*-*"] then {
-    set asm-arch sparc64
-    set asm-flags "-xarch=v9 -gstabs -I${srcdir}/${subdir} -I${objdir}/${subdir}"
-}
-if [istarget "xstormy16-*-*"] then {
-    set asm-arch xstormy16
-    set asm-flags "-gdwarf2 -I${srcdir}/${subdir} -I${objdir}/${subdir}"
-}
-if [istarget "v850-*-*"] then {
-    set asm-arch v850
-    set gdb_wrapper_initialized 1
-}
+
 if { "${asm-arch}" == "" } {
     gdb_suppress_entire_file "Assembly source test -- not implemented for this target."
 }
@@ -293,11 +299,35 @@ gdb_test "next" "17\[ \t\]+gdbasm_leave" "next over foo3"
 gdb_test "return" "\#0  main .*37\[ \t\]+gdbasm_exit0" "return from foo2" \
 	"Make (foo2|selected stack frame) return now\?.*" "y"
 
-# See if we can look at a global variable
+# Disassemble something, check the output
+proc test_dis { command var } {
+    global gdb_prompt
+    send_gdb "${command}\n"
+    gdb_expect {
+	-re "${var}.*:.*Cannot access" {
+	    # The "disassembler" was only accessing the local
+	    # executable and that would cause attempts to disassemble
+	    # variables to fail (memory not valid).
+	    fail "${command} (memory read error)"
+	}
+	-re "${var}.*:.*${gdb_prompt}" {
+	    pass "${command}"
+	}
+	timeout {
+	    fail "${command} (timeout)"
+	}
+    }
+}
+
+# See if we can look at a global variable, three ways
 gdb_test "print globalvar" ".* = 11" "look at global variable"
+test_dis "x/i globalvar" "globalvar"
+test_dis "disassem &globalvar &globalvar+1" "globalvar"
 
-# See if we can look at a static variable
+# See if we can look at a static variable, three ways
 gdb_test "print staticvar" ".* = 5" "look at static variable"
+test_dis "x/i &staticvar" "staticvar"
+test_dis "disassem &staticvar &staticvar+1" "staticvar"
 
 # See if we can look at a static function
 gdb_test "disassem foostatic" ".*<foostatic\\+0>:.*End of assembler dump." \
diff --git a/gdb/testsuite/gdb.asm/s390x.inc b/gdb/testsuite/gdb.asm/s390x.inc
new file mode 100644
index 00000000000..4e5bf2ea65d
--- /dev/null
+++ b/gdb/testsuite/gdb.asm/s390x.inc
@@ -0,0 +1,68 @@
+### entry point code
+        .macro gdbasm_startup
+
+        # Align the stack pointer to an 8-byte boundary.
+        lghi %r0,-16
+        ngr %r15,%r0
+
+        # Reserve space for the standard stack frame:
+        # back chain, and space for the callee to save its registers.
+        aghi %r15,-168
+        
+        # Zero this frame's back chain pointer.
+        xc 0(8,%r15),0(%r15)
+        .endm
+
+
+### Call a function.
+        .macro gdbasm_call subr
+        brasl %r14, \subr
+        .endm
+
+
+### Exit with a zero status.
+        .macro gdbasm_exit0
+        lghi %r2, 0
+        svc 1
+        .endm
+
+### Standard subroutine prologue.
+        .macro gdbasm_enter
+
+        # Save all the callee-saves registers.  What the heck.
+        stmg %r6,%r15,48(%r15)
+
+        # Allocate the stack frame, and write the back chain pointer.
+        # Keep the original SP in %r11.
+        lgr %r11,%r15
+        aghi %r15,-168
+        stg %r11,0(%r15)
+        .endm
+
+
+### Standard subroutine epilogue.
+        .macro gdbasm_leave
+
+        # Restore all our registers.  This also pops the frame, and
+	# restores our return address.
+        lmg %r6,%r15,216(%r15)
+
+        # Jump to the return address.
+        br %r14
+
+        .endm
+
+### Several nops.
+        .macro gdbasm_several_nops
+        lr %r0, %r0
+        lr %r0, %r0
+        lr %r0, %r0
+        lr %r0, %r0
+        .endm
+
+### Declare an `int' variable.
+        .macro gdbasm_datavar name value
+        .data
+\name:
+        .long \value
+        .endm
diff --git a/gdb/testsuite/gdb.base/charset.exp b/gdb/testsuite/gdb.base/charset.exp
index 8e765aa3a95..e17bb14bbce 100644
--- a/gdb/testsuite/gdb.base/charset.exp
+++ b/gdb/testsuite/gdb.base/charset.exp
@@ -48,11 +48,23 @@ proc parse_show_charset_output {testname} {
         -re "The current host and target character set is `(.*)'\\.\[\r\n\]+$gdb_prompt $" {
             set host_charset $expect_out(1,string)
             set target_charset $expect_out(1,string)
+	    set retlist [list $host_charset $target_charset]
             pass $testname
         }
         -re "The current host character set is `(.*)'\\.\[\r\n\]+The current target character set is `(.*)'\\.\[\r\n\]+$gdb_prompt $" {
             set host_charset $expect_out(1,string)
             set target_charset $expect_out(2,string)
+	    set retlist [list $host_charset $target_charset]
+            pass $testname
+        }
+        -re "The host character set is \"(.*)\"\\.\[\r\n\]+$gdb_prompt $" {
+            set host_charset $expect_out(1,string)
+	    set retlist [list $host_charset]
+            pass $testname
+        }
+        -re "The target character set is \"(.*)\"\\.\[\r\n\]+$gdb_prompt $" {
+            set target_charset $expect_out(1,string)
+	    set retlist [list $target_charset]
             pass $testname
         }
         -re ".*$gdb_prompt $" {
@@ -63,7 +75,7 @@ proc parse_show_charset_output {testname} {
         }
     }
 
-    return [list $host_charset $target_charset]
+    return $retlist
 }
 
 
@@ -77,7 +89,7 @@ set show_charset [parse_show_charset_output "show charset"]
 send_gdb "show target-charset\n"
 set show_target_charset [parse_show_charset_output "show target-charset"]
 
-if {! [string compare $show_charset $show_target_charset]} {
+if {[lsearch $show_charset $show_target_charset] >= 0} {
     pass "check `show target-charset' against `show charset'"
 } else {
     fail "check `show target-charset' against `show charset'"
@@ -86,21 +98,71 @@ if {! [string compare $show_charset $show_target_charset]} {
 send_gdb "show host-charset\n"
 set show_host_charset [parse_show_charset_output "show host-charset"]
 
-if {! [string compare $show_charset $show_host_charset]} {
+if {[lsearch $show_charset $show_host_charset] >= 0} {
     pass "check `show host-charset' against `show charset'"
 } else {
     fail "check `show host-charset' against `show charset'"
 }
 
 
-# Get the list of supported charsets.
-send_gdb "set charset\n"
+# Get the list of supported (host) charsets as possible completions.
+send_gdb "set charset \t\t"
 
-# True iff we've seen the "Valid character sets are:" message.
-set seen_valid 0
+# Check that we can at least use ASCII as a host character set.
+sleep 1
+gdb_expect {
+    -re "^set charset .*\r\nASCII.*\r\n$gdb_prompt set charset " {
+	# We got the output that we wanted, including ASCII as possible
+	# charset. Send a newline to get us back to the prompt. This will
+	# also generate an error message. Let's not check here that the error
+	# message makes sense, we do that below, as a separate testcase.
+        send_gdb "\n"
+        gdb_expect {
+	    -re ".*Requires an argument.*$gdb_prompt $" {
+		pass "get valid character sets"
+	    }
+	    -re ".*$gdb_prompt $" {
+		send_gdb "\n"
+		gdb_expect {
+		    -re ".*$gdb_prompt $" {
+			fail "get valid character sets"
+		    }
+		}
+	    }
+	    timeout {
+		fail "(timeout) get valid character sets"
+	    }
+	}
+    }
+    -re ".*$gdb_prompt $" {
+	# We got some output that ended with a regular prompt
+        fail "get valid character sets"
+    }
+    -re "^set charset.*$" {
+	# We got some other output, send a cntrl-c to gdb to get us back
+        # to the prompt.
+	send_gdb "\003"
+        fail "get valid character sets"
+    }
+    timeout {
+        fail "get valid character sets (timeout)"
+    }
+}
+
+# Try a malformed `set charset'.
+gdb_test "set charset" \
+         "Requires an argument. Valid arguments are.*" \
+         "try malformed `set charset'"
+
+# Try using `set host-charset' on an invalid character set.
+gdb_test "set host-charset my_grandma_bonnie" \
+         "Undefined item: \"my_grandma_bonnie\"." \
+         "try `set host-charset' with invalid charset"
 
-# True iff we've seen the "can be used as a host character set" message.
-set seen_can_host 0
+# Try using `set target-charset' on an invalid character set.
+gdb_test "set target-charset my_grandma_bonnie" \
+         "Undefined item: \"my_grandma_bonnie\"." \
+         "try `set target-charset' with invalid charset"
 
 # A Tcl array mapping the names of all the character sets we've seen
 # to "1" if the character set can be used as a host character set, or
@@ -113,73 +175,73 @@ proc all_charset_names {} {
     return [array names charsets]
 }
 
-proc charset_exists {charset} {
-    global charsets
-    return [info exists charsets($charset)]
-}
-
 proc valid_host_charset {charset} {
     global charsets
     return $charsets($charset)
 }
 
+send_gdb "set host-charset\n"
 gdb_expect {
-    -re "Valid character sets are:\[\r\n\]+" {
-        # There's no ^ at the beginning of the pattern above, so that
-        # expect can skip the echoed `set charset' command.
-        set seen_valid 1
-        exp_continue
+    -re "Requires an argument. Valid arguments are (\[^ \t\n\r,.\]*)" {
+	#set host_charset_list $expect_out(1,string)
+	set charsets($expect_out(1,string)) 1
+	exp_continue
+	#pass "capture valid host charsets"
     }
-    -re "^  (\[^ \t\n\]*) \\*\[\r\n\]+" {
-        set charsets($expect_out(1,string)) 1
-        exp_continue
-    }
-    -re "^  (\[^ \t\n\]*)\[ \t\]*\[\r\n\]+" {
-        set charsets($expect_out(1,string)) 0
-        exp_continue
+
+    -re ", (\[^ \t\n\r,.\]*)" {
+	#set host_charset_list $expect_out(1,string)
+	set charsets($expect_out(1,string)) 1
+	exp_continue
+	#pass "capture valid host charsets"
     }
-    -re "^\\* - can be used as a host character set\[\r\n\]+" {
-        set seen_can_host 1
-        exp_continue
+
+    -re "\\.\r\n$gdb_prompt $" {
+	#set host_charset_list $expect_out(1,string)
+	set charsets($expect_out(1,string)) 1
+	pass "capture valid host charsets"
     }
-    -re ".*${gdb_prompt} $" {
-        # We don't do an exp_continue here.
+
+    -re ".*$gdb_prompt $" {
+	fail "capture valid host charsets"
     }
     timeout {
-        fail "get valid character sets (timeout)"
+	fail "(timeout) capture valid host charsets"
     }
 }
 
 
-# Check that we've seen all the right pieces of the output, and that
-# we can at least use ASCII as a host character set.
-if {$seen_valid && $seen_can_host && [charset_exists ascii]} {
-    # We can't do the below as part of the test above, since all the
-    # [] substitution takes place before any expression evaluation
-    # takes place; && doesn't really short circuit things the way
-    # you'd like.  We'd get an "can't read $charsets(ascii)" error
-    # even when `info exists' had returned zero.
-    if {[valid_host_charset ascii]} {
-        pass "get valid character sets"
-    } else {
-        fail "get valid character sets"
+send_gdb "set target-charset\n"
+gdb_expect {
+    -re "Requires an argument. Valid arguments are (\[^ \t\n\r,.\]*)" {
+	set target_charset $expect_out(1,string)
+	if {! [info exists charsets($target_charset)]} {
+	    set charsets($target_charset) 0
+	}
+	exp_continue
     }
-} else {
-    fail "get valid character sets (no ascii charset)"
-}
 
+    -re ", (\[^ \t\n\r,.\]*)" {
+	set target_charset $expect_out(1,string)
+	if {! [info exists charsets($target_charset)]} {
+	    set charsets($target_charset) 0
+	}
+	exp_continue
+    }
 
-# Try using `set host-charset' on an invalid character set.
-gdb_test "set host-charset my_grandma_bonnie" \
-         "GDB doesn't know of any character set named `my_grandma_bonnie'." \
-         "try `set host-charset' with invalid charset"
+    -re "\\.\r\n$gdb_prompt $" {
+	pass "capture valid target charsets"
 
+    }
 
-# Try using `set target-charset' on an invalid character set.
-gdb_test "set target-charset my_grandma_bonnie" \
-         "GDB doesn't know of any character set named `my_grandma_bonnie'." \
-         "try `set target-charset' with invalid charset"
+    -re ".*$gdb_prompt $" {
+	fail "capture valid target charsets"
+    }
 
+    timeout {
+	fail "(timeout) capture valid target charsets"
+    }
+}
 
 # Make sure that GDB supports every host/target charset combination.
 foreach host_charset [all_charset_names] {
@@ -341,7 +403,7 @@ gdb_expect {
 }
 
 
-gdb_test "set host-charset ascii" ""
+gdb_test "set host-charset ASCII" ""
 foreach target_charset [all_charset_names] {
     send_gdb "set target-charset $target_charset\n" 
     gdb_expect {
diff --git a/gdb/testsuite/gdb.base/maint.exp b/gdb/testsuite/gdb.base/maint.exp
index d8286508699..f82bf0202b0 100644
--- a/gdb/testsuite/gdb.base/maint.exp
+++ b/gdb/testsuite/gdb.base/maint.exp
@@ -35,6 +35,7 @@
 #maintenance info -- Commands for showing internal info about the program being debugged
 #maintenance internal-error -- Give GDB an internal error.
 #
+#maintenance print dummy-frames -- Print the dummy frame stack
 #maintenance print statistics -- Print statistics about internal gdb state
 #maintenance print objfiles -- Print dump of current object file definitions
 #maintenance print psymbols -- Print dump of current partial symbol definitions
@@ -186,6 +187,9 @@ gdb_expect  {
         timeout         { fail "(timeout) maint print statistics" }
         }
 
+# There aren't any ...
+gdb_test "maint print dummy-frames" ""
+
 send_gdb "maint print objfiles\n"
 
 # To avoid timeouts, we avoid expects with many .* patterns that match
@@ -524,6 +528,9 @@ gdb_expect  {
         timeout         { fail "(timeout) help maint print statistics" }
         }
 
+gdb_test "help maint print dummy-frames" \
+	"Print the contents of the internal dummy-frame stack."
+
 send_gdb "help maint print objfiles\n"
 gdb_expect  {
         -re "Print dump of current object file definitions\\..*$gdb_prompt $"\
diff --git a/gdb/testsuite/gdb.base/signals.exp b/gdb/testsuite/gdb.base/signals.exp
index 2bf719234bd..be974550e21 100644
--- a/gdb/testsuite/gdb.base/signals.exp
+++ b/gdb/testsuite/gdb.base/signals.exp
@@ -1,4 +1,4 @@
-#   Copyright 1997, 1998, 1999 Free Software Foundation, Inc.
+#   Copyright 1997, 1998, 1999, 2003 Free Software Foundation, Inc.
 
 # This program is free software; you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
@@ -185,7 +185,7 @@ proc signal_tests_1 {} {
 	# #2, #3, or higher.  At some point this should be fixed (but
 	# it quite possibly would introduce new FAILs on some systems).
 	setup_xfail "i*86-*-bsdi2.0"
-	gdb_test "backtrace 10" "#0.*handler.*#1.*#2.*main.*" \
+	gdb_test "backtrace 10" "#0.*handler.*#1.*signal handler.*#2.* main .*" \
 	    "backtrace in signals_tests_1"
 
 	gdb_test "break func1" "Breakpoint \[0-9\]+ .*"
@@ -415,7 +415,7 @@ The program being debugged stopped while in a function called from GDB.*" \
     # But we should be able to backtrace...
     # On alpha-*-osf2.0 this test works when run manually but sometime fails when
     # run under dejagnu, making it very hard to debug the problem.  Weird...
-    gdb_test "bt 10" "#0.*handler.*#1.*#2.*main.*" "bt in signals.exp"
+    gdb_test "bt 10" "#0.*handler.*#1.*signal handler.*#2.* main .*" "bt in signals.exp"
     # ...and continue...
     gdb_test "continue" "Continuing\\." "continue in signals.exp"
     # ...and then count should have been incremented
diff --git a/gdb/testsuite/gdb.base/watchpoint.exp b/gdb/testsuite/gdb.base/watchpoint.exp
index c5e37d451a5..fd5d8f286b2 100644
--- a/gdb/testsuite/gdb.base/watchpoint.exp
+++ b/gdb/testsuite/gdb.base/watchpoint.exp
@@ -377,7 +377,7 @@ proc test_stepping {} {
 	# The problem is that GDB confuses stepping through the call
 	# dummy with hitting the breakpoint at the end of the call dummy.
 	# Will be fixed once all architectures define 
-	# CALL_DUMMY_BREAKPOINT_OFFSET.
+	# DEPRECATED_CALL_DUMMY_BREAKPOINT_OFFSET.
 	setup_xfail "*-*-*"
 	# This doesn't occur if the call dummy starts with a call,
 	# because we are out of the dummy by the first time the inferior
@@ -388,7 +388,7 @@ proc test_stepping {} {
 	clear_xfail "m68*-*-*"
 	clear_xfail "i*86*-*-*"
 	clear_xfail "vax-*-*"
-	# The following architectures define CALL_DUMMY_BREAKPOINT_OFFSET.
+	# The following architectures define DEPRECATED_CALL_DUMMY_BREAKPOINT_OFFSET.
 	clear_xfail "alpha-*-*"
 	clear_xfail "mips*-*-*"
 	clear_xfail "sparc-*-*"
diff --git a/gdb/testsuite/gdb.c++/maint.exp b/gdb/testsuite/gdb.c++/maint.exp
index 6e1da97bd52..a0f15f96bc5 100644
--- a/gdb/testsuite/gdb.c++/maint.exp
+++ b/gdb/testsuite/gdb.c++/maint.exp
@@ -63,6 +63,18 @@ proc test_first_component {} {
     test_single_component "foo(std::basic_streambuf<wchar_t,std::char_traits<wchar_t> >)"
     test_single_component "operator>(X::Y)"
 
+    # Operator names can show up in weird places.
+
+    test_single_component "int operator<< <char>()"
+    test_single_component "T<Cooperator>"
+
+    # NOTE: carlton/2003-04-23: I've only seen the first of these
+    # produced by the demangler, but I'm including two more just to be
+    # on the safe side.
+    test_single_component "int foo<&(operator<<(C, C))>()"
+    test_single_component "int foo<&operator<<(C, C)>()"
+    test_single_component "int foo<operator<<(C, C)>()"
+
     gdb_test "maint cp first_component foo::bar" "foo"
     gdb_test "maint cp first_component foo::bar::baz" "foo"
     gdb_test "maint cp first_component C<A>::bar" "C<A>"
diff --git a/gdb/testsuite/gdb.mi/ChangeLog b/gdb/testsuite/gdb.mi/ChangeLog
index d2aae785bb4..e4aec350f68 100644
--- a/gdb/testsuite/gdb.mi/ChangeLog
+++ b/gdb/testsuite/gdb.mi/ChangeLog
@@ -1,3 +1,9 @@
+2003-05-03  J. Brobecker  <brobecker@gnat.com>
+
+	From Thierry Schneider  <tpschneider1@yahoo.com>:
+	* mi1-symbol.exp (-symbol-list-lines): New test file to
+	validate all symbol-related commands
+
 2003-04-08  Andrew Cagney  <cagney@redhat.com>
 
 	* gdb792.exp: Skip when C++.
diff --git a/gdb/testsuite/gdb.mi/mi1-symbol.exp b/gdb/testsuite/gdb.mi/mi1-symbol.exp
new file mode 100644
index 00000000000..f0da1975b0c
--- /dev/null
+++ b/gdb/testsuite/gdb.mi/mi1-symbol.exp
@@ -0,0 +1,61 @@
+# Copyright 2003 Free Software Foundation, Inc.
+
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+# 
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+# 
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  
+
+# Please email any bugs, comments, and/or additions to this file to:
+# bug-gdb@prep.ai.mit.edu
+
+#
+# The goal is not to test gdb functionality, which is done by other tests,
+# but to verify the correct output response to MI operations.
+#
+
+load_lib mi-support.exp
+set MIFLAGS "-i=mi1"
+
+gdb_exit
+if [mi_gdb_start] {
+    continue
+}
+
+set testfile "basics"
+set srcfile ${testfile}.c
+set binfile ${objdir}/${subdir}/${testfile}
+if  { [gdb_compile "${srcdir}/${subdir}/${srcfile}" "${binfile}" executable {debug additional_flags=-DFAKEARGV}] != "" } {
+     gdb_suppress_entire_file "Testcase compile failed, so all tests in this file will automatically fail."
+}
+
+mi_run_to_main
+
+proc test_list_lines {} {
+    global mi_gdb_prompt
+    global hex
+    global decimal
+    global srcfile
+
+    # Test list-lines.
+    # Tests:
+    # -symbol-list-lines ${srcfile} 
+
+    mi_gdb_test "-symbol-list-lines ${srcfile}" \
+	    "\\^done,lines=\[\{pc=\"$hex\",line=\"$decimal\"\}.*\]" \
+             "symbol-list-lines for source file ${srcfile}"
+
+}
+
+test_list_lines
+
+mi_gdb_exit
+return 0
diff --git a/gdb/testsuite/gdb.objc/Makefile.in b/gdb/testsuite/gdb.objc/Makefile.in
new file mode 100644
index 00000000000..381e48a0789
--- /dev/null
+++ b/gdb/testsuite/gdb.objc/Makefile.in
@@ -0,0 +1,22 @@
+VPATH = @srcdir@
+srcdir = @srcdir@
+
+EXECUTABLES = basicclass
+
+all: 
+	@echo "Nothing to be done for all..."
+
+info:
+install-info:
+dvi:
+install:
+uninstall: force
+installcheck:
+check:
+
+clean mostlyclean:
+	-rm -f *~ *.o *.ci
+	-rm -f core ${EXECUTABLES}
+
+distclean maintainer-clean realclean: clean
+	-rm -f Makefile config.status config.log
diff --git a/gdb/testsuite/gdb.objc/basicclass.exp b/gdb/testsuite/gdb.objc/basicclass.exp
new file mode 100644
index 00000000000..44b709e3e27
--- /dev/null
+++ b/gdb/testsuite/gdb.objc/basicclass.exp
@@ -0,0 +1,199 @@
+# Copyright 2003 Free Software Foundation, Inc.
+
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+# 
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+# 
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  
+
+# This file was written by Adam Fedor (fedor@gnu.org)
+
+if $tracelevel then {
+	strace $tracelevel
+}
+
+set testfile "basicclass"
+set srcfile ${testfile}.m
+set binfile ${objdir}/${subdir}/${testfile}
+
+#
+# Objective-C program compilation isn't standard. We need to figure out
+# which libraries to link in. Most of the time it uses pthread
+#
+if {[gdb_compile_objc "${srcdir}/${subdir}/${srcfile}" "${binfile}" executable [list debug ]] != "" } {
+  gdb_suppress_entire_file "Testcase compile failed, so all tests in this file will automatically fail."
+}
+
+#
+# Deduce language of main()
+#
+
+proc deduce_language_of_main {} {
+    global gdb_prompt
+
+    # See what language gdb thinks main() is, prior to reading full symbols.
+    # I think this fails for COFF targets.
+    send_gdb "show language\n"
+    gdb_expect {
+	-re ".* source language is \"auto; currently objective-c\".*$gdb_prompt $" {
+	    pass "deduced language is Objective-C, before full symbols"
+	}
+	-re ".*$gdb_prompt $" {
+	    fail "source language not correct for Objective-C (psymtabs only)"
+	    return
+	}
+	timeout {
+	    fail "can't show language (timeout)"
+	    return
+	}
+    }
+
+    runto_main
+
+    # See if our idea of the language has changed.
+
+    send_gdb "show language\n"
+    gdb_expect {
+	-re ".* source language is \"auto; currently objective-c\".*$gdb_prompt $" {
+	    pass "deduced language is Objective-C, after full symbols"
+	}
+	-re ".*$gdb_prompt $" {
+	    fail "source language not correct for Objective-C (full symbols)"
+	    return
+	}
+	timeout {
+	    fail "can't show language (timeout)"
+	    return
+	}
+    }
+}
+
+proc do_objc_tests {} {
+    global prms_id
+    global bug_id
+    global subdir
+    global objdir
+    global srcdir
+    global binfile
+    global gdb_prompt
+
+    set prms_id 0
+    set bug_id 0
+
+    # Start with a fresh gdb.
+
+    gdb_exit
+    gdb_start
+    gdb_reinitialize_dir $srcdir/$subdir
+    gdb_load $binfile
+
+    deduce_language_of_main
+}
+
+do_objc_tests
+
+#
+# Breakpoint tests
+#
+gdb_test "break doIt" \
+    "Breakpoint.*at.* file .*$srcfile, line.29.*" \
+    "breakpoint method"
+
+gdb_test "break takeArg:" \
+    "Breakpoint.*at.* file .*$srcfile, line.34.*" \
+    "breakpoint method with colon"
+
+gdb_test "break newWithArg:" \
+    "Breakpoint.*at.* file .*$srcfile, line.22.*" \
+    "breakpoint class method with colon"
+
+#
+# Continue until breakpoint (test re-setting breakpoint)
+#
+gdb_test continue \
+    "Continuing\\..*Breakpoint \[0-9\]+, -.BasicClass takeArg:. \\(self=.*, _cmd=.*, arg=.*\\) at .*$srcfile:34.*" \
+    "continue until method breakpoint"
+
+#
+# Test resetting breakpoints when re-running program
+#
+send_gdb "run\n"
+gdb_expect {
+    -re "The program .* has been started already.*y or n. $" {
+        send_gdb "y\n"
+        exp_continue
+    }
+    -re "Starting program.*Breakpoint \[0-9\]+,.*main .*argc.*argv.* at .*$srcfile:.*$gdb_prompt $"\
+                            { pass "resetting breakpoints when rerunning" }
+    -re ".*$gdb_prompt $"       { fail "resetting breakpoints when rerunning" }
+    timeout                 { fail "resetting breakpoints when rerunning" }
+}
+
+#
+# Continue until breakpoint (test re-setting breakpoint)
+#
+gdb_test continue \
+    "Continuing\\..*Breakpoint \[0-9\]+, -.BasicClass takeArg:. \\(self=.*, _cmd=.*, arg=.*\\) at .*$srcfile:34.*" \
+    "continue until method breakpoint"
+
+#
+# Test printing objects
+#
+gdb_test "print object" \
+    "\\$\[0-9\] = .*0x0" \
+    " print an ivar of self"
+
+gdb_test "print self" \
+    "\\$\[0-9\] = \\(.*BasicClass \\*\\) 0x\[0-9a-f\]+" \
+    " print self"
+
+gdb_test "print \*self" \
+    "\\$\[0-9\] = \{isa = 0x\[0-9a-f\]+, object = 0x0\}" \
+    " print contents of self"
+
+#
+# Break in a category
+#
+gdb_test "break hiddenMethod" \
+    "Breakpoint.*at.* file .*$srcfile, line.61." \
+    "breakpoint in category method"
+
+
+#
+# Continue until breakpoint (test re-setting category breakpoint)
+#
+gdb_test continue \
+    "Continuing\\..*Breakpoint \[0-9\]+, -.BasicClass\\(Private\\) hiddenMethod. \\(self=.*, _cmd=.*\\) at .*$srcfile:61.*" \
+     "continue until category method"
+
+#
+# Test calling Objective-C methods
+#
+gdb_test "print \[self printHi\]" \
+    "Hi.*\\$\[0-9\] = \[0-9\]+" \
+    "Call an Objective-C method with no arguments"
+
+gdb_test "print \[self printNumber: 42\]" \
+    "42.*\\$\[0-9\] = 43" \
+    "Call an Objective-C method with one argument"
+
+#
+# Test printing the object description
+#
+gdb_test "print-object object" \
+    "BasicClass gdb test object" \
+    "Use of the print-object command"
+
+gdb_test "po self" \
+    "BasicClass gdb test object" \
+    "Use of the po (print-object) command"
+
+
diff --git a/gdb/testsuite/gdb.objc/basicclass.m b/gdb/testsuite/gdb.objc/basicclass.m
new file mode 100644
index 00000000000..0de12db25a1
--- /dev/null
+++ b/gdb/testsuite/gdb.objc/basicclass.m
@@ -0,0 +1,81 @@
+#include <objc/Object.h>
+
+@interface BasicClass: Object
+{
+  id object;
+}
++ newWithArg: arg;
+- doIt;
+- takeArg: arg;
+- printHi;
+- (int) printNumber: (int)number;
+- (const char *) myDescription;
+@end
+
+@interface BasicClass (Private)
+- hiddenMethod;
+@end
+
+@implementation BasicClass
++ newWithArg: arg
+{
+  id obj = [self new];
+  [obj takeArg: arg];
+  return obj;
+}
+
+- doIt
+{
+  return self;
+}
+
+- takeArg: arg
+{
+  object = arg;
+  [self hiddenMethod];
+  return self;
+}
+
+- printHi
+{
+  printf("Hi\n");
+  return self;
+}
+
+- (int) printNumber: (int)number
+{
+  printf("%d\n", number);
+  return number+1;
+}
+
+- (const char *) myDescription
+{
+  return "BasicClass gdb test object";
+}
+
+@end
+
+@implementation BasicClass (Private)
+- hiddenMethod
+{
+  return self;
+}
+@end
+
+int main (int argc, const char *argv[])
+{
+  id obj;
+  obj = [BasicClass new];
+  [obj takeArg: obj];
+  return 0;
+}
+
+const char *_NSPrintForDebugger(id object)
+{
+  /* This is not really what _NSPrintForDebugger should do, but it
+     is a simple test if gdb can call this function */
+  if (object && [object respondsTo: @selector(myDescription)])
+    return [object myDescription];
+
+  return NULL;
+}
diff --git a/gdb/testsuite/gdb.threads/schedlock.exp b/gdb/testsuite/gdb.threads/schedlock.exp
index 28298c684a9..44785808ce3 100644
--- a/gdb/testsuite/gdb.threads/schedlock.exp
+++ b/gdb/testsuite/gdb.threads/schedlock.exp
@@ -112,8 +112,8 @@ proc my_continue { msg } {
 
   stop_process "stop all threads ($msg)"
 
-  # Make sure we're in one of the looping threads.
-  gdb_breakpoint [gdb_get_line_number "schedlock.exp: main loop"]
+  # Make sure we're in one of the non-main looping threads.
+  gdb_breakpoint [concat [gdb_get_line_number "schedlock.exp: main loop"] " if arg != 5"]
   gdb_continue_to_breakpoint "return to loop ($msg)"
   delete_breakpoints
 }
@@ -230,12 +230,11 @@ if {$curthread == $newthread} {
 set start_args $cont_args
 set cont_args [get_args]
 
+set num_other_threads 0
 for {set i 0} {[expr $i < 6]} {set i [expr $i + 1]} {
   if {[lindex $start_args $i] == [lindex $cont_args $i]} {
     if {$i == $curthread} {
       fail "current thread stepped (didn't run)"
-    } else {
-      fail "other thread $i ran (didn't run) (1)"
     }
   } else {
     if {$i == $curthread} {
@@ -245,10 +244,15 @@ for {set i 0} {[expr $i < 6]} {set i [expr $i + 1]} {
 	    fail "current thread stepped (wrong amount)"
 	}
     } else {
-      pass "other thread $i ran (1)"
+      set num_other_threads [expr $num_other_threads + 1]
     }
   }
 }
+if {$num_other_threads > 0} {
+  pass "other threads ran (1)"
+} else {
+  fail "other threads ran (no other threads ran) (1)"
+}
 
 # Test continue with scheduler locking
 gdb_test "set scheduler-locking on"  ""
diff --git a/gdb/testsuite/lib/gdb.exp b/gdb/testsuite/lib/gdb.exp
index 4dfbf76c950..a16b0fa7fec 100644
--- a/gdb/testsuite/lib/gdb.exp
+++ b/gdb/testsuite/lib/gdb.exp
@@ -1283,6 +1283,46 @@ proc gdb_compile_pthreads {source dest type options} {
     }
 }
 
+# This is just like gdb_compile_pthreads, above, except that we always add the
+# objc library for compiling Objective-C programs
+proc gdb_compile_objc {source dest type options} {
+    set built_binfile 0
+    set why_msg "unrecognized error"
+    foreach lib {-lobjc -lpthreads -lpthread -lthread solaris} {
+        # This kind of wipes out whatever libs the caller may have
+        # set.  Or maybe theirs will override ours.  How infelicitous.
+        if { $lib == "solaris" } {
+            set lib "-lpthread -lposix4"
+	}
+        if { $lib != "-lobjc" } {
+	  set lib "-lobjc $lib"
+	}
+        set options_with_lib [concat $options [list libs=$lib quiet]]
+        set ccout [gdb_compile $source $dest $type $options_with_lib]
+        switch -regexp -- $ccout {
+            ".*no posix threads support.*" {
+                set why_msg "missing threads include file"
+                break
+            }
+            ".*cannot open -lpthread.*" {
+                set why_msg "missing runtime threads library"
+            }
+            ".*Can't find library for -lpthread.*" {
+                set why_msg "missing runtime threads library"
+            }
+            {^$} {
+                pass "successfully compiled objc with posix threads test case"
+                set built_binfile 1
+                break
+            }
+        }
+    }
+    if {!$built_binfile} {
+        unsupported "Couldn't compile $source: ${why_msg}"
+        return -1
+    }
+}
+
 proc send_gdb { string } {
     global suppress_flag;
     if { $suppress_flag } {
diff --git a/gdb/thread-db.c b/gdb/thread-db.c
index bac464151fa..0a6138b3afa 100644
--- a/gdb/thread-db.c
+++ b/gdb/thread-db.c
@@ -945,7 +945,7 @@ thread_db_store_registers (int regno)
 
   if (regno != -1)
     {
-      char *raw = alloca (max_register_size (current_gdbarch));
+      char raw[MAX_REGISTER_SIZE];
 
       deprecated_read_register_gen (regno, raw);
       thread_db_fetch_registers (-1);
diff --git a/gdb/thread.c b/gdb/thread.c
index 53a2d4f49f4..315f33b1c4a 100644
--- a/gdb/thread.c
+++ b/gdb/thread.c
@@ -292,7 +292,6 @@ gdb_list_thread_ids (struct ui_out *uiout)
 void
 load_infrun_state (ptid_t ptid,
 		   CORE_ADDR *prev_pc,
-		   char **prev_func_name,
 		   int *trap_expected,
 		   struct breakpoint **step_resume_breakpoint,
 		   struct breakpoint **through_sigtramp_breakpoint,
@@ -316,7 +315,6 @@ load_infrun_state (ptid_t ptid,
     return;
 
   *prev_pc = tp->prev_pc;
-  *prev_func_name = tp->prev_func_name;
   *trap_expected = tp->trap_expected;
   *step_resume_breakpoint = tp->step_resume_breakpoint;
   *through_sigtramp_breakpoint = tp->through_sigtramp_breakpoint;
@@ -340,7 +338,6 @@ load_infrun_state (ptid_t ptid,
 void
 save_infrun_state (ptid_t ptid,
 		   CORE_ADDR prev_pc,
-		   char *prev_func_name,
 		   int trap_expected,
 		   struct breakpoint *step_resume_breakpoint,
 		   struct breakpoint *through_sigtramp_breakpoint,
@@ -364,7 +361,6 @@ save_infrun_state (ptid_t ptid,
     return;
 
   tp->prev_pc = prev_pc;
-  tp->prev_func_name = prev_func_name;
   tp->trap_expected = trap_expected;
   tp->step_resume_breakpoint = step_resume_breakpoint;
   tp->through_sigtramp_breakpoint = through_sigtramp_breakpoint;
diff --git a/gdb/tracepoint.c b/gdb/tracepoint.c
index 855a5b23b42..17ee07c898d 100644
--- a/gdb/tracepoint.c
+++ b/gdb/tracepoint.c
@@ -1115,7 +1115,7 @@ memrange_sortmerge (struct collection_list *memranges)
 	{
 	  if (memranges->list[a].type == memranges->list[b].type &&
 	      memranges->list[b].start - memranges->list[a].end <=
-	      MAX_REGISTER_VIRTUAL_SIZE)
+	      MAX_REGISTER_SIZE)
 	    {
 	      /* memrange b starts before memrange a ends; merge them.  */
 	      if (memranges->list[b].end > memranges->list[a].end)
diff --git a/gdb/tui/ChangeLog b/gdb/tui/ChangeLog
index 7069f965796..f44f9aa9a48 100644
--- a/gdb/tui/ChangeLog
+++ b/gdb/tui/ChangeLog
@@ -1,3 +1,19 @@
+2003-05-08  Andrew Cagney  <cagney@redhat.com>
+
+	* tuiRegs.c: Use MAX_REGISTER_SIZE instead of
+	MAX_REGISTER_RAW_SIZE.
+
+2003-05-03  Andrew Cagney  <cagney@redhat.com>
+
+	* tuiDisassem.c (tui_disassemble): Call gdb_print_insn, instead of
+	TARGET_PRINT_INSN.  Do not initialize a disassemble_info object.
+
+2003-04-30  Andrew Cagney  <cagney@redhat.com>
+
+	* tuiDisassem.c (tui_disassemble): Use
+	"deprecated_tm_print_insn_info" instead of TARGET_PRINT_INSN_INFO,
+	add comment.
+
 2003-03-14  Andrew Cagney  <cagney@redhat.com>
 
 	* tuiRegs.c (_tuiGetRegisterRawValue): Use frame_read_register,
diff --git a/gdb/tui/tuiDisassem.c b/gdb/tui/tuiDisassem.c
index 93d2df42dc9..0ddf32c1b99 100644
--- a/gdb/tui/tuiDisassem.c
+++ b/gdb/tui/tuiDisassem.c
@@ -68,22 +68,10 @@ static CORE_ADDR
 tui_disassemble (struct tui_asm_line* lines, CORE_ADDR pc, int count)
 {
   struct ui_file *gdb_dis_out;
-  disassemble_info asm_info;
 
   /* now init the ui_file structure */
   gdb_dis_out = tui_sfileopen (256);
 
-  memcpy (&asm_info, TARGET_PRINT_INSN_INFO, sizeof (asm_info));
-  asm_info.stream = gdb_dis_out;
-
-  if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG)
-    asm_info.endian = BFD_ENDIAN_BIG;
-  else
-    asm_info.endian = BFD_ENDIAN_LITTLE;
-
-  if (TARGET_ARCHITECTURE != NULL)
-    asm_info.mach = TARGET_ARCHITECTURE->mach;
-
   /* Now construct each line */
   for (; count > 0; count--, lines++)
     {
@@ -98,7 +86,7 @@ tui_disassemble (struct tui_asm_line* lines, CORE_ADDR pc, int count)
 
       ui_file_rewind (gdb_dis_out);
 
-      pc = pc + TARGET_PRINT_INSN (pc, &asm_info);
+      pc = pc + gdb_print_insn (pc, gdb_dis_out);
 
       lines->insn = xstrdup (tui_file_get_strbuf (gdb_dis_out));
 
diff --git a/gdb/tui/tuiRegs.c b/gdb/tui/tuiRegs.c
index 6920d80d975..61b933444da 100644
--- a/gdb/tui/tuiRegs.c
+++ b/gdb/tui/tuiRegs.c
@@ -489,7 +489,7 @@ tuiCheckRegisterValues (struct frame_info *frame)
       else
 	{
 	  int i, j;
-	  char rawBuf[MAX_REGISTER_RAW_SIZE];
+	  char rawBuf[MAX_REGISTER_SIZE];
 
 	  for (i = 0;
 	       (i < dataWin->detail.dataDisplayInfo.regsContentCount); i++)
@@ -766,7 +766,7 @@ _tuiRegValueHasChanged (TuiDataElementPtr dataElement,
   if (dataElement->itemNo != UNDEFINED_ITEM &&
       _tuiRegisterName (dataElement->itemNo) != (char *) NULL)
     {
-      char rawBuf[MAX_REGISTER_RAW_SIZE];
+      char rawBuf[MAX_REGISTER_SIZE];
       int i;
 
       if (_tuiGetRegisterRawValue (
@@ -830,7 +830,7 @@ _tuiSetRegisterElement (int regNum, struct frame_info *frame,
 	  dataElement->highlight = FALSE;
 	}
       if (dataElement->value == (Opaque) NULL)
-	dataElement->value = (Opaque) xmalloc (MAX_REGISTER_RAW_SIZE);
+	dataElement->value = (Opaque) xmalloc (MAX_REGISTER_SIZE);
       if (dataElement->value != (Opaque) NULL)
 	_tuiGetRegisterRawValue (regNum, dataElement->value, frame);
     }
diff --git a/gdb/v850-tdep.c b/gdb/v850-tdep.c
index de810565e04..1828d1c74df 100644
--- a/gdb/v850-tdep.c
+++ b/gdb/v850-tdep.c
@@ -613,8 +613,8 @@ v850_scan_prologue (CORE_ADDR pc, struct prologue_info *pi)
       int insn2 = -1; /* dummy value */
 
 #ifdef DEBUG
-      printf_filtered ("0x%.8lx ", (long) current_pc);
-      TARGET_PRINT_INSN (current_pc, &tm_print_insn_info);
+      fprintf_filtered (gdb_stdlog, "0x%.8lx ", (long) current_pc);
+      gdb_print_insn (current_pc, gdb_stdlog);
 #endif
 
       insn = read_memory_unsigned_integer (current_pc, 2);
@@ -1155,9 +1155,10 @@ v850_frame_init_saved_regs (struct frame_info *fi)
    be valid only if this routine uses FP.  For previous frames, fi-frame will
    always be correct (since that is derived from v850_frame_chain ()).
 
-   We can be called with the PC in the call dummy under two circumstances.
-   First, during normal backtracing, second, while figuring out the frame
-   pointer just prior to calling the target function (see run_stack_dummy).  */
+   We can be called with the PC in the call dummy under two
+   circumstances.  First, during normal backtracing, second, while
+   figuring out the frame pointer just prior to calling the target
+   function (see call_function_by_hand).  */
 
 static void
 v850_init_extra_frame_info (int fromleaf, struct frame_info *fi)
@@ -1214,7 +1215,7 @@ v850_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
       if (v850_processor_type_table[i].mach == info.bfd_arch_info->mach)
 	{
 	  v850_register_names = v850_processor_type_table[i].regnames;
-	  tm_print_insn_info.mach = info.bfd_arch_info->mach;
+	  deprecated_tm_print_insn_info.mach = info.bfd_arch_info->mach;
 	  break;
 	}
     }
@@ -1225,10 +1226,10 @@ v850_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
   set_gdbarch_num_regs (gdbarch, E_NUM_REGS);
   set_gdbarch_num_pseudo_regs (gdbarch, 0);
   set_gdbarch_sp_regnum (gdbarch, E_SP_REGNUM);
-  set_gdbarch_fp_regnum (gdbarch, E_FP_REGNUM);
+  set_gdbarch_deprecated_fp_regnum (gdbarch, E_FP_REGNUM);
   set_gdbarch_pc_regnum (gdbarch, E_PC_REGNUM);
   set_gdbarch_register_name (gdbarch, v850_register_name);
-  set_gdbarch_register_size (gdbarch, v850_reg_size);
+  set_gdbarch_deprecated_register_size (gdbarch, v850_reg_size);
   set_gdbarch_register_bytes (gdbarch, E_ALL_REGS_SIZE);
   set_gdbarch_register_byte (gdbarch, v850_register_byte);
   set_gdbarch_register_raw_size (gdbarch, v850_register_raw_size);
@@ -1237,7 +1238,7 @@ v850_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
   set_gdbarch_deprecated_max_register_virtual_size (gdbarch, v850_reg_size);
   set_gdbarch_register_virtual_type (gdbarch, v850_reg_virtual_type);
 
-  set_gdbarch_read_fp (gdbarch, v850_target_read_fp);
+  set_gdbarch_deprecated_target_read_fp (gdbarch, v850_target_read_fp);
 
   /*
    * Frame Info
@@ -1276,9 +1277,9 @@ v850_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
   set_gdbarch_deprecated_store_return_value (gdbarch, v850_store_return_value);
   set_gdbarch_deprecated_extract_struct_value_address (gdbarch, v850_extract_struct_value_address);
   set_gdbarch_use_struct_convention (gdbarch, v850_use_struct_convention);
-  set_gdbarch_call_dummy_words (gdbarch, call_dummy_nil);
-  set_gdbarch_sizeof_call_dummy_words (gdbarch, 0);
-  set_gdbarch_fix_call_dummy (gdbarch, v850_fix_call_dummy);
+  set_gdbarch_deprecated_call_dummy_words (gdbarch, call_dummy_nil);
+  set_gdbarch_deprecated_sizeof_call_dummy_words (gdbarch, 0);
+  set_gdbarch_deprecated_fix_call_dummy (gdbarch, v850_fix_call_dummy);
   set_gdbarch_breakpoint_from_pc (gdbarch, v850_breakpoint_from_pc);
 
   set_gdbarch_int_bit (gdbarch, 4 * TARGET_CHAR_BIT);
@@ -1295,6 +1296,6 @@ v850_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
 void
 _initialize_v850_tdep (void)
 {
-  tm_print_insn = print_insn_v850;
+  deprecated_tm_print_insn = print_insn_v850;
   register_gdbarch_init (bfd_arch_v850, v850_gdbarch_init);
 }
diff --git a/gdb/valarith.c b/gdb/valarith.c
index ed0fe05f35e..854a1517ae6 100644
--- a/gdb/valarith.c
+++ b/gdb/valarith.c
@@ -31,6 +31,7 @@
 #include "gdb_string.h"
 #include "doublest.h"
 #include <math.h>
+#include "infcall.h"
 
 /* Define whether or not the C operator '/' truncates towards zero for
    differently signed operands (truncation direction is undefined in C). */
diff --git a/gdb/valops.c b/gdb/valops.c
index a2a2e978bd3..e54969c3743 100644
--- a/gdb/valops.c
+++ b/gdb/valops.c
@@ -34,6 +34,7 @@
 #include "regcache.h"
 #include "cp-abi.h"
 #include "block.h"
+#include "infcall.h"
 
 #include <errno.h>
 #include "gdb_string.h"
@@ -49,10 +50,6 @@ extern int overload_debug;
 static int typecmp (int staticp, int varargs, int nargs,
 		    struct field t1[], struct value *t2[]);
 
-static CORE_ADDR find_function_addr (struct value *, struct type **);
-static struct value *value_arg_coerce (struct value *, struct type *, int);
-
-
 static CORE_ADDR value_push (CORE_ADDR, struct value *);
 
 static struct value *search_struct_field (char *, struct value *, int,
@@ -84,37 +81,6 @@ static int auto_abandon = 0;
 
 int overload_resolution = 0;
 
-/* This boolean tells what gdb should do if a signal is received while in
-   a function called from gdb (call dummy).  If set, gdb unwinds the stack
-   and restore the context to what as it was before the call.
-   The default is to stop in the frame where the signal was received. */
-
-int unwind_on_signal_p = 0;
-
-/* How you should pass arguments to a function depends on whether it
-   was defined in K&R style or prototype style.  If you define a
-   function using the K&R syntax that takes a `float' argument, then
-   callers must pass that argument as a `double'.  If you define the
-   function using the prototype syntax, then you must pass the
-   argument as a `float', with no promotion.
-
-   Unfortunately, on certain older platforms, the debug info doesn't
-   indicate reliably how each function was defined.  A function type's
-   TYPE_FLAG_PROTOTYPED flag may be clear, even if the function was
-   defined in prototype style.  When calling a function whose
-   TYPE_FLAG_PROTOTYPED flag is clear, GDB consults this flag to decide
-   what to do.
-
-   For modern targets, it is proper to assume that, if the prototype
-   flag is clear, that can be trusted: `float' arguments should be
-   promoted to `double'.  For some older targets, if the prototype
-   flag is clear, that doesn't tell us anything.  The default is to
-   trust the debug information; the user can override this behavior
-   with "set coerce-float-to-double 0".  */
-
-static int coerce_float_to_double;
-
-
 /* Find the address of function name NAME in the inferior.  */
 
 struct value *
@@ -514,7 +480,7 @@ value_assign (struct value *toval, struct value *fromval)
 {
   register struct type *type;
   struct value *val;
-  char *raw_buffer = (char*) alloca (MAX_REGISTER_RAW_SIZE);
+  char raw_buffer[MAX_REGISTER_SIZE];
   int use_buffer = 0;
   struct frame_id old_frame;
 
@@ -668,8 +634,7 @@ value_assign (struct value *toval, struct value *fromval)
 	  amount_to_copy = byte_offset + TYPE_LENGTH (type);
 
 	/* And a bounce buffer.  Be slightly over generous.  */
-	buffer = (char *) alloca (amount_to_copy
-				  + MAX_REGISTER_RAW_SIZE);
+	buffer = (char *) alloca (amount_to_copy + MAX_REGISTER_SIZE);
 
 	/* Copy it in.  */
 	for (regno = reg_offset, amount_copied = 0;
@@ -996,8 +961,8 @@ value_ind (struct value *arg1)
 CORE_ADDR
 push_word (CORE_ADDR sp, ULONGEST word)
 {
-  register int len = REGISTER_SIZE;
-  char *buffer = alloca (MAX_REGISTER_RAW_SIZE);
+  register int len = DEPRECATED_REGISTER_SIZE;
+  char buffer[MAX_REGISTER_SIZE];
 
   store_unsigned_integer (buffer, len, word);
   if (INNER_THAN (1, 2))
@@ -1089,774 +1054,6 @@ legacy_push_arguments (int nargs, struct value **args, CORE_ADDR sp,
   return sp;
 }
 
-/* Perform the standard coercions that are specified
-   for arguments to be passed to C functions.
-
-   If PARAM_TYPE is non-NULL, it is the expected parameter type.
-   IS_PROTOTYPED is non-zero if the function declaration is prototyped.  */
-
-static struct value *
-value_arg_coerce (struct value *arg, struct type *param_type,
-		  int is_prototyped)
-{
-  register struct type *arg_type = check_typedef (VALUE_TYPE (arg));
-  register struct type *type
-    = param_type ? check_typedef (param_type) : arg_type;
-
-  switch (TYPE_CODE (type))
-    {
-    case TYPE_CODE_REF:
-      if (TYPE_CODE (arg_type) != TYPE_CODE_REF
-	  && TYPE_CODE (arg_type) != TYPE_CODE_PTR)
-	{
-	  arg = value_addr (arg);
-	  VALUE_TYPE (arg) = param_type;
-	  return arg;
-	}
-      break;
-    case TYPE_CODE_INT:
-    case TYPE_CODE_CHAR:
-    case TYPE_CODE_BOOL:
-    case TYPE_CODE_ENUM:
-      /* If we don't have a prototype, coerce to integer type if necessary.  */
-      if (!is_prototyped)
-	{
-	  if (TYPE_LENGTH (type) < TYPE_LENGTH (builtin_type_int))
-	    type = builtin_type_int;
-	}
-      /* Currently all target ABIs require at least the width of an integer
-         type for an argument.  We may have to conditionalize the following
-         type coercion for future targets.  */
-      if (TYPE_LENGTH (type) < TYPE_LENGTH (builtin_type_int))
-	type = builtin_type_int;
-      break;
-    case TYPE_CODE_FLT:
-      if (!is_prototyped && coerce_float_to_double)
-	{
-	  if (TYPE_LENGTH (type) < TYPE_LENGTH (builtin_type_double))
-	    type = builtin_type_double;
-	  else if (TYPE_LENGTH (type) > TYPE_LENGTH (builtin_type_double))
-	    type = builtin_type_long_double;
-	}
-      break;
-    case TYPE_CODE_FUNC:
-      type = lookup_pointer_type (type);
-      break;
-    case TYPE_CODE_ARRAY:
-      /* Arrays are coerced to pointers to their first element, unless
-         they are vectors, in which case we want to leave them alone,
-         because they are passed by value.  */
-      if (current_language->c_style_arrays)
-	if (!TYPE_VECTOR (type))
-	  type = lookup_pointer_type (TYPE_TARGET_TYPE (type));
-      break;
-    case TYPE_CODE_UNDEF:
-    case TYPE_CODE_PTR:
-    case TYPE_CODE_STRUCT:
-    case TYPE_CODE_UNION:
-    case TYPE_CODE_VOID:
-    case TYPE_CODE_SET:
-    case TYPE_CODE_RANGE:
-    case TYPE_CODE_STRING:
-    case TYPE_CODE_BITSTRING:
-    case TYPE_CODE_ERROR:
-    case TYPE_CODE_MEMBER:
-    case TYPE_CODE_METHOD:
-    case TYPE_CODE_COMPLEX:
-    default:
-      break;
-    }
-
-  return value_cast (type, arg);
-}
-
-/* Determine a function's address and its return type from its value.
-   Calls error() if the function is not valid for calling.  */
-
-static CORE_ADDR
-find_function_addr (struct value *function, struct type **retval_type)
-{
-  register struct type *ftype = check_typedef (VALUE_TYPE (function));
-  register enum type_code code = TYPE_CODE (ftype);
-  struct type *value_type;
-  CORE_ADDR funaddr;
-
-  /* If it's a member function, just look at the function
-     part of it.  */
-
-  /* Determine address to call.  */
-  if (code == TYPE_CODE_FUNC || code == TYPE_CODE_METHOD)
-    {
-      funaddr = VALUE_ADDRESS (function);
-      value_type = TYPE_TARGET_TYPE (ftype);
-    }
-  else if (code == TYPE_CODE_PTR)
-    {
-      funaddr = value_as_address (function);
-      ftype = check_typedef (TYPE_TARGET_TYPE (ftype));
-      if (TYPE_CODE (ftype) == TYPE_CODE_FUNC
-	  || TYPE_CODE (ftype) == TYPE_CODE_METHOD)
-	{
-	  funaddr = CONVERT_FROM_FUNC_PTR_ADDR (funaddr);
-	  value_type = TYPE_TARGET_TYPE (ftype);
-	}
-      else
-	value_type = builtin_type_int;
-    }
-  else if (code == TYPE_CODE_INT)
-    {
-      /* Handle the case of functions lacking debugging info.
-         Their values are characters since their addresses are char */
-      if (TYPE_LENGTH (ftype) == 1)
-	funaddr = value_as_address (value_addr (function));
-      else
-	/* Handle integer used as address of a function.  */
-	funaddr = (CORE_ADDR) value_as_long (function);
-
-      value_type = builtin_type_int;
-    }
-  else
-    error ("Invalid data type for function to be called.");
-
-  *retval_type = value_type;
-  return funaddr;
-}
-
-/* All this stuff with a dummy frame may seem unnecessarily complicated
-   (why not just save registers in GDB?).  The purpose of pushing a dummy
-   frame which looks just like a real frame is so that if you call a
-   function and then hit a breakpoint (get a signal, etc), "backtrace"
-   will look right.  Whether the backtrace needs to actually show the
-   stack at the time the inferior function was called is debatable, but
-   it certainly needs to not display garbage.  So if you are contemplating
-   making dummy frames be different from normal frames, consider that.  */
-
-/* Perform a function call in the inferior.
-   ARGS is a vector of values of arguments (NARGS of them).
-   FUNCTION is a value, the function to be called.
-   Returns a value representing what the function returned.
-   May fail to return, if a breakpoint or signal is hit
-   during the execution of the function.
-
-   ARGS is modified to contain coerced values. */
-
-struct value *
-call_function_by_hand (struct value *function, int nargs, struct value **args)
-{
-  register CORE_ADDR sp;
-  register int i;
-  int rc;
-  CORE_ADDR start_sp;
-  /* CALL_DUMMY is an array of words (REGISTER_SIZE), but each word
-     is in host byte order.  Before calling FIX_CALL_DUMMY, we byteswap it
-     and remove any extra bytes which might exist because ULONGEST is
-     bigger than REGISTER_SIZE.
-
-     NOTE: This is pretty wierd, as the call dummy is actually a
-     sequence of instructions.  But CISC machines will have
-     to pack the instructions into REGISTER_SIZE units (and
-     so will RISC machines for which INSTRUCTION_SIZE is not
-     REGISTER_SIZE).
-
-     NOTE: This is pretty stupid.  CALL_DUMMY should be in strict
-     target byte order. */
-
-  static ULONGEST *dummy;
-  int sizeof_dummy1;
-  char *dummy1;
-  CORE_ADDR dummy_addr;
-  CORE_ADDR old_sp;
-  struct type *value_type;
-  unsigned char struct_return;
-  CORE_ADDR struct_addr = 0;
-  struct regcache *retbuf;
-  struct cleanup *retbuf_cleanup;
-  struct inferior_status *inf_status;
-  struct cleanup *inf_status_cleanup;
-  CORE_ADDR funaddr;
-  int using_gcc;		/* Set to version of gcc in use, or zero if not gcc */
-  CORE_ADDR real_pc;
-  struct type *param_type = NULL;
-  struct type *ftype = check_typedef (SYMBOL_TYPE (function));
-  int n_method_args = 0;
-
-  dummy = alloca (SIZEOF_CALL_DUMMY_WORDS);
-  sizeof_dummy1 = REGISTER_SIZE * SIZEOF_CALL_DUMMY_WORDS / sizeof (ULONGEST);
-  dummy1 = alloca (sizeof_dummy1);
-  memcpy (dummy, CALL_DUMMY_WORDS, SIZEOF_CALL_DUMMY_WORDS);
-
-  if (!target_has_execution)
-    noprocess ();
-
-  /* Create a cleanup chain that contains the retbuf (buffer
-     containing the register values).  This chain is create BEFORE the
-     inf_status chain so that the inferior status can cleaned up
-     (restored or discarded) without having the retbuf freed.  */
-  retbuf = regcache_xmalloc (current_gdbarch);
-  retbuf_cleanup = make_cleanup_regcache_xfree (retbuf);
-
-  /* A cleanup for the inferior status.  Create this AFTER the retbuf
-     so that this can be discarded or applied without interfering with
-     the regbuf.  */
-  inf_status = save_inferior_status (1);
-  inf_status_cleanup = make_cleanup_restore_inferior_status (inf_status);
-
-  if (DEPRECATED_PUSH_DUMMY_FRAME_P ())
-    {
-      /* DEPRECATED_PUSH_DUMMY_FRAME is responsible for saving the
-	 inferior registers (and frame_pop() for restoring them).  (At
-	 least on most machines) they are saved on the stack in the
-	 inferior.  */
-      DEPRECATED_PUSH_DUMMY_FRAME;
-    }
-  else
-    {
-      /* FIXME: cagney/2003-02-26: Step zero of this little tinker is
-      to extract the generic dummy frame code from the architecture
-      vector.  Hence this direct call.
-
-      A follow-on change is to modify this interface so that it takes
-      thread OR frame OR tpid as a parameter, and returns a dummy
-      frame handle.  The handle can then be used further down as a
-      parameter SAVE_DUMMY_FRAME_TOS.  Hmm, thinking about it, since
-      everything is ment to be using generic dummy frames, why not
-      even use some of the dummy frame code to here - do a regcache
-      dup and then pass the duped regcache, along with all the other
-      stuff, at one single point.
-
-      In fact, you can even save the structure's return address in the
-      dummy frame and fix one of those nasty lost struct return edge
-      conditions.  */
-      generic_push_dummy_frame ();
-    }
-
-  old_sp = read_sp ();
-
-  /* Ensure that the initial SP is correctly aligned.  */
-  if (gdbarch_frame_align_p (current_gdbarch))
-    {
-      /* NOTE: cagney/2002-09-18:
-
-	 On a RISC architecture, a void parameterless generic dummy
-	 frame (i.e., no parameters, no result) typically does not
-	 need to push anything the stack and hence can leave SP and
-	 FP.  Similarly, a framelss (possibly leaf) function does not
-	 push anything on the stack and, hence, that too can leave FP
-	 and SP unchanged.  As a consequence, a sequence of void
-	 parameterless generic dummy frame calls to frameless
-	 functions will create a sequence of effectively identical
-	 frames (SP, FP and TOS and PC the same).  This, not
-	 suprisingly, results in what appears to be a stack in an
-	 infinite loop --- when GDB tries to find a generic dummy
-	 frame on the internal dummy frame stack, it will always find
-	 the first one.
-
-	 To avoid this problem, the code below always grows the stack.
-	 That way, two dummy frames can never be identical.  It does
-	 burn a few bytes of stack but that is a small price to pay
-	 :-).  */
-      sp = gdbarch_frame_align (current_gdbarch, old_sp);
-      if (sp == old_sp)
-	{
-	  if (INNER_THAN (1, 2))
-	    /* Stack grows down.  */
-	    sp = gdbarch_frame_align (current_gdbarch, old_sp - 1);
-	  else
-	    /* Stack grows up.  */
-	    sp = gdbarch_frame_align (current_gdbarch, old_sp + 1);
-	}
-      gdb_assert ((INNER_THAN (1, 2) && sp <= old_sp)
-		  || (INNER_THAN (2, 1) && sp >= old_sp));
-    }
-  else
-    /* FIXME: cagney/2002-09-18: Hey, you loose!  Who knows how badly
-       aligned the SP is!  Further, per comment above, if the generic
-       dummy frame ends up empty (because nothing is pushed) GDB won't
-       be able to correctly perform back traces.  If a target is
-       having trouble with backtraces, first thing to do is add
-       FRAME_ALIGN() to its architecture vector.  After that, try
-       adding SAVE_DUMMY_FRAME_TOS() and modifying
-       DEPRECATED_FRAME_CHAIN so that when the next outer frame is a
-       generic dummy, it returns the current frame's base.  */
-    sp = old_sp;
-
-  if (INNER_THAN (1, 2))
-    {
-      /* Stack grows down */
-      sp -= sizeof_dummy1;
-      start_sp = sp;
-    }
-  else
-    {
-      /* Stack grows up */
-      start_sp = sp;
-      sp += sizeof_dummy1;
-    }
-
-  /* NOTE: cagney/2002-09-10: Don't bother re-adjusting the stack
-     after allocating space for the call dummy.  A target can specify
-     a SIZEOF_DUMMY1 (via SIZEOF_CALL_DUMMY_WORDS) such that all local
-     alignment requirements are met.  */
-
-  funaddr = find_function_addr (function, &value_type);
-  CHECK_TYPEDEF (value_type);
-
-  {
-    struct block *b = block_for_pc (funaddr);
-    /* If compiled without -g, assume GCC 2.  */
-    using_gcc = (b == NULL ? 2 : BLOCK_GCC_COMPILED (b));
-  }
-
-  /* Are we returning a value using a structure return or a normal
-     value return? */
-
-  struct_return = using_struct_return (function, funaddr, value_type,
-				       using_gcc);
-
-  /* Create a call sequence customized for this function
-     and the number of arguments for it.  */
-  for (i = 0; i < (int) (SIZEOF_CALL_DUMMY_WORDS / sizeof (dummy[0])); i++)
-    store_unsigned_integer (&dummy1[i * REGISTER_SIZE],
-			    REGISTER_SIZE,
-			    (ULONGEST) dummy[i]);
-
-#ifdef GDB_TARGET_IS_HPPA
-  real_pc = FIX_CALL_DUMMY (dummy1, start_sp, funaddr, nargs, args,
-			    value_type, using_gcc);
-#else
-  if (FIX_CALL_DUMMY_P ())
-    {
-      /* gdb_assert (CALL_DUMMY_LOCATION == ON_STACK) true?  */
-      FIX_CALL_DUMMY (dummy1, start_sp, funaddr, nargs, args, value_type,
-		      using_gcc);
-    }
-  real_pc = start_sp;
-#endif
-
-  switch (CALL_DUMMY_LOCATION)
-    {
-    case ON_STACK:
-      dummy_addr = start_sp;
-      write_memory (start_sp, (char *) dummy1, sizeof_dummy1);
-      if (DEPRECATED_USE_GENERIC_DUMMY_FRAMES)
-	generic_save_call_dummy_addr (start_sp, start_sp + sizeof_dummy1);
-      break;
-    case AT_ENTRY_POINT:
-      real_pc = funaddr;
-      dummy_addr = CALL_DUMMY_ADDRESS ();
-      if (DEPRECATED_USE_GENERIC_DUMMY_FRAMES)
-	/* NOTE: cagney/2002-04-13: The entry point is going to be
-           modified with a single breakpoint.  */
-	generic_save_call_dummy_addr (CALL_DUMMY_ADDRESS (),
-				      CALL_DUMMY_ADDRESS () + 1);
-      break;
-    default:
-      internal_error (__FILE__, __LINE__, "bad switch");
-    }
-
-#ifdef lint
-  sp = old_sp;			/* It really is used, for some ifdef's... */
-#endif
-
-  if (nargs < TYPE_NFIELDS (ftype))
-    error ("too few arguments in function call");
-
-  for (i = nargs - 1; i >= 0; i--)
-    {
-      int prototyped;
-
-      /* FIXME drow/2002-05-31: Should just always mark methods as
-	 prototyped.  Can we respect TYPE_VARARGS?  Probably not.  */
-      if (TYPE_CODE (ftype) == TYPE_CODE_METHOD)
-	prototyped = 1;
-      else
-	prototyped = TYPE_PROTOTYPED (ftype);
-
-      if (i < TYPE_NFIELDS (ftype))
-	args[i] = value_arg_coerce (args[i], TYPE_FIELD_TYPE (ftype, i),
-				    prototyped);
-      else
-	args[i] = value_arg_coerce (args[i], NULL, 0);
-
-      /*elz: this code is to handle the case in which the function to be called
-         has a pointer to function as parameter and the corresponding actual argument
-         is the address of a function and not a pointer to function variable.
-         In aCC compiled code, the calls through pointers to functions (in the body
-         of the function called by hand) are made via $$dyncall_external which
-         requires some registers setting, this is taken care of if we call
-         via a function pointer variable, but not via a function address.
-         In cc this is not a problem. */
-
-      if (using_gcc == 0)
-	if (param_type && TYPE_CODE (ftype) != TYPE_CODE_METHOD)
-	  /* if this parameter is a pointer to function */
-	  if (TYPE_CODE (param_type) == TYPE_CODE_PTR)
-	    if (TYPE_CODE (TYPE_TARGET_TYPE (param_type)) == TYPE_CODE_FUNC)
-	      /* elz: FIXME here should go the test about the compiler used
-	         to compile the target. We want to issue the error
-	         message only if the compiler used was HP's aCC.
-	         If we used HP's cc, then there is no problem and no need
-	         to return at this point */
-	      if (using_gcc == 0)	/* && compiler == aCC */
-		/* go see if the actual parameter is a variable of type
-		   pointer to function or just a function */
-		if (args[i]->lval == not_lval)
-		  {
-		    char *arg_name;
-		    if (find_pc_partial_function ((CORE_ADDR) args[i]->aligner.contents[0], &arg_name, NULL, NULL))
-		      error ("\
-You cannot use function <%s> as argument. \n\
-You must use a pointer to function type variable. Command ignored.", arg_name);
-		  }
-    }
-
-  if (REG_STRUCT_HAS_ADDR_P ())
-    {
-      /* This is a machine like the sparc, where we may need to pass a
-	 pointer to the structure, not the structure itself.  */
-      for (i = nargs - 1; i >= 0; i--)
-	{
-	  struct type *arg_type = check_typedef (VALUE_TYPE (args[i]));
-	  if ((TYPE_CODE (arg_type) == TYPE_CODE_STRUCT
-	       || TYPE_CODE (arg_type) == TYPE_CODE_UNION
-	       || TYPE_CODE (arg_type) == TYPE_CODE_ARRAY
-	       || TYPE_CODE (arg_type) == TYPE_CODE_STRING
-	       || TYPE_CODE (arg_type) == TYPE_CODE_BITSTRING
-	       || TYPE_CODE (arg_type) == TYPE_CODE_SET
-	       || (TYPE_CODE (arg_type) == TYPE_CODE_FLT
-		   && TYPE_LENGTH (arg_type) > 8)
-	       )
-	      && REG_STRUCT_HAS_ADDR (using_gcc, arg_type))
-	    {
-	      CORE_ADDR addr;
-	      int len;		/*  = TYPE_LENGTH (arg_type); */
-	      int aligned_len;
-	      arg_type = check_typedef (VALUE_ENCLOSING_TYPE (args[i]));
-	      len = TYPE_LENGTH (arg_type);
-
-	      if (STACK_ALIGN_P ())
-		/* MVS 11/22/96: I think at least some of this
-		   stack_align code is really broken.  Better to let
-		   PUSH_ARGUMENTS adjust the stack in a target-defined
-		   manner.  */
-		aligned_len = STACK_ALIGN (len);
-	      else
-		aligned_len = len;
-	      if (INNER_THAN (1, 2))
-		{
-		  /* stack grows downward */
-		  sp -= aligned_len;
-		  /* ... so the address of the thing we push is the
-		     stack pointer after we push it.  */
-		  addr = sp;
-		}
-	      else
-		{
-		  /* The stack grows up, so the address of the thing
-		     we push is the stack pointer before we push it.  */
-		  addr = sp;
-		  sp += aligned_len;
-		}
-	      /* Push the structure.  */
-	      write_memory (addr, VALUE_CONTENTS_ALL (args[i]), len);
-	      /* The value we're going to pass is the address of the
-		 thing we just pushed.  */
-	      /*args[i] = value_from_longest (lookup_pointer_type (value_type),
-		(LONGEST) addr); */
-	      args[i] = value_from_pointer (lookup_pointer_type (arg_type),
-					    addr);
-	    }
-	}
-    }
-
-
-  /* Reserve space for the return structure to be written on the
-     stack, if necessary.  Make certain that the value is correctly
-     aligned. */
-
-  if (struct_return)
-    {
-      int len = TYPE_LENGTH (value_type);
-      if (STACK_ALIGN_P ())
-	/* NOTE: cagney/2003-03-22: Should rely on frame align, rather
-           than stack align to force the alignment of the stack.  */
-	len = STACK_ALIGN (len);
-      if (INNER_THAN (1, 2))
-	{
-	  /* Stack grows downward.  Align STRUCT_ADDR and SP after
-             making space for the return value.  */
-	  sp -= len;
-	  if (gdbarch_frame_align_p (current_gdbarch))
-	    sp = gdbarch_frame_align (current_gdbarch, sp);
-	  struct_addr = sp;
-	}
-      else
-	{
-	  /* Stack grows upward.  Align the frame, allocate space, and
-             then again, re-align the frame??? */
-	  if (gdbarch_frame_align_p (current_gdbarch))
-	    sp = gdbarch_frame_align (current_gdbarch, sp);
-	  struct_addr = sp;
-	  sp += len;
-	  if (gdbarch_frame_align_p (current_gdbarch))
-	    sp = gdbarch_frame_align (current_gdbarch, sp);
-	}
-    }
-
-  /* elz: on HPPA no need for this extra alignment, maybe it is needed
-     on other architectures. This is because all the alignment is
-     taken care of in the above code (ifdef REG_STRUCT_HAS_ADDR) and
-     in hppa_push_arguments */
-  /* NOTE: cagney/2003-03-24: The below code is very broken.  Given an
-     odd sized parameter the below will mis-align the stack.  As was
-     suggested back in '96, better to let PUSH_ARGUMENTS handle it.  */
-  if (DEPRECATED_EXTRA_STACK_ALIGNMENT_NEEDED)
-    {
-      /* MVS 11/22/96: I think at least some of this stack_align code
-	 is really broken.  Better to let push_dummy_call() adjust the
-	 stack in a target-defined manner.  */
-      if (STACK_ALIGN_P () && INNER_THAN (1, 2))
-	{
-	  /* If stack grows down, we must leave a hole at the top. */
-	  int len = 0;
-
-	  for (i = nargs - 1; i >= 0; i--)
-	    len += TYPE_LENGTH (VALUE_ENCLOSING_TYPE (args[i]));
-	  if (DEPRECATED_CALL_DUMMY_STACK_ADJUST_P ())
-	    len += DEPRECATED_CALL_DUMMY_STACK_ADJUST;
-	  sp -= STACK_ALIGN (len) - len;
-	}
-    }
-
-  /* Create the dummy stack frame.  Pass in the call dummy address as,
-     presumably, the ABI code knows where, in the call dummy, the
-     return address should be pointed.  */
-  if (gdbarch_push_dummy_call_p (current_gdbarch))
-    /* When there is no push_dummy_call method, should this code
-       simply error out.  That would the implementation of this method
-       for all ABIs (which is probably a good thing).  */
-    sp = gdbarch_push_dummy_call (current_gdbarch, current_regcache,
-				  dummy_addr, nargs, args, sp, struct_return,
-				  struct_addr);
-  else  if (DEPRECATED_PUSH_ARGUMENTS_P ())
-    /* Keep old targets working.  */
-    sp = DEPRECATED_PUSH_ARGUMENTS (nargs, args, sp, struct_return,
-				    struct_addr);
-  else
-    sp = legacy_push_arguments (nargs, args, sp, struct_return, struct_addr);
-
-  if (DEPRECATED_PUSH_RETURN_ADDRESS_P ())
-    /* for targets that use no CALL_DUMMY */
-    /* There are a number of targets now which actually don't write
-       any CALL_DUMMY instructions into the target, but instead just
-       save the machine state, push the arguments, and jump directly
-       to the callee function.  Since this doesn't actually involve
-       executing a JSR/BSR instruction, the return address must be set
-       up by hand, either by pushing onto the stack or copying into a
-       return-address register as appropriate.  Formerly this has been
-       done in PUSH_ARGUMENTS, but that's overloading its
-       functionality a bit, so I'm making it explicit to do it here.  */
-    sp = DEPRECATED_PUSH_RETURN_ADDRESS (real_pc, sp);
-
-  /* NOTE: cagney/2003-03-23: Diable this code when there is a
-     push_dummy_call() method.  Since that method will have already
-     handled any alignment issues, the code below is entirely
-     redundant.  */
-  if (!gdbarch_push_dummy_call_p (current_gdbarch)
-      && STACK_ALIGN_P () && !INNER_THAN (1, 2))
-    {
-      /* If stack grows up, we must leave a hole at the bottom, note
-         that sp already has been advanced for the arguments!  */
-      if (DEPRECATED_CALL_DUMMY_STACK_ADJUST_P ())
-	sp += DEPRECATED_CALL_DUMMY_STACK_ADJUST;
-      sp = STACK_ALIGN (sp);
-    }
-
-/* XXX This seems wrong.  For stacks that grow down we shouldn't do
-   anything here!  */
-  /* MVS 11/22/96: I think at least some of this stack_align code is
-     really broken.  Better to let PUSH_ARGUMENTS adjust the stack in
-     a target-defined manner.  */
-  if (DEPRECATED_CALL_DUMMY_STACK_ADJUST_P ())
-    if (INNER_THAN (1, 2))
-      {
-	/* stack grows downward */
-	sp -= DEPRECATED_CALL_DUMMY_STACK_ADJUST;
-      }
-
-  /* Store the address at which the structure is supposed to be
-     written.  */
-  /* NOTE: 2003-03-24: Since PUSH_ARGUMENTS can (and typically does)
-     store the struct return address, this call is entirely redundant.  */
-  if (struct_return && DEPRECATED_STORE_STRUCT_RETURN_P ())
-    DEPRECATED_STORE_STRUCT_RETURN (struct_addr, sp);
-
-  /* Write the stack pointer.  This is here because the statements above
-     might fool with it.  On SPARC, this write also stores the register
-     window into the right place in the new stack frame, which otherwise
-     wouldn't happen.  (See store_inferior_registers in sparc-nat.c.)  */
-  /* NOTE: cagney/2003-03-23: Disable this code when there is a
-     push_dummy_call() method.  Since that method will have already
-     stored the stack pointer (as part of creating the fake call
-     frame), and none of the code following that code adjusts the
-     stack-pointer value, the below call is entirely redundant.  */
-  if (DEPRECATED_DUMMY_WRITE_SP_P ())
-    DEPRECATED_DUMMY_WRITE_SP (sp);
-
-  if (SAVE_DUMMY_FRAME_TOS_P ())
-    SAVE_DUMMY_FRAME_TOS (sp);
-
-  {
-    char *name;
-    struct symbol *symbol;
-
-    name = NULL;
-    symbol = find_pc_function (funaddr);
-    if (symbol)
-      {
-	name = SYMBOL_PRINT_NAME (symbol);
-      }
-    else
-      {
-	/* Try the minimal symbols.  */
-	struct minimal_symbol *msymbol = lookup_minimal_symbol_by_pc (funaddr);
-
-	if (msymbol)
-	  {
-	    name = SYMBOL_PRINT_NAME (msymbol);
-	  }
-      }
-    if (name == NULL)
-      {
-	char format[80];
-	sprintf (format, "at %s", local_hex_format ());
-	name = alloca (80);
-	/* FIXME-32x64: assumes funaddr fits in a long.  */
-	sprintf (name, format, (unsigned long) funaddr);
-      }
-
-    /* Execute the stack dummy routine, calling FUNCTION.
-       When it is done, discard the empty frame
-       after storing the contents of all regs into retbuf.  */
-    rc = run_stack_dummy (real_pc + CALL_DUMMY_START_OFFSET, retbuf);
-
-    if (rc == 1)
-      {
-	/* We stopped inside the FUNCTION because of a random signal.
-	   Further execution of the FUNCTION is not allowed. */
-
-        if (unwind_on_signal_p)
-	  {
-	    /* The user wants the context restored. */
-
-            /* We must get back to the frame we were before the dummy
-               call. */
-	    frame_pop (get_current_frame ());
-
-	    /* FIXME: Insert a bunch of wrap_here; name can be very long if it's
-	       a C++ name with arguments and stuff.  */
-	    error ("\
-The program being debugged was signaled while in a function called from GDB.\n\
-GDB has restored the context to what it was before the call.\n\
-To change this behavior use \"set unwindonsignal off\"\n\
-Evaluation of the expression containing the function (%s) will be abandoned.",
-		   name);
-	  }
-	else
-	  {
-	    /* The user wants to stay in the frame where we stopped (default).*/
-
-	    /* If we restored the inferior status (via the cleanup),
-	       we would print a spurious error message (Unable to
-	       restore previously selected frame), would write the
-	       registers from the inf_status (which is wrong), and
-	       would do other wrong things.  */
-	    discard_cleanups (inf_status_cleanup);
-	    discard_inferior_status (inf_status);
-
-	    /* FIXME: Insert a bunch of wrap_here; name can be very long if it's
-	       a C++ name with arguments and stuff.  */
-	    error ("\
-The program being debugged was signaled while in a function called from GDB.\n\
-GDB remains in the frame where the signal was received.\n\
-To change this behavior use \"set unwindonsignal on\"\n\
-Evaluation of the expression containing the function (%s) will be abandoned.",
-		   name);
-	  }
-      }
-
-    if (rc == 2)
-      {
-	/* We hit a breakpoint inside the FUNCTION. */
-
-	/* If we restored the inferior status (via the cleanup), we
-	   would print a spurious error message (Unable to restore
-	   previously selected frame), would write the registers from
-	   the inf_status (which is wrong), and would do other wrong
-	   things.  */
-	discard_cleanups (inf_status_cleanup);
-	discard_inferior_status (inf_status);
-
-	/* The following error message used to say "The expression
-	   which contained the function call has been discarded."  It
-	   is a hard concept to explain in a few words.  Ideally, GDB
-	   would be able to resume evaluation of the expression when
-	   the function finally is done executing.  Perhaps someday
-	   this will be implemented (it would not be easy).  */
-
-	/* FIXME: Insert a bunch of wrap_here; name can be very long if it's
-	   a C++ name with arguments and stuff.  */
-	error ("\
-The program being debugged stopped while in a function called from GDB.\n\
-When the function (%s) is done executing, GDB will silently\n\
-stop (instead of continuing to evaluate the expression containing\n\
-the function call).", name);
-      }
-
-    /* If we get here the called FUNCTION run to completion. */
-
-    /* Restore the inferior status, via its cleanup.  At this stage,
-       leave the RETBUF alone.  */
-    do_cleanups (inf_status_cleanup);
-
-    /* Figure out the value returned by the function.  */
-    /* elz: I defined this new macro for the hppa architecture only.
-       this gives us a way to get the value returned by the function
-       from the stack, at the same address we told the function to put
-       it.  We cannot assume on the pa that r28 still contains the
-       address of the returned structure. Usually this will be
-       overwritten by the callee.  I don't know about other
-       architectures, so I defined this macro */
-#ifdef VALUE_RETURNED_FROM_STACK
-    if (struct_return)
-      {
-	do_cleanups (retbuf_cleanup);
-	return VALUE_RETURNED_FROM_STACK (value_type, struct_addr);
-      }
-#endif
-    /* NOTE: cagney/2002-09-10: Only when the stack has been correctly
-       aligned (using frame_align()) do we can trust STRUCT_ADDR and
-       fetch the return value direct from the stack.  This lack of
-       trust comes about because legacy targets have a nasty habit of
-       silently, and local to PUSH_ARGUMENTS(), moving STRUCT_ADDR.
-       For such targets, just hope that value_being_returned() can
-       find the adjusted value.  */
-    if (struct_return && gdbarch_frame_align_p (current_gdbarch))
-      {
-        struct value *retval = value_at (value_type, struct_addr, NULL);
-        do_cleanups (retbuf_cleanup);
-        return retval;
-      }
-    else
-      {
-	struct value *retval = value_being_returned (value_type, retbuf,
-						     struct_return);
-	do_cleanups (retbuf_cleanup);
-	return retval;
-      }
-  }
-}
-
 /* Create a value for an array by allocating space in the inferior, copying
    the data into that space, and then setting up an array value.
 
@@ -3485,29 +2682,4 @@ _initialize_valops (void)
 		  &setlist),
      &showlist);
   overload_resolution = 1;
-
-  add_show_from_set (
-  add_set_cmd ("unwindonsignal", no_class, var_boolean,
-	       (char *) &unwind_on_signal_p,
-"Set unwinding of stack if a signal is received while in a call dummy.\n\
-The unwindonsignal lets the user determine what gdb should do if a signal\n\
-is received while in a function called from gdb (call dummy).  If set, gdb\n\
-unwinds the stack and restore the context to what as it was before the call.\n\
-The default is to stop in the frame where the signal was received.", &setlist),
-		     &showlist);
-
-  add_show_from_set
-    (add_set_cmd ("coerce-float-to-double", class_obscure, var_boolean,
-		  (char *) &coerce_float_to_double,
-		  "Set coercion of floats to doubles when calling functions\n"
- "Variables of type float should generally be converted to doubles before\n"
- "calling an unprototyped function, and left alone when calling a prototyped\n"
- "function.  However, some older debug info formats do not provide enough\n"
- "information to determine that a function is prototyped.  If this flag is\n"
- "set, GDB will perform the conversion for a function it considers\n"
- "unprototyped.\n"
- "The default is to perform the conversion.\n",
-		  &setlist),
-     &showlist);
-  coerce_float_to_double = 1;
 }
diff --git a/gdb/value.h b/gdb/value.h
index ad488a788fa..54854e5f563 100644
--- a/gdb/value.h
+++ b/gdb/value.h
@@ -549,9 +549,6 @@ extern struct value *varying_to_slice (struct value *);
 
 extern struct value *value_slice (struct value *, int, int);
 
-extern struct value *call_function_by_hand (struct value *, int,
-					    struct value **);
-
 extern struct value *value_literal_complex (struct value *, struct value *,
 					    struct type *);
 
diff --git a/gdb/vax-tdep.c b/gdb/vax-tdep.c
index 859e2b377d5..54ca48dd58a 100644
--- a/gdb/vax-tdep.c
+++ b/gdb/vax-tdep.c
@@ -50,7 +50,6 @@ static gdbarch_deprecated_extract_struct_value_address_ftype
     vax_extract_struct_value_address;
 
 static gdbarch_deprecated_push_dummy_frame_ftype vax_push_dummy_frame;
-static gdbarch_fix_call_dummy_ftype vax_fix_call_dummy;
 
 /* Return 1 if P points to an invalid floating point value.
    LEN is the length in bytes -- not relevant on the Vax.  */
@@ -143,12 +142,12 @@ vax_frame_init_saved_regs (struct frame_info *frame)
     }
 
   get_frame_saved_regs (frame)[SP_REGNUM] = next_addr + 4;
-  if (regmask & (1 << FP_REGNUM))
+  if (regmask & (1 << DEPRECATED_FP_REGNUM))
     get_frame_saved_regs (frame)[SP_REGNUM] +=
       4 + (4 * read_memory_integer (next_addr + 4, 4));
 
   get_frame_saved_regs (frame)[PC_REGNUM] = get_frame_base (frame) + 16;
-  get_frame_saved_regs (frame)[FP_REGNUM] = get_frame_base (frame) + 12;
+  get_frame_saved_regs (frame)[DEPRECATED_FP_REGNUM] = get_frame_base (frame) + 12;
   get_frame_saved_regs (frame)[VAX_AP_REGNUM] = get_frame_base (frame) + 8;
   get_frame_saved_regs (frame)[PS_REGNUM] = get_frame_base (frame) + 4;
 }
@@ -252,19 +251,19 @@ vax_push_dummy_frame (void)
   for (regnum = 11; regnum >= 0; regnum--)
     sp = push_word (sp, read_register (regnum));
   sp = push_word (sp, read_register (PC_REGNUM));
-  sp = push_word (sp, read_register (FP_REGNUM));
+  sp = push_word (sp, read_register (DEPRECATED_FP_REGNUM));
   sp = push_word (sp, read_register (VAX_AP_REGNUM));
   sp = push_word (sp, (read_register (PS_REGNUM) & 0xffef) + 0x2fff0000);
   sp = push_word (sp, 0);
   write_register (SP_REGNUM, sp);
-  write_register (FP_REGNUM, sp);
+  write_register (DEPRECATED_FP_REGNUM, sp);
   write_register (VAX_AP_REGNUM, sp + (17 * 4));
 }
 
 static void
 vax_pop_frame (void)
 {
-  CORE_ADDR fp = read_register (FP_REGNUM);
+  CORE_ADDR fp = read_register (DEPRECATED_FP_REGNUM);
   int regnum;
   int regmask = read_memory_integer (fp + 4, 4);
 
@@ -272,7 +271,7 @@ vax_pop_frame (void)
 		  (regmask & 0xffff)
 		  | (read_register (PS_REGNUM) & 0xffff0000));
   write_register (PC_REGNUM, read_memory_integer (fp + 16, 4));
-  write_register (FP_REGNUM, read_memory_integer (fp + 12, 4));
+  write_register (DEPRECATED_FP_REGNUM, read_memory_integer (fp + 12, 4));
   write_register (VAX_AP_REGNUM, read_memory_integer (fp + 8, 4));
   fp += 16;
   for (regnum = 0; regnum < 12; regnum++)
@@ -622,12 +621,12 @@ vax_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
   /* Register info */
   set_gdbarch_num_regs (gdbarch, VAX_NUM_REGS);
   set_gdbarch_sp_regnum (gdbarch, VAX_SP_REGNUM);
-  set_gdbarch_fp_regnum (gdbarch, VAX_FP_REGNUM);
+  set_gdbarch_deprecated_fp_regnum (gdbarch, VAX_FP_REGNUM);
   set_gdbarch_pc_regnum (gdbarch, VAX_PC_REGNUM);
   set_gdbarch_ps_regnum (gdbarch, VAX_PS_REGNUM);
 
   set_gdbarch_register_name (gdbarch, vax_register_name);
-  set_gdbarch_register_size (gdbarch, VAX_REGISTER_SIZE);
+  set_gdbarch_deprecated_register_size (gdbarch, VAX_REGISTER_SIZE);
   set_gdbarch_register_bytes (gdbarch, VAX_REGISTER_BYTES);
   set_gdbarch_register_byte (gdbarch, vax_register_byte);
   set_gdbarch_register_raw_size (gdbarch, vax_register_raw_size);
@@ -667,10 +666,10 @@ vax_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
   set_gdbarch_deprecated_push_dummy_frame (gdbarch, vax_push_dummy_frame);
   set_gdbarch_deprecated_pop_frame (gdbarch, vax_pop_frame);
   set_gdbarch_call_dummy_location (gdbarch, ON_STACK);
-  set_gdbarch_call_dummy_words (gdbarch, vax_call_dummy_words);
-  set_gdbarch_sizeof_call_dummy_words (gdbarch, sizeof_vax_call_dummy_words);
-  set_gdbarch_fix_call_dummy (gdbarch, vax_fix_call_dummy);
-  set_gdbarch_call_dummy_breakpoint_offset (gdbarch, 7);
+  set_gdbarch_deprecated_call_dummy_words (gdbarch, vax_call_dummy_words);
+  set_gdbarch_deprecated_sizeof_call_dummy_words (gdbarch, sizeof_vax_call_dummy_words);
+  set_gdbarch_deprecated_fix_call_dummy (gdbarch, vax_fix_call_dummy);
+  set_gdbarch_deprecated_call_dummy_breakpoint_offset (gdbarch, 7);
   set_gdbarch_deprecated_use_generic_dummy_frames (gdbarch, 0);
   set_gdbarch_deprecated_pc_in_call_dummy (gdbarch, deprecated_pc_in_call_dummy_on_stack);
 
@@ -696,5 +695,5 @@ _initialize_vax_tdep (void)
 {
   gdbarch_register (bfd_arch_vax, vax_gdbarch_init, NULL);
 
-  tm_print_insn = vax_print_insn;
+  deprecated_tm_print_insn = vax_print_insn;
 }
diff --git a/gdb/version.in b/gdb/version.in
index 47a3e49edaa..f67ef295d96 100644
--- a/gdb/version.in
+++ b/gdb/version.in
@@ -1 +1 @@
-2003-04-19-cvs
+2003-05-09-cvs
diff --git a/gdb/x86-64-tdep.c b/gdb/x86-64-tdep.c
index f3c08e340d5..7dd5f1e11d2 100644
--- a/gdb/x86-64-tdep.c
+++ b/gdb/x86-64-tdep.c
@@ -935,7 +935,7 @@ x86_64_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
 
   /* Register numbers of various important registers.  */
   set_gdbarch_sp_regnum (gdbarch, 7); /* %rsp */
-  set_gdbarch_fp_regnum (gdbarch, 6); /* %rbp */
+  set_gdbarch_deprecated_fp_regnum (gdbarch, 6); /* %rbp */
   set_gdbarch_pc_regnum (gdbarch, 16); /* %rip */
   set_gdbarch_ps_regnum (gdbarch, 17); /* %eflags */
   set_gdbarch_fp0_regnum (gdbarch, X86_64_NUM_GREGS); /* %st(0) */
@@ -954,7 +954,7 @@ x86_64_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
      in use on any of the supported x86-64 targets.  */
 
   set_gdbarch_register_name (gdbarch, x86_64_register_name);
-  set_gdbarch_register_size (gdbarch, 8);
+  set_gdbarch_deprecated_register_size (gdbarch, 8);
 
   /* Total amount of space needed to store our copies of the machine's
      register (SIZEOF_GREGS + SIZEOF_FPU_REGS + SIZEOF_FPU_CTRL_REGS +
@@ -977,7 +977,7 @@ x86_64_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
   set_gdbarch_deprecated_get_saved_register (gdbarch, cfi_get_saved_register);
 
   /* FIXME: kettenis/20021026: Should we set parm_boundary to 64 here?  */
-  set_gdbarch_read_fp (gdbarch, cfi_read_fp);
+  set_gdbarch_deprecated_target_read_fp (gdbarch, cfi_read_fp);
 
   set_gdbarch_extract_return_value (gdbarch, x86_64_extract_return_value);
 
diff --git a/gdb/xstormy16-tdep.c b/gdb/xstormy16-tdep.c
index 2d3b7afe41c..d6aa0183e1e 100644
--- a/gdb/xstormy16-tdep.c
+++ b/gdb/xstormy16-tdep.c
@@ -1035,10 +1035,10 @@ xstormy16_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
   set_gdbarch_num_regs (gdbarch, E_NUM_REGS);
   set_gdbarch_num_pseudo_regs (gdbarch, 0);
   set_gdbarch_sp_regnum (gdbarch, E_SP_REGNUM);
-  set_gdbarch_fp_regnum (gdbarch, E_FP_REGNUM);
+  set_gdbarch_deprecated_fp_regnum (gdbarch, E_FP_REGNUM);
   set_gdbarch_pc_regnum (gdbarch, E_PC_REGNUM);
   set_gdbarch_register_name (gdbarch, xstormy16_register_name);
-  set_gdbarch_register_size (gdbarch, xstormy16_reg_size);
+  set_gdbarch_deprecated_register_size (gdbarch, xstormy16_reg_size);
   set_gdbarch_register_bytes (gdbarch, E_ALL_REGS_SIZE);
   set_gdbarch_register_byte (gdbarch, xstormy16_register_byte);
   set_gdbarch_register_raw_size (gdbarch, xstormy16_register_raw_size);
@@ -1092,8 +1092,8 @@ xstormy16_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
   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_call_dummy_words (gdbarch, call_dummy_words);
-  set_gdbarch_sizeof_call_dummy_words (gdbarch, 0);
+  set_gdbarch_deprecated_call_dummy_words (gdbarch, call_dummy_words);
+  set_gdbarch_deprecated_sizeof_call_dummy_words (gdbarch, 0);
   set_gdbarch_breakpoint_from_pc (gdbarch, xstormy16_breakpoint_from_pc);
 
   set_gdbarch_char_signed (gdbarch, 0);
@@ -1130,5 +1130,5 @@ _initialize_xstormy16_tdep (void)
   extern int print_insn_xstormy16 ();
 
   register_gdbarch_init (bfd_arch_xstormy16, xstormy16_gdbarch_init);
-  tm_print_insn = print_insn_xstormy16;
+  deprecated_tm_print_insn = print_insn_xstormy16;
 }
author	nobody <>	2003-05-09 16:41:43 +0000
committer	nobody <>	2003-05-09 16:41:43 +0000
commit	b41719d9f61907f1c810753438454c6f5656347b (patch)
tree	a9a2a8e140602339a92e5990e1238c48b6d14f34 /gdb
parent	291862d73dc6b445dae7638c7490d74473dea27c (diff)
download	binutils-gdb-b41719d9f61907f1c810753438454c6f5656347b.tar.gz