X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gdb%2Fgdbarch.c;h=ab6e6ecd4746b9825b31c4a317c9a8a91c377251;hb=cde9ea48081fcfec378c5b6e22e3d4b41fa3e2ad;hp=ef568205a206e30de69e22c6d8d803f147dafdca;hpb=2ca6c561875beb2a062b218f81ebf30e2dd7ec9c;p=deliverable%2Fbinutils-gdb.git

diff --git a/gdb/gdbarch.c b/gdb/gdbarch.c
index ef568205a2..ab6e6ecd47 100644
--- a/gdb/gdbarch.c
+++ b/gdb/gdbarch.c
@@ -1,7 +1,7 @@
 /* *INDENT-OFF* */ /* THIS FILE IS GENERATED */
 
 /* Dynamic architecture support for GDB, the GNU debugger.
-   Copyright 1998, 1999, 2000, 2001, 2002 Free Software Foundation, Inc.
+   Copyright 1998, 1999, 2000, 2001, 2002, 2003 Free Software Foundation, Inc.
 
    This file is part of GDB.
 
@@ -65,6 +65,8 @@
 #include "gdb_string.h"
 #include "gdb-events.h"
 #include "reggroups.h"
+#include "osabi.h"
+#include "symfile.h"		/* For entry_point_address.  */
 
 /* Static function declarations */
 
@@ -93,6 +95,7 @@ struct gdbarch
   /* basic architectural information */
   const struct bfd_arch_info * bfd_arch_info;
   int byte_order;
+  enum gdb_osabi osabi;
 
   /* target specific vector. */
   struct gdbarch_tdep *tdep;
@@ -144,16 +147,16 @@ 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_write_sp_ftype *write_sp;
+  gdbarch_deprecated_dummy_write_sp_ftype *deprecated_dummy_write_sp;
   gdbarch_virtual_frame_pointer_ftype *virtual_frame_pointer;
   gdbarch_pseudo_register_read_ftype *pseudo_register_read;
   gdbarch_pseudo_register_write_ftype *pseudo_register_write;
   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;
@@ -164,14 +167,15 @@ 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 register_bytes;
+  int deprecated_register_size;
+  int deprecated_register_bytes;
   gdbarch_register_byte_ftype *register_byte;
   gdbarch_register_raw_size_ftype *register_raw_size;
-  int max_register_raw_size;
+  int deprecated_max_register_raw_size;
   gdbarch_register_virtual_size_ftype *register_virtual_size;
-  int max_register_virtual_size;
+  int deprecated_max_register_virtual_size;
   gdbarch_register_virtual_type_ftype *register_virtual_type;
+  gdbarch_register_type_ftype *register_type;
   gdbarch_deprecated_do_registers_info_ftype *deprecated_do_registers_info;
   gdbarch_print_registers_info_ftype *print_registers_info;
   gdbarch_print_float_info_ftype *print_float_info;
@@ -184,23 +188,20 @@ 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_breakpoint_offset_p;
-  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;
-  int call_dummy_p;
-  LONGEST * call_dummy_words;
-  int sizeof_call_dummy_words;
-  int call_dummy_stack_adjust_p;
-  int call_dummy_stack_adjust;
-  gdbarch_fix_call_dummy_ftype *fix_call_dummy;
+  LONGEST * deprecated_call_dummy_words;
+  int deprecated_sizeof_call_dummy_words;
+  int deprecated_call_dummy_stack_adjust;
+  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_init_frame_pc_ftype *init_frame_pc;
+  gdbarch_deprecated_init_frame_pc_ftype *deprecated_init_frame_pc;
   int believe_pcc_promotion;
   int believe_pcc_promotion_type;
-  gdbarch_coerce_float_to_double_ftype *coerce_float_to_double;
-  gdbarch_get_saved_register_ftype *get_saved_register;
+  gdbarch_deprecated_get_saved_register_ftype *deprecated_get_saved_register;
   gdbarch_register_convertible_ftype *register_convertible;
   gdbarch_register_convert_to_virtual_ftype *register_convert_to_virtual;
   gdbarch_register_convert_to_raw_ftype *register_convert_to_raw;
@@ -211,11 +212,12 @@ struct gdbarch
   gdbarch_address_to_pointer_ftype *address_to_pointer;
   gdbarch_integer_to_address_ftype *integer_to_address;
   gdbarch_return_value_on_stack_ftype *return_value_on_stack;
-  gdbarch_push_arguments_ftype *push_arguments;
-  gdbarch_push_dummy_frame_ftype *push_dummy_frame;
-  gdbarch_push_return_address_ftype *push_return_address;
-  gdbarch_pop_frame_ftype *pop_frame;
-  gdbarch_store_struct_return_ftype *store_struct_return;
+  gdbarch_deprecated_push_arguments_ftype *deprecated_push_arguments;
+  gdbarch_push_dummy_call_ftype *push_dummy_call;
+  gdbarch_deprecated_push_dummy_frame_ftype *deprecated_push_dummy_frame;
+  gdbarch_deprecated_push_return_address_ftype *deprecated_push_return_address;
+  gdbarch_deprecated_pop_frame_ftype *deprecated_pop_frame;
+  gdbarch_deprecated_store_struct_return_ftype *deprecated_store_struct_return;
   gdbarch_extract_return_value_ftype *extract_return_value;
   gdbarch_store_return_value_ftype *store_return_value;
   gdbarch_deprecated_extract_return_value_ftype *deprecated_extract_return_value;
@@ -223,8 +225,8 @@ struct gdbarch
   gdbarch_extract_struct_value_address_ftype *extract_struct_value_address;
   gdbarch_deprecated_extract_struct_value_address_ftype *deprecated_extract_struct_value_address;
   gdbarch_use_struct_convention_ftype *use_struct_convention;
-  gdbarch_frame_init_saved_regs_ftype *frame_init_saved_regs;
-  gdbarch_init_extra_frame_info_ftype *init_extra_frame_info;
+  gdbarch_deprecated_frame_init_saved_regs_ftype *deprecated_frame_init_saved_regs;
+  gdbarch_deprecated_init_extra_frame_info_ftype *deprecated_init_extra_frame_info;
   gdbarch_skip_prologue_ftype *skip_prologue;
   gdbarch_prologue_frameless_p_ftype *prologue_frameless_p;
   gdbarch_inner_than_ftype *inner_than;
@@ -237,18 +239,20 @@ struct gdbarch
   gdbarch_remote_translate_xfer_address_ftype *remote_translate_xfer_address;
   CORE_ADDR frame_args_skip;
   gdbarch_frameless_function_invocation_ftype *frameless_function_invocation;
-  gdbarch_frame_chain_ftype *frame_chain;
-  gdbarch_frame_chain_valid_ftype *frame_chain_valid;
-  gdbarch_frame_saved_pc_ftype *frame_saved_pc;
+  gdbarch_deprecated_frame_chain_ftype *deprecated_frame_chain;
+  gdbarch_deprecated_frame_chain_valid_ftype *deprecated_frame_chain_valid;
+  gdbarch_deprecated_frame_saved_pc_ftype *deprecated_frame_saved_pc;
+  gdbarch_unwind_pc_ftype *unwind_pc;
   gdbarch_frame_args_address_ftype *frame_args_address;
   gdbarch_frame_locals_address_ftype *frame_locals_address;
-  gdbarch_saved_pc_after_call_ftype *saved_pc_after_call;
+  gdbarch_deprecated_saved_pc_after_call_ftype *deprecated_saved_pc_after_call;
   gdbarch_frame_num_args_ftype *frame_num_args;
   gdbarch_stack_align_ftype *stack_align;
   gdbarch_frame_align_ftype *frame_align;
-  int extra_stack_alignment_needed;
+  int deprecated_extra_stack_alignment_needed;
   gdbarch_reg_struct_has_addr_ftype *reg_struct_has_addr;
   gdbarch_save_dummy_frame_tos_ftype *save_dummy_frame_tos;
+  gdbarch_unwind_dummy_id_ftype *unwind_dummy_id;
   int parm_boundary;
   const struct floatformat * float_format;
   const struct floatformat * double_format;
@@ -276,6 +280,7 @@ struct gdbarch
   gdbarch_address_class_type_flags_to_name_ftype *address_class_type_flags_to_name;
   gdbarch_address_class_name_to_type_flags_ftype *address_class_name_to_type_flags;
   gdbarch_register_reggroup_p_ftype *register_reggroup_p;
+  gdbarch_fetch_pointer_argument_ftype *fetch_pointer_argument;
 };
 
 
@@ -290,6 +295,7 @@ struct gdbarch startup_gdbarch =
   /* basic architecture information */
   &bfd_default_arch_struct,
   BFD_ENDIAN_BIG,
+  GDB_OSABI_UNKNOWN,
   /* target specific vector and its dump routine */
   NULL, NULL,
   /*per-architecture data-pointers and swap regions */
@@ -337,8 +343,8 @@ struct gdbarch startup_gdbarch =
   0,
   0,
   0,
-  default_print_registers_info,
   0,
+  default_print_registers_info,
   0,
   0,
   0,
@@ -397,6 +403,7 @@ struct gdbarch startup_gdbarch =
   0,
   0,
   0,
+  generic_remote_translate_xfer_address,
   0,
   0,
   0,
@@ -440,6 +447,7 @@ struct gdbarch startup_gdbarch =
   0,
   0,
   default_register_reggroup_p,
+  0,
   /* startup_gdbarch() */
 };
 
@@ -480,6 +488,7 @@ gdbarch_alloc (const struct gdbarch_info *info,
 
   current_gdbarch->bfd_arch_info = info->bfd_arch_info;
   current_gdbarch->byte_order = info->byte_order;
+  current_gdbarch->osabi = info->osabi;
 
   /* Force the explicit initialization of these. */
   current_gdbarch->short_bit = 2*TARGET_CHAR_BIT;
@@ -492,15 +501,12 @@ gdbarch_alloc (const struct gdbarch_info *info,
   current_gdbarch->ptr_bit = TARGET_INT_BIT;
   current_gdbarch->bfd_vma_bit = TARGET_ARCHITECTURE->bits_per_address;
   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->write_sp = generic_target_write_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;
@@ -511,30 +517,19 @@ 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->max_register_raw_size = -1;
   current_gdbarch->register_virtual_size = generic_register_size;
-  current_gdbarch->max_register_virtual_size = -1;
   current_gdbarch->print_registers_info = default_print_registers_info;
   current_gdbarch->register_sim_regno = legacy_register_sim_regno;
   current_gdbarch->cannot_fetch_register = cannot_register_not;
   current_gdbarch->cannot_store_register = cannot_register_not;
   current_gdbarch->deprecated_use_generic_dummy_frames = 1;
   current_gdbarch->call_dummy_location = AT_ENTRY_POINT;
-  current_gdbarch->call_dummy_start_offset = -1;
-  current_gdbarch->call_dummy_breakpoint_offset = -1;
-  current_gdbarch->call_dummy_breakpoint_offset_p = -1;
-  current_gdbarch->call_dummy_length = -1;
+  current_gdbarch->call_dummy_address = entry_point_address;
   current_gdbarch->deprecated_pc_in_call_dummy = generic_pc_in_call_dummy;
-  current_gdbarch->call_dummy_p = -1;
-  current_gdbarch->call_dummy_words = legacy_call_dummy_words;
-  current_gdbarch->sizeof_call_dummy_words = legacy_sizeof_call_dummy_words;
-  current_gdbarch->call_dummy_stack_adjust_p = -1;
-  current_gdbarch->init_frame_pc = init_frame_pc_default;
-  current_gdbarch->coerce_float_to_double = default_coerce_float_to_double;
+  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;
@@ -542,12 +537,10 @@ gdbarch_alloc (const struct gdbarch_info *info,
   current_gdbarch->pointer_to_address = unsigned_pointer_to_address;
   current_gdbarch->address_to_pointer = unsigned_address_to_pointer;
   current_gdbarch->return_value_on_stack = generic_return_value_on_stack_not;
-  current_gdbarch->push_arguments = default_push_arguments;
   current_gdbarch->extract_return_value = legacy_extract_return_value;
   current_gdbarch->store_return_value = legacy_store_return_value;
   current_gdbarch->use_struct_convention = generic_use_struct_convention;
   current_gdbarch->prologue_frameless_p = generic_prologue_frameless_p;
-  current_gdbarch->breakpoint_from_pc = legacy_breakpoint_from_pc;
   current_gdbarch->memory_insert_breakpoint = default_memory_insert_breakpoint;
   current_gdbarch->memory_remove_breakpoint = default_memory_remove_breakpoint;
   current_gdbarch->decr_pc_after_break = -1;
@@ -556,10 +549,8 @@ gdbarch_alloc (const struct gdbarch_info *info,
   current_gdbarch->remote_translate_xfer_address = generic_remote_translate_xfer_address;
   current_gdbarch->frame_args_skip = -1;
   current_gdbarch->frameless_function_invocation = generic_frameless_function_invocation_not;
-  current_gdbarch->frame_chain_valid = generic_func_frame_chain_valid;
   current_gdbarch->frame_args_address = get_frame_base;
   current_gdbarch->frame_locals_address = get_frame_base;
-  current_gdbarch->extra_stack_alignment_needed = 1;
   current_gdbarch->convert_from_func_ptr_addr = core_addr_identity;
   current_gdbarch->addr_bits_remove = core_addr_identity;
   current_gdbarch->smash_text_address = core_addr_identity;
@@ -628,11 +619,11 @@ verify_gdbarch (struct gdbarch *gdbarch)
   /* Skip verify of bfd_vma_bit, invalid_p == 0 */
   if (gdbarch->char_signed == -1)
     gdbarch->char_signed = 1;
-  /* Skip verify of read_pc, invalid_p == 0 */
+  /* Skip verify of read_pc, has predicate */
   /* 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 write_sp, invalid_p == 0 */
+  /* Skip verify of deprecated_dummy_write_sp, has predicate */
   /* Skip verify of virtual_frame_pointer, invalid_p == 0 */
   /* Skip verify of pseudo_register_read, has predicate */
   /* Skip verify of pseudo_register_write, has predicate */
@@ -641,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 */
@@ -652,24 +643,13 @@ 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 */
-  if ((GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL)
-      && (gdbarch->max_register_raw_size == -1))
-    fprintf_unfiltered (log, "\n\tmax_register_raw_size");
+  /* Skip verify of deprecated_max_register_raw_size, has predicate */
   /* Skip verify of register_virtual_size, invalid_p == 0 */
-  if ((GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL)
-      && (gdbarch->max_register_virtual_size == -1))
-    fprintf_unfiltered (log, "\n\tmax_register_virtual_size");
-  if ((GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL)
-      && (gdbarch->register_virtual_type == 0))
-    fprintf_unfiltered (log, "\n\tregister_virtual_type");
+  /* Skip verify of deprecated_max_register_virtual_size, has predicate */
+  /* Skip verify of register_virtual_type, has predicate */
+  /* Skip verify of register_type, has predicate */
   /* Skip verify of deprecated_do_registers_info, has predicate */
   /* Skip verify of print_registers_info, invalid_p == 0 */
   /* Skip verify of print_float_info, has predicate */
@@ -681,40 +661,16 @@ verify_gdbarch (struct gdbarch *gdbarch)
   /* Skip verify of get_longjmp_target, has predicate */
   /* Skip verify of deprecated_use_generic_dummy_frames, invalid_p == 0 */
   /* Skip verify of call_dummy_location, invalid_p == 0 */
-  if ((GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL)
-      && (gdbarch->call_dummy_location == AT_ENTRY_POINT && gdbarch->call_dummy_address == 0))
-    fprintf_unfiltered (log, "\n\tcall_dummy_address");
-  if ((GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL)
-      && (gdbarch->call_dummy_start_offset == -1))
-    fprintf_unfiltered (log, "\n\tcall_dummy_start_offset");
-  if ((GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL)
-      && (gdbarch->call_dummy_breakpoint_offset_p && gdbarch->call_dummy_breakpoint_offset == -1))
-    fprintf_unfiltered (log, "\n\tcall_dummy_breakpoint_offset");
-  if ((GDB_MULTI_ARCH >= GDB_MULTI_ARCH_PARTIAL)
-      && (gdbarch->call_dummy_breakpoint_offset_p == -1))
-    fprintf_unfiltered (log, "\n\tcall_dummy_breakpoint_offset_p");
-  if ((GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL)
-      && (gdbarch->call_dummy_length == -1))
-    fprintf_unfiltered (log, "\n\tcall_dummy_length");
+  /* Skip verify of call_dummy_address, invalid_p == 0 */
   /* Skip verify of deprecated_pc_in_call_dummy, has predicate */
-  if ((GDB_MULTI_ARCH >= GDB_MULTI_ARCH_PARTIAL)
-      && (gdbarch->call_dummy_p == -1))
-    fprintf_unfiltered (log, "\n\tcall_dummy_p");
-  /* Skip verify of call_dummy_words, invalid_p == 0 */
-  /* Skip verify of sizeof_call_dummy_words, invalid_p == 0 */
-  if ((GDB_MULTI_ARCH >= GDB_MULTI_ARCH_PARTIAL)
-      && (gdbarch->call_dummy_stack_adjust_p == -1))
-    fprintf_unfiltered (log, "\n\tcall_dummy_stack_adjust_p");
-  if ((GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL)
-      && (gdbarch->call_dummy_stack_adjust_p && gdbarch->call_dummy_stack_adjust == 0))
-    fprintf_unfiltered (log, "\n\tcall_dummy_stack_adjust");
-  if ((GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL)
-      && (gdbarch->fix_call_dummy == 0))
-    fprintf_unfiltered (log, "\n\tfix_call_dummy");
+  /* 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 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 init_frame_pc, invalid_p == 0 */
-  /* Skip verify of coerce_float_to_double, invalid_p == 0 */
-  /* Skip verify of get_saved_register, has predicate */
+  /* Skip verify of deprecated_init_frame_pc, has predicate */
+  /* Skip verify of deprecated_get_saved_register, has predicate */
   /* Skip verify of register_convertible, invalid_p == 0 */
   /* Skip verify of register_convert_to_virtual, invalid_p == 0 */
   /* Skip verify of register_convert_to_raw, invalid_p == 0 */
@@ -725,26 +681,19 @@ verify_gdbarch (struct gdbarch *gdbarch)
   /* Skip verify of address_to_pointer, invalid_p == 0 */
   /* Skip verify of integer_to_address, has predicate */
   /* Skip verify of return_value_on_stack, invalid_p == 0 */
-  /* Skip verify of push_arguments, invalid_p == 0 */
-  if ((GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL)
-      && (gdbarch->push_dummy_frame == 0))
-    fprintf_unfiltered (log, "\n\tpush_dummy_frame");
-  /* Skip verify of push_return_address, has predicate */
-  if ((GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL)
-      && (gdbarch->pop_frame == 0))
-    fprintf_unfiltered (log, "\n\tpop_frame");
-  if ((GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL)
-      && (gdbarch->store_struct_return == 0))
-    fprintf_unfiltered (log, "\n\tstore_struct_return");
+  /* Skip verify of deprecated_push_arguments, has predicate */
+  /* Skip verify of push_dummy_call, has predicate */
+  /* Skip verify of deprecated_push_dummy_frame, has predicate */
+  /* Skip verify of deprecated_push_return_address, has predicate */
+  /* Skip verify of deprecated_pop_frame, has predicate */
+  /* Skip verify of deprecated_store_struct_return, has predicate */
   /* Skip verify of extract_return_value, invalid_p == 0 */
   /* Skip verify of store_return_value, invalid_p == 0 */
   /* Skip verify of extract_struct_value_address, has predicate */
   /* Skip verify of deprecated_extract_struct_value_address, has predicate */
   /* Skip verify of use_struct_convention, invalid_p == 0 */
-  if ((GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL)
-      && (gdbarch->frame_init_saved_regs == 0))
-    fprintf_unfiltered (log, "\n\tframe_init_saved_regs");
-  /* Skip verify of init_extra_frame_info, has predicate */
+  /* Skip verify of deprecated_frame_init_saved_regs, has predicate */
+  /* Skip verify of deprecated_init_extra_frame_info, has predicate */
   if ((GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL)
       && (gdbarch->skip_prologue == 0))
     fprintf_unfiltered (log, "\n\tskip_prologue");
@@ -752,7 +701,9 @@ verify_gdbarch (struct gdbarch *gdbarch)
   if ((GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL)
       && (gdbarch->inner_than == 0))
     fprintf_unfiltered (log, "\n\tinner_than");
-  /* Skip verify of breakpoint_from_pc, invalid_p == 0 */
+  if ((GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL)
+      && (gdbarch->breakpoint_from_pc == 0))
+    fprintf_unfiltered (log, "\n\tbreakpoint_from_pc");
   /* Skip verify of memory_insert_breakpoint, invalid_p == 0 */
   /* Skip verify of memory_remove_breakpoint, invalid_p == 0 */
   if ((GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL)
@@ -767,26 +718,22 @@ verify_gdbarch (struct gdbarch *gdbarch)
       && (gdbarch->frame_args_skip == -1))
     fprintf_unfiltered (log, "\n\tframe_args_skip");
   /* Skip verify of frameless_function_invocation, invalid_p == 0 */
-  if ((GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL)
-      && (gdbarch->frame_chain == 0))
-    fprintf_unfiltered (log, "\n\tframe_chain");
-  /* Skip verify of frame_chain_valid, invalid_p == 0 */
-  if ((GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL)
-      && (gdbarch->frame_saved_pc == 0))
-    fprintf_unfiltered (log, "\n\tframe_saved_pc");
+  /* Skip verify of deprecated_frame_chain, has predicate */
+  /* Skip verify of deprecated_frame_chain_valid, has predicate */
+  /* Skip verify of deprecated_frame_saved_pc, has predicate */
+  /* Skip verify of unwind_pc, has predicate */
   /* Skip verify of frame_args_address, invalid_p == 0 */
   /* Skip verify of frame_locals_address, invalid_p == 0 */
-  if ((GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL)
-      && (gdbarch->saved_pc_after_call == 0))
-    fprintf_unfiltered (log, "\n\tsaved_pc_after_call");
+  /* Skip verify of deprecated_saved_pc_after_call, has predicate */
   if ((GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL)
       && (gdbarch->frame_num_args == 0))
     fprintf_unfiltered (log, "\n\tframe_num_args");
   /* Skip verify of stack_align, has predicate */
   /* Skip verify of frame_align, has predicate */
-  /* Skip verify of extra_stack_alignment_needed, invalid_p == 0 */
+  /* Skip verify of deprecated_extra_stack_alignment_needed, invalid_p == 0 */
   /* Skip verify of reg_struct_has_addr, has predicate */
   /* Skip verify of save_dummy_frame_tos, has predicate */
+  /* Skip verify of unwind_dummy_id, has predicate */
   if (gdbarch->float_format == 0)
     gdbarch->float_format = default_float_format (gdbarch);
   if (gdbarch->double_format == 0)
@@ -816,6 +763,7 @@ verify_gdbarch (struct gdbarch *gdbarch)
   /* Skip verify of address_class_type_flags_to_name, has predicate */
   /* Skip verify of address_class_name_to_type_flags, has predicate */
   /* Skip verify of register_reggroup_p, invalid_p == 0 */
+  /* Skip verify of fetch_pointer_argument, has predicate */
   buf = ui_file_xstrdup (log, &dummy);
   make_cleanup (xfree, buf);
   if (strlen (buf) > 0)
@@ -896,7 +844,7 @@ gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file)
                       XSTRING (ADDRESS_CLASS_TYPE_FLAGS (byte_size, dwarf2_addr_class)));
   if (GDB_MULTI_ARCH)
     fprintf_unfiltered (file,
-                        "gdbarch_dump: ADDRESS_CLASS_TYPE_FLAGS = 0x%08lx\n",
+                        "gdbarch_dump: ADDRESS_CLASS_TYPE_FLAGS = <0x%08lx>\n",
                         (long) current_gdbarch->address_class_type_flags
                         /*ADDRESS_CLASS_TYPE_FLAGS ()*/);
 #endif
@@ -918,7 +866,7 @@ gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file)
 #endif
   if (GDB_MULTI_ARCH)
     fprintf_unfiltered (file,
-                        "gdbarch_dump: ADDRESS_TO_POINTER = 0x%08lx\n",
+                        "gdbarch_dump: ADDRESS_TO_POINTER = <0x%08lx>\n",
                         (long) current_gdbarch->address_to_pointer
                         /*ADDRESS_TO_POINTER ()*/);
 #endif
@@ -929,7 +877,7 @@ gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file)
                       XSTRING (ADDR_BITS_REMOVE (addr)));
   if (GDB_MULTI_ARCH)
     fprintf_unfiltered (file,
-                        "gdbarch_dump: ADDR_BITS_REMOVE = 0x%08lx\n",
+                        "gdbarch_dump: ADDR_BITS_REMOVE = <0x%08lx>\n",
                         (long) current_gdbarch->addr_bits_remove
                         /*ADDR_BITS_REMOVE ()*/);
 #endif
@@ -956,7 +904,7 @@ gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file)
                       XSTRING (BREAKPOINT_FROM_PC (pcptr, lenptr)));
   if (GDB_MULTI_ARCH)
     fprintf_unfiltered (file,
-                        "gdbarch_dump: BREAKPOINT_FROM_PC = 0x%08lx\n",
+                        "gdbarch_dump: BREAKPOINT_FROM_PC = <0x%08lx>\n",
                         (long) current_gdbarch->breakpoint_from_pc
                         /*BREAKPOINT_FROM_PC ()*/);
 #endif
@@ -967,36 +915,10 @@ gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file)
                       XSTRING (CALL_DUMMY_ADDRESS ()));
   if (GDB_MULTI_ARCH)
     fprintf_unfiltered (file,
-                        "gdbarch_dump: CALL_DUMMY_ADDRESS = 0x%08lx\n",
+                        "gdbarch_dump: CALL_DUMMY_ADDRESS = <0x%08lx>\n",
                         (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));
-  if (CALL_DUMMY_BREAKPOINT_OFFSET_P)
-    fprintf_unfiltered (file,
-                        "gdbarch_dump: CALL_DUMMY_BREAKPOINT_OFFSET = 0x%08lx\n",
-                        (long) CALL_DUMMY_BREAKPOINT_OFFSET);
-#endif
-#ifdef CALL_DUMMY_BREAKPOINT_OFFSET_P
-  fprintf_unfiltered (file,
-                      "gdbarch_dump: CALL_DUMMY_BREAKPOINT_OFFSET_P # %s\n",
-                      XSTRING (CALL_DUMMY_BREAKPOINT_OFFSET_P));
-  fprintf_unfiltered (file,
-                      "gdbarch_dump: CALL_DUMMY_BREAKPOINT_OFFSET_P = %d\n",
-                      CALL_DUMMY_BREAKPOINT_OFFSET_P);
-#endif
-#ifdef CALL_DUMMY_LENGTH
-  fprintf_unfiltered (file,
-                      "gdbarch_dump: CALL_DUMMY_LENGTH # %s\n",
-                      XSTRING (CALL_DUMMY_LENGTH));
-  if (CALL_DUMMY_LOCATION == BEFORE_TEXT_END || CALL_DUMMY_LOCATION == AFTER_TEXT_END)
-    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",
@@ -1005,47 +927,6 @@ gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file)
                       "gdbarch_dump: CALL_DUMMY_LOCATION = %d\n",
                       CALL_DUMMY_LOCATION);
 #endif
-#ifdef CALL_DUMMY_P
-  fprintf_unfiltered (file,
-                      "gdbarch_dump: CALL_DUMMY_P # %s\n",
-                      XSTRING (CALL_DUMMY_P));
-  fprintf_unfiltered (file,
-                      "gdbarch_dump: CALL_DUMMY_P = %d\n",
-                      CALL_DUMMY_P);
-#endif
-#ifdef CALL_DUMMY_STACK_ADJUST
-  fprintf_unfiltered (file,
-                      "gdbarch_dump: CALL_DUMMY_STACK_ADJUST # %s\n",
-                      XSTRING (CALL_DUMMY_STACK_ADJUST));
-  if (CALL_DUMMY_STACK_ADJUST_P)
-    fprintf_unfiltered (file,
-                        "gdbarch_dump: CALL_DUMMY_STACK_ADJUST = 0x%08lx\n",
-                        (long) CALL_DUMMY_STACK_ADJUST);
-#endif
-#ifdef CALL_DUMMY_STACK_ADJUST_P
-  fprintf_unfiltered (file,
-                      "gdbarch_dump: CALL_DUMMY_STACK_ADJUST_P # %s\n",
-                      XSTRING (CALL_DUMMY_STACK_ADJUST_P));
-  fprintf_unfiltered (file,
-                      "gdbarch_dump: CALL_DUMMY_STACK_ADJUST_P = 0x%08lx\n",
-                      (long) CALL_DUMMY_STACK_ADJUST_P);
-#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 = 0x%08lx\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",
@@ -1053,7 +934,7 @@ gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file)
                       XSTRING (CANNOT_FETCH_REGISTER (regnum)));
   if (GDB_MULTI_ARCH)
     fprintf_unfiltered (file,
-                        "gdbarch_dump: CANNOT_FETCH_REGISTER = 0x%08lx\n",
+                        "gdbarch_dump: CANNOT_FETCH_REGISTER = <0x%08lx>\n",
                         (long) current_gdbarch->cannot_fetch_register
                         /*CANNOT_FETCH_REGISTER ()*/);
 #endif
@@ -1072,21 +953,10 @@ gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file)
                       XSTRING (CANNOT_STORE_REGISTER (regnum)));
   if (GDB_MULTI_ARCH)
     fprintf_unfiltered (file,
-                        "gdbarch_dump: CANNOT_STORE_REGISTER = 0x%08lx\n",
+                        "gdbarch_dump: CANNOT_STORE_REGISTER = <0x%08lx>\n",
                         (long) current_gdbarch->cannot_store_register
                         /*CANNOT_STORE_REGISTER ()*/);
 #endif
-#ifdef COERCE_FLOAT_TO_DOUBLE
-  fprintf_unfiltered (file,
-                      "gdbarch_dump: %s # %s\n",
-                      "COERCE_FLOAT_TO_DOUBLE(formal, actual)",
-                      XSTRING (COERCE_FLOAT_TO_DOUBLE (formal, actual)));
-  if (GDB_MULTI_ARCH)
-    fprintf_unfiltered (file,
-                        "gdbarch_dump: COERCE_FLOAT_TO_DOUBLE = 0x%08lx\n",
-                        (long) current_gdbarch->coerce_float_to_double
-                        /*COERCE_FLOAT_TO_DOUBLE ()*/);
-#endif
 #ifdef COFF_MAKE_MSYMBOL_SPECIAL
 #if GDB_MULTI_ARCH
   /* Macro might contain `[{}]' when not multi-arch */
@@ -1097,7 +967,7 @@ gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file)
 #endif
   if (GDB_MULTI_ARCH)
     fprintf_unfiltered (file,
-                        "gdbarch_dump: COFF_MAKE_MSYMBOL_SPECIAL = 0x%08lx\n",
+                        "gdbarch_dump: COFF_MAKE_MSYMBOL_SPECIAL = <0x%08lx>\n",
                         (long) current_gdbarch->coff_make_msymbol_special
                         /*COFF_MAKE_MSYMBOL_SPECIAL ()*/);
 #endif
@@ -1112,7 +982,7 @@ gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file)
                       XSTRING (CONVERT_FROM_FUNC_PTR_ADDR (addr)));
   if (GDB_MULTI_ARCH)
     fprintf_unfiltered (file,
-                        "gdbarch_dump: CONVERT_FROM_FUNC_PTR_ADDR = 0x%08lx\n",
+                        "gdbarch_dump: CONVERT_FROM_FUNC_PTR_ADDR = <0x%08lx>\n",
                         (long) current_gdbarch->convert_from_func_ptr_addr
                         /*CONVERT_FROM_FUNC_PTR_ADDR ()*/);
 #endif
@@ -1123,7 +993,7 @@ gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file)
                       XSTRING (CONVERT_REGISTER_P (regnum)));
   if (GDB_MULTI_ARCH)
     fprintf_unfiltered (file,
-                        "gdbarch_dump: CONVERT_REGISTER_P = 0x%08lx\n",
+                        "gdbarch_dump: CONVERT_REGISTER_P = <0x%08lx>\n",
                         (long) current_gdbarch->convert_register_p
                         /*CONVERT_REGISTER_P ()*/);
 #endif
@@ -1135,6 +1005,55 @@ 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",
+                      "DEPRECATED_CALL_DUMMY_STACK_ADJUST_P()",
+                      XSTRING (DEPRECATED_CALL_DUMMY_STACK_ADJUST_P ()));
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: DEPRECATED_CALL_DUMMY_STACK_ADJUST_P() = %d\n",
+                      DEPRECATED_CALL_DUMMY_STACK_ADJUST_P ());
+#endif
+#ifdef DEPRECATED_CALL_DUMMY_STACK_ADJUST
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: DEPRECATED_CALL_DUMMY_STACK_ADJUST # %s\n",
+                      XSTRING (DEPRECATED_CALL_DUMMY_STACK_ADJUST));
+  fprintf_unfiltered (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",
@@ -1154,10 +1073,33 @@ gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file)
 #endif
   if (GDB_MULTI_ARCH)
     fprintf_unfiltered (file,
-                        "gdbarch_dump: DEPRECATED_DO_REGISTERS_INFO = 0x%08lx\n",
+                        "gdbarch_dump: DEPRECATED_DO_REGISTERS_INFO = <0x%08lx>\n",
                         (long) current_gdbarch->deprecated_do_registers_info
                         /*DEPRECATED_DO_REGISTERS_INFO ()*/);
 #endif
+#ifdef DEPRECATED_DUMMY_WRITE_SP_P
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: %s # %s\n",
+                      "DEPRECATED_DUMMY_WRITE_SP_P()",
+                      XSTRING (DEPRECATED_DUMMY_WRITE_SP_P ()));
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: DEPRECATED_DUMMY_WRITE_SP_P() = %d\n",
+                      DEPRECATED_DUMMY_WRITE_SP_P ());
+#endif
+#ifdef DEPRECATED_DUMMY_WRITE_SP
+#if GDB_MULTI_ARCH
+  /* Macro might contain `[{}]' when not multi-arch */
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: %s # %s\n",
+                      "DEPRECATED_DUMMY_WRITE_SP(val)",
+                      XSTRING (DEPRECATED_DUMMY_WRITE_SP (val)));
+#endif
+  if (GDB_MULTI_ARCH)
+    fprintf_unfiltered (file,
+                        "gdbarch_dump: DEPRECATED_DUMMY_WRITE_SP = <0x%08lx>\n",
+                        (long) current_gdbarch->deprecated_dummy_write_sp
+                        /*DEPRECATED_DUMMY_WRITE_SP ()*/);
+#endif
 #ifdef DEPRECATED_EXTRACT_RETURN_VALUE
 #if GDB_MULTI_ARCH
   /* Macro might contain `[{}]' when not multi-arch */
@@ -1168,7 +1110,7 @@ gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file)
 #endif
   if (GDB_MULTI_ARCH)
     fprintf_unfiltered (file,
-                        "gdbarch_dump: DEPRECATED_EXTRACT_RETURN_VALUE = 0x%08lx\n",
+                        "gdbarch_dump: DEPRECATED_EXTRACT_RETURN_VALUE = <0x%08lx>\n",
                         (long) current_gdbarch->deprecated_extract_return_value
                         /*DEPRECATED_EXTRACT_RETURN_VALUE ()*/);
 #endif
@@ -1188,10 +1130,198 @@ gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file)
                       XSTRING (DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS (regbuf)));
   if (GDB_MULTI_ARCH)
     fprintf_unfiltered (file,
-                        "gdbarch_dump: DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS = 0x%08lx\n",
+                        "gdbarch_dump: DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS = <0x%08lx>\n",
                         (long) current_gdbarch->deprecated_extract_struct_value_address
                         /*DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS ()*/);
 #endif
+#ifdef DEPRECATED_EXTRA_STACK_ALIGNMENT_NEEDED
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: DEPRECATED_EXTRA_STACK_ALIGNMENT_NEEDED # %s\n",
+                      XSTRING (DEPRECATED_EXTRA_STACK_ALIGNMENT_NEEDED));
+  fprintf_unfiltered (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",
+                      "DEPRECATED_FRAME_CHAIN_P()",
+                      XSTRING (DEPRECATED_FRAME_CHAIN_P ()));
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: DEPRECATED_FRAME_CHAIN_P() = %d\n",
+                      DEPRECATED_FRAME_CHAIN_P ());
+#endif
+#ifdef DEPRECATED_FRAME_CHAIN
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: %s # %s\n",
+                      "DEPRECATED_FRAME_CHAIN(frame)",
+                      XSTRING (DEPRECATED_FRAME_CHAIN (frame)));
+  if (GDB_MULTI_ARCH)
+    fprintf_unfiltered (file,
+                        "gdbarch_dump: DEPRECATED_FRAME_CHAIN = <0x%08lx>\n",
+                        (long) current_gdbarch->deprecated_frame_chain
+                        /*DEPRECATED_FRAME_CHAIN ()*/);
+#endif
+#ifdef DEPRECATED_FRAME_CHAIN_VALID_P
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: %s # %s\n",
+                      "DEPRECATED_FRAME_CHAIN_VALID_P()",
+                      XSTRING (DEPRECATED_FRAME_CHAIN_VALID_P ()));
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: DEPRECATED_FRAME_CHAIN_VALID_P() = %d\n",
+                      DEPRECATED_FRAME_CHAIN_VALID_P ());
+#endif
+#ifdef DEPRECATED_FRAME_CHAIN_VALID
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: %s # %s\n",
+                      "DEPRECATED_FRAME_CHAIN_VALID(chain, thisframe)",
+                      XSTRING (DEPRECATED_FRAME_CHAIN_VALID (chain, thisframe)));
+  if (GDB_MULTI_ARCH)
+    fprintf_unfiltered (file,
+                        "gdbarch_dump: DEPRECATED_FRAME_CHAIN_VALID = <0x%08lx>\n",
+                        (long) current_gdbarch->deprecated_frame_chain_valid
+                        /*DEPRECATED_FRAME_CHAIN_VALID ()*/);
+#endif
+#ifdef DEPRECATED_FRAME_INIT_SAVED_REGS_P
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: %s # %s\n",
+                      "DEPRECATED_FRAME_INIT_SAVED_REGS_P()",
+                      XSTRING (DEPRECATED_FRAME_INIT_SAVED_REGS_P ()));
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: DEPRECATED_FRAME_INIT_SAVED_REGS_P() = %d\n",
+                      DEPRECATED_FRAME_INIT_SAVED_REGS_P ());
+#endif
+#ifdef DEPRECATED_FRAME_INIT_SAVED_REGS
+#if GDB_MULTI_ARCH
+  /* Macro might contain `[{}]' when not multi-arch */
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: %s # %s\n",
+                      "DEPRECATED_FRAME_INIT_SAVED_REGS(frame)",
+                      XSTRING (DEPRECATED_FRAME_INIT_SAVED_REGS (frame)));
+#endif
+  if (GDB_MULTI_ARCH)
+    fprintf_unfiltered (file,
+                        "gdbarch_dump: DEPRECATED_FRAME_INIT_SAVED_REGS = <0x%08lx>\n",
+                        (long) current_gdbarch->deprecated_frame_init_saved_regs
+                        /*DEPRECATED_FRAME_INIT_SAVED_REGS ()*/);
+#endif
+#ifdef DEPRECATED_FRAME_SAVED_PC_P
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: %s # %s\n",
+                      "DEPRECATED_FRAME_SAVED_PC_P()",
+                      XSTRING (DEPRECATED_FRAME_SAVED_PC_P ()));
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: DEPRECATED_FRAME_SAVED_PC_P() = %d\n",
+                      DEPRECATED_FRAME_SAVED_PC_P ());
+#endif
+#ifdef DEPRECATED_FRAME_SAVED_PC
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: %s # %s\n",
+                      "DEPRECATED_FRAME_SAVED_PC(fi)",
+                      XSTRING (DEPRECATED_FRAME_SAVED_PC (fi)));
+  if (GDB_MULTI_ARCH)
+    fprintf_unfiltered (file,
+                        "gdbarch_dump: DEPRECATED_FRAME_SAVED_PC = <0x%08lx>\n",
+                        (long) current_gdbarch->deprecated_frame_saved_pc
+                        /*DEPRECATED_FRAME_SAVED_PC ()*/);
+#endif
+#ifdef DEPRECATED_GET_SAVED_REGISTER_P
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: %s # %s\n",
+                      "DEPRECATED_GET_SAVED_REGISTER_P()",
+                      XSTRING (DEPRECATED_GET_SAVED_REGISTER_P ()));
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: DEPRECATED_GET_SAVED_REGISTER_P() = %d\n",
+                      DEPRECATED_GET_SAVED_REGISTER_P ());
+#endif
+#ifdef DEPRECATED_GET_SAVED_REGISTER
+#if GDB_MULTI_ARCH
+  /* Macro might contain `[{}]' when not multi-arch */
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: %s # %s\n",
+                      "DEPRECATED_GET_SAVED_REGISTER(raw_buffer, optimized, addrp, frame, regnum, lval)",
+                      XSTRING (DEPRECATED_GET_SAVED_REGISTER (raw_buffer, optimized, addrp, frame, regnum, lval)));
+#endif
+  if (GDB_MULTI_ARCH)
+    fprintf_unfiltered (file,
+                        "gdbarch_dump: DEPRECATED_GET_SAVED_REGISTER = <0x%08lx>\n",
+                        (long) current_gdbarch->deprecated_get_saved_register
+                        /*DEPRECATED_GET_SAVED_REGISTER ()*/);
+#endif
+#ifdef DEPRECATED_INIT_EXTRA_FRAME_INFO_P
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: %s # %s\n",
+                      "DEPRECATED_INIT_EXTRA_FRAME_INFO_P()",
+                      XSTRING (DEPRECATED_INIT_EXTRA_FRAME_INFO_P ()));
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: DEPRECATED_INIT_EXTRA_FRAME_INFO_P() = %d\n",
+                      DEPRECATED_INIT_EXTRA_FRAME_INFO_P ());
+#endif
+#ifdef DEPRECATED_INIT_EXTRA_FRAME_INFO
+#if GDB_MULTI_ARCH
+  /* Macro might contain `[{}]' when not multi-arch */
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: %s # %s\n",
+                      "DEPRECATED_INIT_EXTRA_FRAME_INFO(fromleaf, frame)",
+                      XSTRING (DEPRECATED_INIT_EXTRA_FRAME_INFO (fromleaf, frame)));
+#endif
+  if (GDB_MULTI_ARCH)
+    fprintf_unfiltered (file,
+                        "gdbarch_dump: DEPRECATED_INIT_EXTRA_FRAME_INFO = <0x%08lx>\n",
+                        (long) current_gdbarch->deprecated_init_extra_frame_info
+                        /*DEPRECATED_INIT_EXTRA_FRAME_INFO ()*/);
+#endif
+#ifdef DEPRECATED_INIT_FRAME_PC_P
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: %s # %s\n",
+                      "DEPRECATED_INIT_FRAME_PC_P()",
+                      XSTRING (DEPRECATED_INIT_FRAME_PC_P ()));
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: DEPRECATED_INIT_FRAME_PC_P() = %d\n",
+                      DEPRECATED_INIT_FRAME_PC_P ());
+#endif
+#ifdef DEPRECATED_INIT_FRAME_PC
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: %s # %s\n",
+                      "DEPRECATED_INIT_FRAME_PC(fromleaf, prev)",
+                      XSTRING (DEPRECATED_INIT_FRAME_PC (fromleaf, prev)));
+  if (GDB_MULTI_ARCH)
+    fprintf_unfiltered (file,
+                        "gdbarch_dump: DEPRECATED_INIT_FRAME_PC = <0x%08lx>\n",
+                        (long) current_gdbarch->deprecated_init_frame_pc
+                        /*DEPRECATED_INIT_FRAME_PC ()*/);
+#endif
 #ifdef DEPRECATED_INIT_FRAME_PC_FIRST_P
   fprintf_unfiltered (file,
                       "gdbarch_dump: %s # %s\n",
@@ -1202,19 +1332,50 @@ gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file)
                       DEPRECATED_INIT_FRAME_PC_FIRST_P ());
 #endif
 #ifdef DEPRECATED_INIT_FRAME_PC_FIRST
-#if GDB_MULTI_ARCH
-  /* Macro might contain `[{}]' when not multi-arch */
   fprintf_unfiltered (file,
                       "gdbarch_dump: %s # %s\n",
                       "DEPRECATED_INIT_FRAME_PC_FIRST(fromleaf, prev)",
                       XSTRING (DEPRECATED_INIT_FRAME_PC_FIRST (fromleaf, prev)));
-#endif
   if (GDB_MULTI_ARCH)
     fprintf_unfiltered (file,
-                        "gdbarch_dump: DEPRECATED_INIT_FRAME_PC_FIRST = 0x%08lx\n",
+                        "gdbarch_dump: DEPRECATED_INIT_FRAME_PC_FIRST = <0x%08lx>\n",
                         (long) current_gdbarch->deprecated_init_frame_pc_first
                         /*DEPRECATED_INIT_FRAME_PC_FIRST ()*/);
 #endif
+#ifdef DEPRECATED_MAX_REGISTER_RAW_SIZE_P
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: %s # %s\n",
+                      "DEPRECATED_MAX_REGISTER_RAW_SIZE_P()",
+                      XSTRING (DEPRECATED_MAX_REGISTER_RAW_SIZE_P ()));
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: DEPRECATED_MAX_REGISTER_RAW_SIZE_P() = %d\n",
+                      DEPRECATED_MAX_REGISTER_RAW_SIZE_P ());
+#endif
+#ifdef DEPRECATED_MAX_REGISTER_RAW_SIZE
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: DEPRECATED_MAX_REGISTER_RAW_SIZE # %s\n",
+                      XSTRING (DEPRECATED_MAX_REGISTER_RAW_SIZE));
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: DEPRECATED_MAX_REGISTER_RAW_SIZE = %d\n",
+                      DEPRECATED_MAX_REGISTER_RAW_SIZE);
+#endif
+#ifdef DEPRECATED_MAX_REGISTER_VIRTUAL_SIZE_P
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: %s # %s\n",
+                      "DEPRECATED_MAX_REGISTER_VIRTUAL_SIZE_P()",
+                      XSTRING (DEPRECATED_MAX_REGISTER_VIRTUAL_SIZE_P ()));
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: DEPRECATED_MAX_REGISTER_VIRTUAL_SIZE_P() = %d\n",
+                      DEPRECATED_MAX_REGISTER_VIRTUAL_SIZE_P ());
+#endif
+#ifdef DEPRECATED_MAX_REGISTER_VIRTUAL_SIZE
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: DEPRECATED_MAX_REGISTER_VIRTUAL_SIZE # %s\n",
+                      XSTRING (DEPRECATED_MAX_REGISTER_VIRTUAL_SIZE));
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: DEPRECATED_MAX_REGISTER_VIRTUAL_SIZE = %d\n",
+                      DEPRECATED_MAX_REGISTER_VIRTUAL_SIZE);
+#endif
 #ifdef DEPRECATED_PC_IN_CALL_DUMMY_P
   fprintf_unfiltered (file,
                       "gdbarch_dump: %s # %s\n",
@@ -1231,10 +1392,140 @@ gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file)
                       XSTRING (DEPRECATED_PC_IN_CALL_DUMMY (pc, sp, frame_address)));
   if (GDB_MULTI_ARCH)
     fprintf_unfiltered (file,
-                        "gdbarch_dump: DEPRECATED_PC_IN_CALL_DUMMY = 0x%08lx\n",
+                        "gdbarch_dump: DEPRECATED_PC_IN_CALL_DUMMY = <0x%08lx>\n",
                         (long) current_gdbarch->deprecated_pc_in_call_dummy
                         /*DEPRECATED_PC_IN_CALL_DUMMY ()*/);
 #endif
+#ifdef DEPRECATED_POP_FRAME_P
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: %s # %s\n",
+                      "DEPRECATED_POP_FRAME_P()",
+                      XSTRING (DEPRECATED_POP_FRAME_P ()));
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: DEPRECATED_POP_FRAME_P() = %d\n",
+                      DEPRECATED_POP_FRAME_P ());
+#endif
+#ifdef DEPRECATED_POP_FRAME
+#if GDB_MULTI_ARCH
+  /* Macro might contain `[{}]' when not multi-arch */
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: %s # %s\n",
+                      "DEPRECATED_POP_FRAME(-)",
+                      XSTRING (DEPRECATED_POP_FRAME (-)));
+#endif
+  if (GDB_MULTI_ARCH)
+    fprintf_unfiltered (file,
+                        "gdbarch_dump: DEPRECATED_POP_FRAME = <0x%08lx>\n",
+                        (long) current_gdbarch->deprecated_pop_frame
+                        /*DEPRECATED_POP_FRAME ()*/);
+#endif
+#ifdef DEPRECATED_PUSH_ARGUMENTS_P
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: %s # %s\n",
+                      "DEPRECATED_PUSH_ARGUMENTS_P()",
+                      XSTRING (DEPRECATED_PUSH_ARGUMENTS_P ()));
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: DEPRECATED_PUSH_ARGUMENTS_P() = %d\n",
+                      DEPRECATED_PUSH_ARGUMENTS_P ());
+#endif
+#ifdef DEPRECATED_PUSH_ARGUMENTS
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: %s # %s\n",
+                      "DEPRECATED_PUSH_ARGUMENTS(nargs, args, sp, struct_return, struct_addr)",
+                      XSTRING (DEPRECATED_PUSH_ARGUMENTS (nargs, args, sp, struct_return, struct_addr)));
+  if (GDB_MULTI_ARCH)
+    fprintf_unfiltered (file,
+                        "gdbarch_dump: DEPRECATED_PUSH_ARGUMENTS = <0x%08lx>\n",
+                        (long) current_gdbarch->deprecated_push_arguments
+                        /*DEPRECATED_PUSH_ARGUMENTS ()*/);
+#endif
+#ifdef DEPRECATED_PUSH_DUMMY_FRAME_P
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: %s # %s\n",
+                      "DEPRECATED_PUSH_DUMMY_FRAME_P()",
+                      XSTRING (DEPRECATED_PUSH_DUMMY_FRAME_P ()));
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: DEPRECATED_PUSH_DUMMY_FRAME_P() = %d\n",
+                      DEPRECATED_PUSH_DUMMY_FRAME_P ());
+#endif
+#ifdef DEPRECATED_PUSH_DUMMY_FRAME
+#if GDB_MULTI_ARCH
+  /* Macro might contain `[{}]' when not multi-arch */
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: %s # %s\n",
+                      "DEPRECATED_PUSH_DUMMY_FRAME(-)",
+                      XSTRING (DEPRECATED_PUSH_DUMMY_FRAME (-)));
+#endif
+  if (GDB_MULTI_ARCH)
+    fprintf_unfiltered (file,
+                        "gdbarch_dump: DEPRECATED_PUSH_DUMMY_FRAME = <0x%08lx>\n",
+                        (long) current_gdbarch->deprecated_push_dummy_frame
+                        /*DEPRECATED_PUSH_DUMMY_FRAME ()*/);
+#endif
+#ifdef DEPRECATED_PUSH_RETURN_ADDRESS_P
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: %s # %s\n",
+                      "DEPRECATED_PUSH_RETURN_ADDRESS_P()",
+                      XSTRING (DEPRECATED_PUSH_RETURN_ADDRESS_P ()));
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: DEPRECATED_PUSH_RETURN_ADDRESS_P() = %d\n",
+                      DEPRECATED_PUSH_RETURN_ADDRESS_P ());
+#endif
+#ifdef DEPRECATED_PUSH_RETURN_ADDRESS
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: %s # %s\n",
+                      "DEPRECATED_PUSH_RETURN_ADDRESS(pc, sp)",
+                      XSTRING (DEPRECATED_PUSH_RETURN_ADDRESS (pc, sp)));
+  if (GDB_MULTI_ARCH)
+    fprintf_unfiltered (file,
+                        "gdbarch_dump: DEPRECATED_PUSH_RETURN_ADDRESS = <0x%08lx>\n",
+                        (long) current_gdbarch->deprecated_push_return_address
+                        /*DEPRECATED_PUSH_RETURN_ADDRESS ()*/);
+#endif
+#ifdef DEPRECATED_REGISTER_BYTES
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: DEPRECATED_REGISTER_BYTES # %s\n",
+                      XSTRING (DEPRECATED_REGISTER_BYTES));
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: DEPRECATED_REGISTER_BYTES = %d\n",
+                      DEPRECATED_REGISTER_BYTES);
+#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",
+                      "DEPRECATED_SAVED_PC_AFTER_CALL_P()",
+                      XSTRING (DEPRECATED_SAVED_PC_AFTER_CALL_P ()));
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: DEPRECATED_SAVED_PC_AFTER_CALL_P() = %d\n",
+                      DEPRECATED_SAVED_PC_AFTER_CALL_P ());
+#endif
+#ifdef DEPRECATED_SAVED_PC_AFTER_CALL
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: %s # %s\n",
+                      "DEPRECATED_SAVED_PC_AFTER_CALL(frame)",
+                      XSTRING (DEPRECATED_SAVED_PC_AFTER_CALL (frame)));
+  if (GDB_MULTI_ARCH)
+    fprintf_unfiltered (file,
+                        "gdbarch_dump: DEPRECATED_SAVED_PC_AFTER_CALL = <0x%08lx>\n",
+                        (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 */
@@ -1245,10 +1536,53 @@ gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file)
 #endif
   if (GDB_MULTI_ARCH)
     fprintf_unfiltered (file,
-                        "gdbarch_dump: DEPRECATED_STORE_RETURN_VALUE = 0x%08lx\n",
+                        "gdbarch_dump: DEPRECATED_STORE_RETURN_VALUE = <0x%08lx>\n",
                         (long) current_gdbarch->deprecated_store_return_value
                         /*DEPRECATED_STORE_RETURN_VALUE ()*/);
 #endif
+#ifdef DEPRECATED_STORE_STRUCT_RETURN_P
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: %s # %s\n",
+                      "DEPRECATED_STORE_STRUCT_RETURN_P()",
+                      XSTRING (DEPRECATED_STORE_STRUCT_RETURN_P ()));
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: DEPRECATED_STORE_STRUCT_RETURN_P() = %d\n",
+                      DEPRECATED_STORE_STRUCT_RETURN_P ());
+#endif
+#ifdef DEPRECATED_STORE_STRUCT_RETURN
+#if GDB_MULTI_ARCH
+  /* Macro might contain `[{}]' when not multi-arch */
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: %s # %s\n",
+                      "DEPRECATED_STORE_STRUCT_RETURN(addr, sp)",
+                      XSTRING (DEPRECATED_STORE_STRUCT_RETURN (addr, sp)));
+#endif
+  if (GDB_MULTI_ARCH)
+    fprintf_unfiltered (file,
+                        "gdbarch_dump: DEPRECATED_STORE_STRUCT_RETURN = <0x%08lx>\n",
+                        (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",
@@ -1276,7 +1610,7 @@ gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file)
 #endif
   if (GDB_MULTI_ARCH)
     fprintf_unfiltered (file,
-                        "gdbarch_dump: DWARF2_BUILD_FRAME_INFO = 0x%08lx\n",
+                        "gdbarch_dump: DWARF2_BUILD_FRAME_INFO = <0x%08lx>\n",
                         (long) current_gdbarch->dwarf2_build_frame_info
                         /*DWARF2_BUILD_FRAME_INFO ()*/);
 #endif
@@ -1287,7 +1621,7 @@ gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file)
                       XSTRING (DWARF2_REG_TO_REGNUM (dwarf2_regnr)));
   if (GDB_MULTI_ARCH)
     fprintf_unfiltered (file,
-                        "gdbarch_dump: DWARF2_REG_TO_REGNUM = 0x%08lx\n",
+                        "gdbarch_dump: DWARF2_REG_TO_REGNUM = <0x%08lx>\n",
                         (long) current_gdbarch->dwarf2_reg_to_regnum
                         /*DWARF2_REG_TO_REGNUM ()*/);
 #endif
@@ -1298,7 +1632,7 @@ gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file)
                       XSTRING (DWARF_REG_TO_REGNUM (dwarf_regnr)));
   if (GDB_MULTI_ARCH)
     fprintf_unfiltered (file,
-                        "gdbarch_dump: DWARF_REG_TO_REGNUM = 0x%08lx\n",
+                        "gdbarch_dump: DWARF_REG_TO_REGNUM = <0x%08lx>\n",
                         (long) current_gdbarch->dwarf_reg_to_regnum
                         /*DWARF_REG_TO_REGNUM ()*/);
 #endif
@@ -1309,7 +1643,7 @@ gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file)
                       XSTRING (ECOFF_REG_TO_REGNUM (ecoff_regnr)));
   if (GDB_MULTI_ARCH)
     fprintf_unfiltered (file,
-                        "gdbarch_dump: ECOFF_REG_TO_REGNUM = 0x%08lx\n",
+                        "gdbarch_dump: ECOFF_REG_TO_REGNUM = <0x%08lx>\n",
                         (long) current_gdbarch->ecoff_reg_to_regnum
                         /*ECOFF_REG_TO_REGNUM ()*/);
 #endif
@@ -1323,7 +1657,7 @@ gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file)
 #endif
   if (GDB_MULTI_ARCH)
     fprintf_unfiltered (file,
-                        "gdbarch_dump: ELF_MAKE_MSYMBOL_SPECIAL = 0x%08lx\n",
+                        "gdbarch_dump: ELF_MAKE_MSYMBOL_SPECIAL = <0x%08lx>\n",
                         (long) current_gdbarch->elf_make_msymbol_special
                         /*ELF_MAKE_MSYMBOL_SPECIAL ()*/);
 #endif
@@ -1337,7 +1671,7 @@ gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file)
 #endif
   if (GDB_MULTI_ARCH)
     fprintf_unfiltered (file,
-                        "gdbarch_dump: EXTRACT_RETURN_VALUE = 0x%08lx\n",
+                        "gdbarch_dump: EXTRACT_RETURN_VALUE = <0x%08lx>\n",
                         (long) current_gdbarch->extract_return_value
                         /*EXTRACT_RETURN_VALUE ()*/);
 #endif
@@ -1357,31 +1691,29 @@ gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file)
                       XSTRING (EXTRACT_STRUCT_VALUE_ADDRESS (regcache)));
   if (GDB_MULTI_ARCH)
     fprintf_unfiltered (file,
-                        "gdbarch_dump: EXTRACT_STRUCT_VALUE_ADDRESS = 0x%08lx\n",
+                        "gdbarch_dump: EXTRACT_STRUCT_VALUE_ADDRESS = <0x%08lx>\n",
                         (long) current_gdbarch->extract_struct_value_address
                         /*EXTRACT_STRUCT_VALUE_ADDRESS ()*/);
 #endif
-#ifdef EXTRA_STACK_ALIGNMENT_NEEDED
+#ifdef FETCH_POINTER_ARGUMENT_P
   fprintf_unfiltered (file,
-                      "gdbarch_dump: EXTRA_STACK_ALIGNMENT_NEEDED # %s\n",
-                      XSTRING (EXTRA_STACK_ALIGNMENT_NEEDED));
+                      "gdbarch_dump: %s # %s\n",
+                      "FETCH_POINTER_ARGUMENT_P()",
+                      XSTRING (FETCH_POINTER_ARGUMENT_P ()));
   fprintf_unfiltered (file,
-                      "gdbarch_dump: EXTRA_STACK_ALIGNMENT_NEEDED = %d\n",
-                      EXTRA_STACK_ALIGNMENT_NEEDED);
+                      "gdbarch_dump: FETCH_POINTER_ARGUMENT_P() = %d\n",
+                      FETCH_POINTER_ARGUMENT_P ());
 #endif
-#ifdef FIX_CALL_DUMMY
-#if GDB_MULTI_ARCH
-  /* Macro might contain `[{}]' when not multi-arch */
+#ifdef FETCH_POINTER_ARGUMENT
   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
+                      "FETCH_POINTER_ARGUMENT(frame, argi, type)",
+                      XSTRING (FETCH_POINTER_ARGUMENT (frame, argi, type)));
   if (GDB_MULTI_ARCH)
     fprintf_unfiltered (file,
-                        "gdbarch_dump: FIX_CALL_DUMMY = 0x%08lx\n",
-                        (long) current_gdbarch->fix_call_dummy
-                        /*FIX_CALL_DUMMY ()*/);
+                        "gdbarch_dump: FETCH_POINTER_ARGUMENT = <0x%08lx>\n",
+                        (long) current_gdbarch->fetch_pointer_argument
+                        /*FETCH_POINTER_ARGUMENT ()*/);
 #endif
 #ifdef FP0_REGNUM
   fprintf_unfiltered (file,
@@ -1391,14 +1723,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",
@@ -1406,7 +1730,7 @@ gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file)
                       XSTRING (FRAMELESS_FUNCTION_INVOCATION (fi)));
   if (GDB_MULTI_ARCH)
     fprintf_unfiltered (file,
-                        "gdbarch_dump: FRAMELESS_FUNCTION_INVOCATION = 0x%08lx\n",
+                        "gdbarch_dump: FRAMELESS_FUNCTION_INVOCATION = <0x%08lx>\n",
                         (long) current_gdbarch->frameless_function_invocation
                         /*FRAMELESS_FUNCTION_INVOCATION ()*/);
 #endif
@@ -1417,7 +1741,7 @@ gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file)
                       XSTRING (FRAME_ARGS_ADDRESS (fi)));
   if (GDB_MULTI_ARCH)
     fprintf_unfiltered (file,
-                        "gdbarch_dump: FRAME_ARGS_ADDRESS = 0x%08lx\n",
+                        "gdbarch_dump: FRAME_ARGS_ADDRESS = <0x%08lx>\n",
                         (long) current_gdbarch->frame_args_address
                         /*FRAME_ARGS_ADDRESS ()*/);
 #endif
@@ -1429,42 +1753,6 @@ gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file)
                       "gdbarch_dump: FRAME_ARGS_SKIP = %ld\n",
                       (long) FRAME_ARGS_SKIP);
 #endif
-#ifdef FRAME_CHAIN
-  fprintf_unfiltered (file,
-                      "gdbarch_dump: %s # %s\n",
-                      "FRAME_CHAIN(frame)",
-                      XSTRING (FRAME_CHAIN (frame)));
-  if (GDB_MULTI_ARCH)
-    fprintf_unfiltered (file,
-                        "gdbarch_dump: FRAME_CHAIN = 0x%08lx\n",
-                        (long) current_gdbarch->frame_chain
-                        /*FRAME_CHAIN ()*/);
-#endif
-#ifdef FRAME_CHAIN_VALID
-  fprintf_unfiltered (file,
-                      "gdbarch_dump: %s # %s\n",
-                      "FRAME_CHAIN_VALID(chain, thisframe)",
-                      XSTRING (FRAME_CHAIN_VALID (chain, thisframe)));
-  if (GDB_MULTI_ARCH)
-    fprintf_unfiltered (file,
-                        "gdbarch_dump: FRAME_CHAIN_VALID = 0x%08lx\n",
-                        (long) current_gdbarch->frame_chain_valid
-                        /*FRAME_CHAIN_VALID ()*/);
-#endif
-#ifdef FRAME_INIT_SAVED_REGS
-#if GDB_MULTI_ARCH
-  /* Macro might contain `[{}]' when not multi-arch */
-  fprintf_unfiltered (file,
-                      "gdbarch_dump: %s # %s\n",
-                      "FRAME_INIT_SAVED_REGS(frame)",
-                      XSTRING (FRAME_INIT_SAVED_REGS (frame)));
-#endif
-  if (GDB_MULTI_ARCH)
-    fprintf_unfiltered (file,
-                        "gdbarch_dump: FRAME_INIT_SAVED_REGS = 0x%08lx\n",
-                        (long) current_gdbarch->frame_init_saved_regs
-                        /*FRAME_INIT_SAVED_REGS ()*/);
-#endif
 #ifdef FRAME_LOCALS_ADDRESS
   fprintf_unfiltered (file,
                       "gdbarch_dump: %s # %s\n",
@@ -1472,7 +1760,7 @@ gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file)
                       XSTRING (FRAME_LOCALS_ADDRESS (fi)));
   if (GDB_MULTI_ARCH)
     fprintf_unfiltered (file,
-                        "gdbarch_dump: FRAME_LOCALS_ADDRESS = 0x%08lx\n",
+                        "gdbarch_dump: FRAME_LOCALS_ADDRESS = <0x%08lx>\n",
                         (long) current_gdbarch->frame_locals_address
                         /*FRAME_LOCALS_ADDRESS ()*/);
 #endif
@@ -1483,21 +1771,10 @@ gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file)
                       XSTRING (FRAME_NUM_ARGS (frame)));
   if (GDB_MULTI_ARCH)
     fprintf_unfiltered (file,
-                        "gdbarch_dump: FRAME_NUM_ARGS = 0x%08lx\n",
+                        "gdbarch_dump: FRAME_NUM_ARGS = <0x%08lx>\n",
                         (long) current_gdbarch->frame_num_args
                         /*FRAME_NUM_ARGS ()*/);
 #endif
-#ifdef FRAME_SAVED_PC
-  fprintf_unfiltered (file,
-                      "gdbarch_dump: %s # %s\n",
-                      "FRAME_SAVED_PC(fi)",
-                      XSTRING (FRAME_SAVED_PC (fi)));
-  if (GDB_MULTI_ARCH)
-    fprintf_unfiltered (file,
-                        "gdbarch_dump: FRAME_SAVED_PC = 0x%08lx\n",
-                        (long) current_gdbarch->frame_saved_pc
-                        /*FRAME_SAVED_PC ()*/);
-#endif
 #ifdef FUNCTION_START_OFFSET
   fprintf_unfiltered (file,
                       "gdbarch_dump: FUNCTION_START_OFFSET # %s\n",
@@ -1522,33 +1799,10 @@ gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file)
                       XSTRING (GET_LONGJMP_TARGET (pc)));
   if (GDB_MULTI_ARCH)
     fprintf_unfiltered (file,
-                        "gdbarch_dump: GET_LONGJMP_TARGET = 0x%08lx\n",
+                        "gdbarch_dump: GET_LONGJMP_TARGET = <0x%08lx>\n",
                         (long) current_gdbarch->get_longjmp_target
                         /*GET_LONGJMP_TARGET ()*/);
 #endif
-#ifdef GET_SAVED_REGISTER_P
-  fprintf_unfiltered (file,
-                      "gdbarch_dump: %s # %s\n",
-                      "GET_SAVED_REGISTER_P()",
-                      XSTRING (GET_SAVED_REGISTER_P ()));
-  fprintf_unfiltered (file,
-                      "gdbarch_dump: GET_SAVED_REGISTER_P() = %d\n",
-                      GET_SAVED_REGISTER_P ());
-#endif
-#ifdef GET_SAVED_REGISTER
-#if GDB_MULTI_ARCH
-  /* Macro might contain `[{}]' when not multi-arch */
-  fprintf_unfiltered (file,
-                      "gdbarch_dump: %s # %s\n",
-                      "GET_SAVED_REGISTER(raw_buffer, optimized, addrp, frame, regnum, lval)",
-                      XSTRING (GET_SAVED_REGISTER (raw_buffer, optimized, addrp, frame, regnum, lval)));
-#endif
-  if (GDB_MULTI_ARCH)
-    fprintf_unfiltered (file,
-                        "gdbarch_dump: GET_SAVED_REGISTER = 0x%08lx\n",
-                        (long) current_gdbarch->get_saved_register
-                        /*GET_SAVED_REGISTER ()*/);
-#endif
 #ifdef HAVE_NONSTEPPABLE_WATCHPOINT
   fprintf_unfiltered (file,
                       "gdbarch_dump: HAVE_NONSTEPPABLE_WATCHPOINT # %s\n",
@@ -1557,43 +1811,6 @@ gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file)
                       "gdbarch_dump: HAVE_NONSTEPPABLE_WATCHPOINT = %d\n",
                       HAVE_NONSTEPPABLE_WATCHPOINT);
 #endif
-#ifdef INIT_EXTRA_FRAME_INFO_P
-  fprintf_unfiltered (file,
-                      "gdbarch_dump: %s # %s\n",
-                      "INIT_EXTRA_FRAME_INFO_P()",
-                      XSTRING (INIT_EXTRA_FRAME_INFO_P ()));
-  fprintf_unfiltered (file,
-                      "gdbarch_dump: INIT_EXTRA_FRAME_INFO_P() = %d\n",
-                      INIT_EXTRA_FRAME_INFO_P ());
-#endif
-#ifdef INIT_EXTRA_FRAME_INFO
-#if GDB_MULTI_ARCH
-  /* Macro might contain `[{}]' when not multi-arch */
-  fprintf_unfiltered (file,
-                      "gdbarch_dump: %s # %s\n",
-                      "INIT_EXTRA_FRAME_INFO(fromleaf, frame)",
-                      XSTRING (INIT_EXTRA_FRAME_INFO (fromleaf, frame)));
-#endif
-  if (GDB_MULTI_ARCH)
-    fprintf_unfiltered (file,
-                        "gdbarch_dump: INIT_EXTRA_FRAME_INFO = 0x%08lx\n",
-                        (long) current_gdbarch->init_extra_frame_info
-                        /*INIT_EXTRA_FRAME_INFO ()*/);
-#endif
-#ifdef INIT_FRAME_PC
-#if GDB_MULTI_ARCH
-  /* Macro might contain `[{}]' when not multi-arch */
-  fprintf_unfiltered (file,
-                      "gdbarch_dump: %s # %s\n",
-                      "INIT_FRAME_PC(fromleaf, prev)",
-                      XSTRING (INIT_FRAME_PC (fromleaf, prev)));
-#endif
-  if (GDB_MULTI_ARCH)
-    fprintf_unfiltered (file,
-                        "gdbarch_dump: INIT_FRAME_PC = 0x%08lx\n",
-                        (long) current_gdbarch->init_frame_pc
-                        /*INIT_FRAME_PC ()*/);
-#endif
 #ifdef INNER_THAN
   fprintf_unfiltered (file,
                       "gdbarch_dump: %s # %s\n",
@@ -1601,7 +1818,7 @@ gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file)
                       XSTRING (INNER_THAN (lhs, rhs)));
   if (GDB_MULTI_ARCH)
     fprintf_unfiltered (file,
-                        "gdbarch_dump: INNER_THAN = 0x%08lx\n",
+                        "gdbarch_dump: INNER_THAN = <0x%08lx>\n",
                         (long) current_gdbarch->inner_than
                         /*INNER_THAN ()*/);
 #endif
@@ -1621,7 +1838,7 @@ gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file)
                       XSTRING (INTEGER_TO_ADDRESS (type, buf)));
   if (GDB_MULTI_ARCH)
     fprintf_unfiltered (file,
-                        "gdbarch_dump: INTEGER_TO_ADDRESS = 0x%08lx\n",
+                        "gdbarch_dump: INTEGER_TO_ADDRESS = <0x%08lx>\n",
                         (long) current_gdbarch->integer_to_address
                         /*INTEGER_TO_ADDRESS ()*/);
 #endif
@@ -1632,7 +1849,7 @@ gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file)
                       XSTRING (IN_SOLIB_CALL_TRAMPOLINE (pc, name)));
   if (GDB_MULTI_ARCH)
     fprintf_unfiltered (file,
-                        "gdbarch_dump: IN_SOLIB_CALL_TRAMPOLINE = 0x%08lx\n",
+                        "gdbarch_dump: IN_SOLIB_CALL_TRAMPOLINE = <0x%08lx>\n",
                         (long) current_gdbarch->in_solib_call_trampoline
                         /*IN_SOLIB_CALL_TRAMPOLINE ()*/);
 #endif
@@ -1643,26 +1860,10 @@ gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file)
                       XSTRING (IN_SOLIB_RETURN_TRAMPOLINE (pc, name)));
   if (GDB_MULTI_ARCH)
     fprintf_unfiltered (file,
-                        "gdbarch_dump: IN_SOLIB_RETURN_TRAMPOLINE = 0x%08lx\n",
+                        "gdbarch_dump: IN_SOLIB_RETURN_TRAMPOLINE = <0x%08lx>\n",
                         (long) current_gdbarch->in_solib_return_trampoline
                         /*IN_SOLIB_RETURN_TRAMPOLINE ()*/);
 #endif
-#ifdef MAX_REGISTER_RAW_SIZE
-  fprintf_unfiltered (file,
-                      "gdbarch_dump: MAX_REGISTER_RAW_SIZE # %s\n",
-                      XSTRING (MAX_REGISTER_RAW_SIZE));
-  fprintf_unfiltered (file,
-                      "gdbarch_dump: MAX_REGISTER_RAW_SIZE = %d\n",
-                      MAX_REGISTER_RAW_SIZE);
-#endif
-#ifdef MAX_REGISTER_VIRTUAL_SIZE
-  fprintf_unfiltered (file,
-                      "gdbarch_dump: MAX_REGISTER_VIRTUAL_SIZE # %s\n",
-                      XSTRING (MAX_REGISTER_VIRTUAL_SIZE));
-  fprintf_unfiltered (file,
-                      "gdbarch_dump: MAX_REGISTER_VIRTUAL_SIZE = %d\n",
-                      MAX_REGISTER_VIRTUAL_SIZE);
-#endif
 #ifdef MEMORY_INSERT_BREAKPOINT
   fprintf_unfiltered (file,
                       "gdbarch_dump: %s # %s\n",
@@ -1670,7 +1871,7 @@ gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file)
                       XSTRING (MEMORY_INSERT_BREAKPOINT (addr, contents_cache)));
   if (GDB_MULTI_ARCH)
     fprintf_unfiltered (file,
-                        "gdbarch_dump: MEMORY_INSERT_BREAKPOINT = 0x%08lx\n",
+                        "gdbarch_dump: MEMORY_INSERT_BREAKPOINT = <0x%08lx>\n",
                         (long) current_gdbarch->memory_insert_breakpoint
                         /*MEMORY_INSERT_BREAKPOINT ()*/);
 #endif
@@ -1681,7 +1882,7 @@ gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file)
                       XSTRING (MEMORY_REMOVE_BREAKPOINT (addr, contents_cache)));
   if (GDB_MULTI_ARCH)
     fprintf_unfiltered (file,
-                        "gdbarch_dump: MEMORY_REMOVE_BREAKPOINT = 0x%08lx\n",
+                        "gdbarch_dump: MEMORY_REMOVE_BREAKPOINT = <0x%08lx>\n",
                         (long) current_gdbarch->memory_remove_breakpoint
                         /*MEMORY_REMOVE_BREAKPOINT ()*/);
 #endif
@@ -1690,8 +1891,8 @@ gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file)
                       "gdbarch_dump: NAME_OF_MALLOC # %s\n",
                       XSTRING (NAME_OF_MALLOC));
   fprintf_unfiltered (file,
-                      "gdbarch_dump: NAME_OF_MALLOC = %ld\n",
-                      (long) NAME_OF_MALLOC);
+                      "gdbarch_dump: NAME_OF_MALLOC = %s\n",
+                      NAME_OF_MALLOC);
 #endif
 #ifdef NPC_REGNUM
   fprintf_unfiltered (file,
@@ -1732,7 +1933,7 @@ gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file)
                       XSTRING (PC_IN_SIGTRAMP (pc, name)));
   if (GDB_MULTI_ARCH)
     fprintf_unfiltered (file,
-                        "gdbarch_dump: PC_IN_SIGTRAMP = 0x%08lx\n",
+                        "gdbarch_dump: PC_IN_SIGTRAMP = <0x%08lx>\n",
                         (long) current_gdbarch->pc_in_sigtramp
                         /*PC_IN_SIGTRAMP ()*/);
 #endif
@@ -1751,24 +1952,10 @@ gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file)
                       XSTRING (POINTER_TO_ADDRESS (type, buf)));
   if (GDB_MULTI_ARCH)
     fprintf_unfiltered (file,
-                        "gdbarch_dump: POINTER_TO_ADDRESS = 0x%08lx\n",
+                        "gdbarch_dump: POINTER_TO_ADDRESS = <0x%08lx>\n",
                         (long) current_gdbarch->pointer_to_address
                         /*POINTER_TO_ADDRESS ()*/);
 #endif
-#ifdef POP_FRAME
-#if GDB_MULTI_ARCH
-  /* Macro might contain `[{}]' when not multi-arch */
-  fprintf_unfiltered (file,
-                      "gdbarch_dump: %s # %s\n",
-                      "POP_FRAME(-)",
-                      XSTRING (POP_FRAME (-)));
-#endif
-  if (GDB_MULTI_ARCH)
-    fprintf_unfiltered (file,
-                        "gdbarch_dump: POP_FRAME = 0x%08lx\n",
-                        (long) current_gdbarch->pop_frame
-                        /*POP_FRAME ()*/);
-#endif
 #ifdef PREPARE_TO_PROCEED
   fprintf_unfiltered (file,
                       "gdbarch_dump: %s # %s\n",
@@ -1776,7 +1963,7 @@ gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file)
                       XSTRING (PREPARE_TO_PROCEED (select_it)));
   if (GDB_MULTI_ARCH)
     fprintf_unfiltered (file,
-                        "gdbarch_dump: PREPARE_TO_PROCEED = 0x%08lx\n",
+                        "gdbarch_dump: PREPARE_TO_PROCEED = <0x%08lx>\n",
                         (long) current_gdbarch->prepare_to_proceed
                         /*PREPARE_TO_PROCEED ()*/);
 #endif
@@ -1807,7 +1994,7 @@ gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file)
                       XSTRING (PROLOGUE_FRAMELESS_P (ip)));
   if (GDB_MULTI_ARCH)
     fprintf_unfiltered (file,
-                        "gdbarch_dump: PROLOGUE_FRAMELESS_P = 0x%08lx\n",
+                        "gdbarch_dump: PROLOGUE_FRAMELESS_P = <0x%08lx>\n",
                         (long) current_gdbarch->prologue_frameless_p
                         /*PROLOGUE_FRAMELESS_P ()*/);
 #endif
@@ -1819,50 +2006,30 @@ gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file)
                       "gdbarch_dump: PS_REGNUM = %d\n",
                       PS_REGNUM);
 #endif
-#ifdef PUSH_ARGUMENTS
-  fprintf_unfiltered (file,
-                      "gdbarch_dump: %s # %s\n",
-                      "PUSH_ARGUMENTS(nargs, args, sp, struct_return, struct_addr)",
-                      XSTRING (PUSH_ARGUMENTS (nargs, args, sp, struct_return, struct_addr)));
   if (GDB_MULTI_ARCH)
     fprintf_unfiltered (file,
-                        "gdbarch_dump: PUSH_ARGUMENTS = 0x%08lx\n",
-                        (long) current_gdbarch->push_arguments
-                        /*PUSH_ARGUMENTS ()*/);
-#endif
-#ifdef PUSH_DUMMY_FRAME
-#if GDB_MULTI_ARCH
-  /* Macro might contain `[{}]' when not multi-arch */
-  fprintf_unfiltered (file,
-                      "gdbarch_dump: %s # %s\n",
-                      "PUSH_DUMMY_FRAME(-)",
-                      XSTRING (PUSH_DUMMY_FRAME (-)));
-#endif
+                        "gdbarch_dump: gdbarch_push_dummy_call_p() = %d\n",
+                        gdbarch_push_dummy_call_p (current_gdbarch));
   if (GDB_MULTI_ARCH)
     fprintf_unfiltered (file,
-                        "gdbarch_dump: PUSH_DUMMY_FRAME = 0x%08lx\n",
-                        (long) current_gdbarch->push_dummy_frame
-                        /*PUSH_DUMMY_FRAME ()*/);
-#endif
-#ifdef PUSH_RETURN_ADDRESS_P
+                        "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",
-                      "PUSH_RETURN_ADDRESS_P()",
-                      XSTRING (PUSH_RETURN_ADDRESS_P ()));
+                      "REGISTER_BYTE_P()",
+                      XSTRING (REGISTER_BYTE_P ()));
   fprintf_unfiltered (file,
-                      "gdbarch_dump: PUSH_RETURN_ADDRESS_P() = %d\n",
-                      PUSH_RETURN_ADDRESS_P ());
-#endif
-#ifdef PUSH_RETURN_ADDRESS
-  fprintf_unfiltered (file,
-                      "gdbarch_dump: %s # %s\n",
-                      "PUSH_RETURN_ADDRESS(pc, sp)",
-                      XSTRING (PUSH_RETURN_ADDRESS (pc, sp)));
-  if (GDB_MULTI_ARCH)
-    fprintf_unfiltered (file,
-                        "gdbarch_dump: PUSH_RETURN_ADDRESS = 0x%08lx\n",
-                        (long) current_gdbarch->push_return_address
-                        /*PUSH_RETURN_ADDRESS ()*/);
+                      "gdbarch_dump: REGISTER_BYTE_P() = %d\n",
+                      REGISTER_BYTE_P ());
 #endif
 #ifdef REGISTER_BYTE
   fprintf_unfiltered (file,
@@ -1871,18 +2038,10 @@ gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file)
                       XSTRING (REGISTER_BYTE (reg_nr)));
   if (GDB_MULTI_ARCH)
     fprintf_unfiltered (file,
-                        "gdbarch_dump: REGISTER_BYTE = 0x%08lx\n",
+                        "gdbarch_dump: REGISTER_BYTE = <0x%08lx>\n",
                         (long) current_gdbarch->register_byte
                         /*REGISTER_BYTE ()*/);
 #endif
-#ifdef REGISTER_BYTES
-  fprintf_unfiltered (file,
-                      "gdbarch_dump: REGISTER_BYTES # %s\n",
-                      XSTRING (REGISTER_BYTES));
-  fprintf_unfiltered (file,
-                      "gdbarch_dump: REGISTER_BYTES = %d\n",
-                      REGISTER_BYTES);
-#endif
 #ifdef REGISTER_BYTES_OK_P
   fprintf_unfiltered (file,
                       "gdbarch_dump: %s # %s\n",
@@ -1899,7 +2058,7 @@ gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file)
                       XSTRING (REGISTER_BYTES_OK (nr_bytes)));
   if (GDB_MULTI_ARCH)
     fprintf_unfiltered (file,
-                        "gdbarch_dump: REGISTER_BYTES_OK = 0x%08lx\n",
+                        "gdbarch_dump: REGISTER_BYTES_OK = <0x%08lx>\n",
                         (long) current_gdbarch->register_bytes_ok
                         /*REGISTER_BYTES_OK ()*/);
 #endif
@@ -1910,7 +2069,7 @@ gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file)
                       XSTRING (REGISTER_CONVERTIBLE (nr)));
   if (GDB_MULTI_ARCH)
     fprintf_unfiltered (file,
-                        "gdbarch_dump: REGISTER_CONVERTIBLE = 0x%08lx\n",
+                        "gdbarch_dump: REGISTER_CONVERTIBLE = <0x%08lx>\n",
                         (long) current_gdbarch->register_convertible
                         /*REGISTER_CONVERTIBLE ()*/);
 #endif
@@ -1924,7 +2083,7 @@ gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file)
 #endif
   if (GDB_MULTI_ARCH)
     fprintf_unfiltered (file,
-                        "gdbarch_dump: REGISTER_CONVERT_TO_RAW = 0x%08lx\n",
+                        "gdbarch_dump: REGISTER_CONVERT_TO_RAW = <0x%08lx>\n",
                         (long) current_gdbarch->register_convert_to_raw
                         /*REGISTER_CONVERT_TO_RAW ()*/);
 #endif
@@ -1938,7 +2097,7 @@ gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file)
 #endif
   if (GDB_MULTI_ARCH)
     fprintf_unfiltered (file,
-                        "gdbarch_dump: REGISTER_CONVERT_TO_VIRTUAL = 0x%08lx\n",
+                        "gdbarch_dump: REGISTER_CONVERT_TO_VIRTUAL = <0x%08lx>\n",
                         (long) current_gdbarch->register_convert_to_virtual
                         /*REGISTER_CONVERT_TO_VIRTUAL ()*/);
 #endif
@@ -1949,7 +2108,7 @@ gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file)
                       XSTRING (REGISTER_NAME (regnr)));
   if (GDB_MULTI_ARCH)
     fprintf_unfiltered (file,
-                        "gdbarch_dump: REGISTER_NAME = 0x%08lx\n",
+                        "gdbarch_dump: REGISTER_NAME = <0x%08lx>\n",
                         (long) current_gdbarch->register_name
                         /*REGISTER_NAME ()*/);
 #endif
@@ -1960,7 +2119,7 @@ gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file)
                       XSTRING (REGISTER_RAW_SIZE (reg_nr)));
   if (GDB_MULTI_ARCH)
     fprintf_unfiltered (file,
-                        "gdbarch_dump: REGISTER_RAW_SIZE = 0x%08lx\n",
+                        "gdbarch_dump: REGISTER_RAW_SIZE = <0x%08lx>\n",
                         (long) current_gdbarch->register_raw_size
                         /*REGISTER_RAW_SIZE ()*/);
 #endif
@@ -1971,18 +2130,10 @@ gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file)
                       XSTRING (REGISTER_SIM_REGNO (reg_nr)));
   if (GDB_MULTI_ARCH)
     fprintf_unfiltered (file,
-                        "gdbarch_dump: REGISTER_SIM_REGNO = 0x%08lx\n",
+                        "gdbarch_dump: REGISTER_SIM_REGNO = <0x%08lx>\n",
                         (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 */
@@ -1993,10 +2144,18 @@ gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file)
 #endif
   if (GDB_MULTI_ARCH)
     fprintf_unfiltered (file,
-                        "gdbarch_dump: REGISTER_TO_VALUE = 0x%08lx\n",
+                        "gdbarch_dump: REGISTER_TO_VALUE = <0x%08lx>\n",
                         (long) current_gdbarch->register_to_value
                         /*REGISTER_TO_VALUE ()*/);
 #endif
+  if (GDB_MULTI_ARCH)
+    fprintf_unfiltered (file,
+                        "gdbarch_dump: gdbarch_register_type_p() = %d\n",
+                        gdbarch_register_type_p (current_gdbarch));
+  if (GDB_MULTI_ARCH)
+    fprintf_unfiltered (file,
+                        "gdbarch_dump: register_type = 0x%08lx\n",
+                        (long) current_gdbarch->register_type);
 #ifdef REGISTER_VIRTUAL_SIZE
   fprintf_unfiltered (file,
                       "gdbarch_dump: %s # %s\n",
@@ -2004,10 +2163,19 @@ gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file)
                       XSTRING (REGISTER_VIRTUAL_SIZE (reg_nr)));
   if (GDB_MULTI_ARCH)
     fprintf_unfiltered (file,
-                        "gdbarch_dump: REGISTER_VIRTUAL_SIZE = 0x%08lx\n",
+                        "gdbarch_dump: REGISTER_VIRTUAL_SIZE = <0x%08lx>\n",
                         (long) current_gdbarch->register_virtual_size
                         /*REGISTER_VIRTUAL_SIZE ()*/);
 #endif
+#ifdef REGISTER_VIRTUAL_TYPE_P
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: %s # %s\n",
+                      "REGISTER_VIRTUAL_TYPE_P()",
+                      XSTRING (REGISTER_VIRTUAL_TYPE_P ()));
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: REGISTER_VIRTUAL_TYPE_P() = %d\n",
+                      REGISTER_VIRTUAL_TYPE_P ());
+#endif
 #ifdef REGISTER_VIRTUAL_TYPE
   fprintf_unfiltered (file,
                       "gdbarch_dump: %s # %s\n",
@@ -2015,7 +2183,7 @@ gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file)
                       XSTRING (REGISTER_VIRTUAL_TYPE (reg_nr)));
   if (GDB_MULTI_ARCH)
     fprintf_unfiltered (file,
-                        "gdbarch_dump: REGISTER_VIRTUAL_TYPE = 0x%08lx\n",
+                        "gdbarch_dump: REGISTER_VIRTUAL_TYPE = <0x%08lx>\n",
                         (long) current_gdbarch->register_virtual_type
                         /*REGISTER_VIRTUAL_TYPE ()*/);
 #endif
@@ -2035,24 +2203,14 @@ gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file)
                       XSTRING (REG_STRUCT_HAS_ADDR (gcc_p, type)));
   if (GDB_MULTI_ARCH)
     fprintf_unfiltered (file,
-                        "gdbarch_dump: REG_STRUCT_HAS_ADDR = 0x%08lx\n",
+                        "gdbarch_dump: REG_STRUCT_HAS_ADDR = <0x%08lx>\n",
                         (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",
@@ -2060,21 +2218,10 @@ gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file)
                       XSTRING (RETURN_VALUE_ON_STACK (type)));
   if (GDB_MULTI_ARCH)
     fprintf_unfiltered (file,
-                        "gdbarch_dump: RETURN_VALUE_ON_STACK = 0x%08lx\n",
+                        "gdbarch_dump: RETURN_VALUE_ON_STACK = <0x%08lx>\n",
                         (long) current_gdbarch->return_value_on_stack
                         /*RETURN_VALUE_ON_STACK ()*/);
 #endif
-#ifdef SAVED_PC_AFTER_CALL
-  fprintf_unfiltered (file,
-                      "gdbarch_dump: %s # %s\n",
-                      "SAVED_PC_AFTER_CALL(frame)",
-                      XSTRING (SAVED_PC_AFTER_CALL (frame)));
-  if (GDB_MULTI_ARCH)
-    fprintf_unfiltered (file,
-                        "gdbarch_dump: SAVED_PC_AFTER_CALL = 0x%08lx\n",
-                        (long) current_gdbarch->saved_pc_after_call
-                        /*SAVED_PC_AFTER_CALL ()*/);
-#endif
 #ifdef SAVE_DUMMY_FRAME_TOS_P
   fprintf_unfiltered (file,
                       "gdbarch_dump: %s # %s\n",
@@ -2094,7 +2241,7 @@ gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file)
 #endif
   if (GDB_MULTI_ARCH)
     fprintf_unfiltered (file,
-                        "gdbarch_dump: SAVE_DUMMY_FRAME_TOS = 0x%08lx\n",
+                        "gdbarch_dump: SAVE_DUMMY_FRAME_TOS = <0x%08lx>\n",
                         (long) current_gdbarch->save_dummy_frame_tos
                         /*SAVE_DUMMY_FRAME_TOS ()*/);
 #endif
@@ -2105,7 +2252,7 @@ gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file)
                       XSTRING (SDB_REG_TO_REGNUM (sdb_regnr)));
   if (GDB_MULTI_ARCH)
     fprintf_unfiltered (file,
-                        "gdbarch_dump: SDB_REG_TO_REGNUM = 0x%08lx\n",
+                        "gdbarch_dump: SDB_REG_TO_REGNUM = <0x%08lx>\n",
                         (long) current_gdbarch->sdb_reg_to_regnum
                         /*SDB_REG_TO_REGNUM ()*/);
 #endif
@@ -2125,7 +2272,7 @@ gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file)
                       XSTRING (SIGTRAMP_END (pc)));
   if (GDB_MULTI_ARCH)
     fprintf_unfiltered (file,
-                        "gdbarch_dump: SIGTRAMP_END = 0x%08lx\n",
+                        "gdbarch_dump: SIGTRAMP_END = <0x%08lx>\n",
                         (long) current_gdbarch->sigtramp_end
                         /*SIGTRAMP_END ()*/);
 #endif
@@ -2145,18 +2292,10 @@ gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file)
                       XSTRING (SIGTRAMP_START (pc)));
   if (GDB_MULTI_ARCH)
     fprintf_unfiltered (file,
-                        "gdbarch_dump: SIGTRAMP_START = 0x%08lx\n",
+                        "gdbarch_dump: SIGTRAMP_START = <0x%08lx>\n",
                         (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 = 0x%08lx\n",
-                      (long) SIZEOF_CALL_DUMMY_WORDS);
-#endif
 #ifdef SKIP_PROLOGUE
   fprintf_unfiltered (file,
                       "gdbarch_dump: %s # %s\n",
@@ -2164,7 +2303,7 @@ gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file)
                       XSTRING (SKIP_PROLOGUE (ip)));
   if (GDB_MULTI_ARCH)
     fprintf_unfiltered (file,
-                        "gdbarch_dump: SKIP_PROLOGUE = 0x%08lx\n",
+                        "gdbarch_dump: SKIP_PROLOGUE = <0x%08lx>\n",
                         (long) current_gdbarch->skip_prologue
                         /*SKIP_PROLOGUE ()*/);
 #endif
@@ -2175,7 +2314,7 @@ gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file)
                       XSTRING (SKIP_TRAMPOLINE_CODE (pc)));
   if (GDB_MULTI_ARCH)
     fprintf_unfiltered (file,
-                        "gdbarch_dump: SKIP_TRAMPOLINE_CODE = 0x%08lx\n",
+                        "gdbarch_dump: SKIP_TRAMPOLINE_CODE = <0x%08lx>\n",
                         (long) current_gdbarch->skip_trampoline_code
                         /*SKIP_TRAMPOLINE_CODE ()*/);
 #endif
@@ -2186,7 +2325,7 @@ gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file)
                       XSTRING (SMASH_TEXT_ADDRESS (addr)));
   if (GDB_MULTI_ARCH)
     fprintf_unfiltered (file,
-                        "gdbarch_dump: SMASH_TEXT_ADDRESS = 0x%08lx\n",
+                        "gdbarch_dump: SMASH_TEXT_ADDRESS = <0x%08lx>\n",
                         (long) current_gdbarch->smash_text_address
                         /*SMASH_TEXT_ADDRESS ()*/);
 #endif
@@ -2209,7 +2348,7 @@ gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file)
 #endif
   if (GDB_MULTI_ARCH)
     fprintf_unfiltered (file,
-                        "gdbarch_dump: SOFTWARE_SINGLE_STEP = 0x%08lx\n",
+                        "gdbarch_dump: SOFTWARE_SINGLE_STEP = <0x%08lx>\n",
                         (long) current_gdbarch->software_single_step
                         /*SOFTWARE_SINGLE_STEP ()*/);
 #endif
@@ -2228,7 +2367,7 @@ gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file)
                       XSTRING (STAB_REG_TO_REGNUM (stab_regnr)));
   if (GDB_MULTI_ARCH)
     fprintf_unfiltered (file,
-                        "gdbarch_dump: STAB_REG_TO_REGNUM = 0x%08lx\n",
+                        "gdbarch_dump: STAB_REG_TO_REGNUM = <0x%08lx>\n",
                         (long) current_gdbarch->stab_reg_to_regnum
                         /*STAB_REG_TO_REGNUM ()*/);
 #endif
@@ -2248,37 +2387,23 @@ gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file)
                       XSTRING (STACK_ALIGN (sp)));
   if (GDB_MULTI_ARCH)
     fprintf_unfiltered (file,
-                        "gdbarch_dump: STACK_ALIGN = 0x%08lx\n",
+                        "gdbarch_dump: STACK_ALIGN = <0x%08lx>\n",
                         (long) current_gdbarch->stack_align
-                        /*STACK_ALIGN ()*/);
-#endif
-#ifdef STORE_RETURN_VALUE
-#if GDB_MULTI_ARCH
-  /* Macro might contain `[{}]' when not multi-arch */
-  fprintf_unfiltered (file,
-                      "gdbarch_dump: %s # %s\n",
-                      "STORE_RETURN_VALUE(type, regcache, valbuf)",
-                      XSTRING (STORE_RETURN_VALUE (type, regcache, valbuf)));
-#endif
-  if (GDB_MULTI_ARCH)
-    fprintf_unfiltered (file,
-                        "gdbarch_dump: STORE_RETURN_VALUE = 0x%08lx\n",
-                        (long) current_gdbarch->store_return_value
-                        /*STORE_RETURN_VALUE ()*/);
+                        /*STACK_ALIGN ()*/);
 #endif
-#ifdef STORE_STRUCT_RETURN
+#ifdef STORE_RETURN_VALUE
 #if GDB_MULTI_ARCH
   /* Macro might contain `[{}]' when not multi-arch */
   fprintf_unfiltered (file,
                       "gdbarch_dump: %s # %s\n",
-                      "STORE_STRUCT_RETURN(addr, sp)",
-                      XSTRING (STORE_STRUCT_RETURN (addr, sp)));
+                      "STORE_RETURN_VALUE(type, regcache, valbuf)",
+                      XSTRING (STORE_RETURN_VALUE (type, regcache, valbuf)));
 #endif
   if (GDB_MULTI_ARCH)
     fprintf_unfiltered (file,
-                        "gdbarch_dump: STORE_STRUCT_RETURN = 0x%08lx\n",
-                        (long) current_gdbarch->store_struct_return
-                        /*STORE_STRUCT_RETURN ()*/);
+                        "gdbarch_dump: STORE_RETURN_VALUE = <0x%08lx>\n",
+                        (long) current_gdbarch->store_return_value
+                        /*STORE_RETURN_VALUE ()*/);
 #endif
 #ifdef TARGET_ADDR_BIT
   fprintf_unfiltered (file,
@@ -2335,7 +2460,7 @@ gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file)
                       XSTRING (TARGET_DOUBLE_FORMAT));
   fprintf_unfiltered (file,
                       "gdbarch_dump: TARGET_DOUBLE_FORMAT = %s\n",
-                      gdbarch->float_format->name);
+                      (TARGET_DOUBLE_FORMAT)->name);
 #endif
 #ifdef TARGET_FLOAT_BIT
   fprintf_unfiltered (file,
@@ -2351,7 +2476,7 @@ gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file)
                       XSTRING (TARGET_FLOAT_FORMAT));
   fprintf_unfiltered (file,
                       "gdbarch_dump: TARGET_FLOAT_FORMAT = %s\n",
-                      gdbarch->float_format->name);
+                      (TARGET_FLOAT_FORMAT)->name);
 #endif
 #ifdef TARGET_INT_BIT
   fprintf_unfiltered (file,
@@ -2383,7 +2508,7 @@ gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file)
                       XSTRING (TARGET_LONG_DOUBLE_FORMAT));
   fprintf_unfiltered (file,
                       "gdbarch_dump: TARGET_LONG_DOUBLE_FORMAT = %s\n",
-                      gdbarch->float_format->name);
+                      (TARGET_LONG_DOUBLE_FORMAT)->name);
 #endif
 #ifdef TARGET_LONG_LONG_BIT
   fprintf_unfiltered (file,
@@ -2393,6 +2518,14 @@ gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file)
                       "gdbarch_dump: TARGET_LONG_LONG_BIT = %d\n",
                       TARGET_LONG_LONG_BIT);
 #endif
+#ifdef TARGET_OSABI
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: TARGET_OSABI # %s\n",
+                      XSTRING (TARGET_OSABI));
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: TARGET_OSABI = %ld\n",
+                      (long) TARGET_OSABI);
+#endif
 #ifdef TARGET_PRINT_INSN
   fprintf_unfiltered (file,
                       "gdbarch_dump: %s # %s\n",
@@ -2400,7 +2533,7 @@ gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file)
                       XSTRING (TARGET_PRINT_INSN (vma, info)));
   if (GDB_MULTI_ARCH)
     fprintf_unfiltered (file,
-                        "gdbarch_dump: TARGET_PRINT_INSN = 0x%08lx\n",
+                        "gdbarch_dump: TARGET_PRINT_INSN = <0x%08lx>\n",
                         (long) current_gdbarch->print_insn
                         /*TARGET_PRINT_INSN ()*/);
 #endif
@@ -2412,16 +2545,14 @@ gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file)
                       "gdbarch_dump: TARGET_PTR_BIT = %d\n",
                       TARGET_PTR_BIT);
 #endif
-#ifdef TARGET_READ_FP
+#ifdef TARGET_READ_PC_P
   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 ()*/);
+                      "TARGET_READ_PC_P()",
+                      XSTRING (TARGET_READ_PC_P ()));
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: TARGET_READ_PC_P() = %d\n",
+                      TARGET_READ_PC_P ());
 #endif
 #ifdef TARGET_READ_PC
   fprintf_unfiltered (file,
@@ -2430,7 +2561,7 @@ gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file)
                       XSTRING (TARGET_READ_PC (ptid)));
   if (GDB_MULTI_ARCH)
     fprintf_unfiltered (file,
-                        "gdbarch_dump: TARGET_READ_PC = 0x%08lx\n",
+                        "gdbarch_dump: TARGET_READ_PC = <0x%08lx>\n",
                         (long) current_gdbarch->read_pc
                         /*TARGET_READ_PC ()*/);
 #endif
@@ -2441,7 +2572,7 @@ gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file)
                       XSTRING (TARGET_READ_SP ()));
   if (GDB_MULTI_ARCH)
     fprintf_unfiltered (file,
-                        "gdbarch_dump: TARGET_READ_SP = 0x%08lx\n",
+                        "gdbarch_dump: TARGET_READ_SP = <0x%08lx>\n",
                         (long) current_gdbarch->read_sp
                         /*TARGET_READ_SP ()*/);
 #endif
@@ -2463,7 +2594,7 @@ gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file)
 #endif
   if (GDB_MULTI_ARCH)
     fprintf_unfiltered (file,
-                        "gdbarch_dump: TARGET_VIRTUAL_FRAME_POINTER = 0x%08lx\n",
+                        "gdbarch_dump: TARGET_VIRTUAL_FRAME_POINTER = <0x%08lx>\n",
                         (long) current_gdbarch->virtual_frame_pointer
                         /*TARGET_VIRTUAL_FRAME_POINTER ()*/);
 #endif
@@ -2477,24 +2608,26 @@ gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file)
 #endif
   if (GDB_MULTI_ARCH)
     fprintf_unfiltered (file,
-                        "gdbarch_dump: TARGET_WRITE_PC = 0x%08lx\n",
+                        "gdbarch_dump: TARGET_WRITE_PC = <0x%08lx>\n",
                         (long) current_gdbarch->write_pc
                         /*TARGET_WRITE_PC ()*/);
-#endif
-#ifdef TARGET_WRITE_SP
-#if GDB_MULTI_ARCH
-  /* Macro might contain `[{}]' when not multi-arch */
-  fprintf_unfiltered (file,
-                      "gdbarch_dump: %s # %s\n",
-                      "TARGET_WRITE_SP(val)",
-                      XSTRING (TARGET_WRITE_SP (val)));
 #endif
   if (GDB_MULTI_ARCH)
     fprintf_unfiltered (file,
-                        "gdbarch_dump: TARGET_WRITE_SP = 0x%08lx\n",
-                        (long) current_gdbarch->write_sp
-                        /*TARGET_WRITE_SP ()*/);
-#endif
+                        "gdbarch_dump: gdbarch_unwind_dummy_id_p() = %d\n",
+                        gdbarch_unwind_dummy_id_p (current_gdbarch));
+  if (GDB_MULTI_ARCH)
+    fprintf_unfiltered (file,
+                        "gdbarch_dump: unwind_dummy_id = 0x%08lx\n",
+                        (long) current_gdbarch->unwind_dummy_id);
+  if (GDB_MULTI_ARCH)
+    fprintf_unfiltered (file,
+                        "gdbarch_dump: gdbarch_unwind_pc_p() = %d\n",
+                        gdbarch_unwind_pc_p (current_gdbarch));
+  if (GDB_MULTI_ARCH)
+    fprintf_unfiltered (file,
+                        "gdbarch_dump: unwind_pc = 0x%08lx\n",
+                        (long) current_gdbarch->unwind_pc);
 #ifdef USE_STRUCT_CONVENTION
   fprintf_unfiltered (file,
                       "gdbarch_dump: %s # %s\n",
@@ -2502,7 +2635,7 @@ gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file)
                       XSTRING (USE_STRUCT_CONVENTION (gcc_p, value_type)));
   if (GDB_MULTI_ARCH)
     fprintf_unfiltered (file,
-                        "gdbarch_dump: USE_STRUCT_CONVENTION = 0x%08lx\n",
+                        "gdbarch_dump: USE_STRUCT_CONVENTION = <0x%08lx>\n",
                         (long) current_gdbarch->use_struct_convention
                         /*USE_STRUCT_CONVENTION ()*/);
 #endif
@@ -2516,7 +2649,7 @@ gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file)
 #endif
   if (GDB_MULTI_ARCH)
     fprintf_unfiltered (file,
-                        "gdbarch_dump: VALUE_TO_REGISTER = 0x%08lx\n",
+                        "gdbarch_dump: VALUE_TO_REGISTER = <0x%08lx>\n",
                         (long) current_gdbarch->value_to_register
                         /*VALUE_TO_REGISTER ()*/);
 #endif
@@ -2551,6 +2684,15 @@ gdbarch_byte_order (struct gdbarch *gdbarch)
   return gdbarch->byte_order;
 }
 
+enum gdb_osabi
+gdbarch_osabi (struct gdbarch *gdbarch)
+{
+  gdb_assert (gdbarch != NULL);
+  if (gdbarch_debug >= 2)
+    fprintf_unfiltered (gdb_stdlog, "gdbarch_osabi called\n");
+  return gdbarch->osabi;
+}
+
 int
 gdbarch_short_bit (struct gdbarch *gdbarch)
 {
@@ -2742,6 +2884,13 @@ set_gdbarch_char_signed (struct gdbarch *gdbarch,
   gdbarch->char_signed = char_signed;
 }
 
+int
+gdbarch_read_pc_p (struct gdbarch *gdbarch)
+{
+  gdb_assert (gdbarch != NULL);
+  return gdbarch->read_pc != 0;
+}
+
 CORE_ADDR
 gdbarch_read_pc (struct gdbarch *gdbarch, ptid_t ptid)
 {
@@ -2780,23 +2929,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
@@ -2818,23 +2974,30 @@ set_gdbarch_read_sp (struct gdbarch *gdbarch,
   gdbarch->read_sp = read_sp;
 }
 
+int
+gdbarch_deprecated_dummy_write_sp_p (struct gdbarch *gdbarch)
+{
+  gdb_assert (gdbarch != NULL);
+  return gdbarch->deprecated_dummy_write_sp != 0;
+}
+
 void
-gdbarch_write_sp (struct gdbarch *gdbarch, CORE_ADDR val)
+gdbarch_deprecated_dummy_write_sp (struct gdbarch *gdbarch, CORE_ADDR val)
 {
   gdb_assert (gdbarch != NULL);
-  if (gdbarch->write_sp == 0)
+  if (gdbarch->deprecated_dummy_write_sp == 0)
     internal_error (__FILE__, __LINE__,
-                    "gdbarch: gdbarch_write_sp invalid");
+                    "gdbarch: gdbarch_deprecated_dummy_write_sp invalid");
   if (gdbarch_debug >= 2)
-    fprintf_unfiltered (gdb_stdlog, "gdbarch_write_sp called\n");
-  gdbarch->write_sp (val);
+    fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_dummy_write_sp called\n");
+  gdbarch->deprecated_dummy_write_sp (val);
 }
 
 void
-set_gdbarch_write_sp (struct gdbarch *gdbarch,
-                      gdbarch_write_sp_ftype write_sp)
+set_gdbarch_deprecated_dummy_write_sp (struct gdbarch *gdbarch,
+                                       gdbarch_deprecated_dummy_write_sp_ftype deprecated_dummy_write_sp)
 {
-  gdbarch->write_sp = write_sp;
+  gdbarch->deprecated_dummy_write_sp = deprecated_dummy_write_sp;
 }
 
 void
@@ -2962,20 +3125,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
@@ -3161,41 +3324,42 @@ 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)
+gdbarch_deprecated_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;
+    fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_register_bytes called\n");
+  return gdbarch->deprecated_register_bytes;
 }
 
 void
-set_gdbarch_register_bytes (struct gdbarch *gdbarch,
-                            int register_bytes)
+set_gdbarch_deprecated_register_bytes (struct gdbarch *gdbarch,
+                                       int deprecated_register_bytes)
+{
+  gdbarch->deprecated_register_bytes = deprecated_register_bytes;
+}
+
+int
+gdbarch_register_byte_p (struct gdbarch *gdbarch)
 {
-  gdbarch->register_bytes = register_bytes;
+  gdb_assert (gdbarch != NULL);
+  return gdbarch->register_byte != generic_register_byte;
 }
 
 int
@@ -3205,6 +3369,7 @@ gdbarch_register_byte (struct gdbarch *gdbarch, int reg_nr)
   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);
@@ -3237,22 +3402,26 @@ set_gdbarch_register_raw_size (struct gdbarch *gdbarch,
 }
 
 int
-gdbarch_max_register_raw_size (struct gdbarch *gdbarch)
+gdbarch_deprecated_max_register_raw_size_p (struct gdbarch *gdbarch)
+{
+  gdb_assert (gdbarch != NULL);
+  return gdbarch->deprecated_max_register_raw_size != 0;
+}
+
+int
+gdbarch_deprecated_max_register_raw_size (struct gdbarch *gdbarch)
 {
   gdb_assert (gdbarch != NULL);
-  if (gdbarch->max_register_raw_size == -1)
-    internal_error (__FILE__, __LINE__,
-                    "gdbarch: gdbarch_max_register_raw_size invalid");
   if (gdbarch_debug >= 2)
-    fprintf_unfiltered (gdb_stdlog, "gdbarch_max_register_raw_size called\n");
-  return gdbarch->max_register_raw_size;
+    fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_max_register_raw_size called\n");
+  return gdbarch->deprecated_max_register_raw_size;
 }
 
 void
-set_gdbarch_max_register_raw_size (struct gdbarch *gdbarch,
-                                   int max_register_raw_size)
+set_gdbarch_deprecated_max_register_raw_size (struct gdbarch *gdbarch,
+                                              int deprecated_max_register_raw_size)
 {
-  gdbarch->max_register_raw_size = max_register_raw_size;
+  gdbarch->deprecated_max_register_raw_size = deprecated_max_register_raw_size;
 }
 
 int
@@ -3275,22 +3444,33 @@ set_gdbarch_register_virtual_size (struct gdbarch *gdbarch,
 }
 
 int
-gdbarch_max_register_virtual_size (struct gdbarch *gdbarch)
+gdbarch_deprecated_max_register_virtual_size_p (struct gdbarch *gdbarch)
+{
+  gdb_assert (gdbarch != NULL);
+  return gdbarch->deprecated_max_register_virtual_size != 0;
+}
+
+int
+gdbarch_deprecated_max_register_virtual_size (struct gdbarch *gdbarch)
 {
   gdb_assert (gdbarch != NULL);
-  if (gdbarch->max_register_virtual_size == -1)
-    internal_error (__FILE__, __LINE__,
-                    "gdbarch: gdbarch_max_register_virtual_size invalid");
   if (gdbarch_debug >= 2)
-    fprintf_unfiltered (gdb_stdlog, "gdbarch_max_register_virtual_size called\n");
-  return gdbarch->max_register_virtual_size;
+    fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_max_register_virtual_size called\n");
+  return gdbarch->deprecated_max_register_virtual_size;
 }
 
 void
-set_gdbarch_max_register_virtual_size (struct gdbarch *gdbarch,
-                                       int max_register_virtual_size)
+set_gdbarch_deprecated_max_register_virtual_size (struct gdbarch *gdbarch,
+                                                  int deprecated_max_register_virtual_size)
+{
+  gdbarch->deprecated_max_register_virtual_size = deprecated_max_register_virtual_size;
+}
+
+int
+gdbarch_register_virtual_type_p (struct gdbarch *gdbarch)
 {
-  gdbarch->max_register_virtual_size = max_register_virtual_size;
+  gdb_assert (gdbarch != NULL);
+  return gdbarch->register_virtual_type != 0;
 }
 
 struct type *
@@ -3312,6 +3492,32 @@ set_gdbarch_register_virtual_type (struct gdbarch *gdbarch,
   gdbarch->register_virtual_type = register_virtual_type;
 }
 
+int
+gdbarch_register_type_p (struct gdbarch *gdbarch)
+{
+  gdb_assert (gdbarch != NULL);
+  return gdbarch->register_type != 0;
+}
+
+struct type *
+gdbarch_register_type (struct gdbarch *gdbarch, int reg_nr)
+{
+  gdb_assert (gdbarch != NULL);
+  if (gdbarch->register_type == 0)
+    internal_error (__FILE__, __LINE__,
+                    "gdbarch: gdbarch_register_type invalid");
+  if (gdbarch_debug >= 2)
+    fprintf_unfiltered (gdb_stdlog, "gdbarch_register_type called\n");
+  return gdbarch->register_type (gdbarch, reg_nr);
+}
+
+void
+set_gdbarch_register_type (struct gdbarch *gdbarch,
+                           gdbarch_register_type_ftype register_type)
+{
+  gdbarch->register_type = register_type;
+}
+
 int
 gdbarch_deprecated_do_registers_info_p (struct gdbarch *gdbarch)
 {
@@ -3572,79 +3778,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->call_dummy_start_offset == -1)
-    internal_error (__FILE__, __LINE__,
-                    "gdbarch: gdbarch_call_dummy_start_offset invalid");
   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)
-{
-  gdb_assert (gdbarch != NULL);
-  if (gdbarch->call_dummy_breakpoint_offset_p && gdbarch->call_dummy_breakpoint_offset == -1)
-    internal_error (__FILE__, __LINE__,
-                    "gdbarch: gdbarch_call_dummy_breakpoint_offset invalid");
-  if (gdbarch_debug >= 2)
-    fprintf_unfiltered (gdb_stdlog, "gdbarch_call_dummy_breakpoint_offset called\n");
-  return gdbarch->call_dummy_breakpoint_offset;
-}
-
-void
-set_gdbarch_call_dummy_breakpoint_offset (struct gdbarch *gdbarch,
-                                          CORE_ADDR call_dummy_breakpoint_offset)
-{
-  gdbarch->call_dummy_breakpoint_offset = call_dummy_breakpoint_offset;
-}
-
-int
-gdbarch_call_dummy_breakpoint_offset_p (struct gdbarch *gdbarch)
+gdbarch_deprecated_call_dummy_breakpoint_offset (struct gdbarch *gdbarch)
 {
   gdb_assert (gdbarch != NULL);
-  if (gdbarch->call_dummy_breakpoint_offset_p == -1)
-    internal_error (__FILE__, __LINE__,
-                    "gdbarch: gdbarch_call_dummy_breakpoint_offset_p invalid");
   if (gdbarch_debug >= 2)
-    fprintf_unfiltered (gdb_stdlog, "gdbarch_call_dummy_breakpoint_offset_p called\n");
-  return gdbarch->call_dummy_breakpoint_offset_p;
+    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_p (struct gdbarch *gdbarch,
-                                            int call_dummy_breakpoint_offset_p)
+set_gdbarch_deprecated_call_dummy_breakpoint_offset (struct gdbarch *gdbarch,
+                                                     CORE_ADDR deprecated_call_dummy_breakpoint_offset)
 {
-  gdbarch->call_dummy_breakpoint_offset_p = call_dummy_breakpoint_offset_p;
+  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->call_dummy_length == -1)
-    internal_error (__FILE__, __LINE__,
-                    "gdbarch: gdbarch_call_dummy_length invalid");
   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
@@ -3674,114 +3852,113 @@ set_gdbarch_deprecated_pc_in_call_dummy (struct gdbarch *gdbarch,
   gdbarch->deprecated_pc_in_call_dummy = deprecated_pc_in_call_dummy;
 }
 
-int
-gdbarch_call_dummy_p (struct gdbarch *gdbarch)
+LONGEST *
+gdbarch_deprecated_call_dummy_words (struct gdbarch *gdbarch)
 {
   gdb_assert (gdbarch != NULL);
-  if (gdbarch->call_dummy_p == -1)
-    internal_error (__FILE__, __LINE__,
-                    "gdbarch: gdbarch_call_dummy_p invalid");
+  /* Skip verify of deprecated_call_dummy_words, invalid_p == 0 */
   if (gdbarch_debug >= 2)
-    fprintf_unfiltered (gdb_stdlog, "gdbarch_call_dummy_p called\n");
-  return gdbarch->call_dummy_p;
+    fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_call_dummy_words called\n");
+  return gdbarch->deprecated_call_dummy_words;
 }
 
 void
-set_gdbarch_call_dummy_p (struct gdbarch *gdbarch,
-                          int call_dummy_p)
+set_gdbarch_deprecated_call_dummy_words (struct gdbarch *gdbarch,
+                                         LONGEST * deprecated_call_dummy_words)
 {
-  gdbarch->call_dummy_p = call_dummy_p;
+  gdbarch->deprecated_call_dummy_words = deprecated_call_dummy_words;
 }
 
-LONGEST *
-gdbarch_call_dummy_words (struct gdbarch *gdbarch)
+int
+gdbarch_deprecated_sizeof_call_dummy_words (struct gdbarch *gdbarch)
 {
   gdb_assert (gdbarch != NULL);
-  /* Skip verify of 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_call_dummy_words called\n");
-  return gdbarch->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_call_dummy_words (struct gdbarch *gdbarch,
-                              LONGEST * call_dummy_words)
+set_gdbarch_deprecated_sizeof_call_dummy_words (struct gdbarch *gdbarch,
+                                                int deprecated_sizeof_call_dummy_words)
 {
-  gdbarch->call_dummy_words = call_dummy_words;
+  gdbarch->deprecated_sizeof_call_dummy_words = deprecated_sizeof_call_dummy_words;
 }
 
 int
-gdbarch_sizeof_call_dummy_words (struct gdbarch *gdbarch)
+gdbarch_deprecated_call_dummy_stack_adjust_p (struct gdbarch *gdbarch)
 {
   gdb_assert (gdbarch != NULL);
-  /* Skip verify of 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;
-}
-
-void
-set_gdbarch_sizeof_call_dummy_words (struct gdbarch *gdbarch,
-                                     int sizeof_call_dummy_words)
-{
-  gdbarch->sizeof_call_dummy_words = sizeof_call_dummy_words;
+  return gdbarch->deprecated_call_dummy_stack_adjust != 0;
 }
 
 int
-gdbarch_call_dummy_stack_adjust_p (struct gdbarch *gdbarch)
+gdbarch_deprecated_call_dummy_stack_adjust (struct gdbarch *gdbarch)
 {
   gdb_assert (gdbarch != NULL);
-  if (gdbarch->call_dummy_stack_adjust_p == -1)
-    internal_error (__FILE__, __LINE__,
-                    "gdbarch: gdbarch_call_dummy_stack_adjust_p invalid");
   if (gdbarch_debug >= 2)
-    fprintf_unfiltered (gdb_stdlog, "gdbarch_call_dummy_stack_adjust_p called\n");
-  return gdbarch->call_dummy_stack_adjust_p;
+    fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_call_dummy_stack_adjust called\n");
+  return gdbarch->deprecated_call_dummy_stack_adjust;
 }
 
 void
-set_gdbarch_call_dummy_stack_adjust_p (struct gdbarch *gdbarch,
-                                       int call_dummy_stack_adjust_p)
+set_gdbarch_deprecated_call_dummy_stack_adjust (struct gdbarch *gdbarch,
+                                                int deprecated_call_dummy_stack_adjust)
 {
-  gdbarch->call_dummy_stack_adjust_p = call_dummy_stack_adjust_p;
+  gdbarch->deprecated_call_dummy_stack_adjust = deprecated_call_dummy_stack_adjust;
 }
 
 int
-gdbarch_call_dummy_stack_adjust (struct gdbarch *gdbarch)
+gdbarch_deprecated_fix_call_dummy_p (struct gdbarch *gdbarch)
+{
+  gdb_assert (gdbarch != NULL);
+  return gdbarch->deprecated_fix_call_dummy != 0;
+}
+
+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)
 {
   gdb_assert (gdbarch != NULL);
-  if (gdbarch->call_dummy_stack_adjust_p && gdbarch->call_dummy_stack_adjust == 0)
+  if (gdbarch->deprecated_fix_call_dummy == 0)
     internal_error (__FILE__, __LINE__,
-                    "gdbarch: gdbarch_call_dummy_stack_adjust invalid");
+                    "gdbarch: gdbarch_deprecated_fix_call_dummy invalid");
   if (gdbarch_debug >= 2)
-    fprintf_unfiltered (gdb_stdlog, "gdbarch_call_dummy_stack_adjust called\n");
-  return gdbarch->call_dummy_stack_adjust;
+    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_call_dummy_stack_adjust (struct gdbarch *gdbarch,
-                                     int call_dummy_stack_adjust)
+set_gdbarch_deprecated_fix_call_dummy (struct gdbarch *gdbarch,
+                                       gdbarch_deprecated_fix_call_dummy_ftype deprecated_fix_call_dummy)
 {
-  gdbarch->call_dummy_stack_adjust = call_dummy_stack_adjust;
+  gdbarch->deprecated_fix_call_dummy = deprecated_fix_call_dummy;
 }
 
-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)
+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->fix_call_dummy == 0)
+  if (gdbarch->push_dummy_code == 0)
     internal_error (__FILE__, __LINE__,
-                    "gdbarch: gdbarch_fix_call_dummy invalid");
+                    "gdbarch: gdbarch_push_dummy_code 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_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_fix_call_dummy (struct gdbarch *gdbarch,
-                            gdbarch_fix_call_dummy_ftype fix_call_dummy)
+set_gdbarch_push_dummy_code (struct gdbarch *gdbarch,
+                             gdbarch_push_dummy_code_ftype push_dummy_code)
 {
-  gdbarch->fix_call_dummy = fix_call_dummy;
+  gdbarch->push_dummy_code = push_dummy_code;
 }
 
 int
@@ -3791,7 +3968,7 @@ gdbarch_deprecated_init_frame_pc_first_p (struct gdbarch *gdbarch)
   return gdbarch->deprecated_init_frame_pc_first != 0;
 }
 
-void
+CORE_ADDR
 gdbarch_deprecated_init_frame_pc_first (struct gdbarch *gdbarch, int fromleaf, struct frame_info *prev)
 {
   gdb_assert (gdbarch != NULL);
@@ -3800,7 +3977,7 @@ gdbarch_deprecated_init_frame_pc_first (struct gdbarch *gdbarch, int fromleaf, s
                     "gdbarch: gdbarch_deprecated_init_frame_pc_first invalid");
   if (gdbarch_debug >= 2)
     fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_init_frame_pc_first called\n");
-  gdbarch->deprecated_init_frame_pc_first (fromleaf, prev);
+  return gdbarch->deprecated_init_frame_pc_first (fromleaf, prev);
 }
 
 void
@@ -3810,23 +3987,30 @@ set_gdbarch_deprecated_init_frame_pc_first (struct gdbarch *gdbarch,
   gdbarch->deprecated_init_frame_pc_first = deprecated_init_frame_pc_first;
 }
 
-void
-gdbarch_init_frame_pc (struct gdbarch *gdbarch, int fromleaf, struct frame_info *prev)
+int
+gdbarch_deprecated_init_frame_pc_p (struct gdbarch *gdbarch)
+{
+  gdb_assert (gdbarch != NULL);
+  return gdbarch->deprecated_init_frame_pc != 0;
+}
+
+CORE_ADDR
+gdbarch_deprecated_init_frame_pc (struct gdbarch *gdbarch, int fromleaf, struct frame_info *prev)
 {
   gdb_assert (gdbarch != NULL);
-  if (gdbarch->init_frame_pc == 0)
+  if (gdbarch->deprecated_init_frame_pc == 0)
     internal_error (__FILE__, __LINE__,
-                    "gdbarch: gdbarch_init_frame_pc invalid");
+                    "gdbarch: gdbarch_deprecated_init_frame_pc invalid");
   if (gdbarch_debug >= 2)
-    fprintf_unfiltered (gdb_stdlog, "gdbarch_init_frame_pc called\n");
-  gdbarch->init_frame_pc (fromleaf, prev);
+    fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_init_frame_pc called\n");
+  return gdbarch->deprecated_init_frame_pc (fromleaf, prev);
 }
 
 void
-set_gdbarch_init_frame_pc (struct gdbarch *gdbarch,
-                           gdbarch_init_frame_pc_ftype init_frame_pc)
+set_gdbarch_deprecated_init_frame_pc (struct gdbarch *gdbarch,
+                                      gdbarch_deprecated_init_frame_pc_ftype deprecated_init_frame_pc)
 {
-  gdbarch->init_frame_pc = init_frame_pc;
+  gdbarch->deprecated_init_frame_pc = deprecated_init_frame_pc;
 }
 
 int
@@ -3862,48 +4046,29 @@ set_gdbarch_believe_pcc_promotion_type (struct gdbarch *gdbarch,
 }
 
 int
-gdbarch_coerce_float_to_double (struct gdbarch *gdbarch, struct type *formal, struct type *actual)
-{
-  gdb_assert (gdbarch != NULL);
-  if (gdbarch->coerce_float_to_double == 0)
-    internal_error (__FILE__, __LINE__,
-                    "gdbarch: gdbarch_coerce_float_to_double invalid");
-  if (gdbarch_debug >= 2)
-    fprintf_unfiltered (gdb_stdlog, "gdbarch_coerce_float_to_double called\n");
-  return gdbarch->coerce_float_to_double (formal, actual);
-}
-
-void
-set_gdbarch_coerce_float_to_double (struct gdbarch *gdbarch,
-                                    gdbarch_coerce_float_to_double_ftype coerce_float_to_double)
-{
-  gdbarch->coerce_float_to_double = coerce_float_to_double;
-}
-
-int
-gdbarch_get_saved_register_p (struct gdbarch *gdbarch)
+gdbarch_deprecated_get_saved_register_p (struct gdbarch *gdbarch)
 {
   gdb_assert (gdbarch != NULL);
-  return gdbarch->get_saved_register != 0;
+  return gdbarch->deprecated_get_saved_register != 0;
 }
 
 void
-gdbarch_get_saved_register (struct gdbarch *gdbarch, char *raw_buffer, int *optimized, CORE_ADDR *addrp, struct frame_info *frame, int regnum, enum lval_type *lval)
+gdbarch_deprecated_get_saved_register (struct gdbarch *gdbarch, char *raw_buffer, int *optimized, CORE_ADDR *addrp, struct frame_info *frame, int regnum, enum lval_type *lval)
 {
   gdb_assert (gdbarch != NULL);
-  if (gdbarch->get_saved_register == 0)
+  if (gdbarch->deprecated_get_saved_register == 0)
     internal_error (__FILE__, __LINE__,
-                    "gdbarch: gdbarch_get_saved_register invalid");
+                    "gdbarch: gdbarch_deprecated_get_saved_register invalid");
   if (gdbarch_debug >= 2)
-    fprintf_unfiltered (gdb_stdlog, "gdbarch_get_saved_register called\n");
-  gdbarch->get_saved_register (raw_buffer, optimized, addrp, frame, regnum, lval);
+    fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_get_saved_register called\n");
+  gdbarch->deprecated_get_saved_register (raw_buffer, optimized, addrp, frame, regnum, lval);
 }
 
 void
-set_gdbarch_get_saved_register (struct gdbarch *gdbarch,
-                                gdbarch_get_saved_register_ftype get_saved_register)
+set_gdbarch_deprecated_get_saved_register (struct gdbarch *gdbarch,
+                                           gdbarch_deprecated_get_saved_register_ftype deprecated_get_saved_register)
 {
-  gdbarch->get_saved_register = get_saved_register;
+  gdbarch->deprecated_get_saved_register = deprecated_get_saved_register;
 }
 
 int
@@ -4021,7 +4186,7 @@ set_gdbarch_value_to_register (struct gdbarch *gdbarch,
 }
 
 CORE_ADDR
-gdbarch_pointer_to_address (struct gdbarch *gdbarch, struct type *type, void *buf)
+gdbarch_pointer_to_address (struct gdbarch *gdbarch, struct type *type, const void *buf)
 {
   gdb_assert (gdbarch != NULL);
   if (gdbarch->pointer_to_address == 0)
@@ -4103,106 +4268,160 @@ set_gdbarch_return_value_on_stack (struct gdbarch *gdbarch,
   gdbarch->return_value_on_stack = return_value_on_stack;
 }
 
+int
+gdbarch_deprecated_push_arguments_p (struct gdbarch *gdbarch)
+{
+  gdb_assert (gdbarch != NULL);
+  return gdbarch->deprecated_push_arguments != 0;
+}
+
+CORE_ADDR
+gdbarch_deprecated_push_arguments (struct gdbarch *gdbarch, int nargs, struct value **args, CORE_ADDR sp, int struct_return, CORE_ADDR struct_addr)
+{
+  gdb_assert (gdbarch != NULL);
+  if (gdbarch->deprecated_push_arguments == 0)
+    internal_error (__FILE__, __LINE__,
+                    "gdbarch: gdbarch_deprecated_push_arguments invalid");
+  if (gdbarch_debug >= 2)
+    fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_push_arguments called\n");
+  return gdbarch->deprecated_push_arguments (nargs, args, sp, struct_return, struct_addr);
+}
+
+void
+set_gdbarch_deprecated_push_arguments (struct gdbarch *gdbarch,
+                                       gdbarch_deprecated_push_arguments_ftype deprecated_push_arguments)
+{
+  gdbarch->deprecated_push_arguments = deprecated_push_arguments;
+}
+
+int
+gdbarch_push_dummy_call_p (struct gdbarch *gdbarch)
+{
+  gdb_assert (gdbarch != NULL);
+  return gdbarch->push_dummy_call != 0;
+}
+
 CORE_ADDR
-gdbarch_push_arguments (struct gdbarch *gdbarch, int nargs, struct value **args, CORE_ADDR sp, int struct_return, CORE_ADDR struct_addr)
+gdbarch_push_dummy_call (struct gdbarch *gdbarch, CORE_ADDR func_addr, struct regcache *regcache, CORE_ADDR bp_addr, int nargs, struct value **args, CORE_ADDR sp, int struct_return, CORE_ADDR struct_addr)
 {
   gdb_assert (gdbarch != NULL);
-  if (gdbarch->push_arguments == 0)
+  if (gdbarch->push_dummy_call == 0)
     internal_error (__FILE__, __LINE__,
-                    "gdbarch: gdbarch_push_arguments invalid");
+                    "gdbarch: gdbarch_push_dummy_call invalid");
   if (gdbarch_debug >= 2)
-    fprintf_unfiltered (gdb_stdlog, "gdbarch_push_arguments called\n");
-  return gdbarch->push_arguments (nargs, args, sp, struct_return, struct_addr);
+    fprintf_unfiltered (gdb_stdlog, "gdbarch_push_dummy_call called\n");
+  return gdbarch->push_dummy_call (gdbarch, func_addr, regcache, bp_addr, nargs, args, sp, struct_return, struct_addr);
 }
 
 void
-set_gdbarch_push_arguments (struct gdbarch *gdbarch,
-                            gdbarch_push_arguments_ftype push_arguments)
+set_gdbarch_push_dummy_call (struct gdbarch *gdbarch,
+                             gdbarch_push_dummy_call_ftype push_dummy_call)
+{
+  gdbarch->push_dummy_call = push_dummy_call;
+}
+
+int
+gdbarch_deprecated_push_dummy_frame_p (struct gdbarch *gdbarch)
 {
-  gdbarch->push_arguments = push_arguments;
+  gdb_assert (gdbarch != NULL);
+  return gdbarch->deprecated_push_dummy_frame != 0;
 }
 
 void
-gdbarch_push_dummy_frame (struct gdbarch *gdbarch)
+gdbarch_deprecated_push_dummy_frame (struct gdbarch *gdbarch)
 {
   gdb_assert (gdbarch != NULL);
-  if (gdbarch->push_dummy_frame == 0)
+  if (gdbarch->deprecated_push_dummy_frame == 0)
     internal_error (__FILE__, __LINE__,
-                    "gdbarch: gdbarch_push_dummy_frame invalid");
+                    "gdbarch: gdbarch_deprecated_push_dummy_frame invalid");
   if (gdbarch_debug >= 2)
-    fprintf_unfiltered (gdb_stdlog, "gdbarch_push_dummy_frame called\n");
-  gdbarch->push_dummy_frame ();
+    fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_push_dummy_frame called\n");
+  gdbarch->deprecated_push_dummy_frame ();
 }
 
 void
-set_gdbarch_push_dummy_frame (struct gdbarch *gdbarch,
-                              gdbarch_push_dummy_frame_ftype push_dummy_frame)
+set_gdbarch_deprecated_push_dummy_frame (struct gdbarch *gdbarch,
+                                         gdbarch_deprecated_push_dummy_frame_ftype deprecated_push_dummy_frame)
 {
-  gdbarch->push_dummy_frame = push_dummy_frame;
+  gdbarch->deprecated_push_dummy_frame = deprecated_push_dummy_frame;
 }
 
 int
-gdbarch_push_return_address_p (struct gdbarch *gdbarch)
+gdbarch_deprecated_push_return_address_p (struct gdbarch *gdbarch)
 {
   gdb_assert (gdbarch != NULL);
-  return gdbarch->push_return_address != 0;
+  return gdbarch->deprecated_push_return_address != 0;
 }
 
 CORE_ADDR
-gdbarch_push_return_address (struct gdbarch *gdbarch, CORE_ADDR pc, CORE_ADDR sp)
+gdbarch_deprecated_push_return_address (struct gdbarch *gdbarch, CORE_ADDR pc, CORE_ADDR sp)
 {
   gdb_assert (gdbarch != NULL);
-  if (gdbarch->push_return_address == 0)
+  if (gdbarch->deprecated_push_return_address == 0)
     internal_error (__FILE__, __LINE__,
-                    "gdbarch: gdbarch_push_return_address invalid");
+                    "gdbarch: gdbarch_deprecated_push_return_address invalid");
   if (gdbarch_debug >= 2)
-    fprintf_unfiltered (gdb_stdlog, "gdbarch_push_return_address called\n");
-  return gdbarch->push_return_address (pc, sp);
+    fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_push_return_address called\n");
+  return gdbarch->deprecated_push_return_address (pc, sp);
 }
 
 void
-set_gdbarch_push_return_address (struct gdbarch *gdbarch,
-                                 gdbarch_push_return_address_ftype push_return_address)
+set_gdbarch_deprecated_push_return_address (struct gdbarch *gdbarch,
+                                            gdbarch_deprecated_push_return_address_ftype deprecated_push_return_address)
+{
+  gdbarch->deprecated_push_return_address = deprecated_push_return_address;
+}
+
+int
+gdbarch_deprecated_pop_frame_p (struct gdbarch *gdbarch)
 {
-  gdbarch->push_return_address = push_return_address;
+  gdb_assert (gdbarch != NULL);
+  return gdbarch->deprecated_pop_frame != 0;
 }
 
 void
-gdbarch_pop_frame (struct gdbarch *gdbarch)
+gdbarch_deprecated_pop_frame (struct gdbarch *gdbarch)
 {
   gdb_assert (gdbarch != NULL);
-  if (gdbarch->pop_frame == 0)
+  if (gdbarch->deprecated_pop_frame == 0)
     internal_error (__FILE__, __LINE__,
-                    "gdbarch: gdbarch_pop_frame invalid");
+                    "gdbarch: gdbarch_deprecated_pop_frame invalid");
   if (gdbarch_debug >= 2)
-    fprintf_unfiltered (gdb_stdlog, "gdbarch_pop_frame called\n");
-  gdbarch->pop_frame ();
+    fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_pop_frame called\n");
+  gdbarch->deprecated_pop_frame ();
 }
 
 void
-set_gdbarch_pop_frame (struct gdbarch *gdbarch,
-                       gdbarch_pop_frame_ftype pop_frame)
+set_gdbarch_deprecated_pop_frame (struct gdbarch *gdbarch,
+                                  gdbarch_deprecated_pop_frame_ftype deprecated_pop_frame)
+{
+  gdbarch->deprecated_pop_frame = deprecated_pop_frame;
+}
+
+int
+gdbarch_deprecated_store_struct_return_p (struct gdbarch *gdbarch)
 {
-  gdbarch->pop_frame = pop_frame;
+  gdb_assert (gdbarch != NULL);
+  return gdbarch->deprecated_store_struct_return != 0;
 }
 
 void
-gdbarch_store_struct_return (struct gdbarch *gdbarch, CORE_ADDR addr, CORE_ADDR sp)
+gdbarch_deprecated_store_struct_return (struct gdbarch *gdbarch, CORE_ADDR addr, CORE_ADDR sp)
 {
   gdb_assert (gdbarch != NULL);
-  if (gdbarch->store_struct_return == 0)
+  if (gdbarch->deprecated_store_struct_return == 0)
     internal_error (__FILE__, __LINE__,
-                    "gdbarch: gdbarch_store_struct_return invalid");
+                    "gdbarch: gdbarch_deprecated_store_struct_return invalid");
   if (gdbarch_debug >= 2)
-    fprintf_unfiltered (gdb_stdlog, "gdbarch_store_struct_return called\n");
-  gdbarch->store_struct_return (addr, sp);
+    fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_store_struct_return called\n");
+  gdbarch->deprecated_store_struct_return (addr, sp);
 }
 
 void
-set_gdbarch_store_struct_return (struct gdbarch *gdbarch,
-                                 gdbarch_store_struct_return_ftype store_struct_return)
+set_gdbarch_deprecated_store_struct_return (struct gdbarch *gdbarch,
+                                            gdbarch_deprecated_store_struct_return_ftype deprecated_store_struct_return)
 {
-  gdbarch->store_struct_return = store_struct_return;
+  gdbarch->deprecated_store_struct_return = deprecated_store_struct_return;
 }
 
 void
@@ -4352,49 +4571,56 @@ set_gdbarch_use_struct_convention (struct gdbarch *gdbarch,
   gdbarch->use_struct_convention = use_struct_convention;
 }
 
+int
+gdbarch_deprecated_frame_init_saved_regs_p (struct gdbarch *gdbarch)
+{
+  gdb_assert (gdbarch != NULL);
+  return gdbarch->deprecated_frame_init_saved_regs != 0;
+}
+
 void
-gdbarch_frame_init_saved_regs (struct gdbarch *gdbarch, struct frame_info *frame)
+gdbarch_deprecated_frame_init_saved_regs (struct gdbarch *gdbarch, struct frame_info *frame)
 {
   gdb_assert (gdbarch != NULL);
-  if (gdbarch->frame_init_saved_regs == 0)
+  if (gdbarch->deprecated_frame_init_saved_regs == 0)
     internal_error (__FILE__, __LINE__,
-                    "gdbarch: gdbarch_frame_init_saved_regs invalid");
+                    "gdbarch: gdbarch_deprecated_frame_init_saved_regs invalid");
   if (gdbarch_debug >= 2)
-    fprintf_unfiltered (gdb_stdlog, "gdbarch_frame_init_saved_regs called\n");
-  gdbarch->frame_init_saved_regs (frame);
+    fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_frame_init_saved_regs called\n");
+  gdbarch->deprecated_frame_init_saved_regs (frame);
 }
 
 void
-set_gdbarch_frame_init_saved_regs (struct gdbarch *gdbarch,
-                                   gdbarch_frame_init_saved_regs_ftype frame_init_saved_regs)
+set_gdbarch_deprecated_frame_init_saved_regs (struct gdbarch *gdbarch,
+                                              gdbarch_deprecated_frame_init_saved_regs_ftype deprecated_frame_init_saved_regs)
 {
-  gdbarch->frame_init_saved_regs = frame_init_saved_regs;
+  gdbarch->deprecated_frame_init_saved_regs = deprecated_frame_init_saved_regs;
 }
 
 int
-gdbarch_init_extra_frame_info_p (struct gdbarch *gdbarch)
+gdbarch_deprecated_init_extra_frame_info_p (struct gdbarch *gdbarch)
 {
   gdb_assert (gdbarch != NULL);
-  return gdbarch->init_extra_frame_info != 0;
+  return gdbarch->deprecated_init_extra_frame_info != 0;
 }
 
 void
-gdbarch_init_extra_frame_info (struct gdbarch *gdbarch, int fromleaf, struct frame_info *frame)
+gdbarch_deprecated_init_extra_frame_info (struct gdbarch *gdbarch, int fromleaf, struct frame_info *frame)
 {
   gdb_assert (gdbarch != NULL);
-  if (gdbarch->init_extra_frame_info == 0)
+  if (gdbarch->deprecated_init_extra_frame_info == 0)
     internal_error (__FILE__, __LINE__,
-                    "gdbarch: gdbarch_init_extra_frame_info invalid");
+                    "gdbarch: gdbarch_deprecated_init_extra_frame_info invalid");
   if (gdbarch_debug >= 2)
-    fprintf_unfiltered (gdb_stdlog, "gdbarch_init_extra_frame_info called\n");
-  gdbarch->init_extra_frame_info (fromleaf, frame);
+    fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_init_extra_frame_info called\n");
+  gdbarch->deprecated_init_extra_frame_info (fromleaf, frame);
 }
 
 void
-set_gdbarch_init_extra_frame_info (struct gdbarch *gdbarch,
-                                   gdbarch_init_extra_frame_info_ftype init_extra_frame_info)
+set_gdbarch_deprecated_init_extra_frame_info (struct gdbarch *gdbarch,
+                                              gdbarch_deprecated_init_extra_frame_info_ftype deprecated_init_extra_frame_info)
 {
-  gdbarch->init_extra_frame_info = init_extra_frame_info;
+  gdbarch->deprecated_init_extra_frame_info = deprecated_init_extra_frame_info;
 }
 
 CORE_ADDR
@@ -4569,7 +4795,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)
@@ -4577,7 +4803,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
@@ -4625,61 +4851,108 @@ set_gdbarch_frameless_function_invocation (struct gdbarch *gdbarch,
   gdbarch->frameless_function_invocation = frameless_function_invocation;
 }
 
+int
+gdbarch_deprecated_frame_chain_p (struct gdbarch *gdbarch)
+{
+  gdb_assert (gdbarch != NULL);
+  return gdbarch->deprecated_frame_chain != 0;
+}
+
 CORE_ADDR
-gdbarch_frame_chain (struct gdbarch *gdbarch, struct frame_info *frame)
+gdbarch_deprecated_frame_chain (struct gdbarch *gdbarch, struct frame_info *frame)
+{
+  gdb_assert (gdbarch != NULL);
+  if (gdbarch->deprecated_frame_chain == 0)
+    internal_error (__FILE__, __LINE__,
+                    "gdbarch: gdbarch_deprecated_frame_chain invalid");
+  if (gdbarch_debug >= 2)
+    fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_frame_chain called\n");
+  return gdbarch->deprecated_frame_chain (frame);
+}
+
+void
+set_gdbarch_deprecated_frame_chain (struct gdbarch *gdbarch,
+                                    gdbarch_deprecated_frame_chain_ftype deprecated_frame_chain)
+{
+  gdbarch->deprecated_frame_chain = deprecated_frame_chain;
+}
+
+int
+gdbarch_deprecated_frame_chain_valid_p (struct gdbarch *gdbarch)
+{
+  gdb_assert (gdbarch != NULL);
+  return gdbarch->deprecated_frame_chain_valid != 0;
+}
+
+int
+gdbarch_deprecated_frame_chain_valid (struct gdbarch *gdbarch, CORE_ADDR chain, struct frame_info *thisframe)
 {
   gdb_assert (gdbarch != NULL);
-  if (gdbarch->frame_chain == 0)
+  if (gdbarch->deprecated_frame_chain_valid == 0)
     internal_error (__FILE__, __LINE__,
-                    "gdbarch: gdbarch_frame_chain invalid");
+                    "gdbarch: gdbarch_deprecated_frame_chain_valid invalid");
   if (gdbarch_debug >= 2)
-    fprintf_unfiltered (gdb_stdlog, "gdbarch_frame_chain called\n");
-  return gdbarch->frame_chain (frame);
+    fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_frame_chain_valid called\n");
+  return gdbarch->deprecated_frame_chain_valid (chain, thisframe);
 }
 
 void
-set_gdbarch_frame_chain (struct gdbarch *gdbarch,
-                         gdbarch_frame_chain_ftype frame_chain)
+set_gdbarch_deprecated_frame_chain_valid (struct gdbarch *gdbarch,
+                                          gdbarch_deprecated_frame_chain_valid_ftype deprecated_frame_chain_valid)
 {
-  gdbarch->frame_chain = frame_chain;
+  gdbarch->deprecated_frame_chain_valid = deprecated_frame_chain_valid;
 }
 
 int
-gdbarch_frame_chain_valid (struct gdbarch *gdbarch, CORE_ADDR chain, struct frame_info *thisframe)
+gdbarch_deprecated_frame_saved_pc_p (struct gdbarch *gdbarch)
+{
+  gdb_assert (gdbarch != NULL);
+  return gdbarch->deprecated_frame_saved_pc != 0;
+}
+
+CORE_ADDR
+gdbarch_deprecated_frame_saved_pc (struct gdbarch *gdbarch, struct frame_info *fi)
 {
   gdb_assert (gdbarch != NULL);
-  if (gdbarch->frame_chain_valid == 0)
+  if (gdbarch->deprecated_frame_saved_pc == 0)
     internal_error (__FILE__, __LINE__,
-                    "gdbarch: gdbarch_frame_chain_valid invalid");
+                    "gdbarch: gdbarch_deprecated_frame_saved_pc invalid");
   if (gdbarch_debug >= 2)
-    fprintf_unfiltered (gdb_stdlog, "gdbarch_frame_chain_valid called\n");
-  return gdbarch->frame_chain_valid (chain, thisframe);
+    fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_frame_saved_pc called\n");
+  return gdbarch->deprecated_frame_saved_pc (fi);
 }
 
 void
-set_gdbarch_frame_chain_valid (struct gdbarch *gdbarch,
-                               gdbarch_frame_chain_valid_ftype frame_chain_valid)
+set_gdbarch_deprecated_frame_saved_pc (struct gdbarch *gdbarch,
+                                       gdbarch_deprecated_frame_saved_pc_ftype deprecated_frame_saved_pc)
 {
-  gdbarch->frame_chain_valid = frame_chain_valid;
+  gdbarch->deprecated_frame_saved_pc = deprecated_frame_saved_pc;
+}
+
+int
+gdbarch_unwind_pc_p (struct gdbarch *gdbarch)
+{
+  gdb_assert (gdbarch != NULL);
+  return gdbarch->unwind_pc != 0;
 }
 
 CORE_ADDR
-gdbarch_frame_saved_pc (struct gdbarch *gdbarch, struct frame_info *fi)
+gdbarch_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame)
 {
   gdb_assert (gdbarch != NULL);
-  if (gdbarch->frame_saved_pc == 0)
+  if (gdbarch->unwind_pc == 0)
     internal_error (__FILE__, __LINE__,
-                    "gdbarch: gdbarch_frame_saved_pc invalid");
+                    "gdbarch: gdbarch_unwind_pc invalid");
   if (gdbarch_debug >= 2)
-    fprintf_unfiltered (gdb_stdlog, "gdbarch_frame_saved_pc called\n");
-  return gdbarch->frame_saved_pc (fi);
+    fprintf_unfiltered (gdb_stdlog, "gdbarch_unwind_pc called\n");
+  return gdbarch->unwind_pc (gdbarch, next_frame);
 }
 
 void
-set_gdbarch_frame_saved_pc (struct gdbarch *gdbarch,
-                            gdbarch_frame_saved_pc_ftype frame_saved_pc)
+set_gdbarch_unwind_pc (struct gdbarch *gdbarch,
+                       gdbarch_unwind_pc_ftype unwind_pc)
 {
-  gdbarch->frame_saved_pc = frame_saved_pc;
+  gdbarch->unwind_pc = unwind_pc;
 }
 
 CORE_ADDR
@@ -4720,23 +4993,30 @@ set_gdbarch_frame_locals_address (struct gdbarch *gdbarch,
   gdbarch->frame_locals_address = frame_locals_address;
 }
 
+int
+gdbarch_deprecated_saved_pc_after_call_p (struct gdbarch *gdbarch)
+{
+  gdb_assert (gdbarch != NULL);
+  return gdbarch->deprecated_saved_pc_after_call != 0;
+}
+
 CORE_ADDR
-gdbarch_saved_pc_after_call (struct gdbarch *gdbarch, struct frame_info *frame)
+gdbarch_deprecated_saved_pc_after_call (struct gdbarch *gdbarch, struct frame_info *frame)
 {
   gdb_assert (gdbarch != NULL);
-  if (gdbarch->saved_pc_after_call == 0)
+  if (gdbarch->deprecated_saved_pc_after_call == 0)
     internal_error (__FILE__, __LINE__,
-                    "gdbarch: gdbarch_saved_pc_after_call invalid");
+                    "gdbarch: gdbarch_deprecated_saved_pc_after_call invalid");
   if (gdbarch_debug >= 2)
-    fprintf_unfiltered (gdb_stdlog, "gdbarch_saved_pc_after_call called\n");
-  return gdbarch->saved_pc_after_call (frame);
+    fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_saved_pc_after_call called\n");
+  return gdbarch->deprecated_saved_pc_after_call (frame);
 }
 
 void
-set_gdbarch_saved_pc_after_call (struct gdbarch *gdbarch,
-                                 gdbarch_saved_pc_after_call_ftype saved_pc_after_call)
+set_gdbarch_deprecated_saved_pc_after_call (struct gdbarch *gdbarch,
+                                            gdbarch_deprecated_saved_pc_after_call_ftype deprecated_saved_pc_after_call)
 {
-  gdbarch->saved_pc_after_call = saved_pc_after_call;
+  gdbarch->deprecated_saved_pc_after_call = deprecated_saved_pc_after_call;
 }
 
 int
@@ -4811,20 +5091,20 @@ set_gdbarch_frame_align (struct gdbarch *gdbarch,
 }
 
 int
-gdbarch_extra_stack_alignment_needed (struct gdbarch *gdbarch)
+gdbarch_deprecated_extra_stack_alignment_needed (struct gdbarch *gdbarch)
 {
   gdb_assert (gdbarch != NULL);
-  /* Skip verify of extra_stack_alignment_needed, invalid_p == 0 */
+  /* Skip verify of deprecated_extra_stack_alignment_needed, invalid_p == 0 */
   if (gdbarch_debug >= 2)
-    fprintf_unfiltered (gdb_stdlog, "gdbarch_extra_stack_alignment_needed called\n");
-  return gdbarch->extra_stack_alignment_needed;
+    fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_extra_stack_alignment_needed called\n");
+  return gdbarch->deprecated_extra_stack_alignment_needed;
 }
 
 void
-set_gdbarch_extra_stack_alignment_needed (struct gdbarch *gdbarch,
-                                          int extra_stack_alignment_needed)
+set_gdbarch_deprecated_extra_stack_alignment_needed (struct gdbarch *gdbarch,
+                                                     int deprecated_extra_stack_alignment_needed)
 {
-  gdbarch->extra_stack_alignment_needed = extra_stack_alignment_needed;
+  gdbarch->deprecated_extra_stack_alignment_needed = deprecated_extra_stack_alignment_needed;
 }
 
 int
@@ -4879,6 +5159,32 @@ set_gdbarch_save_dummy_frame_tos (struct gdbarch *gdbarch,
   gdbarch->save_dummy_frame_tos = save_dummy_frame_tos;
 }
 
+int
+gdbarch_unwind_dummy_id_p (struct gdbarch *gdbarch)
+{
+  gdb_assert (gdbarch != NULL);
+  return gdbarch->unwind_dummy_id != 0;
+}
+
+struct frame_id
+gdbarch_unwind_dummy_id (struct gdbarch *gdbarch, struct frame_info *info)
+{
+  gdb_assert (gdbarch != NULL);
+  if (gdbarch->unwind_dummy_id == 0)
+    internal_error (__FILE__, __LINE__,
+                    "gdbarch: gdbarch_unwind_dummy_id invalid");
+  if (gdbarch_debug >= 2)
+    fprintf_unfiltered (gdb_stdlog, "gdbarch_unwind_dummy_id called\n");
+  return gdbarch->unwind_dummy_id (gdbarch, info);
+}
+
+void
+set_gdbarch_unwind_dummy_id (struct gdbarch *gdbarch,
+                             gdbarch_unwind_dummy_id_ftype unwind_dummy_id)
+{
+  gdbarch->unwind_dummy_id = unwind_dummy_id;
+}
+
 int
 gdbarch_parm_boundary (struct gdbarch *gdbarch)
 {
@@ -5359,7 +5665,7 @@ gdbarch_address_class_type_flags_to_name_p (struct gdbarch *gdbarch)
   return gdbarch->address_class_type_flags_to_name != 0;
 }
 
-char *
+const char *
 gdbarch_address_class_type_flags_to_name (struct gdbarch *gdbarch, int type_flags)
 {
   gdb_assert (gdbarch != NULL);
@@ -5386,7 +5692,7 @@ gdbarch_address_class_name_to_type_flags_p (struct gdbarch *gdbarch)
 }
 
 int
-gdbarch_address_class_name_to_type_flags (struct gdbarch *gdbarch, char *name, int *type_flags_ptr)
+gdbarch_address_class_name_to_type_flags (struct gdbarch *gdbarch, const char *name, int *type_flags_ptr)
 {
   gdb_assert (gdbarch != NULL);
   if (gdbarch->address_class_name_to_type_flags == 0)
@@ -5423,6 +5729,32 @@ set_gdbarch_register_reggroup_p (struct gdbarch *gdbarch,
   gdbarch->register_reggroup_p = register_reggroup_p;
 }
 
+int
+gdbarch_fetch_pointer_argument_p (struct gdbarch *gdbarch)
+{
+  gdb_assert (gdbarch != NULL);
+  return gdbarch->fetch_pointer_argument != 0;
+}
+
+CORE_ADDR
+gdbarch_fetch_pointer_argument (struct gdbarch *gdbarch, struct frame_info *frame, int argi, struct type *type)
+{
+  gdb_assert (gdbarch != NULL);
+  if (gdbarch->fetch_pointer_argument == 0)
+    internal_error (__FILE__, __LINE__,
+                    "gdbarch: gdbarch_fetch_pointer_argument invalid");
+  if (gdbarch_debug >= 2)
+    fprintf_unfiltered (gdb_stdlog, "gdbarch_fetch_pointer_argument called\n");
+  return gdbarch->fetch_pointer_argument (frame, argi, type);
+}
+
+void
+set_gdbarch_fetch_pointer_argument (struct gdbarch *gdbarch,
+                                    gdbarch_fetch_pointer_argument_ftype fetch_pointer_argument)
+{
+  gdbarch->fetch_pointer_argument = fetch_pointer_argument;
+}
+
 
 /* Keep a registry of per-architecture data-pointers required by GDB
    modules. */
@@ -5770,6 +6102,8 @@ gdbarch_list_lookup_by_info (struct gdbarch_list *arches,
 	continue;
       if (info->byte_order != arches->gdbarch->byte_order)
 	continue;
+      if (info->osabi != arches->gdbarch->osabi)
+	continue;
       return arches;
     }
   return NULL;
@@ -5815,6 +6149,12 @@ gdbarch_update_p (struct gdbarch_info info)
   if (info.byte_order == BFD_ENDIAN_UNKNOWN)
     info.byte_order = TARGET_BYTE_ORDER;
 
+  /* ``(gdb) set osabi ...'' is handled by gdbarch_lookup_osabi.  */
+  if (info.osabi == GDB_OSABI_UNINITIALIZED)
+    info.osabi = gdbarch_lookup_osabi (info.abfd);
+  if (info.osabi == GDB_OSABI_UNINITIALIZED)
+    info.osabi = current_gdbarch->osabi;
+
   /* Must have found some sort of architecture. */
   gdb_assert (info.bfd_arch_info != NULL);
 
@@ -5831,6 +6171,9 @@ gdbarch_update_p (struct gdbarch_info info)
 			  (info.byte_order == BFD_ENDIAN_BIG ? "big"
 			   : info.byte_order == BFD_ENDIAN_LITTLE ? "little"
 			   : "default"));
+      fprintf_unfiltered (gdb_stdlog,
+			  "gdbarch_update: info.osabi %d (%s)\n",
+			  info.osabi, gdbarch_osabi_name (info.osabi));
       fprintf_unfiltered (gdb_stdlog,
 			  "gdbarch_update: info.abfd 0x%lx\n",
 			  (long) info.abfd);
@@ -5970,9 +6313,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);
 
@@ -5981,12 +6322,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,