* MAINTAINERS (Responsible Maintainers/misc): Add myself

[deliverable/binutils-gdb.git] / gdb / gdbarch.c

diff --git a/gdb/gdbarch.c b/gdb/gdbarch.c
index 4759236d5b5b3c0678673189588366c8a5174e55..26dd4043a609532b967915d9f01747f3d3a81244 100644 (file)
--- a/gdb/gdbarch.c
+++ b/gdb/gdbarch.c
@@ -1,9 +1,10 @@
-/* *INDENT-OFF* */ /* THIS FILE IS GENERATED */
+/* *INDENT-OFF* */ /* THIS FILE IS GENERATED -*- buffer-read-only: t -*- */
+/* vi:set ro: */

 
 /* Dynamic architecture support for GDB, the GNU debugger.
 
 
 /* Dynamic architecture support for GDB, the GNU debugger.
 

-   Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007
-   Free Software Foundation, Inc.
+   Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006,
+   2007, 2008, 2009 Free Software Foundation, Inc.

 
    This file is part of GDB.
 
 
    This file is part of GDB.
 


@@ -30,7 +31,7 @@
    If editing this file, please also run gdbarch.sh and merge any
    changes into that script. Conversely, when making sweeping changes
    to this file, modifying gdbarch.sh and using its output may prove
    If editing this file, please also run gdbarch.sh and merge any
    changes into that script. Conversely, when making sweeping changes
    to this file, modifying gdbarch.sh and using its output may prove

-   easier. */
+   easier.  */

 
 
 #include "defs.h"
 
 
 #include "defs.h"


@@ -44,10 +45,12 @@
 
 #include "gdb_assert.h"
 #include "gdb_string.h"
 
 #include "gdb_assert.h"
 #include "gdb_string.h"

-#include "gdb-events.h"

 #include "reggroups.h"
 #include "osabi.h"
 #include "gdb_obstack.h"
 #include "reggroups.h"
 #include "osabi.h"
 #include "gdb_obstack.h"

+#include "observer.h"
+#include "regcache.h"
+#include "objfiles.h"

 
 /* Static function declarations */
 
 
 /* Static function declarations */
 


@@ -58,7 +61,7 @@ static void alloc_gdbarch_data (struct gdbarch *);
 #ifndef GDBARCH_DEBUG
 #define GDBARCH_DEBUG 0
 #endif
 #ifndef GDBARCH_DEBUG
 #define GDBARCH_DEBUG 0
 #endif

-int gdbarch_debug = GDBARCH_DEBUG;
+unsigned int gdbarch_debug = GDBARCH_DEBUG;

 static void
 show_gdbarch_debug (struct ui_file *file, int from_tty,
                     struct cmd_list_element *c, const char *value)
 static void
 show_gdbarch_debug (struct ui_file *file, int from_tty,
                     struct cmd_list_element *c, const char *value)


@@ -76,8 +79,16 @@ pformat (const struct floatformat **format)
     return format[0]->name;
 }
 
     return format[0]->name;
 }
 

+static const char *
+pstring (const char *string)
+{
+  if (string == NULL)
+    return "(null)";
+  return string;
+}

 
 

-/* Maintain the struct gdbarch object */
+
+/* Maintain the struct gdbarch object.  */

 
 struct gdbarch
 {
 
 struct gdbarch
 {


@@ -87,23 +98,21 @@ struct gdbarch
   /* An obstack bound to the lifetime of the architecture.  */
   struct obstack *obstack;
 
   /* An obstack bound to the lifetime of the architecture.  */
   struct obstack *obstack;
 

-  /* basic architectural information */
+  /* basic architectural information.  */

   const struct bfd_arch_info * bfd_arch_info;
   int byte_order;
   const struct bfd_arch_info * bfd_arch_info;
   int byte_order;

+  int byte_order_for_code;

   enum gdb_osabi osabi;
   const struct target_desc * target_desc;
 
   enum gdb_osabi osabi;
   const struct target_desc * target_desc;
 

-  /* target specific vector. */
+  /* target specific vector.  */

   struct gdbarch_tdep *tdep;
   gdbarch_dump_tdep_ftype *dump_tdep;
 
   struct gdbarch_tdep *tdep;
   gdbarch_dump_tdep_ftype *dump_tdep;
 

-  /* per-architecture data-pointers */
+  /* per-architecture data-pointers.  */

   unsigned nr_data;
   void **data;
 
   unsigned nr_data;
   void **data;
 

-  /* per-architecture swap-regions */
-  struct gdbarch_swap *swap;
-

   /* Multi-arch values.
 
      When extending this structure you must:
   /* Multi-arch values.
 
      When extending this structure you must:


@@ -130,10 +139,14 @@ struct gdbarch
 
      */
 
 
      */
 

+  int bits_big_endian;

   int short_bit;
   int int_bit;
   int long_bit;
   int long_long_bit;
   int short_bit;
   int int_bit;
   int long_bit;
   int long_long_bit;

+  int long_long_align_bit;
+  int half_bit;
+  const struct floatformat ** half_format;

   int float_bit;
   const struct floatformat ** float_format;
   int double_bit;
   int float_bit;
   const struct floatformat ** float_format;
   int double_bit;


@@ -142,26 +155,29 @@ struct gdbarch
   const struct floatformat ** long_double_format;
   int ptr_bit;
   int addr_bit;
   const struct floatformat ** long_double_format;
   int ptr_bit;
   int addr_bit;

+  int dwarf2_addr_size;

   int char_signed;
   gdbarch_read_pc_ftype *read_pc;
   gdbarch_write_pc_ftype *write_pc;
   gdbarch_virtual_frame_pointer_ftype *virtual_frame_pointer;
   gdbarch_pseudo_register_read_ftype *pseudo_register_read;
   int char_signed;
   gdbarch_read_pc_ftype *read_pc;
   gdbarch_write_pc_ftype *write_pc;
   gdbarch_virtual_frame_pointer_ftype *virtual_frame_pointer;
   gdbarch_pseudo_register_read_ftype *pseudo_register_read;

+  gdbarch_pseudo_register_read_value_ftype *pseudo_register_read_value;

   gdbarch_pseudo_register_write_ftype *pseudo_register_write;
   int num_regs;
   int num_pseudo_regs;
   gdbarch_pseudo_register_write_ftype *pseudo_register_write;
   int num_regs;
   int num_pseudo_regs;

+  gdbarch_ax_pseudo_register_collect_ftype *ax_pseudo_register_collect;
+  gdbarch_ax_pseudo_register_push_stack_ftype *ax_pseudo_register_push_stack;

   int sp_regnum;
   int pc_regnum;
   int ps_regnum;
   int fp0_regnum;
   gdbarch_stab_reg_to_regnum_ftype *stab_reg_to_regnum;
   gdbarch_ecoff_reg_to_regnum_ftype *ecoff_reg_to_regnum;
   int sp_regnum;
   int pc_regnum;
   int ps_regnum;
   int fp0_regnum;
   gdbarch_stab_reg_to_regnum_ftype *stab_reg_to_regnum;
   gdbarch_ecoff_reg_to_regnum_ftype *ecoff_reg_to_regnum;

-  gdbarch_dwarf_reg_to_regnum_ftype *dwarf_reg_to_regnum;

   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;
   gdbarch_register_type_ftype *register_type;
   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;
   gdbarch_register_type_ftype *register_type;

-  gdbarch_unwind_dummy_id_ftype *unwind_dummy_id;
+  gdbarch_dummy_id_ftype *dummy_id;

   int deprecated_fp_regnum;
   gdbarch_push_dummy_call_ftype *push_dummy_call;
   int call_dummy_location;
   int deprecated_fp_regnum;
   gdbarch_push_dummy_call_ftype *push_dummy_call;
   int call_dummy_location;


@@ -182,9 +198,12 @@ struct gdbarch
   gdbarch_address_to_pointer_ftype *address_to_pointer;
   gdbarch_integer_to_address_ftype *integer_to_address;
   gdbarch_return_value_ftype *return_value;
   gdbarch_address_to_pointer_ftype *address_to_pointer;
   gdbarch_integer_to_address_ftype *integer_to_address;
   gdbarch_return_value_ftype *return_value;

+  gdbarch_return_in_first_hidden_param_p_ftype *return_in_first_hidden_param_p;

   gdbarch_skip_prologue_ftype *skip_prologue;
   gdbarch_skip_prologue_ftype *skip_prologue;

+  gdbarch_skip_main_prologue_ftype *skip_main_prologue;

   gdbarch_inner_than_ftype *inner_than;
   gdbarch_breakpoint_from_pc_ftype *breakpoint_from_pc;
   gdbarch_inner_than_ftype *inner_than;
   gdbarch_breakpoint_from_pc_ftype *breakpoint_from_pc;

+  gdbarch_remote_breakpoint_from_pc_ftype *remote_breakpoint_from_pc;

   gdbarch_adjust_breakpoint_address_ftype *adjust_breakpoint_address;
   gdbarch_memory_insert_breakpoint_ftype *memory_insert_breakpoint;
   gdbarch_memory_remove_breakpoint_ftype *memory_remove_breakpoint;
   gdbarch_adjust_breakpoint_address_ftype *adjust_breakpoint_address;
   gdbarch_memory_insert_breakpoint_ftype *memory_insert_breakpoint;
   gdbarch_memory_remove_breakpoint_ftype *memory_remove_breakpoint;


@@ -209,10 +228,8 @@ struct gdbarch
   gdbarch_skip_solib_resolver_ftype *skip_solib_resolver;
   gdbarch_in_solib_return_trampoline_ftype *in_solib_return_trampoline;
   gdbarch_in_function_epilogue_p_ftype *in_function_epilogue_p;
   gdbarch_skip_solib_resolver_ftype *skip_solib_resolver;
   gdbarch_in_solib_return_trampoline_ftype *in_solib_return_trampoline;
   gdbarch_in_function_epilogue_p_ftype *in_function_epilogue_p;

-  gdbarch_construct_inferior_arguments_ftype *construct_inferior_arguments;

   gdbarch_elf_make_msymbol_special_ftype *elf_make_msymbol_special;
   gdbarch_coff_make_msymbol_special_ftype *coff_make_msymbol_special;
   gdbarch_elf_make_msymbol_special_ftype *elf_make_msymbol_special;
   gdbarch_coff_make_msymbol_special_ftype *coff_make_msymbol_special;

-  const char * name_of_malloc;

   int cannot_step_breakpoint;
   int have_nonsteppable_watchpoint;
   gdbarch_address_class_type_flags_ftype *address_class_type_flags;
   int cannot_step_breakpoint;
   int have_nonsteppable_watchpoint;
   gdbarch_address_class_type_flags_ftype *address_class_type_flags;


@@ -221,19 +238,58 @@ struct gdbarch
   gdbarch_register_reggroup_p_ftype *register_reggroup_p;
   gdbarch_fetch_pointer_argument_ftype *fetch_pointer_argument;
   gdbarch_regset_from_core_section_ftype *regset_from_core_section;
   gdbarch_register_reggroup_p_ftype *register_reggroup_p;
   gdbarch_fetch_pointer_argument_ftype *fetch_pointer_argument;
   gdbarch_regset_from_core_section_ftype *regset_from_core_section;

+  struct core_regset_section * core_regset_sections;
+  gdbarch_make_corefile_notes_ftype *make_corefile_notes;
+  gdbarch_find_memory_regions_ftype *find_memory_regions;

   gdbarch_core_xfer_shared_libraries_ftype *core_xfer_shared_libraries;
   gdbarch_core_xfer_shared_libraries_ftype *core_xfer_shared_libraries;

+  gdbarch_core_pid_to_str_ftype *core_pid_to_str;
+  const char * gcore_bfd_target;

   int vtable_function_descriptors;
   int vbit_in_delta;
   gdbarch_skip_permanent_breakpoint_ftype *skip_permanent_breakpoint;
   int vtable_function_descriptors;
   int vbit_in_delta;
   gdbarch_skip_permanent_breakpoint_ftype *skip_permanent_breakpoint;

+  ULONGEST max_insn_length;
+  gdbarch_displaced_step_copy_insn_ftype *displaced_step_copy_insn;
+  gdbarch_displaced_step_hw_singlestep_ftype *displaced_step_hw_singlestep;
+  gdbarch_displaced_step_fixup_ftype *displaced_step_fixup;
+  gdbarch_displaced_step_free_closure_ftype *displaced_step_free_closure;
+  gdbarch_displaced_step_location_ftype *displaced_step_location;
+  gdbarch_relocate_instruction_ftype *relocate_instruction;

   gdbarch_overlay_update_ftype *overlay_update;
   gdbarch_core_read_description_ftype *core_read_description;
   gdbarch_static_transform_name_ftype *static_transform_name;
   int sofun_address_maybe_missing;
   gdbarch_overlay_update_ftype *overlay_update;
   gdbarch_core_read_description_ftype *core_read_description;
   gdbarch_static_transform_name_ftype *static_transform_name;
   int sofun_address_maybe_missing;

+  gdbarch_process_record_ftype *process_record;
+  gdbarch_process_record_signal_ftype *process_record_signal;
+  gdbarch_gdb_signal_from_target_ftype *gdb_signal_from_target;
+  gdbarch_get_siginfo_type_ftype *get_siginfo_type;
+  gdbarch_record_special_symbol_ftype *record_special_symbol;
+  gdbarch_get_syscall_number_ftype *get_syscall_number;
+  const char * stap_integer_prefix;
+  const char * stap_integer_suffix;
+  const char * stap_register_prefix;
+  const char * stap_register_suffix;
+  const char * stap_register_indirection_prefix;
+  const char * stap_register_indirection_suffix;
+  const char * stap_gdb_register_prefix;
+  const char * stap_gdb_register_suffix;
+  gdbarch_stap_is_single_operand_ftype *stap_is_single_operand;
+  gdbarch_stap_parse_special_token_ftype *stap_parse_special_token;
+  int has_global_solist;
+  int has_global_breakpoints;
+  gdbarch_has_shared_address_space_ftype *has_shared_address_space;
+  gdbarch_fast_tracepoint_valid_at_ftype *fast_tracepoint_valid_at;
+  gdbarch_auto_charset_ftype *auto_charset;
+  gdbarch_auto_wide_charset_ftype *auto_wide_charset;
+  const char * solib_symbols_extension;
+  int has_dos_based_file_system;
+  gdbarch_gen_return_address_ftype *gen_return_address;
+  gdbarch_info_proc_ftype *info_proc;
+  gdbarch_iterate_over_objfiles_in_search_order_ftype *iterate_over_objfiles_in_search_order;

 };
 
 
 /* The default architecture uses host values (for want of a better
 };
 
 
 /* The default architecture uses host values (for want of a better

-   choice). */
+   choice).  */

 
 extern const struct bfd_arch_info bfd_default_arch_struct;
 
 
 extern const struct bfd_arch_info bfd_default_arch_struct;
 


@@ -241,20 +297,25 @@ struct gdbarch startup_gdbarch =
 {
   1, /* Always initialized.  */
   NULL, /* The obstack.  */
 {
   1, /* Always initialized.  */
   NULL, /* The obstack.  */

-  /* basic architecture information */
+  /* basic architecture information.  */

   &bfd_default_arch_struct,  /* bfd_arch_info */
   BFD_ENDIAN_BIG,  /* byte_order */
   &bfd_default_arch_struct,  /* bfd_arch_info */
   BFD_ENDIAN_BIG,  /* byte_order */

+  BFD_ENDIAN_BIG,  /* byte_order_for_code */

   GDB_OSABI_UNKNOWN,  /* osabi */
   0,  /* target_desc */
   GDB_OSABI_UNKNOWN,  /* osabi */
   0,  /* target_desc */

-  /* target specific vector and its dump routine */
+  /* target specific vector and its dump routine.  */

   NULL, NULL,
   NULL, NULL,

-  /*per-architecture data-pointers and swap regions */
-  0, NULL, NULL,
+  /*per-architecture data-pointers.  */
+  0, NULL,

   /* Multi-arch values */
   /* Multi-arch values */

+  1,  /* bits_big_endian */

   8 * sizeof (short),  /* short_bit */
   8 * sizeof (int),  /* int_bit */
   8 * sizeof (long),  /* long_bit */
   8 * sizeof (LONGEST),  /* long_long_bit */
   8 * sizeof (short),  /* short_bit */
   8 * sizeof (int),  /* int_bit */
   8 * sizeof (long),  /* long_bit */
   8 * sizeof (LONGEST),  /* long_long_bit */

+  8 * sizeof (LONGEST),  /* long_long_align_bit */
+  16,  /* half_bit */
+  0,  /* half_format */

   8 * sizeof (float),  /* float_bit */
   0,  /* float_format */
   8 * sizeof (double),  /* double_bit */
   8 * sizeof (float),  /* float_bit */
   0,  /* float_format */
   8 * sizeof (double),  /* double_bit */


@@ -263,26 +324,29 @@ struct gdbarch startup_gdbarch =
   0,  /* long_double_format */
   8 * sizeof (void*),  /* ptr_bit */
   8 * sizeof (void*),  /* addr_bit */
   0,  /* long_double_format */
   8 * sizeof (void*),  /* ptr_bit */
   8 * sizeof (void*),  /* addr_bit */

+  sizeof (void*),  /* dwarf2_addr_size */

   1,  /* char_signed */
   0,  /* read_pc */
   0,  /* write_pc */
   1,  /* char_signed */
   0,  /* read_pc */
   0,  /* write_pc */

-  0,  /* virtual_frame_pointer */
+  legacy_virtual_frame_pointer,  /* virtual_frame_pointer */

   0,  /* pseudo_register_read */
   0,  /* pseudo_register_read */

+  0,  /* pseudo_register_read_value */

   0,  /* pseudo_register_write */
   0,  /* num_regs */
   0,  /* num_pseudo_regs */
   0,  /* pseudo_register_write */
   0,  /* num_regs */
   0,  /* num_pseudo_regs */

+  0,  /* ax_pseudo_register_collect */
+  0,  /* ax_pseudo_register_push_stack */

   -1,  /* sp_regnum */
   -1,  /* pc_regnum */
   -1,  /* ps_regnum */
   0,  /* fp0_regnum */
   -1,  /* sp_regnum */
   -1,  /* pc_regnum */
   -1,  /* ps_regnum */
   0,  /* fp0_regnum */

-  0,  /* stab_reg_to_regnum */
-  0,  /* ecoff_reg_to_regnum */
-  0,  /* dwarf_reg_to_regnum */
-  0,  /* sdb_reg_to_regnum */
-  0,  /* dwarf2_reg_to_regnum */
+  no_op_reg_to_regnum,  /* stab_reg_to_regnum */
+  no_op_reg_to_regnum,  /* ecoff_reg_to_regnum */
+  no_op_reg_to_regnum,  /* sdb_reg_to_regnum */
+  no_op_reg_to_regnum,  /* dwarf2_reg_to_regnum */

   0,  /* register_name */
   0,  /* register_type */
   0,  /* register_name */
   0,  /* register_type */

-  0,  /* unwind_dummy_id */
+  0,  /* dummy_id */

   -1,  /* deprecated_fp_regnum */
   0,  /* push_dummy_call */
   0,  /* call_dummy_location */
   -1,  /* deprecated_fp_regnum */
   0,  /* push_dummy_call */
   0,  /* call_dummy_location */


@@ -290,25 +354,28 @@ struct gdbarch startup_gdbarch =
   default_print_registers_info,  /* print_registers_info */
   0,  /* print_float_info */
   0,  /* print_vector_info */
   default_print_registers_info,  /* print_registers_info */
   0,  /* print_float_info */
   0,  /* print_vector_info */

-  0,  /* register_sim_regno */
-  0,  /* cannot_fetch_register */
-  0,  /* cannot_store_register */
+  legacy_register_sim_regno,  /* register_sim_regno */
+  cannot_register_not,  /* cannot_fetch_register */
+  cannot_register_not,  /* cannot_store_register */

   0,  /* get_longjmp_target */
   0,  /* believe_pcc_promotion */
   0,  /* get_longjmp_target */
   0,  /* believe_pcc_promotion */

-  0,  /* convert_register_p */
+  generic_convert_register_p,  /* convert_register_p */

   0,  /* register_to_value */
   0,  /* value_to_register */
   0,  /* value_from_register */
   0,  /* register_to_value */
   0,  /* value_to_register */
   0,  /* value_from_register */

-  0,  /* pointer_to_address */
-  0,  /* address_to_pointer */
+  unsigned_pointer_to_address,  /* pointer_to_address */
+  unsigned_address_to_pointer,  /* address_to_pointer */

   0,  /* integer_to_address */
   0,  /* return_value */
   0,  /* integer_to_address */
   0,  /* return_value */

+  default_return_in_first_hidden_param_p,  /* return_in_first_hidden_param_p */

   0,  /* skip_prologue */
   0,  /* skip_prologue */

+  0,  /* skip_main_prologue */

   0,  /* inner_than */
   0,  /* breakpoint_from_pc */
   0,  /* inner_than */
   0,  /* breakpoint_from_pc */

+  default_remote_breakpoint_from_pc,  /* remote_breakpoint_from_pc */

   0,  /* adjust_breakpoint_address */
   0,  /* adjust_breakpoint_address */

-  0,  /* memory_insert_breakpoint */
-  0,  /* memory_remove_breakpoint */
+  default_memory_insert_breakpoint,  /* memory_insert_breakpoint */
+  default_memory_remove_breakpoint,  /* memory_remove_breakpoint */

   0,  /* decr_pc_after_break */
   0,  /* deprecated_function_start_offset */
   default_remote_register_number,  /* remote_register_number */
   0,  /* decr_pc_after_break */
   0,  /* deprecated_function_start_offset */
   default_remote_register_number,  /* remote_register_number */


@@ -321,19 +388,17 @@ struct gdbarch startup_gdbarch =
   default_stabs_argument_has_addr,  /* stabs_argument_has_addr */
   0,  /* frame_red_zone_size */
   convert_from_func_ptr_addr_identity,  /* convert_from_func_ptr_addr */
   default_stabs_argument_has_addr,  /* stabs_argument_has_addr */
   0,  /* frame_red_zone_size */
   convert_from_func_ptr_addr_identity,  /* convert_from_func_ptr_addr */

-  0,  /* addr_bits_remove */
-  0,  /* smash_text_address */
+  core_addr_identity,  /* addr_bits_remove */
+  core_addr_identity,  /* smash_text_address */

   0,  /* software_single_step */
   0,  /* single_step_through_delay */
   0,  /* print_insn */
   0,  /* skip_trampoline_code */
   generic_skip_solib_resolver,  /* skip_solib_resolver */
   0,  /* software_single_step */
   0,  /* single_step_through_delay */
   0,  /* print_insn */
   0,  /* skip_trampoline_code */
   generic_skip_solib_resolver,  /* skip_solib_resolver */

-  0,  /* in_solib_return_trampoline */
+  generic_in_solib_return_trampoline,  /* in_solib_return_trampoline */

   generic_in_function_epilogue_p,  /* in_function_epilogue_p */
   generic_in_function_epilogue_p,  /* in_function_epilogue_p */

-  construct_inferior_arguments,  /* construct_inferior_arguments */

   0,  /* elf_make_msymbol_special */
   0,  /* coff_make_msymbol_special */
   0,  /* elf_make_msymbol_special */
   0,  /* coff_make_msymbol_special */

-  "malloc",  /* name_of_malloc */

   0,  /* cannot_step_breakpoint */
   0,  /* have_nonsteppable_watchpoint */
   0,  /* address_class_type_flags */
   0,  /* cannot_step_breakpoint */
   0,  /* have_nonsteppable_watchpoint */
   0,  /* address_class_type_flags */


@@ -342,101 +407,147 @@ struct gdbarch startup_gdbarch =
   default_register_reggroup_p,  /* register_reggroup_p */
   0,  /* fetch_pointer_argument */
   0,  /* regset_from_core_section */
   default_register_reggroup_p,  /* register_reggroup_p */
   0,  /* fetch_pointer_argument */
   0,  /* regset_from_core_section */

+  0,  /* core_regset_sections */
+  0,  /* make_corefile_notes */
+  0,  /* find_memory_regions */

   0,  /* core_xfer_shared_libraries */
   0,  /* core_xfer_shared_libraries */

+  0,  /* core_pid_to_str */
+  0,  /* gcore_bfd_target */

   0,  /* vtable_function_descriptors */
   0,  /* vbit_in_delta */
   0,  /* skip_permanent_breakpoint */
   0,  /* vtable_function_descriptors */
   0,  /* vbit_in_delta */
   0,  /* skip_permanent_breakpoint */

+  0,  /* max_insn_length */
+  0,  /* displaced_step_copy_insn */
+  default_displaced_step_hw_singlestep,  /* displaced_step_hw_singlestep */
+  0,  /* displaced_step_fixup */
+  NULL,  /* displaced_step_free_closure */
+  NULL,  /* displaced_step_location */
+  0,  /* relocate_instruction */

   0,  /* overlay_update */
   0,  /* core_read_description */
   0,  /* static_transform_name */
   0,  /* sofun_address_maybe_missing */
   0,  /* overlay_update */
   0,  /* core_read_description */
   0,  /* static_transform_name */
   0,  /* sofun_address_maybe_missing */

+  0,  /* process_record */
+  0,  /* process_record_signal */
+  0,  /* gdb_signal_from_target */
+  0,  /* get_siginfo_type */
+  0,  /* record_special_symbol */
+  0,  /* get_syscall_number */
+  0,  /* stap_integer_prefix */
+  0,  /* stap_integer_suffix */
+  0,  /* stap_register_prefix */
+  0,  /* stap_register_suffix */
+  0,  /* stap_register_indirection_prefix */
+  0,  /* stap_register_indirection_suffix */
+  0,  /* stap_gdb_register_prefix */
+  0,  /* stap_gdb_register_suffix */
+  0,  /* stap_is_single_operand */
+  0,  /* stap_parse_special_token */
+  0,  /* has_global_solist */
+  0,  /* has_global_breakpoints */
+  default_has_shared_address_space,  /* has_shared_address_space */
+  default_fast_tracepoint_valid_at,  /* fast_tracepoint_valid_at */
+  default_auto_charset,  /* auto_charset */
+  default_auto_wide_charset,  /* auto_wide_charset */
+  0,  /* solib_symbols_extension */
+  0,  /* has_dos_based_file_system */
+  default_gen_return_address,  /* gen_return_address */
+  0,  /* info_proc */
+  default_iterate_over_objfiles_in_search_order,  /* iterate_over_objfiles_in_search_order */

   /* startup_gdbarch() */
 };
 
   /* startup_gdbarch() */
 };
 

-struct gdbarch *current_gdbarch = &startup_gdbarch;

 
 /* Create a new ``struct gdbarch'' based on information provided by
 
 /* Create a new ``struct gdbarch'' based on information provided by

-   ``struct gdbarch_info''. */
+   ``struct gdbarch_info''.  */

 
 struct gdbarch *
 gdbarch_alloc (const struct gdbarch_info *info,
                struct gdbarch_tdep *tdep)
 {
 
 struct gdbarch *
 gdbarch_alloc (const struct gdbarch_info *info,
                struct gdbarch_tdep *tdep)
 {

-  /* NOTE: The new architecture variable is named ``current_gdbarch''
-     so that macros such as TARGET_ARCHITECTURE, when expanded, refer to
-     the current local architecture and not the previous global
-     architecture.  This ensures that the new architectures initial
-     values are not influenced by the previous architecture.  Once
-     everything is parameterised with gdbarch, this will go away.  */
-  struct gdbarch *current_gdbarch;
+  struct gdbarch *gdbarch;

 
   /* Create an obstack for allocating all the per-architecture memory,
      then use that to allocate the architecture vector.  */
   struct obstack *obstack = XMALLOC (struct obstack);
   obstack_init (obstack);
 
   /* Create an obstack for allocating all the per-architecture memory,
      then use that to allocate the architecture vector.  */
   struct obstack *obstack = XMALLOC (struct obstack);
   obstack_init (obstack);

-  current_gdbarch = obstack_alloc (obstack, sizeof (*current_gdbarch));
-  memset (current_gdbarch, 0, sizeof (*current_gdbarch));
-  current_gdbarch->obstack = obstack;
-
-  alloc_gdbarch_data (current_gdbarch);
-
-  current_gdbarch->tdep = tdep;
-
-  current_gdbarch->bfd_arch_info = info->bfd_arch_info;
-  current_gdbarch->byte_order = info->byte_order;
-  current_gdbarch->osabi = info->osabi;
-  current_gdbarch->target_desc = info->target_desc;
-
-  /* Force the explicit initialization of these. */
-  current_gdbarch->short_bit = 2*TARGET_CHAR_BIT;
-  current_gdbarch->int_bit = 4*TARGET_CHAR_BIT;
-  current_gdbarch->long_bit = 4*TARGET_CHAR_BIT;
-  current_gdbarch->long_long_bit = 2*current_gdbarch->long_bit;
-  current_gdbarch->float_bit = 4*TARGET_CHAR_BIT;
-  current_gdbarch->double_bit = 8*TARGET_CHAR_BIT;
-  current_gdbarch->long_double_bit = 8*TARGET_CHAR_BIT;
-  current_gdbarch->ptr_bit = current_gdbarch->int_bit;
-  current_gdbarch->char_signed = -1;
-  current_gdbarch->virtual_frame_pointer = legacy_virtual_frame_pointer;
-  current_gdbarch->num_regs = -1;
-  current_gdbarch->sp_regnum = -1;
-  current_gdbarch->pc_regnum = -1;
-  current_gdbarch->ps_regnum = -1;
-  current_gdbarch->fp0_regnum = -1;
-  current_gdbarch->stab_reg_to_regnum = no_op_reg_to_regnum;
-  current_gdbarch->ecoff_reg_to_regnum = no_op_reg_to_regnum;
-  current_gdbarch->dwarf_reg_to_regnum = no_op_reg_to_regnum;
-  current_gdbarch->sdb_reg_to_regnum = no_op_reg_to_regnum;
-  current_gdbarch->dwarf2_reg_to_regnum = no_op_reg_to_regnum;
-  current_gdbarch->deprecated_fp_regnum = -1;
-  current_gdbarch->call_dummy_location = AT_ENTRY_POINT;
-  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->convert_register_p = generic_convert_register_p;
-  current_gdbarch->value_from_register = default_value_from_register;
-  current_gdbarch->pointer_to_address = unsigned_pointer_to_address;
-  current_gdbarch->address_to_pointer = unsigned_address_to_pointer;
-  current_gdbarch->memory_insert_breakpoint = default_memory_insert_breakpoint;
-  current_gdbarch->memory_remove_breakpoint = default_memory_remove_breakpoint;
-  current_gdbarch->remote_register_number = default_remote_register_number;
-  current_gdbarch->stabs_argument_has_addr = default_stabs_argument_has_addr;
-  current_gdbarch->convert_from_func_ptr_addr = convert_from_func_ptr_addr_identity;
-  current_gdbarch->addr_bits_remove = core_addr_identity;
-  current_gdbarch->smash_text_address = core_addr_identity;
-  current_gdbarch->skip_trampoline_code = generic_skip_trampoline_code;
-  current_gdbarch->skip_solib_resolver = generic_skip_solib_resolver;
-  current_gdbarch->in_solib_return_trampoline = generic_in_solib_return_trampoline;
-  current_gdbarch->in_function_epilogue_p = generic_in_function_epilogue_p;
-  current_gdbarch->construct_inferior_arguments = construct_inferior_arguments;
-  current_gdbarch->elf_make_msymbol_special = default_elf_make_msymbol_special;
-  current_gdbarch->coff_make_msymbol_special = default_coff_make_msymbol_special;
-  current_gdbarch->name_of_malloc = "malloc";
-  current_gdbarch->register_reggroup_p = default_register_reggroup_p;
+  gdbarch = obstack_alloc (obstack, sizeof (*gdbarch));
+  memset (gdbarch, 0, sizeof (*gdbarch));
+  gdbarch->obstack = obstack;
+
+  alloc_gdbarch_data (gdbarch);
+
+  gdbarch->tdep = tdep;
+
+  gdbarch->bfd_arch_info = info->bfd_arch_info;
+  gdbarch->byte_order = info->byte_order;
+  gdbarch->byte_order_for_code = info->byte_order_for_code;
+  gdbarch->osabi = info->osabi;
+  gdbarch->target_desc = info->target_desc;
+
+  /* Force the explicit initialization of these.  */
+  gdbarch->bits_big_endian = (gdbarch->byte_order == BFD_ENDIAN_BIG);
+  gdbarch->short_bit = 2*TARGET_CHAR_BIT;
+  gdbarch->int_bit = 4*TARGET_CHAR_BIT;
+  gdbarch->long_bit = 4*TARGET_CHAR_BIT;
+  gdbarch->long_long_bit = 2*gdbarch->long_bit;
+  gdbarch->long_long_align_bit = 2*gdbarch->long_bit;
+  gdbarch->half_bit = 2*TARGET_CHAR_BIT;
+  gdbarch->float_bit = 4*TARGET_CHAR_BIT;
+  gdbarch->double_bit = 8*TARGET_CHAR_BIT;
+  gdbarch->long_double_bit = 8*TARGET_CHAR_BIT;
+  gdbarch->ptr_bit = gdbarch->int_bit;
+  gdbarch->char_signed = -1;
+  gdbarch->virtual_frame_pointer = legacy_virtual_frame_pointer;
+  gdbarch->num_regs = -1;
+  gdbarch->sp_regnum = -1;
+  gdbarch->pc_regnum = -1;
+  gdbarch->ps_regnum = -1;
+  gdbarch->fp0_regnum = -1;
+  gdbarch->stab_reg_to_regnum = no_op_reg_to_regnum;
+  gdbarch->ecoff_reg_to_regnum = no_op_reg_to_regnum;
+  gdbarch->sdb_reg_to_regnum = no_op_reg_to_regnum;
+  gdbarch->dwarf2_reg_to_regnum = no_op_reg_to_regnum;
+  gdbarch->deprecated_fp_regnum = -1;
+  gdbarch->call_dummy_location = AT_ENTRY_POINT;
+  gdbarch->print_registers_info = default_print_registers_info;
+  gdbarch->register_sim_regno = legacy_register_sim_regno;
+  gdbarch->cannot_fetch_register = cannot_register_not;
+  gdbarch->cannot_store_register = cannot_register_not;
+  gdbarch->convert_register_p = generic_convert_register_p;
+  gdbarch->value_from_register = default_value_from_register;
+  gdbarch->pointer_to_address = unsigned_pointer_to_address;
+  gdbarch->address_to_pointer = unsigned_address_to_pointer;
+  gdbarch->return_in_first_hidden_param_p = default_return_in_first_hidden_param_p;
+  gdbarch->remote_breakpoint_from_pc = default_remote_breakpoint_from_pc;
+  gdbarch->memory_insert_breakpoint = default_memory_insert_breakpoint;
+  gdbarch->memory_remove_breakpoint = default_memory_remove_breakpoint;
+  gdbarch->remote_register_number = default_remote_register_number;
+  gdbarch->stabs_argument_has_addr = default_stabs_argument_has_addr;
+  gdbarch->convert_from_func_ptr_addr = convert_from_func_ptr_addr_identity;
+  gdbarch->addr_bits_remove = core_addr_identity;
+  gdbarch->smash_text_address = core_addr_identity;
+  gdbarch->skip_trampoline_code = generic_skip_trampoline_code;
+  gdbarch->skip_solib_resolver = generic_skip_solib_resolver;
+  gdbarch->in_solib_return_trampoline = generic_in_solib_return_trampoline;
+  gdbarch->in_function_epilogue_p = generic_in_function_epilogue_p;
+  gdbarch->elf_make_msymbol_special = default_elf_make_msymbol_special;
+  gdbarch->coff_make_msymbol_special = default_coff_make_msymbol_special;
+  gdbarch->register_reggroup_p = default_register_reggroup_p;
+  gdbarch->displaced_step_hw_singlestep = default_displaced_step_hw_singlestep;
+  gdbarch->displaced_step_fixup = NULL;
+  gdbarch->displaced_step_free_closure = NULL;
+  gdbarch->displaced_step_location = NULL;
+  gdbarch->relocate_instruction = NULL;
+  gdbarch->has_shared_address_space = default_has_shared_address_space;
+  gdbarch->fast_tracepoint_valid_at = default_fast_tracepoint_valid_at;
+  gdbarch->auto_charset = default_auto_charset;
+  gdbarch->auto_wide_charset = default_auto_wide_charset;
+  gdbarch->gen_return_address = default_gen_return_address;
+  gdbarch->iterate_over_objfiles_in_search_order = default_iterate_over_objfiles_in_search_order;

   /* gdbarch_alloc() */
 
   /* gdbarch_alloc() */
 

-  return current_gdbarch;
+  return gdbarch;

 }
 
 
 }
 
 


@@ -446,6 +557,7 @@ void *
 gdbarch_obstack_zalloc (struct gdbarch *arch, long size)
 {
   void *data = obstack_alloc (arch->obstack, size);
 gdbarch_obstack_zalloc (struct gdbarch *arch, long size)
 {
   void *data = obstack_alloc (arch->obstack, size);

+

   memset (data, 0, size);
   return data;
 }
   memset (data, 0, size);
   return data;
 }


@@ -461,6 +573,7 @@ void
 gdbarch_free (struct gdbarch *arch)
 {
   struct obstack *obstack;
 gdbarch_free (struct gdbarch *arch)
 {
   struct obstack *obstack;

+

   gdb_assert (arch != NULL);
   gdb_assert (!arch->initialized_p);
   obstack = arch->obstack;
   gdb_assert (arch != NULL);
   gdb_assert (!arch->initialized_p);
   obstack = arch->obstack;


@@ -471,134 +584,180 @@ gdbarch_free (struct gdbarch *arch)
 
 /* Ensure that all values in a GDBARCH are reasonable.  */
 
 
 /* Ensure that all values in a GDBARCH are reasonable.  */
 

-/* NOTE/WARNING: The parameter is called ``current_gdbarch'' so that it
-   just happens to match the global variable ``current_gdbarch''.  That
-   way macros refering to that variable get the local and not the global
-   version - ulgh.  Once everything is parameterised with gdbarch, this
-   will go away. */
-

 static void
 static void

-verify_gdbarch (struct gdbarch *current_gdbarch)
+verify_gdbarch (struct gdbarch *gdbarch)

 {
   struct ui_file *log;
   struct cleanup *cleanups;
 {
   struct ui_file *log;
   struct cleanup *cleanups;

-  long dummy;
+  long length;

   char *buf;
   char *buf;

+

   log = mem_fileopen ();
   cleanups = make_cleanup_ui_file_delete (log);
   /* fundamental */
   log = mem_fileopen ();
   cleanups = make_cleanup_ui_file_delete (log);
   /* fundamental */

-  if (current_gdbarch->byte_order == BFD_ENDIAN_UNKNOWN)
+  if (gdbarch->byte_order == BFD_ENDIAN_UNKNOWN)

     fprintf_unfiltered (log, "\n\tbyte-order");
     fprintf_unfiltered (log, "\n\tbyte-order");

-  if (current_gdbarch->bfd_arch_info == NULL)
+  if (gdbarch->bfd_arch_info == NULL)

     fprintf_unfiltered (log, "\n\tbfd_arch_info");
     fprintf_unfiltered (log, "\n\tbfd_arch_info");

-  /* Check those that need to be defined for the given multi-arch level. */
+  /* Check those that need to be defined for the given multi-arch level.  */
+  /* Skip verify of bits_big_endian, invalid_p == 0 */

   /* Skip verify of short_bit, invalid_p == 0 */
   /* Skip verify of int_bit, invalid_p == 0 */
   /* Skip verify of long_bit, invalid_p == 0 */
   /* Skip verify of long_long_bit, invalid_p == 0 */
   /* Skip verify of short_bit, invalid_p == 0 */
   /* Skip verify of int_bit, invalid_p == 0 */
   /* Skip verify of long_bit, invalid_p == 0 */
   /* Skip verify of long_long_bit, invalid_p == 0 */

+  /* Skip verify of long_long_align_bit, invalid_p == 0 */
+  /* Skip verify of half_bit, invalid_p == 0 */
+  if (gdbarch->half_format == 0)
+    gdbarch->half_format = floatformats_ieee_half;

   /* Skip verify of float_bit, invalid_p == 0 */
   /* Skip verify of float_bit, invalid_p == 0 */

-  if (current_gdbarch->float_format == 0)
-    current_gdbarch->float_format = floatformats_ieee_single;
+  if (gdbarch->float_format == 0)
+    gdbarch->float_format = floatformats_ieee_single;

   /* Skip verify of double_bit, invalid_p == 0 */
   /* Skip verify of double_bit, invalid_p == 0 */

-  if (current_gdbarch->double_format == 0)
-    current_gdbarch->double_format = floatformats_ieee_double;
+  if (gdbarch->double_format == 0)
+    gdbarch->double_format = floatformats_ieee_double;

   /* Skip verify of long_double_bit, invalid_p == 0 */
   /* Skip verify of long_double_bit, invalid_p == 0 */

-  if (current_gdbarch->long_double_format == 0)
-    current_gdbarch->long_double_format = floatformats_ieee_double;
+  if (gdbarch->long_double_format == 0)
+    gdbarch->long_double_format = floatformats_ieee_double;

   /* Skip verify of ptr_bit, invalid_p == 0 */
   /* Skip verify of ptr_bit, invalid_p == 0 */

-  if (current_gdbarch->addr_bit == 0)
-    current_gdbarch->addr_bit = gdbarch_ptr_bit (current_gdbarch);
-  if (current_gdbarch->char_signed == -1)
-    current_gdbarch->char_signed = 1;
-  /* Skip verify of read_pc, has predicate */
-  /* Skip verify of write_pc, has predicate */
+  if (gdbarch->addr_bit == 0)
+    gdbarch->addr_bit = gdbarch_ptr_bit (gdbarch);
+  if (gdbarch->dwarf2_addr_size == 0)
+    gdbarch->dwarf2_addr_size = gdbarch_ptr_bit (gdbarch) / TARGET_CHAR_BIT;
+  if (gdbarch->char_signed == -1)
+    gdbarch->char_signed = 1;
+  /* Skip verify of read_pc, has predicate.  */
+  /* Skip verify of write_pc, has predicate.  */

   /* Skip verify of virtual_frame_pointer, invalid_p == 0 */
   /* 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 */
-  if (current_gdbarch->num_regs == -1)
+  /* Skip verify of pseudo_register_read, has predicate.  */
+  /* Skip verify of pseudo_register_read_value, has predicate.  */
+  /* Skip verify of pseudo_register_write, has predicate.  */
+  if (gdbarch->num_regs == -1)

     fprintf_unfiltered (log, "\n\tnum_regs");
   /* Skip verify of num_pseudo_regs, invalid_p == 0 */
     fprintf_unfiltered (log, "\n\tnum_regs");
   /* Skip verify of num_pseudo_regs, invalid_p == 0 */

+  /* Skip verify of ax_pseudo_register_collect, has predicate.  */
+  /* Skip verify of ax_pseudo_register_push_stack, has predicate.  */

   /* Skip verify of sp_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 */
   /* Skip verify of stab_reg_to_regnum, invalid_p == 0 */
   /* Skip verify of ecoff_reg_to_regnum, invalid_p == 0 */
   /* Skip verify of sp_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 */
   /* Skip verify of stab_reg_to_regnum, invalid_p == 0 */
   /* Skip verify of ecoff_reg_to_regnum, invalid_p == 0 */

-  /* Skip verify of dwarf_reg_to_regnum, invalid_p == 0 */

   /* Skip verify of sdb_reg_to_regnum, invalid_p == 0 */
   /* Skip verify of dwarf2_reg_to_regnum, invalid_p == 0 */
   /* Skip verify of sdb_reg_to_regnum, invalid_p == 0 */
   /* Skip verify of dwarf2_reg_to_regnum, invalid_p == 0 */

-  /* Skip verify of register_type, has predicate */
-  /* Skip verify of unwind_dummy_id, has predicate */
+  if (gdbarch->register_name == 0)
+    fprintf_unfiltered (log, "\n\tregister_name");
+  /* Skip verify of register_type, has predicate.  */
+  /* Skip verify of dummy_id, has predicate.  */

   /* Skip verify of deprecated_fp_regnum, invalid_p == 0 */
   /* Skip verify of deprecated_fp_regnum, invalid_p == 0 */

-  /* Skip verify of push_dummy_call, has predicate */
+  /* Skip verify of push_dummy_call, has predicate.  */

   /* Skip verify of call_dummy_location, invalid_p == 0 */
   /* Skip verify of call_dummy_location, invalid_p == 0 */

-  /* Skip verify of push_dummy_code, has predicate */
+  /* Skip verify of push_dummy_code, has predicate.  */

   /* Skip verify of print_registers_info, invalid_p == 0 */
   /* Skip verify of print_registers_info, invalid_p == 0 */

-  /* Skip verify of print_float_info, has predicate */
-  /* Skip verify of print_vector_info, has predicate */
+  /* Skip verify of print_float_info, has predicate.  */
+  /* Skip verify of print_vector_info, has predicate.  */

   /* Skip verify of register_sim_regno, invalid_p == 0 */
   /* Skip verify of cannot_fetch_register, invalid_p == 0 */
   /* Skip verify of cannot_store_register, invalid_p == 0 */
   /* Skip verify of register_sim_regno, invalid_p == 0 */
   /* Skip verify of cannot_fetch_register, invalid_p == 0 */
   /* Skip verify of cannot_store_register, invalid_p == 0 */

-  /* Skip verify of get_longjmp_target, has predicate */
+  /* Skip verify of get_longjmp_target, has predicate.  */

   /* Skip verify of convert_register_p, invalid_p == 0 */
   /* Skip verify of value_from_register, invalid_p == 0 */
   /* Skip verify of pointer_to_address, invalid_p == 0 */
   /* Skip verify of address_to_pointer, invalid_p == 0 */
   /* Skip verify of convert_register_p, invalid_p == 0 */
   /* Skip verify of value_from_register, invalid_p == 0 */
   /* Skip verify of pointer_to_address, invalid_p == 0 */
   /* Skip verify of address_to_pointer, invalid_p == 0 */

-  /* Skip verify of integer_to_address, has predicate */
-  /* Skip verify of return_value, has predicate */
-  if (current_gdbarch->skip_prologue == 0)
+  /* Skip verify of integer_to_address, has predicate.  */
+  /* Skip verify of return_value, has predicate.  */
+  /* Skip verify of return_in_first_hidden_param_p, invalid_p == 0 */
+  if (gdbarch->skip_prologue == 0)

     fprintf_unfiltered (log, "\n\tskip_prologue");
     fprintf_unfiltered (log, "\n\tskip_prologue");

-  if (current_gdbarch->inner_than == 0)
+  /* Skip verify of skip_main_prologue, has predicate.  */
+  if (gdbarch->inner_than == 0)

     fprintf_unfiltered (log, "\n\tinner_than");
     fprintf_unfiltered (log, "\n\tinner_than");

-  if (current_gdbarch->breakpoint_from_pc == 0)
+  if (gdbarch->breakpoint_from_pc == 0)

     fprintf_unfiltered (log, "\n\tbreakpoint_from_pc");
     fprintf_unfiltered (log, "\n\tbreakpoint_from_pc");

-  /* Skip verify of adjust_breakpoint_address, has predicate */
+  /* Skip verify of remote_breakpoint_from_pc, invalid_p == 0 */
+  /* Skip verify of adjust_breakpoint_address, has predicate.  */

   /* Skip verify of memory_insert_breakpoint, invalid_p == 0 */
   /* Skip verify of memory_remove_breakpoint, invalid_p == 0 */
   /* Skip verify of decr_pc_after_break, invalid_p == 0 */
   /* Skip verify of deprecated_function_start_offset, invalid_p == 0 */
   /* Skip verify of remote_register_number, invalid_p == 0 */
   /* Skip verify of memory_insert_breakpoint, invalid_p == 0 */
   /* Skip verify of memory_remove_breakpoint, invalid_p == 0 */
   /* Skip verify of decr_pc_after_break, invalid_p == 0 */
   /* Skip verify of deprecated_function_start_offset, invalid_p == 0 */
   /* Skip verify of remote_register_number, invalid_p == 0 */

-  /* Skip verify of fetch_tls_load_module_address, has predicate */
+  /* Skip verify of fetch_tls_load_module_address, has predicate.  */

   /* Skip verify of frame_args_skip, invalid_p == 0 */
   /* Skip verify of frame_args_skip, invalid_p == 0 */

-  /* Skip verify of unwind_pc, has predicate */
-  /* Skip verify of unwind_sp, has predicate */
-  /* Skip verify of frame_num_args, has predicate */
-  /* Skip verify of frame_align, has predicate */
+  /* Skip verify of unwind_pc, has predicate.  */
+  /* Skip verify of unwind_sp, has predicate.  */
+  /* Skip verify of frame_num_args, has predicate.  */
+  /* Skip verify of frame_align, has predicate.  */

   /* Skip verify of stabs_argument_has_addr, invalid_p == 0 */
   /* Skip verify of convert_from_func_ptr_addr, invalid_p == 0 */
   /* Skip verify of addr_bits_remove, invalid_p == 0 */
   /* Skip verify of smash_text_address, invalid_p == 0 */
   /* Skip verify of stabs_argument_has_addr, invalid_p == 0 */
   /* Skip verify of convert_from_func_ptr_addr, invalid_p == 0 */
   /* Skip verify of addr_bits_remove, invalid_p == 0 */
   /* Skip verify of smash_text_address, invalid_p == 0 */

-  /* Skip verify of software_single_step, has predicate */
-  /* Skip verify of single_step_through_delay, has predicate */
-  if (current_gdbarch->print_insn == 0)
+  /* Skip verify of software_single_step, has predicate.  */
+  /* Skip verify of single_step_through_delay, has predicate.  */
+  if (gdbarch->print_insn == 0)

     fprintf_unfiltered (log, "\n\tprint_insn");
   /* Skip verify of skip_trampoline_code, invalid_p == 0 */
   /* Skip verify of skip_solib_resolver, invalid_p == 0 */
   /* Skip verify of in_solib_return_trampoline, invalid_p == 0 */
   /* Skip verify of in_function_epilogue_p, invalid_p == 0 */
     fprintf_unfiltered (log, "\n\tprint_insn");
   /* Skip verify of skip_trampoline_code, invalid_p == 0 */
   /* Skip verify of skip_solib_resolver, invalid_p == 0 */
   /* Skip verify of in_solib_return_trampoline, invalid_p == 0 */
   /* Skip verify of in_function_epilogue_p, invalid_p == 0 */

-  /* Skip verify of construct_inferior_arguments, invalid_p == 0 */

   /* Skip verify of elf_make_msymbol_special, invalid_p == 0 */
   /* Skip verify of coff_make_msymbol_special, invalid_p == 0 */
   /* Skip verify of elf_make_msymbol_special, invalid_p == 0 */
   /* Skip verify of coff_make_msymbol_special, invalid_p == 0 */

-  /* Skip verify of name_of_malloc, invalid_p == 0 */

   /* Skip verify of cannot_step_breakpoint, invalid_p == 0 */
   /* Skip verify of have_nonsteppable_watchpoint, invalid_p == 0 */
   /* Skip verify of cannot_step_breakpoint, invalid_p == 0 */
   /* Skip verify of have_nonsteppable_watchpoint, invalid_p == 0 */

-  /* Skip verify of address_class_type_flags, has predicate */
-  /* 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 address_class_type_flags, has predicate.  */
+  /* 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 register_reggroup_p, invalid_p == 0 */

-  /* Skip verify of fetch_pointer_argument, has predicate */
-  /* Skip verify of regset_from_core_section, has predicate */
-  /* Skip verify of core_xfer_shared_libraries, has predicate */
+  /* Skip verify of fetch_pointer_argument, has predicate.  */
+  /* Skip verify of regset_from_core_section, has predicate.  */
+  /* Skip verify of make_corefile_notes, has predicate.  */
+  /* Skip verify of find_memory_regions, has predicate.  */
+  /* Skip verify of core_xfer_shared_libraries, has predicate.  */
+  /* Skip verify of core_pid_to_str, has predicate.  */
+  /* Skip verify of gcore_bfd_target, has predicate.  */

   /* Skip verify of vtable_function_descriptors, invalid_p == 0 */
   /* Skip verify of vbit_in_delta, invalid_p == 0 */
   /* Skip verify of vtable_function_descriptors, invalid_p == 0 */
   /* Skip verify of vbit_in_delta, invalid_p == 0 */

-  /* Skip verify of skip_permanent_breakpoint, has predicate */
-  /* Skip verify of overlay_update, has predicate */
-  /* Skip verify of core_read_description, has predicate */
-  /* Skip verify of static_transform_name, has predicate */
+  /* Skip verify of skip_permanent_breakpoint, has predicate.  */
+  /* Skip verify of max_insn_length, has predicate.  */
+  /* Skip verify of displaced_step_copy_insn, has predicate.  */
+  /* Skip verify of displaced_step_hw_singlestep, invalid_p == 0 */
+  /* Skip verify of displaced_step_fixup, has predicate.  */
+  if ((! gdbarch->displaced_step_free_closure) != (! gdbarch->displaced_step_copy_insn))
+    fprintf_unfiltered (log, "\n\tdisplaced_step_free_closure");
+  if ((! gdbarch->displaced_step_location) != (! gdbarch->displaced_step_copy_insn))
+    fprintf_unfiltered (log, "\n\tdisplaced_step_location");
+  /* Skip verify of relocate_instruction, has predicate.  */
+  /* Skip verify of overlay_update, has predicate.  */
+  /* Skip verify of core_read_description, has predicate.  */
+  /* Skip verify of static_transform_name, has predicate.  */

   /* Skip verify of sofun_address_maybe_missing, invalid_p == 0 */
   /* Skip verify of sofun_address_maybe_missing, invalid_p == 0 */

-  buf = ui_file_xstrdup (log, &dummy);
+  /* Skip verify of process_record, has predicate.  */
+  /* Skip verify of process_record_signal, has predicate.  */
+  /* Skip verify of gdb_signal_from_target, has predicate.  */
+  /* Skip verify of get_siginfo_type, has predicate.  */
+  /* Skip verify of record_special_symbol, has predicate.  */
+  /* Skip verify of get_syscall_number, has predicate.  */
+  /* Skip verify of stap_integer_prefix, invalid_p == 0 */
+  /* Skip verify of stap_integer_suffix, invalid_p == 0 */
+  /* Skip verify of stap_register_prefix, invalid_p == 0 */
+  /* Skip verify of stap_register_suffix, invalid_p == 0 */
+  /* Skip verify of stap_register_indirection_prefix, invalid_p == 0 */
+  /* Skip verify of stap_register_indirection_suffix, invalid_p == 0 */
+  /* Skip verify of stap_gdb_register_prefix, invalid_p == 0 */
+  /* Skip verify of stap_gdb_register_suffix, invalid_p == 0 */
+  /* Skip verify of stap_is_single_operand, has predicate.  */
+  /* Skip verify of stap_parse_special_token, has predicate.  */
+  /* Skip verify of has_global_solist, invalid_p == 0 */
+  /* Skip verify of has_global_breakpoints, invalid_p == 0 */
+  /* Skip verify of has_shared_address_space, invalid_p == 0 */
+  /* Skip verify of fast_tracepoint_valid_at, invalid_p == 0 */
+  /* Skip verify of auto_charset, invalid_p == 0 */
+  /* Skip verify of auto_wide_charset, invalid_p == 0 */
+  /* Skip verify of has_dos_based_file_system, invalid_p == 0 */
+  /* Skip verify of gen_return_address, invalid_p == 0 */
+  /* Skip verify of info_proc, has predicate.  */
+  /* Skip verify of iterate_over_objfiles_in_search_order, invalid_p == 0 */
+  buf = ui_file_xstrdup (log, &length);

   make_cleanup (xfree, buf);
   make_cleanup (xfree, buf);

-  if (strlen (buf) > 0)
+  if (length > 0)

     internal_error (__FILE__, __LINE__,
                     _("verify_gdbarch: the following are invalid ...%s"),
                     buf);
     internal_error (__FILE__, __LINE__,
                     _("verify_gdbarch: the following are invalid ...%s"),
                     buf);


@@ -606,442 +765,630 @@ verify_gdbarch (struct gdbarch *current_gdbarch)
 }
 
 
 }
 
 

-/* Print out the details of the current architecture. */
-
-/* NOTE/WARNING: The parameter is called ``current_gdbarch'' so that it
-   just happens to match the global variable ``current_gdbarch''.  That
-   way macros refering to that variable get the local and not the global
-   version - ulgh.  Once everything is parameterised with gdbarch, this
-   will go away. */
+/* Print out the details of the current architecture.  */

 
 void
 
 void

-gdbarch_dump (struct gdbarch *current_gdbarch, struct ui_file *file)
+gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file)

 {
 {

-  const char *gdb_xm_file = "<not-defined>";

   const char *gdb_nm_file = "<not-defined>";
   const char *gdb_nm_file = "<not-defined>";

-  const char *gdb_tm_file = "<not-defined>";
-#if defined (GDB_XM_FILE)
-  gdb_xm_file = GDB_XM_FILE;
-#endif
-  fprintf_unfiltered (file,
-                      "gdbarch_dump: GDB_XM_FILE = %s\n",
-                      gdb_xm_file);
+

 #if defined (GDB_NM_FILE)
   gdb_nm_file = GDB_NM_FILE;
 #endif
   fprintf_unfiltered (file,
                       "gdbarch_dump: GDB_NM_FILE = %s\n",
                       gdb_nm_file);
 #if defined (GDB_NM_FILE)
   gdb_nm_file = GDB_NM_FILE;
 #endif
   fprintf_unfiltered (file,
                       "gdbarch_dump: GDB_NM_FILE = %s\n",
                       gdb_nm_file);

-#if defined (GDB_TM_FILE)
-  gdb_tm_file = GDB_TM_FILE;
-#endif
-  fprintf_unfiltered (file,
-                      "gdbarch_dump: GDB_TM_FILE = %s\n",
-                      gdb_tm_file);

   fprintf_unfiltered (file,
                       "gdbarch_dump: addr_bit = %s\n",
   fprintf_unfiltered (file,
                       "gdbarch_dump: addr_bit = %s\n",

-                      paddr_d (current_gdbarch->addr_bit));
+                      plongest (gdbarch->addr_bit));

   fprintf_unfiltered (file,
   fprintf_unfiltered (file,

-                      "gdbarch_dump: addr_bits_remove = <0x%lx>\n",
-                      (long) current_gdbarch->addr_bits_remove);
+                      "gdbarch_dump: addr_bits_remove = <%s>\n",
+                      host_address_to_string (gdbarch->addr_bits_remove));

   fprintf_unfiltered (file,
                       "gdbarch_dump: gdbarch_address_class_name_to_type_flags_p() = %d\n",
   fprintf_unfiltered (file,
                       "gdbarch_dump: gdbarch_address_class_name_to_type_flags_p() = %d\n",

-                      gdbarch_address_class_name_to_type_flags_p (current_gdbarch));
+                      gdbarch_address_class_name_to_type_flags_p (gdbarch));

   fprintf_unfiltered (file,
   fprintf_unfiltered (file,

-                      "gdbarch_dump: address_class_name_to_type_flags = <0x%lx>\n",
-                      (long) current_gdbarch->address_class_name_to_type_flags);
+                      "gdbarch_dump: address_class_name_to_type_flags = <%s>\n",
+                      host_address_to_string (gdbarch->address_class_name_to_type_flags));

   fprintf_unfiltered (file,
                       "gdbarch_dump: gdbarch_address_class_type_flags_p() = %d\n",
   fprintf_unfiltered (file,
                       "gdbarch_dump: gdbarch_address_class_type_flags_p() = %d\n",

-                      gdbarch_address_class_type_flags_p (current_gdbarch));
+                      gdbarch_address_class_type_flags_p (gdbarch));

   fprintf_unfiltered (file,
   fprintf_unfiltered (file,

-                      "gdbarch_dump: address_class_type_flags = <0x%lx>\n",
-                      (long) current_gdbarch->address_class_type_flags);
+                      "gdbarch_dump: address_class_type_flags = <%s>\n",
+                      host_address_to_string (gdbarch->address_class_type_flags));

   fprintf_unfiltered (file,
                       "gdbarch_dump: gdbarch_address_class_type_flags_to_name_p() = %d\n",
   fprintf_unfiltered (file,
                       "gdbarch_dump: gdbarch_address_class_type_flags_to_name_p() = %d\n",

-                      gdbarch_address_class_type_flags_to_name_p (current_gdbarch));
+                      gdbarch_address_class_type_flags_to_name_p (gdbarch));

   fprintf_unfiltered (file,
   fprintf_unfiltered (file,

-                      "gdbarch_dump: address_class_type_flags_to_name = <0x%lx>\n",
-                      (long) current_gdbarch->address_class_type_flags_to_name);
+                      "gdbarch_dump: address_class_type_flags_to_name = <%s>\n",
+                      host_address_to_string (gdbarch->address_class_type_flags_to_name));

   fprintf_unfiltered (file,
   fprintf_unfiltered (file,

-                      "gdbarch_dump: address_to_pointer = <0x%lx>\n",
-                      (long) current_gdbarch->address_to_pointer);
+                      "gdbarch_dump: address_to_pointer = <%s>\n",
+                      host_address_to_string (gdbarch->address_to_pointer));

   fprintf_unfiltered (file,
                       "gdbarch_dump: gdbarch_adjust_breakpoint_address_p() = %d\n",
   fprintf_unfiltered (file,
                       "gdbarch_dump: gdbarch_adjust_breakpoint_address_p() = %d\n",

-                      gdbarch_adjust_breakpoint_address_p (current_gdbarch));
+                      gdbarch_adjust_breakpoint_address_p (gdbarch));
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: adjust_breakpoint_address = <%s>\n",
+                      host_address_to_string (gdbarch->adjust_breakpoint_address));
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: auto_charset = <%s>\n",
+                      host_address_to_string (gdbarch->auto_charset));
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: auto_wide_charset = <%s>\n",
+                      host_address_to_string (gdbarch->auto_wide_charset));

   fprintf_unfiltered (file,
   fprintf_unfiltered (file,

-                      "gdbarch_dump: adjust_breakpoint_address = <0x%lx>\n",
-                      (long) current_gdbarch->adjust_breakpoint_address);
+                      "gdbarch_dump: gdbarch_ax_pseudo_register_collect_p() = %d\n",
+                      gdbarch_ax_pseudo_register_collect_p (gdbarch));
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: ax_pseudo_register_collect = <%s>\n",
+                      host_address_to_string (gdbarch->ax_pseudo_register_collect));
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: gdbarch_ax_pseudo_register_push_stack_p() = %d\n",
+                      gdbarch_ax_pseudo_register_push_stack_p (gdbarch));
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: ax_pseudo_register_push_stack = <%s>\n",
+                      host_address_to_string (gdbarch->ax_pseudo_register_push_stack));

   fprintf_unfiltered (file,
                       "gdbarch_dump: believe_pcc_promotion = %s\n",
   fprintf_unfiltered (file,
                       "gdbarch_dump: believe_pcc_promotion = %s\n",

-                      paddr_d (current_gdbarch->believe_pcc_promotion));
+                      plongest (gdbarch->believe_pcc_promotion));

   fprintf_unfiltered (file,
                       "gdbarch_dump: bfd_arch_info = %s\n",
   fprintf_unfiltered (file,
                       "gdbarch_dump: bfd_arch_info = %s\n",

-                      gdbarch_bfd_arch_info (current_gdbarch)->printable_name);
+                      gdbarch_bfd_arch_info (gdbarch)->printable_name);
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: bits_big_endian = %s\n",
+                      plongest (gdbarch->bits_big_endian));

   fprintf_unfiltered (file,
   fprintf_unfiltered (file,

-                      "gdbarch_dump: breakpoint_from_pc = <0x%lx>\n",
-                      (long) current_gdbarch->breakpoint_from_pc);
+                      "gdbarch_dump: breakpoint_from_pc = <%s>\n",
+                      host_address_to_string (gdbarch->breakpoint_from_pc));

   fprintf_unfiltered (file,
                       "gdbarch_dump: byte_order = %s\n",
   fprintf_unfiltered (file,
                       "gdbarch_dump: byte_order = %s\n",

-                      paddr_d (current_gdbarch->byte_order));
+                      plongest (gdbarch->byte_order));
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: byte_order_for_code = %s\n",
+                      plongest (gdbarch->byte_order_for_code));

   fprintf_unfiltered (file,
                       "gdbarch_dump: call_dummy_location = %s\n",
   fprintf_unfiltered (file,
                       "gdbarch_dump: call_dummy_location = %s\n",

-                      paddr_d (current_gdbarch->call_dummy_location));
+                      plongest (gdbarch->call_dummy_location));

   fprintf_unfiltered (file,
   fprintf_unfiltered (file,

-                      "gdbarch_dump: cannot_fetch_register = <0x%lx>\n",
-                      (long) current_gdbarch->cannot_fetch_register);
+                      "gdbarch_dump: cannot_fetch_register = <%s>\n",
+                      host_address_to_string (gdbarch->cannot_fetch_register));

   fprintf_unfiltered (file,
                       "gdbarch_dump: cannot_step_breakpoint = %s\n",
   fprintf_unfiltered (file,
                       "gdbarch_dump: cannot_step_breakpoint = %s\n",

-                      paddr_d (current_gdbarch->cannot_step_breakpoint));
+                      plongest (gdbarch->cannot_step_breakpoint));

   fprintf_unfiltered (file,
   fprintf_unfiltered (file,

-                      "gdbarch_dump: cannot_store_register = <0x%lx>\n",
-                      (long) current_gdbarch->cannot_store_register);
+                      "gdbarch_dump: cannot_store_register = <%s>\n",
+                      host_address_to_string (gdbarch->cannot_store_register));

   fprintf_unfiltered (file,
                       "gdbarch_dump: char_signed = %s\n",
   fprintf_unfiltered (file,
                       "gdbarch_dump: char_signed = %s\n",

-                      paddr_d (current_gdbarch->char_signed));
+                      plongest (gdbarch->char_signed));
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: coff_make_msymbol_special = <%s>\n",
+                      host_address_to_string (gdbarch->coff_make_msymbol_special));

   fprintf_unfiltered (file,
   fprintf_unfiltered (file,

-                      "gdbarch_dump: coff_make_msymbol_special = <0x%lx>\n",
-                      (long) current_gdbarch->coff_make_msymbol_special);
+                      "gdbarch_dump: convert_from_func_ptr_addr = <%s>\n",
+                      host_address_to_string (gdbarch->convert_from_func_ptr_addr));

   fprintf_unfiltered (file,
   fprintf_unfiltered (file,

-                      "gdbarch_dump: construct_inferior_arguments = <0x%lx>\n",
-                      (long) current_gdbarch->construct_inferior_arguments);
+                      "gdbarch_dump: convert_register_p = <%s>\n",
+                      host_address_to_string (gdbarch->convert_register_p));

   fprintf_unfiltered (file,
   fprintf_unfiltered (file,

-                      "gdbarch_dump: convert_from_func_ptr_addr = <0x%lx>\n",
-                      (long) current_gdbarch->convert_from_func_ptr_addr);
+                      "gdbarch_dump: gdbarch_core_pid_to_str_p() = %d\n",
+                      gdbarch_core_pid_to_str_p (gdbarch));

   fprintf_unfiltered (file,
   fprintf_unfiltered (file,

-                      "gdbarch_dump: convert_register_p = <0x%lx>\n",
-                      (long) current_gdbarch->convert_register_p);
+                      "gdbarch_dump: core_pid_to_str = <%s>\n",
+                      host_address_to_string (gdbarch->core_pid_to_str));

   fprintf_unfiltered (file,
                       "gdbarch_dump: gdbarch_core_read_description_p() = %d\n",
   fprintf_unfiltered (file,
                       "gdbarch_dump: gdbarch_core_read_description_p() = %d\n",

-                      gdbarch_core_read_description_p (current_gdbarch));
+                      gdbarch_core_read_description_p (gdbarch));

   fprintf_unfiltered (file,
   fprintf_unfiltered (file,

-                      "gdbarch_dump: core_read_description = <0x%lx>\n",
-                      (long) current_gdbarch->core_read_description);
+                      "gdbarch_dump: core_read_description = <%s>\n",
+                      host_address_to_string (gdbarch->core_read_description));
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: core_regset_sections = %s\n",
+                      host_address_to_string (gdbarch->core_regset_sections));

   fprintf_unfiltered (file,
                       "gdbarch_dump: gdbarch_core_xfer_shared_libraries_p() = %d\n",
   fprintf_unfiltered (file,
                       "gdbarch_dump: gdbarch_core_xfer_shared_libraries_p() = %d\n",

-                      gdbarch_core_xfer_shared_libraries_p (current_gdbarch));
+                      gdbarch_core_xfer_shared_libraries_p (gdbarch));

   fprintf_unfiltered (file,
   fprintf_unfiltered (file,

-                      "gdbarch_dump: core_xfer_shared_libraries = <0x%lx>\n",
-                      (long) current_gdbarch->core_xfer_shared_libraries);
+                      "gdbarch_dump: core_xfer_shared_libraries = <%s>\n",
+                      host_address_to_string (gdbarch->core_xfer_shared_libraries));

   fprintf_unfiltered (file,
   fprintf_unfiltered (file,

-                      "gdbarch_dump: decr_pc_after_break = 0x%s\n",
-                      paddr_nz (current_gdbarch->decr_pc_after_break));
+                      "gdbarch_dump: decr_pc_after_break = %s\n",
+                      core_addr_to_string_nz (gdbarch->decr_pc_after_break));

   fprintf_unfiltered (file,
                       "gdbarch_dump: deprecated_fp_regnum = %s\n",
   fprintf_unfiltered (file,
                       "gdbarch_dump: deprecated_fp_regnum = %s\n",

-                      paddr_d (current_gdbarch->deprecated_fp_regnum));
+                      plongest (gdbarch->deprecated_fp_regnum));
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: deprecated_function_start_offset = %s\n",
+                      core_addr_to_string_nz (gdbarch->deprecated_function_start_offset));
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: gdbarch_displaced_step_copy_insn_p() = %d\n",
+                      gdbarch_displaced_step_copy_insn_p (gdbarch));
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: displaced_step_copy_insn = <%s>\n",
+                      host_address_to_string (gdbarch->displaced_step_copy_insn));
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: gdbarch_displaced_step_fixup_p() = %d\n",
+                      gdbarch_displaced_step_fixup_p (gdbarch));
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: displaced_step_fixup = <%s>\n",
+                      host_address_to_string (gdbarch->displaced_step_fixup));

   fprintf_unfiltered (file,
   fprintf_unfiltered (file,

-                      "gdbarch_dump: deprecated_function_start_offset = 0x%s\n",
-                      paddr_nz (current_gdbarch->deprecated_function_start_offset));
+                      "gdbarch_dump: displaced_step_free_closure = <%s>\n",
+                      host_address_to_string (gdbarch->displaced_step_free_closure));
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: displaced_step_hw_singlestep = <%s>\n",
+                      host_address_to_string (gdbarch->displaced_step_hw_singlestep));
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: displaced_step_location = <%s>\n",
+                      host_address_to_string (gdbarch->displaced_step_location));

   fprintf_unfiltered (file,
                       "gdbarch_dump: double_bit = %s\n",
   fprintf_unfiltered (file,
                       "gdbarch_dump: double_bit = %s\n",

-                      paddr_d (current_gdbarch->double_bit));
+                      plongest (gdbarch->double_bit));

   fprintf_unfiltered (file,
                       "gdbarch_dump: double_format = %s\n",
   fprintf_unfiltered (file,
                       "gdbarch_dump: double_format = %s\n",

-                      pformat (current_gdbarch->double_format));
+                      pformat (gdbarch->double_format));
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: gdbarch_dummy_id_p() = %d\n",
+                      gdbarch_dummy_id_p (gdbarch));
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: dummy_id = <%s>\n",
+                      host_address_to_string (gdbarch->dummy_id));

   fprintf_unfiltered (file,
   fprintf_unfiltered (file,

-                      "gdbarch_dump: dwarf2_reg_to_regnum = <0x%lx>\n",
-                      (long) current_gdbarch->dwarf2_reg_to_regnum);
+                      "gdbarch_dump: dwarf2_addr_size = %s\n",
+                      plongest (gdbarch->dwarf2_addr_size));

   fprintf_unfiltered (file,
   fprintf_unfiltered (file,

-                      "gdbarch_dump: dwarf_reg_to_regnum = <0x%lx>\n",
-                      (long) current_gdbarch->dwarf_reg_to_regnum);
+                      "gdbarch_dump: dwarf2_reg_to_regnum = <%s>\n",
+                      host_address_to_string (gdbarch->dwarf2_reg_to_regnum));

   fprintf_unfiltered (file,
   fprintf_unfiltered (file,

-                      "gdbarch_dump: ecoff_reg_to_regnum = <0x%lx>\n",
-                      (long) current_gdbarch->ecoff_reg_to_regnum);
+                      "gdbarch_dump: ecoff_reg_to_regnum = <%s>\n",
+                      host_address_to_string (gdbarch->ecoff_reg_to_regnum));

   fprintf_unfiltered (file,
   fprintf_unfiltered (file,

-                      "gdbarch_dump: elf_make_msymbol_special = <0x%lx>\n",
-                      (long) current_gdbarch->elf_make_msymbol_special);
+                      "gdbarch_dump: elf_make_msymbol_special = <%s>\n",
+                      host_address_to_string (gdbarch->elf_make_msymbol_special));
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: fast_tracepoint_valid_at = <%s>\n",
+                      host_address_to_string (gdbarch->fast_tracepoint_valid_at));

   fprintf_unfiltered (file,
                       "gdbarch_dump: gdbarch_fetch_pointer_argument_p() = %d\n",
   fprintf_unfiltered (file,
                       "gdbarch_dump: gdbarch_fetch_pointer_argument_p() = %d\n",

-                      gdbarch_fetch_pointer_argument_p (current_gdbarch));
+                      gdbarch_fetch_pointer_argument_p (gdbarch));

   fprintf_unfiltered (file,
   fprintf_unfiltered (file,

-                      "gdbarch_dump: fetch_pointer_argument = <0x%lx>\n",
-                      (long) current_gdbarch->fetch_pointer_argument);
+                      "gdbarch_dump: fetch_pointer_argument = <%s>\n",
+                      host_address_to_string (gdbarch->fetch_pointer_argument));

   fprintf_unfiltered (file,
                       "gdbarch_dump: gdbarch_fetch_tls_load_module_address_p() = %d\n",
   fprintf_unfiltered (file,
                       "gdbarch_dump: gdbarch_fetch_tls_load_module_address_p() = %d\n",

-                      gdbarch_fetch_tls_load_module_address_p (current_gdbarch));
+                      gdbarch_fetch_tls_load_module_address_p (gdbarch));
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: fetch_tls_load_module_address = <%s>\n",
+                      host_address_to_string (gdbarch->fetch_tls_load_module_address));

   fprintf_unfiltered (file,
   fprintf_unfiltered (file,

-                      "gdbarch_dump: fetch_tls_load_module_address = <0x%lx>\n",
-                      (long) current_gdbarch->fetch_tls_load_module_address);
+                      "gdbarch_dump: gdbarch_find_memory_regions_p() = %d\n",
+                      gdbarch_find_memory_regions_p (gdbarch));
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: find_memory_regions = <%s>\n",
+                      host_address_to_string (gdbarch->find_memory_regions));

   fprintf_unfiltered (file,
                       "gdbarch_dump: float_bit = %s\n",
   fprintf_unfiltered (file,
                       "gdbarch_dump: float_bit = %s\n",

-                      paddr_d (current_gdbarch->float_bit));
+                      plongest (gdbarch->float_bit));

   fprintf_unfiltered (file,
                       "gdbarch_dump: float_format = %s\n",
   fprintf_unfiltered (file,
                       "gdbarch_dump: float_format = %s\n",

-                      pformat (current_gdbarch->float_format));
+                      pformat (gdbarch->float_format));

   fprintf_unfiltered (file,
                       "gdbarch_dump: fp0_regnum = %s\n",
   fprintf_unfiltered (file,
                       "gdbarch_dump: fp0_regnum = %s\n",

-                      paddr_d (current_gdbarch->fp0_regnum));
+                      plongest (gdbarch->fp0_regnum));

   fprintf_unfiltered (file,
                       "gdbarch_dump: gdbarch_frame_align_p() = %d\n",
   fprintf_unfiltered (file,
                       "gdbarch_dump: gdbarch_frame_align_p() = %d\n",

-                      gdbarch_frame_align_p (current_gdbarch));
+                      gdbarch_frame_align_p (gdbarch));

   fprintf_unfiltered (file,
   fprintf_unfiltered (file,

-                      "gdbarch_dump: frame_align = <0x%lx>\n",
-                      (long) current_gdbarch->frame_align);
+                      "gdbarch_dump: frame_align = <%s>\n",
+                      host_address_to_string (gdbarch->frame_align));

   fprintf_unfiltered (file,
   fprintf_unfiltered (file,

-                      "gdbarch_dump: frame_args_skip = 0x%s\n",
-                      paddr_nz (current_gdbarch->frame_args_skip));
+                      "gdbarch_dump: frame_args_skip = %s\n",
+                      core_addr_to_string_nz (gdbarch->frame_args_skip));

   fprintf_unfiltered (file,
                       "gdbarch_dump: gdbarch_frame_num_args_p() = %d\n",
   fprintf_unfiltered (file,
                       "gdbarch_dump: gdbarch_frame_num_args_p() = %d\n",

-                      gdbarch_frame_num_args_p (current_gdbarch));
+                      gdbarch_frame_num_args_p (gdbarch));

   fprintf_unfiltered (file,
   fprintf_unfiltered (file,

-                      "gdbarch_dump: frame_num_args = <0x%lx>\n",
-                      (long) current_gdbarch->frame_num_args);
+                      "gdbarch_dump: frame_num_args = <%s>\n",
+                      host_address_to_string (gdbarch->frame_num_args));

   fprintf_unfiltered (file,
                       "gdbarch_dump: frame_red_zone_size = %s\n",
   fprintf_unfiltered (file,
                       "gdbarch_dump: frame_red_zone_size = %s\n",

-                      paddr_d (current_gdbarch->frame_red_zone_size));
+                      plongest (gdbarch->frame_red_zone_size));
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: gdbarch_gcore_bfd_target_p() = %d\n",
+                      gdbarch_gcore_bfd_target_p (gdbarch));
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: gcore_bfd_target = %s\n",
+                      pstring (gdbarch->gcore_bfd_target));
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: gdbarch_gdb_signal_from_target_p() = %d\n",
+                      gdbarch_gdb_signal_from_target_p (gdbarch));
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: gdb_signal_from_target = <%s>\n",
+                      host_address_to_string (gdbarch->gdb_signal_from_target));
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: gen_return_address = <%s>\n",
+                      host_address_to_string (gdbarch->gen_return_address));

   fprintf_unfiltered (file,
                       "gdbarch_dump: gdbarch_get_longjmp_target_p() = %d\n",
   fprintf_unfiltered (file,
                       "gdbarch_dump: gdbarch_get_longjmp_target_p() = %d\n",

-                      gdbarch_get_longjmp_target_p (current_gdbarch));
+                      gdbarch_get_longjmp_target_p (gdbarch));
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: get_longjmp_target = <%s>\n",
+                      host_address_to_string (gdbarch->get_longjmp_target));
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: gdbarch_get_siginfo_type_p() = %d\n",
+                      gdbarch_get_siginfo_type_p (gdbarch));
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: get_siginfo_type = <%s>\n",
+                      host_address_to_string (gdbarch->get_siginfo_type));
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: gdbarch_get_syscall_number_p() = %d\n",
+                      gdbarch_get_syscall_number_p (gdbarch));

   fprintf_unfiltered (file,
   fprintf_unfiltered (file,

-                      "gdbarch_dump: get_longjmp_target = <0x%lx>\n",
-                      (long) current_gdbarch->get_longjmp_target);
+                      "gdbarch_dump: get_syscall_number = <%s>\n",
+                      host_address_to_string (gdbarch->get_syscall_number));
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: half_bit = %s\n",
+                      plongest (gdbarch->half_bit));
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: half_format = %s\n",
+                      pformat (gdbarch->half_format));
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: has_dos_based_file_system = %s\n",
+                      plongest (gdbarch->has_dos_based_file_system));
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: has_global_breakpoints = %s\n",
+                      plongest (gdbarch->has_global_breakpoints));
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: has_global_solist = %s\n",
+                      plongest (gdbarch->has_global_solist));
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: has_shared_address_space = <%s>\n",
+                      host_address_to_string (gdbarch->has_shared_address_space));

   fprintf_unfiltered (file,
                       "gdbarch_dump: have_nonsteppable_watchpoint = %s\n",
   fprintf_unfiltered (file,
                       "gdbarch_dump: have_nonsteppable_watchpoint = %s\n",

-                      paddr_d (current_gdbarch->have_nonsteppable_watchpoint));
+                      plongest (gdbarch->have_nonsteppable_watchpoint));
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: in_function_epilogue_p = <%s>\n",
+                      host_address_to_string (gdbarch->in_function_epilogue_p));
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: in_solib_return_trampoline = <%s>\n",
+                      host_address_to_string (gdbarch->in_solib_return_trampoline));

   fprintf_unfiltered (file,
   fprintf_unfiltered (file,

-                      "gdbarch_dump: in_function_epilogue_p = <0x%lx>\n",
-                      (long) current_gdbarch->in_function_epilogue_p);
+                      "gdbarch_dump: gdbarch_info_proc_p() = %d\n",
+                      gdbarch_info_proc_p (gdbarch));

   fprintf_unfiltered (file,
   fprintf_unfiltered (file,

-                      "gdbarch_dump: in_solib_return_trampoline = <0x%lx>\n",
-                      (long) current_gdbarch->in_solib_return_trampoline);
+                      "gdbarch_dump: info_proc = <%s>\n",
+                      host_address_to_string (gdbarch->info_proc));

   fprintf_unfiltered (file,
   fprintf_unfiltered (file,

-                      "gdbarch_dump: inner_than = <0x%lx>\n",
-                      (long) current_gdbarch->inner_than);
+                      "gdbarch_dump: inner_than = <%s>\n",
+                      host_address_to_string (gdbarch->inner_than));

   fprintf_unfiltered (file,
                       "gdbarch_dump: int_bit = %s\n",
   fprintf_unfiltered (file,
                       "gdbarch_dump: int_bit = %s\n",

-                      paddr_d (current_gdbarch->int_bit));
+                      plongest (gdbarch->int_bit));

   fprintf_unfiltered (file,
                       "gdbarch_dump: gdbarch_integer_to_address_p() = %d\n",
   fprintf_unfiltered (file,
                       "gdbarch_dump: gdbarch_integer_to_address_p() = %d\n",

-                      gdbarch_integer_to_address_p (current_gdbarch));
+                      gdbarch_integer_to_address_p (gdbarch));

   fprintf_unfiltered (file,
   fprintf_unfiltered (file,

-                      "gdbarch_dump: integer_to_address = <0x%lx>\n",
-                      (long) current_gdbarch->integer_to_address);
+                      "gdbarch_dump: integer_to_address = <%s>\n",
+                      host_address_to_string (gdbarch->integer_to_address));
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: iterate_over_objfiles_in_search_order = <%s>\n",
+                      host_address_to_string (gdbarch->iterate_over_objfiles_in_search_order));

   fprintf_unfiltered (file,
                       "gdbarch_dump: long_bit = %s\n",
   fprintf_unfiltered (file,
                       "gdbarch_dump: long_bit = %s\n",

-                      paddr_d (current_gdbarch->long_bit));
+                      plongest (gdbarch->long_bit));

   fprintf_unfiltered (file,
                       "gdbarch_dump: long_double_bit = %s\n",
   fprintf_unfiltered (file,
                       "gdbarch_dump: long_double_bit = %s\n",

-                      paddr_d (current_gdbarch->long_double_bit));
+                      plongest (gdbarch->long_double_bit));

   fprintf_unfiltered (file,
                       "gdbarch_dump: long_double_format = %s\n",
   fprintf_unfiltered (file,
                       "gdbarch_dump: long_double_format = %s\n",

-                      pformat (current_gdbarch->long_double_format));
+                      pformat (gdbarch->long_double_format));
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: long_long_align_bit = %s\n",
+                      plongest (gdbarch->long_long_align_bit));

   fprintf_unfiltered (file,
                       "gdbarch_dump: long_long_bit = %s\n",
   fprintf_unfiltered (file,
                       "gdbarch_dump: long_long_bit = %s\n",

-                      paddr_d (current_gdbarch->long_long_bit));
+                      plongest (gdbarch->long_long_bit));
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: gdbarch_make_corefile_notes_p() = %d\n",
+                      gdbarch_make_corefile_notes_p (gdbarch));
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: make_corefile_notes = <%s>\n",
+                      host_address_to_string (gdbarch->make_corefile_notes));

   fprintf_unfiltered (file,
   fprintf_unfiltered (file,

-                      "gdbarch_dump: memory_insert_breakpoint = <0x%lx>\n",
-                      (long) current_gdbarch->memory_insert_breakpoint);
+                      "gdbarch_dump: gdbarch_max_insn_length_p() = %d\n",
+                      gdbarch_max_insn_length_p (gdbarch));

   fprintf_unfiltered (file,
   fprintf_unfiltered (file,

-                      "gdbarch_dump: memory_remove_breakpoint = <0x%lx>\n",
-                      (long) current_gdbarch->memory_remove_breakpoint);
+                      "gdbarch_dump: max_insn_length = %s\n",
+                      plongest (gdbarch->max_insn_length));

   fprintf_unfiltered (file,
   fprintf_unfiltered (file,

-                      "gdbarch_dump: name_of_malloc = %s\n",
-                      current_gdbarch->name_of_malloc);
+                      "gdbarch_dump: memory_insert_breakpoint = <%s>\n",
+                      host_address_to_string (gdbarch->memory_insert_breakpoint));
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: memory_remove_breakpoint = <%s>\n",
+                      host_address_to_string (gdbarch->memory_remove_breakpoint));

   fprintf_unfiltered (file,
                       "gdbarch_dump: num_pseudo_regs = %s\n",
   fprintf_unfiltered (file,
                       "gdbarch_dump: num_pseudo_regs = %s\n",

-                      paddr_d (current_gdbarch->num_pseudo_regs));
+                      plongest (gdbarch->num_pseudo_regs));

   fprintf_unfiltered (file,
                       "gdbarch_dump: num_regs = %s\n",
   fprintf_unfiltered (file,
                       "gdbarch_dump: num_regs = %s\n",

-                      paddr_d (current_gdbarch->num_regs));
+                      plongest (gdbarch->num_regs));

   fprintf_unfiltered (file,
                       "gdbarch_dump: osabi = %s\n",
   fprintf_unfiltered (file,
                       "gdbarch_dump: osabi = %s\n",

-                      paddr_d (current_gdbarch->osabi));
+                      plongest (gdbarch->osabi));

   fprintf_unfiltered (file,
                       "gdbarch_dump: gdbarch_overlay_update_p() = %d\n",
   fprintf_unfiltered (file,
                       "gdbarch_dump: gdbarch_overlay_update_p() = %d\n",

-                      gdbarch_overlay_update_p (current_gdbarch));
+                      gdbarch_overlay_update_p (gdbarch));

   fprintf_unfiltered (file,
   fprintf_unfiltered (file,

-                      "gdbarch_dump: overlay_update = <0x%lx>\n",
-                      (long) current_gdbarch->overlay_update);
+                      "gdbarch_dump: overlay_update = <%s>\n",
+                      host_address_to_string (gdbarch->overlay_update));

   fprintf_unfiltered (file,
                       "gdbarch_dump: pc_regnum = %s\n",
   fprintf_unfiltered (file,
                       "gdbarch_dump: pc_regnum = %s\n",

-                      paddr_d (current_gdbarch->pc_regnum));
+                      plongest (gdbarch->pc_regnum));

   fprintf_unfiltered (file,
   fprintf_unfiltered (file,

-                      "gdbarch_dump: pointer_to_address = <0x%lx>\n",
-                      (long) current_gdbarch->pointer_to_address);
+                      "gdbarch_dump: pointer_to_address = <%s>\n",
+                      host_address_to_string (gdbarch->pointer_to_address));

   fprintf_unfiltered (file,
                       "gdbarch_dump: gdbarch_print_float_info_p() = %d\n",
   fprintf_unfiltered (file,
                       "gdbarch_dump: gdbarch_print_float_info_p() = %d\n",

-                      gdbarch_print_float_info_p (current_gdbarch));
+                      gdbarch_print_float_info_p (gdbarch));

   fprintf_unfiltered (file,
   fprintf_unfiltered (file,

-                      "gdbarch_dump: print_float_info = <0x%lx>\n",
-                      (long) current_gdbarch->print_float_info);
+                      "gdbarch_dump: print_float_info = <%s>\n",
+                      host_address_to_string (gdbarch->print_float_info));

   fprintf_unfiltered (file,
   fprintf_unfiltered (file,

-                      "gdbarch_dump: print_insn = <0x%lx>\n",
-                      (long) current_gdbarch->print_insn);
+                      "gdbarch_dump: print_insn = <%s>\n",
+                      host_address_to_string (gdbarch->print_insn));

   fprintf_unfiltered (file,
   fprintf_unfiltered (file,

-                      "gdbarch_dump: print_registers_info = <0x%lx>\n",
-                      (long) current_gdbarch->print_registers_info);
+                      "gdbarch_dump: print_registers_info = <%s>\n",
+                      host_address_to_string (gdbarch->print_registers_info));

   fprintf_unfiltered (file,
                       "gdbarch_dump: gdbarch_print_vector_info_p() = %d\n",
   fprintf_unfiltered (file,
                       "gdbarch_dump: gdbarch_print_vector_info_p() = %d\n",

-                      gdbarch_print_vector_info_p (current_gdbarch));
+                      gdbarch_print_vector_info_p (gdbarch));
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: print_vector_info = <%s>\n",
+                      host_address_to_string (gdbarch->print_vector_info));
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: gdbarch_process_record_p() = %d\n",
+                      gdbarch_process_record_p (gdbarch));
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: process_record = <%s>\n",
+                      host_address_to_string (gdbarch->process_record));

   fprintf_unfiltered (file,
   fprintf_unfiltered (file,

-                      "gdbarch_dump: print_vector_info = <0x%lx>\n",
-                      (long) current_gdbarch->print_vector_info);
+                      "gdbarch_dump: gdbarch_process_record_signal_p() = %d\n",
+                      gdbarch_process_record_signal_p (gdbarch));
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: process_record_signal = <%s>\n",
+                      host_address_to_string (gdbarch->process_record_signal));

   fprintf_unfiltered (file,
                       "gdbarch_dump: ps_regnum = %s\n",
   fprintf_unfiltered (file,
                       "gdbarch_dump: ps_regnum = %s\n",

-                      paddr_d (current_gdbarch->ps_regnum));
+                      plongest (gdbarch->ps_regnum));

   fprintf_unfiltered (file,
                       "gdbarch_dump: gdbarch_pseudo_register_read_p() = %d\n",
   fprintf_unfiltered (file,
                       "gdbarch_dump: gdbarch_pseudo_register_read_p() = %d\n",

-                      gdbarch_pseudo_register_read_p (current_gdbarch));
+                      gdbarch_pseudo_register_read_p (gdbarch));
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: pseudo_register_read = <%s>\n",
+                      host_address_to_string (gdbarch->pseudo_register_read));

   fprintf_unfiltered (file,
   fprintf_unfiltered (file,

-                      "gdbarch_dump: pseudo_register_read = <0x%lx>\n",
-                      (long) current_gdbarch->pseudo_register_read);
+                      "gdbarch_dump: gdbarch_pseudo_register_read_value_p() = %d\n",
+                      gdbarch_pseudo_register_read_value_p (gdbarch));
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: pseudo_register_read_value = <%s>\n",
+                      host_address_to_string (gdbarch->pseudo_register_read_value));

   fprintf_unfiltered (file,
                       "gdbarch_dump: gdbarch_pseudo_register_write_p() = %d\n",
   fprintf_unfiltered (file,
                       "gdbarch_dump: gdbarch_pseudo_register_write_p() = %d\n",

-                      gdbarch_pseudo_register_write_p (current_gdbarch));
+                      gdbarch_pseudo_register_write_p (gdbarch));

   fprintf_unfiltered (file,
   fprintf_unfiltered (file,

-                      "gdbarch_dump: pseudo_register_write = <0x%lx>\n",
-                      (long) current_gdbarch->pseudo_register_write);
+                      "gdbarch_dump: pseudo_register_write = <%s>\n",
+                      host_address_to_string (gdbarch->pseudo_register_write));

   fprintf_unfiltered (file,
                       "gdbarch_dump: ptr_bit = %s\n",
   fprintf_unfiltered (file,
                       "gdbarch_dump: ptr_bit = %s\n",

-                      paddr_d (current_gdbarch->ptr_bit));
+                      plongest (gdbarch->ptr_bit));

   fprintf_unfiltered (file,
                       "gdbarch_dump: gdbarch_push_dummy_call_p() = %d\n",
   fprintf_unfiltered (file,
                       "gdbarch_dump: gdbarch_push_dummy_call_p() = %d\n",

-                      gdbarch_push_dummy_call_p (current_gdbarch));
+                      gdbarch_push_dummy_call_p (gdbarch));

   fprintf_unfiltered (file,
   fprintf_unfiltered (file,

-                      "gdbarch_dump: push_dummy_call = <0x%lx>\n",
-                      (long) current_gdbarch->push_dummy_call);
+                      "gdbarch_dump: push_dummy_call = <%s>\n",
+                      host_address_to_string (gdbarch->push_dummy_call));

   fprintf_unfiltered (file,
                       "gdbarch_dump: gdbarch_push_dummy_code_p() = %d\n",
   fprintf_unfiltered (file,
                       "gdbarch_dump: gdbarch_push_dummy_code_p() = %d\n",

-                      gdbarch_push_dummy_code_p (current_gdbarch));
+                      gdbarch_push_dummy_code_p (gdbarch));

   fprintf_unfiltered (file,
   fprintf_unfiltered (file,

-                      "gdbarch_dump: push_dummy_code = <0x%lx>\n",
-                      (long) current_gdbarch->push_dummy_code);
+                      "gdbarch_dump: push_dummy_code = <%s>\n",
+                      host_address_to_string (gdbarch->push_dummy_code));

   fprintf_unfiltered (file,
                       "gdbarch_dump: gdbarch_read_pc_p() = %d\n",
   fprintf_unfiltered (file,
                       "gdbarch_dump: gdbarch_read_pc_p() = %d\n",

-                      gdbarch_read_pc_p (current_gdbarch));
+                      gdbarch_read_pc_p (gdbarch));
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: read_pc = <%s>\n",
+                      host_address_to_string (gdbarch->read_pc));

   fprintf_unfiltered (file,
   fprintf_unfiltered (file,

-                      "gdbarch_dump: read_pc = <0x%lx>\n",
-                      (long) current_gdbarch->read_pc);
+                      "gdbarch_dump: gdbarch_record_special_symbol_p() = %d\n",
+                      gdbarch_record_special_symbol_p (gdbarch));

   fprintf_unfiltered (file,
   fprintf_unfiltered (file,

-                      "gdbarch_dump: register_name = <0x%lx>\n",
-                      (long) current_gdbarch->register_name);
+                      "gdbarch_dump: record_special_symbol = <%s>\n",
+                      host_address_to_string (gdbarch->record_special_symbol));

   fprintf_unfiltered (file,
   fprintf_unfiltered (file,

-                      "gdbarch_dump: register_reggroup_p = <0x%lx>\n",
-                      (long) current_gdbarch->register_reggroup_p);
+                      "gdbarch_dump: register_name = <%s>\n",
+                      host_address_to_string (gdbarch->register_name));

   fprintf_unfiltered (file,
   fprintf_unfiltered (file,

-                      "gdbarch_dump: register_sim_regno = <0x%lx>\n",
-                      (long) current_gdbarch->register_sim_regno);
+                      "gdbarch_dump: register_reggroup_p = <%s>\n",
+                      host_address_to_string (gdbarch->register_reggroup_p));

   fprintf_unfiltered (file,
   fprintf_unfiltered (file,

-                      "gdbarch_dump: register_to_value = <0x%lx>\n",
-                      (long) current_gdbarch->register_to_value);
+                      "gdbarch_dump: register_sim_regno = <%s>\n",
+                      host_address_to_string (gdbarch->register_sim_regno));
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: register_to_value = <%s>\n",
+                      host_address_to_string (gdbarch->register_to_value));

   fprintf_unfiltered (file,
                       "gdbarch_dump: gdbarch_register_type_p() = %d\n",
   fprintf_unfiltered (file,
                       "gdbarch_dump: gdbarch_register_type_p() = %d\n",

-                      gdbarch_register_type_p (current_gdbarch));
+                      gdbarch_register_type_p (gdbarch));

   fprintf_unfiltered (file,
   fprintf_unfiltered (file,

-                      "gdbarch_dump: register_type = <0x%lx>\n",
-                      (long) current_gdbarch->register_type);
+                      "gdbarch_dump: register_type = <%s>\n",
+                      host_address_to_string (gdbarch->register_type));

   fprintf_unfiltered (file,
                       "gdbarch_dump: gdbarch_regset_from_core_section_p() = %d\n",
   fprintf_unfiltered (file,
                       "gdbarch_dump: gdbarch_regset_from_core_section_p() = %d\n",

-                      gdbarch_regset_from_core_section_p (current_gdbarch));
+                      gdbarch_regset_from_core_section_p (gdbarch));
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: regset_from_core_section = <%s>\n",
+                      host_address_to_string (gdbarch->regset_from_core_section));
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: gdbarch_relocate_instruction_p() = %d\n",
+                      gdbarch_relocate_instruction_p (gdbarch));
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: relocate_instruction = <%s>\n",
+                      host_address_to_string (gdbarch->relocate_instruction));

   fprintf_unfiltered (file,
   fprintf_unfiltered (file,

-                      "gdbarch_dump: regset_from_core_section = <0x%lx>\n",
-                      (long) current_gdbarch->regset_from_core_section);
+                      "gdbarch_dump: remote_breakpoint_from_pc = <%s>\n",
+                      host_address_to_string (gdbarch->remote_breakpoint_from_pc));

   fprintf_unfiltered (file,
   fprintf_unfiltered (file,

-                      "gdbarch_dump: remote_register_number = <0x%lx>\n",
-                      (long) current_gdbarch->remote_register_number);
+                      "gdbarch_dump: remote_register_number = <%s>\n",
+                      host_address_to_string (gdbarch->remote_register_number));
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: return_in_first_hidden_param_p = <%s>\n",
+                      host_address_to_string (gdbarch->return_in_first_hidden_param_p));

   fprintf_unfiltered (file,
                       "gdbarch_dump: gdbarch_return_value_p() = %d\n",
   fprintf_unfiltered (file,
                       "gdbarch_dump: gdbarch_return_value_p() = %d\n",

-                      gdbarch_return_value_p (current_gdbarch));
+                      gdbarch_return_value_p (gdbarch));

   fprintf_unfiltered (file,
   fprintf_unfiltered (file,

-                      "gdbarch_dump: return_value = <0x%lx>\n",
-                      (long) current_gdbarch->return_value);
+                      "gdbarch_dump: return_value = <%s>\n",
+                      host_address_to_string (gdbarch->return_value));

   fprintf_unfiltered (file,
   fprintf_unfiltered (file,

-                      "gdbarch_dump: sdb_reg_to_regnum = <0x%lx>\n",
-                      (long) current_gdbarch->sdb_reg_to_regnum);
+                      "gdbarch_dump: sdb_reg_to_regnum = <%s>\n",
+                      host_address_to_string (gdbarch->sdb_reg_to_regnum));

   fprintf_unfiltered (file,
                       "gdbarch_dump: short_bit = %s\n",
   fprintf_unfiltered (file,
                       "gdbarch_dump: short_bit = %s\n",

-                      paddr_d (current_gdbarch->short_bit));
+                      plongest (gdbarch->short_bit));

   fprintf_unfiltered (file,
                       "gdbarch_dump: gdbarch_single_step_through_delay_p() = %d\n",
   fprintf_unfiltered (file,
                       "gdbarch_dump: gdbarch_single_step_through_delay_p() = %d\n",

-                      gdbarch_single_step_through_delay_p (current_gdbarch));
+                      gdbarch_single_step_through_delay_p (gdbarch));
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: single_step_through_delay = <%s>\n",
+                      host_address_to_string (gdbarch->single_step_through_delay));

   fprintf_unfiltered (file,
   fprintf_unfiltered (file,

-                      "gdbarch_dump: single_step_through_delay = <0x%lx>\n",
-                      (long) current_gdbarch->single_step_through_delay);
+                      "gdbarch_dump: gdbarch_skip_main_prologue_p() = %d\n",
+                      gdbarch_skip_main_prologue_p (gdbarch));
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: skip_main_prologue = <%s>\n",
+                      host_address_to_string (gdbarch->skip_main_prologue));

   fprintf_unfiltered (file,
                       "gdbarch_dump: gdbarch_skip_permanent_breakpoint_p() = %d\n",
   fprintf_unfiltered (file,
                       "gdbarch_dump: gdbarch_skip_permanent_breakpoint_p() = %d\n",

-                      gdbarch_skip_permanent_breakpoint_p (current_gdbarch));
+                      gdbarch_skip_permanent_breakpoint_p (gdbarch));

   fprintf_unfiltered (file,
   fprintf_unfiltered (file,

-                      "gdbarch_dump: skip_permanent_breakpoint = <0x%lx>\n",
-                      (long) current_gdbarch->skip_permanent_breakpoint);
+                      "gdbarch_dump: skip_permanent_breakpoint = <%s>\n",
+                      host_address_to_string (gdbarch->skip_permanent_breakpoint));

   fprintf_unfiltered (file,
   fprintf_unfiltered (file,

-                      "gdbarch_dump: skip_prologue = <0x%lx>\n",
-                      (long) current_gdbarch->skip_prologue);
+                      "gdbarch_dump: skip_prologue = <%s>\n",
+                      host_address_to_string (gdbarch->skip_prologue));

   fprintf_unfiltered (file,
   fprintf_unfiltered (file,

-                      "gdbarch_dump: skip_solib_resolver = <0x%lx>\n",
-                      (long) current_gdbarch->skip_solib_resolver);
+                      "gdbarch_dump: skip_solib_resolver = <%s>\n",
+                      host_address_to_string (gdbarch->skip_solib_resolver));

   fprintf_unfiltered (file,
   fprintf_unfiltered (file,

-                      "gdbarch_dump: skip_trampoline_code = <0x%lx>\n",
-                      (long) current_gdbarch->skip_trampoline_code);
+                      "gdbarch_dump: skip_trampoline_code = <%s>\n",
+                      host_address_to_string (gdbarch->skip_trampoline_code));

   fprintf_unfiltered (file,
   fprintf_unfiltered (file,

-                      "gdbarch_dump: smash_text_address = <0x%lx>\n",
-                      (long) current_gdbarch->smash_text_address);
+                      "gdbarch_dump: smash_text_address = <%s>\n",
+                      host_address_to_string (gdbarch->smash_text_address));

   fprintf_unfiltered (file,
                       "gdbarch_dump: gdbarch_software_single_step_p() = %d\n",
   fprintf_unfiltered (file,
                       "gdbarch_dump: gdbarch_software_single_step_p() = %d\n",

-                      gdbarch_software_single_step_p (current_gdbarch));
+                      gdbarch_software_single_step_p (gdbarch));

   fprintf_unfiltered (file,
   fprintf_unfiltered (file,

-                      "gdbarch_dump: software_single_step = <0x%lx>\n",
-                      (long) current_gdbarch->software_single_step);
+                      "gdbarch_dump: software_single_step = <%s>\n",
+                      host_address_to_string (gdbarch->software_single_step));

   fprintf_unfiltered (file,
                       "gdbarch_dump: sofun_address_maybe_missing = %s\n",
   fprintf_unfiltered (file,
                       "gdbarch_dump: sofun_address_maybe_missing = %s\n",

-                      paddr_d (current_gdbarch->sofun_address_maybe_missing));
+                      plongest (gdbarch->sofun_address_maybe_missing));
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: solib_symbols_extension = %s\n",
+                      pstring (gdbarch->solib_symbols_extension));

   fprintf_unfiltered (file,
                       "gdbarch_dump: sp_regnum = %s\n",
   fprintf_unfiltered (file,
                       "gdbarch_dump: sp_regnum = %s\n",

-                      paddr_d (current_gdbarch->sp_regnum));
+                      plongest (gdbarch->sp_regnum));

   fprintf_unfiltered (file,
   fprintf_unfiltered (file,

-                      "gdbarch_dump: stab_reg_to_regnum = <0x%lx>\n",
-                      (long) current_gdbarch->stab_reg_to_regnum);
+                      "gdbarch_dump: stab_reg_to_regnum = <%s>\n",
+                      host_address_to_string (gdbarch->stab_reg_to_regnum));

   fprintf_unfiltered (file,
   fprintf_unfiltered (file,

-                      "gdbarch_dump: stabs_argument_has_addr = <0x%lx>\n",
-                      (long) current_gdbarch->stabs_argument_has_addr);
+                      "gdbarch_dump: stabs_argument_has_addr = <%s>\n",
+                      host_address_to_string (gdbarch->stabs_argument_has_addr));

   fprintf_unfiltered (file,
   fprintf_unfiltered (file,

-                      "gdbarch_dump: gdbarch_static_transform_name_p() = %d\n",
-                      gdbarch_static_transform_name_p (current_gdbarch));
+                      "gdbarch_dump: stap_gdb_register_prefix = %s\n",
+                      pstring (gdbarch->stap_gdb_register_prefix));

   fprintf_unfiltered (file,
   fprintf_unfiltered (file,

-                      "gdbarch_dump: static_transform_name = <0x%lx>\n",
-                      (long) current_gdbarch->static_transform_name);
+                      "gdbarch_dump: stap_gdb_register_suffix = %s\n",
+                      pstring (gdbarch->stap_gdb_register_suffix));

   fprintf_unfiltered (file,
   fprintf_unfiltered (file,

-                      "gdbarch_dump: target_desc = %s\n",
-                      paddr_d ((long) current_gdbarch->target_desc));
+                      "gdbarch_dump: stap_integer_prefix = %s\n",
+                      pstring (gdbarch->stap_integer_prefix));
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: stap_integer_suffix = %s\n",
+                      pstring (gdbarch->stap_integer_suffix));
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: gdbarch_stap_is_single_operand_p() = %d\n",
+                      gdbarch_stap_is_single_operand_p (gdbarch));

   fprintf_unfiltered (file,
   fprintf_unfiltered (file,

-                      "gdbarch_dump: gdbarch_unwind_dummy_id_p() = %d\n",
-                      gdbarch_unwind_dummy_id_p (current_gdbarch));
+                      "gdbarch_dump: stap_is_single_operand = <%s>\n",
+                      host_address_to_string (gdbarch->stap_is_single_operand));

   fprintf_unfiltered (file,
   fprintf_unfiltered (file,

-                      "gdbarch_dump: unwind_dummy_id = <0x%lx>\n",
-                      (long) current_gdbarch->unwind_dummy_id);
+                      "gdbarch_dump: gdbarch_stap_parse_special_token_p() = %d\n",
+                      gdbarch_stap_parse_special_token_p (gdbarch));
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: stap_parse_special_token = <%s>\n",
+                      host_address_to_string (gdbarch->stap_parse_special_token));
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: stap_register_indirection_prefix = %s\n",
+                      pstring (gdbarch->stap_register_indirection_prefix));
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: stap_register_indirection_suffix = %s\n",
+                      pstring (gdbarch->stap_register_indirection_suffix));
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: stap_register_prefix = %s\n",
+                      pstring (gdbarch->stap_register_prefix));
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: stap_register_suffix = %s\n",
+                      pstring (gdbarch->stap_register_suffix));
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: gdbarch_static_transform_name_p() = %d\n",
+                      gdbarch_static_transform_name_p (gdbarch));
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: static_transform_name = <%s>\n",
+                      host_address_to_string (gdbarch->static_transform_name));
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: target_desc = %s\n",
+                      host_address_to_string (gdbarch->target_desc));

   fprintf_unfiltered (file,
                       "gdbarch_dump: gdbarch_unwind_pc_p() = %d\n",
   fprintf_unfiltered (file,
                       "gdbarch_dump: gdbarch_unwind_pc_p() = %d\n",

-                      gdbarch_unwind_pc_p (current_gdbarch));
+                      gdbarch_unwind_pc_p (gdbarch));

   fprintf_unfiltered (file,
   fprintf_unfiltered (file,

-                      "gdbarch_dump: unwind_pc = <0x%lx>\n",
-                      (long) current_gdbarch->unwind_pc);
+                      "gdbarch_dump: unwind_pc = <%s>\n",
+                      host_address_to_string (gdbarch->unwind_pc));

   fprintf_unfiltered (file,
                       "gdbarch_dump: gdbarch_unwind_sp_p() = %d\n",
   fprintf_unfiltered (file,
                       "gdbarch_dump: gdbarch_unwind_sp_p() = %d\n",

-                      gdbarch_unwind_sp_p (current_gdbarch));
+                      gdbarch_unwind_sp_p (gdbarch));

   fprintf_unfiltered (file,
   fprintf_unfiltered (file,

-                      "gdbarch_dump: unwind_sp = <0x%lx>\n",
-                      (long) current_gdbarch->unwind_sp);
+                      "gdbarch_dump: unwind_sp = <%s>\n",
+                      host_address_to_string (gdbarch->unwind_sp));

   fprintf_unfiltered (file,
   fprintf_unfiltered (file,

-                      "gdbarch_dump: value_from_register = <0x%lx>\n",
-                      (long) current_gdbarch->value_from_register);
+                      "gdbarch_dump: value_from_register = <%s>\n",
+                      host_address_to_string (gdbarch->value_from_register));

   fprintf_unfiltered (file,
   fprintf_unfiltered (file,

-                      "gdbarch_dump: value_to_register = <0x%lx>\n",
-                      (long) current_gdbarch->value_to_register);
+                      "gdbarch_dump: value_to_register = <%s>\n",
+                      host_address_to_string (gdbarch->value_to_register));

   fprintf_unfiltered (file,
                       "gdbarch_dump: vbit_in_delta = %s\n",
   fprintf_unfiltered (file,
                       "gdbarch_dump: vbit_in_delta = %s\n",

-                      paddr_d (current_gdbarch->vbit_in_delta));
+                      plongest (gdbarch->vbit_in_delta));

   fprintf_unfiltered (file,
   fprintf_unfiltered (file,

-                      "gdbarch_dump: virtual_frame_pointer = <0x%lx>\n",
-                      (long) current_gdbarch->virtual_frame_pointer);
+                      "gdbarch_dump: virtual_frame_pointer = <%s>\n",
+                      host_address_to_string (gdbarch->virtual_frame_pointer));

   fprintf_unfiltered (file,
                       "gdbarch_dump: vtable_function_descriptors = %s\n",
   fprintf_unfiltered (file,
                       "gdbarch_dump: vtable_function_descriptors = %s\n",

-                      paddr_d (current_gdbarch->vtable_function_descriptors));
+                      plongest (gdbarch->vtable_function_descriptors));

   fprintf_unfiltered (file,
                       "gdbarch_dump: gdbarch_write_pc_p() = %d\n",
   fprintf_unfiltered (file,
                       "gdbarch_dump: gdbarch_write_pc_p() = %d\n",

-                      gdbarch_write_pc_p (current_gdbarch));
+                      gdbarch_write_pc_p (gdbarch));

   fprintf_unfiltered (file,
   fprintf_unfiltered (file,

-                      "gdbarch_dump: write_pc = <0x%lx>\n",
-                      (long) current_gdbarch->write_pc);
-  if (current_gdbarch->dump_tdep != NULL)
-    current_gdbarch->dump_tdep (current_gdbarch, file);
+                      "gdbarch_dump: write_pc = <%s>\n",
+                      host_address_to_string (gdbarch->write_pc));
+  if (gdbarch->dump_tdep != NULL)
+    gdbarch->dump_tdep (gdbarch, file);

 }
 
 struct gdbarch_tdep *
 }
 
 struct gdbarch_tdep *


@@ -1071,6 +1418,15 @@ gdbarch_byte_order (struct gdbarch *gdbarch)
   return gdbarch->byte_order;
 }
 
   return gdbarch->byte_order;
 }
 

+int
+gdbarch_byte_order_for_code (struct gdbarch *gdbarch)
+{
+  gdb_assert (gdbarch != NULL);
+  if (gdbarch_debug >= 2)
+    fprintf_unfiltered (gdb_stdlog, "gdbarch_byte_order_for_code called\n");
+  return gdbarch->byte_order_for_code;
+}
+

 enum gdb_osabi
 gdbarch_osabi (struct gdbarch *gdbarch)
 {
 enum gdb_osabi
 gdbarch_osabi (struct gdbarch *gdbarch)
 {


@@ -1089,6 +1445,23 @@ gdbarch_target_desc (struct gdbarch *gdbarch)
   return gdbarch->target_desc;
 }
 
   return gdbarch->target_desc;
 }
 

+int
+gdbarch_bits_big_endian (struct gdbarch *gdbarch)
+{
+  gdb_assert (gdbarch != NULL);
+  /* Skip verify of bits_big_endian, invalid_p == 0 */
+  if (gdbarch_debug >= 2)
+    fprintf_unfiltered (gdb_stdlog, "gdbarch_bits_big_endian called\n");
+  return gdbarch->bits_big_endian;
+}
+
+void
+set_gdbarch_bits_big_endian (struct gdbarch *gdbarch,
+                             int bits_big_endian)
+{
+  gdbarch->bits_big_endian = bits_big_endian;
+}
+

 int
 gdbarch_short_bit (struct gdbarch *gdbarch)
 {
 int
 gdbarch_short_bit (struct gdbarch *gdbarch)
 {


@@ -1157,6 +1530,56 @@ set_gdbarch_long_long_bit (struct gdbarch *gdbarch,
   gdbarch->long_long_bit = long_long_bit;
 }
 
   gdbarch->long_long_bit = long_long_bit;
 }
 

+int
+gdbarch_long_long_align_bit (struct gdbarch *gdbarch)
+{
+  gdb_assert (gdbarch != NULL);
+  /* Skip verify of long_long_align_bit, invalid_p == 0 */
+  if (gdbarch_debug >= 2)
+    fprintf_unfiltered (gdb_stdlog, "gdbarch_long_long_align_bit called\n");
+  return gdbarch->long_long_align_bit;
+}
+
+void
+set_gdbarch_long_long_align_bit (struct gdbarch *gdbarch,
+                                 int long_long_align_bit)
+{
+  gdbarch->long_long_align_bit = long_long_align_bit;
+}
+
+int
+gdbarch_half_bit (struct gdbarch *gdbarch)
+{
+  gdb_assert (gdbarch != NULL);
+  /* Skip verify of half_bit, invalid_p == 0 */
+  if (gdbarch_debug >= 2)
+    fprintf_unfiltered (gdb_stdlog, "gdbarch_half_bit called\n");
+  return gdbarch->half_bit;
+}
+
+void
+set_gdbarch_half_bit (struct gdbarch *gdbarch,
+                      int half_bit)
+{
+  gdbarch->half_bit = half_bit;
+}
+
+const struct floatformat **
+gdbarch_half_format (struct gdbarch *gdbarch)
+{
+  gdb_assert (gdbarch != NULL);
+  if (gdbarch_debug >= 2)
+    fprintf_unfiltered (gdb_stdlog, "gdbarch_half_format called\n");
+  return gdbarch->half_format;
+}
+
+void
+set_gdbarch_half_format (struct gdbarch *gdbarch,
+                         const struct floatformat ** half_format)
+{
+  gdbarch->half_format = half_format;
+}
+

 int
 gdbarch_float_bit (struct gdbarch *gdbarch)
 {
 int
 gdbarch_float_bit (struct gdbarch *gdbarch)
 {


@@ -1291,6 +1714,24 @@ set_gdbarch_addr_bit (struct gdbarch *gdbarch,
   gdbarch->addr_bit = addr_bit;
 }
 
   gdbarch->addr_bit = addr_bit;
 }
 

+int
+gdbarch_dwarf2_addr_size (struct gdbarch *gdbarch)
+{
+  gdb_assert (gdbarch != NULL);
+  /* Check variable changed from pre-default.  */
+  gdb_assert (gdbarch->dwarf2_addr_size != 0);
+  if (gdbarch_debug >= 2)
+    fprintf_unfiltered (gdb_stdlog, "gdbarch_dwarf2_addr_size called\n");
+  return gdbarch->dwarf2_addr_size;
+}
+
+void
+set_gdbarch_dwarf2_addr_size (struct gdbarch *gdbarch,
+                              int dwarf2_addr_size)
+{
+  gdbarch->dwarf2_addr_size = dwarf2_addr_size;
+}
+

 int
 gdbarch_char_signed (struct gdbarch *gdbarch)
 {
 int
 gdbarch_char_signed (struct gdbarch *gdbarch)
 {


@@ -1364,7 +1805,7 @@ gdbarch_virtual_frame_pointer (struct gdbarch *gdbarch, CORE_ADDR pc, int *frame
   gdb_assert (gdbarch->virtual_frame_pointer != NULL);
   if (gdbarch_debug >= 2)
     fprintf_unfiltered (gdb_stdlog, "gdbarch_virtual_frame_pointer called\n");
   gdb_assert (gdbarch->virtual_frame_pointer != NULL);
   if (gdbarch_debug >= 2)
     fprintf_unfiltered (gdb_stdlog, "gdbarch_virtual_frame_pointer called\n");

-  gdbarch->virtual_frame_pointer (pc, frame_regnum, frame_offset);
+  gdbarch->virtual_frame_pointer (gdbarch, pc, frame_regnum, frame_offset);

 }
 
 void
 }
 
 void


@@ -1381,14 +1822,14 @@ gdbarch_pseudo_register_read_p (struct gdbarch *gdbarch)
   return gdbarch->pseudo_register_read != NULL;
 }
 
   return gdbarch->pseudo_register_read != NULL;
 }
 

-void
+enum register_status

 gdbarch_pseudo_register_read (struct gdbarch *gdbarch, struct regcache *regcache, int cookednum, gdb_byte *buf)
 {
   gdb_assert (gdbarch != NULL);
   gdb_assert (gdbarch->pseudo_register_read != NULL);
   if (gdbarch_debug >= 2)
     fprintf_unfiltered (gdb_stdlog, "gdbarch_pseudo_register_read called\n");
 gdbarch_pseudo_register_read (struct gdbarch *gdbarch, struct regcache *regcache, int cookednum, gdb_byte *buf)
 {
   gdb_assert (gdbarch != NULL);
   gdb_assert (gdbarch->pseudo_register_read != NULL);
   if (gdbarch_debug >= 2)
     fprintf_unfiltered (gdb_stdlog, "gdbarch_pseudo_register_read called\n");

-  gdbarch->pseudo_register_read (gdbarch, regcache, cookednum, buf);
+  return gdbarch->pseudo_register_read (gdbarch, regcache, cookednum, buf);

 }
 
 void
 }
 
 void


@@ -1398,6 +1839,30 @@ set_gdbarch_pseudo_register_read (struct gdbarch *gdbarch,
   gdbarch->pseudo_register_read = pseudo_register_read;
 }
 
   gdbarch->pseudo_register_read = pseudo_register_read;
 }
 

+int
+gdbarch_pseudo_register_read_value_p (struct gdbarch *gdbarch)
+{
+  gdb_assert (gdbarch != NULL);
+  return gdbarch->pseudo_register_read_value != NULL;
+}
+
+struct value *
+gdbarch_pseudo_register_read_value (struct gdbarch *gdbarch, struct regcache *regcache, int cookednum)
+{
+  gdb_assert (gdbarch != NULL);
+  gdb_assert (gdbarch->pseudo_register_read_value != NULL);
+  if (gdbarch_debug >= 2)
+    fprintf_unfiltered (gdb_stdlog, "gdbarch_pseudo_register_read_value called\n");
+  return gdbarch->pseudo_register_read_value (gdbarch, regcache, cookednum);
+}
+
+void
+set_gdbarch_pseudo_register_read_value (struct gdbarch *gdbarch,
+                                        gdbarch_pseudo_register_read_value_ftype pseudo_register_read_value)
+{
+  gdbarch->pseudo_register_read_value = pseudo_register_read_value;
+}
+

 int
 gdbarch_pseudo_register_write_p (struct gdbarch *gdbarch)
 {
 int
 gdbarch_pseudo_register_write_p (struct gdbarch *gdbarch)
 {


@@ -1457,6 +1922,54 @@ set_gdbarch_num_pseudo_regs (struct gdbarch *gdbarch,
   gdbarch->num_pseudo_regs = num_pseudo_regs;
 }
 
   gdbarch->num_pseudo_regs = num_pseudo_regs;
 }
 

+int
+gdbarch_ax_pseudo_register_collect_p (struct gdbarch *gdbarch)
+{
+  gdb_assert (gdbarch != NULL);
+  return gdbarch->ax_pseudo_register_collect != NULL;
+}
+
+int
+gdbarch_ax_pseudo_register_collect (struct gdbarch *gdbarch, struct agent_expr *ax, int reg)
+{
+  gdb_assert (gdbarch != NULL);
+  gdb_assert (gdbarch->ax_pseudo_register_collect != NULL);
+  if (gdbarch_debug >= 2)
+    fprintf_unfiltered (gdb_stdlog, "gdbarch_ax_pseudo_register_collect called\n");
+  return gdbarch->ax_pseudo_register_collect (gdbarch, ax, reg);
+}
+
+void
+set_gdbarch_ax_pseudo_register_collect (struct gdbarch *gdbarch,
+                                        gdbarch_ax_pseudo_register_collect_ftype ax_pseudo_register_collect)
+{
+  gdbarch->ax_pseudo_register_collect = ax_pseudo_register_collect;
+}
+
+int
+gdbarch_ax_pseudo_register_push_stack_p (struct gdbarch *gdbarch)
+{
+  gdb_assert (gdbarch != NULL);
+  return gdbarch->ax_pseudo_register_push_stack != NULL;
+}
+
+int
+gdbarch_ax_pseudo_register_push_stack (struct gdbarch *gdbarch, struct agent_expr *ax, int reg)
+{
+  gdb_assert (gdbarch != NULL);
+  gdb_assert (gdbarch->ax_pseudo_register_push_stack != NULL);
+  if (gdbarch_debug >= 2)
+    fprintf_unfiltered (gdb_stdlog, "gdbarch_ax_pseudo_register_push_stack called\n");
+  return gdbarch->ax_pseudo_register_push_stack (gdbarch, ax, reg);
+}
+
+void
+set_gdbarch_ax_pseudo_register_push_stack (struct gdbarch *gdbarch,
+                                           gdbarch_ax_pseudo_register_push_stack_ftype ax_pseudo_register_push_stack)
+{
+  gdbarch->ax_pseudo_register_push_stack = ax_pseudo_register_push_stack;
+}
+

 int
 gdbarch_sp_regnum (struct gdbarch *gdbarch)
 {
 int
 gdbarch_sp_regnum (struct gdbarch *gdbarch)
 {


@@ -1532,7 +2045,7 @@ gdbarch_stab_reg_to_regnum (struct gdbarch *gdbarch, int stab_regnr)
   gdb_assert (gdbarch->stab_reg_to_regnum != NULL);
   if (gdbarch_debug >= 2)
     fprintf_unfiltered (gdb_stdlog, "gdbarch_stab_reg_to_regnum called\n");
   gdb_assert (gdbarch->stab_reg_to_regnum != NULL);
   if (gdbarch_debug >= 2)
     fprintf_unfiltered (gdb_stdlog, "gdbarch_stab_reg_to_regnum called\n");

-  return gdbarch->stab_reg_to_regnum (stab_regnr);
+  return gdbarch->stab_reg_to_regnum (gdbarch, stab_regnr);

 }
 
 void
 }
 
 void


@@ -1549,7 +2062,7 @@ gdbarch_ecoff_reg_to_regnum (struct gdbarch *gdbarch, int ecoff_regnr)
   gdb_assert (gdbarch->ecoff_reg_to_regnum != NULL);
   if (gdbarch_debug >= 2)
     fprintf_unfiltered (gdb_stdlog, "gdbarch_ecoff_reg_to_regnum called\n");
   gdb_assert (gdbarch->ecoff_reg_to_regnum != NULL);
   if (gdbarch_debug >= 2)
     fprintf_unfiltered (gdb_stdlog, "gdbarch_ecoff_reg_to_regnum called\n");

-  return gdbarch->ecoff_reg_to_regnum (ecoff_regnr);
+  return gdbarch->ecoff_reg_to_regnum (gdbarch, ecoff_regnr);

 }
 
 void
 }
 
 void


@@ -1559,23 +2072,6 @@ set_gdbarch_ecoff_reg_to_regnum (struct gdbarch *gdbarch,
   gdbarch->ecoff_reg_to_regnum = ecoff_reg_to_regnum;
 }
 
   gdbarch->ecoff_reg_to_regnum = ecoff_reg_to_regnum;
 }
 

-int
-gdbarch_dwarf_reg_to_regnum (struct gdbarch *gdbarch, int dwarf_regnr)
-{
-  gdb_assert (gdbarch != NULL);
-  gdb_assert (gdbarch->dwarf_reg_to_regnum != NULL);
-  if (gdbarch_debug >= 2)
-    fprintf_unfiltered (gdb_stdlog, "gdbarch_dwarf_reg_to_regnum called\n");
-  return gdbarch->dwarf_reg_to_regnum (dwarf_regnr);
-}
-
-void
-set_gdbarch_dwarf_reg_to_regnum (struct gdbarch *gdbarch,
-                                 gdbarch_dwarf_reg_to_regnum_ftype dwarf_reg_to_regnum)
-{
-  gdbarch->dwarf_reg_to_regnum = dwarf_reg_to_regnum;
-}
-

 int
 gdbarch_sdb_reg_to_regnum (struct gdbarch *gdbarch, int sdb_regnr)
 {
 int
 gdbarch_sdb_reg_to_regnum (struct gdbarch *gdbarch, int sdb_regnr)
 {


@@ -1583,7 +2079,7 @@ gdbarch_sdb_reg_to_regnum (struct gdbarch *gdbarch, int sdb_regnr)
   gdb_assert (gdbarch->sdb_reg_to_regnum != NULL);
   if (gdbarch_debug >= 2)
     fprintf_unfiltered (gdb_stdlog, "gdbarch_sdb_reg_to_regnum called\n");
   gdb_assert (gdbarch->sdb_reg_to_regnum != NULL);
   if (gdbarch_debug >= 2)
     fprintf_unfiltered (gdb_stdlog, "gdbarch_sdb_reg_to_regnum called\n");

-  return gdbarch->sdb_reg_to_regnum (sdb_regnr);
+  return gdbarch->sdb_reg_to_regnum (gdbarch, sdb_regnr);

 }
 
 void
 }
 
 void


@@ -1600,7 +2096,7 @@ gdbarch_dwarf2_reg_to_regnum (struct gdbarch *gdbarch, int dwarf2_regnr)
   gdb_assert (gdbarch->dwarf2_reg_to_regnum != NULL);
   if (gdbarch_debug >= 2)
     fprintf_unfiltered (gdb_stdlog, "gdbarch_dwarf2_reg_to_regnum called\n");
   gdb_assert (gdbarch->dwarf2_reg_to_regnum != NULL);
   if (gdbarch_debug >= 2)
     fprintf_unfiltered (gdb_stdlog, "gdbarch_dwarf2_reg_to_regnum called\n");

-  return gdbarch->dwarf2_reg_to_regnum (dwarf2_regnr);
+  return gdbarch->dwarf2_reg_to_regnum (gdbarch, dwarf2_regnr);

 }
 
 void
 }
 
 void


@@ -1617,7 +2113,7 @@ gdbarch_register_name (struct gdbarch *gdbarch, int regnr)
   gdb_assert (gdbarch->register_name != NULL);
   if (gdbarch_debug >= 2)
     fprintf_unfiltered (gdb_stdlog, "gdbarch_register_name called\n");
   gdb_assert (gdbarch->register_name != NULL);
   if (gdbarch_debug >= 2)
     fprintf_unfiltered (gdb_stdlog, "gdbarch_register_name called\n");

-  return gdbarch->register_name (regnr);
+  return gdbarch->register_name (gdbarch, regnr);

 }
 
 void
 }
 
 void


@@ -1652,27 +2148,27 @@ set_gdbarch_register_type (struct gdbarch *gdbarch,
 }
 
 int
 }
 
 int

-gdbarch_unwind_dummy_id_p (struct gdbarch *gdbarch)
+gdbarch_dummy_id_p (struct gdbarch *gdbarch)

 {
   gdb_assert (gdbarch != NULL);
 {
   gdb_assert (gdbarch != NULL);

-  return gdbarch->unwind_dummy_id != NULL;
+  return gdbarch->dummy_id != NULL;

 }
 
 struct frame_id
 }
 
 struct frame_id

-gdbarch_unwind_dummy_id (struct gdbarch *gdbarch, struct frame_info *info)
+gdbarch_dummy_id (struct gdbarch *gdbarch, struct frame_info *this_frame)

 {
   gdb_assert (gdbarch != NULL);
 {
   gdb_assert (gdbarch != NULL);

-  gdb_assert (gdbarch->unwind_dummy_id != NULL);
+  gdb_assert (gdbarch->dummy_id != NULL);

   if (gdbarch_debug >= 2)
   if (gdbarch_debug >= 2)

-    fprintf_unfiltered (gdb_stdlog, "gdbarch_unwind_dummy_id called\n");
-  return gdbarch->unwind_dummy_id (gdbarch, info);
+    fprintf_unfiltered (gdb_stdlog, "gdbarch_dummy_id called\n");
+  return gdbarch->dummy_id (gdbarch, this_frame);

 }
 
 void
 }
 
 void

-set_gdbarch_unwind_dummy_id (struct gdbarch *gdbarch,
-                             gdbarch_unwind_dummy_id_ftype unwind_dummy_id)
+set_gdbarch_dummy_id (struct gdbarch *gdbarch,
+                      gdbarch_dummy_id_ftype dummy_id)

 {
 {

-  gdbarch->unwind_dummy_id = unwind_dummy_id;
+  gdbarch->dummy_id = dummy_id;

 }
 
 int
 }
 
 int


@@ -1829,7 +2325,7 @@ gdbarch_register_sim_regno (struct gdbarch *gdbarch, int reg_nr)
   gdb_assert (gdbarch->register_sim_regno != NULL);
   if (gdbarch_debug >= 2)
     fprintf_unfiltered (gdb_stdlog, "gdbarch_register_sim_regno called\n");
   gdb_assert (gdbarch->register_sim_regno != NULL);
   if (gdbarch_debug >= 2)
     fprintf_unfiltered (gdb_stdlog, "gdbarch_register_sim_regno called\n");

-  return gdbarch->register_sim_regno (reg_nr);
+  return gdbarch->register_sim_regno (gdbarch, reg_nr);

 }
 
 void
 }
 
 void


@@ -1846,7 +2342,7 @@ gdbarch_cannot_fetch_register (struct gdbarch *gdbarch, int regnum)
   gdb_assert (gdbarch->cannot_fetch_register != NULL);
   if (gdbarch_debug >= 2)
     fprintf_unfiltered (gdb_stdlog, "gdbarch_cannot_fetch_register called\n");
   gdb_assert (gdbarch->cannot_fetch_register != NULL);
   if (gdbarch_debug >= 2)
     fprintf_unfiltered (gdb_stdlog, "gdbarch_cannot_fetch_register called\n");

-  return gdbarch->cannot_fetch_register (regnum);
+  return gdbarch->cannot_fetch_register (gdbarch, regnum);

 }
 
 void
 }
 
 void


@@ -1863,7 +2359,7 @@ gdbarch_cannot_store_register (struct gdbarch *gdbarch, int regnum)
   gdb_assert (gdbarch->cannot_store_register != NULL);
   if (gdbarch_debug >= 2)
     fprintf_unfiltered (gdb_stdlog, "gdbarch_cannot_store_register called\n");
   gdb_assert (gdbarch->cannot_store_register != NULL);
   if (gdbarch_debug >= 2)
     fprintf_unfiltered (gdb_stdlog, "gdbarch_cannot_store_register called\n");

-  return gdbarch->cannot_store_register (regnum);
+  return gdbarch->cannot_store_register (gdbarch, regnum);

 }
 
 void
 }
 
 void


@@ -1920,7 +2416,7 @@ gdbarch_convert_register_p (struct gdbarch *gdbarch, int regnum, struct type *ty
   gdb_assert (gdbarch->convert_register_p != NULL);
   if (gdbarch_debug >= 2)
     fprintf_unfiltered (gdb_stdlog, "gdbarch_convert_register_p called\n");
   gdb_assert (gdbarch->convert_register_p != NULL);
   if (gdbarch_debug >= 2)
     fprintf_unfiltered (gdb_stdlog, "gdbarch_convert_register_p called\n");

-  return gdbarch->convert_register_p (regnum, type);
+  return gdbarch->convert_register_p (gdbarch, regnum, type);

 }
 
 void
 }
 
 void


@@ -1930,14 +2426,14 @@ set_gdbarch_convert_register_p (struct gdbarch *gdbarch,
   gdbarch->convert_register_p = convert_register_p;
 }
 
   gdbarch->convert_register_p = convert_register_p;
 }
 

-void
-gdbarch_register_to_value (struct gdbarch *gdbarch, struct frame_info *frame, int regnum, struct type *type, gdb_byte *buf)
+int
+gdbarch_register_to_value (struct gdbarch *gdbarch, struct frame_info *frame, int regnum, struct type *type, gdb_byte *buf, int *optimizedp, int *unavailablep)

 {
   gdb_assert (gdbarch != NULL);
   gdb_assert (gdbarch->register_to_value != NULL);
   if (gdbarch_debug >= 2)
     fprintf_unfiltered (gdb_stdlog, "gdbarch_register_to_value called\n");
 {
   gdb_assert (gdbarch != NULL);
   gdb_assert (gdbarch->register_to_value != NULL);
   if (gdbarch_debug >= 2)
     fprintf_unfiltered (gdb_stdlog, "gdbarch_register_to_value called\n");

-  gdbarch->register_to_value (frame, regnum, type, buf);
+  return gdbarch->register_to_value (frame, regnum, type, buf, optimizedp, unavailablep);

 }
 
 void
 }
 
 void


@@ -1988,7 +2484,7 @@ gdbarch_pointer_to_address (struct gdbarch *gdbarch, struct type *type, const gd
   gdb_assert (gdbarch->pointer_to_address != NULL);
   if (gdbarch_debug >= 2)
     fprintf_unfiltered (gdb_stdlog, "gdbarch_pointer_to_address called\n");
   gdb_assert (gdbarch->pointer_to_address != NULL);
   if (gdbarch_debug >= 2)
     fprintf_unfiltered (gdb_stdlog, "gdbarch_pointer_to_address called\n");

-  return gdbarch->pointer_to_address (type, buf);
+  return gdbarch->pointer_to_address (gdbarch, type, buf);

 }
 
 void
 }
 
 void


@@ -2005,7 +2501,7 @@ gdbarch_address_to_pointer (struct gdbarch *gdbarch, struct type *type, gdb_byte
   gdb_assert (gdbarch->address_to_pointer != NULL);
   if (gdbarch_debug >= 2)
     fprintf_unfiltered (gdb_stdlog, "gdbarch_address_to_pointer called\n");
   gdb_assert (gdbarch->address_to_pointer != NULL);
   if (gdbarch_debug >= 2)
     fprintf_unfiltered (gdb_stdlog, "gdbarch_address_to_pointer called\n");

-  gdbarch->address_to_pointer (type, buf, addr);
+  gdbarch->address_to_pointer (gdbarch, type, buf, addr);

 }
 
 void
 }
 
 void


@@ -2047,13 +2543,13 @@ gdbarch_return_value_p (struct gdbarch *gdbarch)
 }
 
 enum return_value_convention
 }
 
 enum return_value_convention

-gdbarch_return_value (struct gdbarch *gdbarch, struct type *valtype, struct regcache *regcache, gdb_byte *readbuf, const gdb_byte *writebuf)
+gdbarch_return_value (struct gdbarch *gdbarch, struct value *function, struct type *valtype, struct regcache *regcache, gdb_byte *readbuf, const gdb_byte *writebuf)

 {
   gdb_assert (gdbarch != NULL);
   gdb_assert (gdbarch->return_value != NULL);
   if (gdbarch_debug >= 2)
     fprintf_unfiltered (gdb_stdlog, "gdbarch_return_value called\n");
 {
   gdb_assert (gdbarch != NULL);
   gdb_assert (gdbarch->return_value != NULL);
   if (gdbarch_debug >= 2)
     fprintf_unfiltered (gdb_stdlog, "gdbarch_return_value called\n");

-  return gdbarch->return_value (gdbarch, valtype, regcache, readbuf, writebuf);
+  return gdbarch->return_value (gdbarch, function, valtype, regcache, readbuf, writebuf);

 }
 
 void
 }
 
 void


@@ -2063,6 +2559,23 @@ set_gdbarch_return_value (struct gdbarch *gdbarch,
   gdbarch->return_value = return_value;
 }
 
   gdbarch->return_value = return_value;
 }
 

+int
+gdbarch_return_in_first_hidden_param_p (struct gdbarch *gdbarch, struct type *type)
+{
+  gdb_assert (gdbarch != NULL);
+  gdb_assert (gdbarch->return_in_first_hidden_param_p != NULL);
+  if (gdbarch_debug >= 2)
+    fprintf_unfiltered (gdb_stdlog, "gdbarch_return_in_first_hidden_param_p called\n");
+  return gdbarch->return_in_first_hidden_param_p (gdbarch, type);
+}
+
+void
+set_gdbarch_return_in_first_hidden_param_p (struct gdbarch *gdbarch,
+                                            gdbarch_return_in_first_hidden_param_p_ftype return_in_first_hidden_param_p)
+{
+  gdbarch->return_in_first_hidden_param_p = return_in_first_hidden_param_p;
+}
+

 CORE_ADDR
 gdbarch_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR ip)
 {
 CORE_ADDR
 gdbarch_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR ip)
 {


@@ -2070,7 +2583,7 @@ gdbarch_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR ip)
   gdb_assert (gdbarch->skip_prologue != NULL);
   if (gdbarch_debug >= 2)
     fprintf_unfiltered (gdb_stdlog, "gdbarch_skip_prologue called\n");
   gdb_assert (gdbarch->skip_prologue != NULL);
   if (gdbarch_debug >= 2)
     fprintf_unfiltered (gdb_stdlog, "gdbarch_skip_prologue called\n");

-  return gdbarch->skip_prologue (ip);
+  return gdbarch->skip_prologue (gdbarch, ip);

 }
 
 void
 }
 
 void


@@ -2080,6 +2593,30 @@ set_gdbarch_skip_prologue (struct gdbarch *gdbarch,
   gdbarch->skip_prologue = skip_prologue;
 }
 
   gdbarch->skip_prologue = skip_prologue;
 }
 

+int
+gdbarch_skip_main_prologue_p (struct gdbarch *gdbarch)
+{
+  gdb_assert (gdbarch != NULL);
+  return gdbarch->skip_main_prologue != NULL;
+}
+
+CORE_ADDR
+gdbarch_skip_main_prologue (struct gdbarch *gdbarch, CORE_ADDR ip)
+{
+  gdb_assert (gdbarch != NULL);
+  gdb_assert (gdbarch->skip_main_prologue != NULL);
+  if (gdbarch_debug >= 2)
+    fprintf_unfiltered (gdb_stdlog, "gdbarch_skip_main_prologue called\n");
+  return gdbarch->skip_main_prologue (gdbarch, ip);
+}
+
+void
+set_gdbarch_skip_main_prologue (struct gdbarch *gdbarch,
+                                gdbarch_skip_main_prologue_ftype skip_main_prologue)
+{
+  gdbarch->skip_main_prologue = skip_main_prologue;
+}
+

 int
 gdbarch_inner_than (struct gdbarch *gdbarch, CORE_ADDR lhs, CORE_ADDR rhs)
 {
 int
 gdbarch_inner_than (struct gdbarch *gdbarch, CORE_ADDR lhs, CORE_ADDR rhs)
 {


@@ -2104,7 +2641,7 @@ gdbarch_breakpoint_from_pc (struct gdbarch *gdbarch, CORE_ADDR *pcptr, int *lenp
   gdb_assert (gdbarch->breakpoint_from_pc != NULL);
   if (gdbarch_debug >= 2)
     fprintf_unfiltered (gdb_stdlog, "gdbarch_breakpoint_from_pc called\n");
   gdb_assert (gdbarch->breakpoint_from_pc != NULL);
   if (gdbarch_debug >= 2)
     fprintf_unfiltered (gdb_stdlog, "gdbarch_breakpoint_from_pc called\n");

-  return gdbarch->breakpoint_from_pc (pcptr, lenptr);
+  return gdbarch->breakpoint_from_pc (gdbarch, pcptr, lenptr);

 }
 
 void
 }
 
 void


@@ -2114,6 +2651,23 @@ set_gdbarch_breakpoint_from_pc (struct gdbarch *gdbarch,
   gdbarch->breakpoint_from_pc = breakpoint_from_pc;
 }
 
   gdbarch->breakpoint_from_pc = breakpoint_from_pc;
 }
 

+void
+gdbarch_remote_breakpoint_from_pc (struct gdbarch *gdbarch, CORE_ADDR *pcptr, int *kindptr)
+{
+  gdb_assert (gdbarch != NULL);
+  gdb_assert (gdbarch->remote_breakpoint_from_pc != NULL);
+  if (gdbarch_debug >= 2)
+    fprintf_unfiltered (gdb_stdlog, "gdbarch_remote_breakpoint_from_pc called\n");
+  gdbarch->remote_breakpoint_from_pc (gdbarch, pcptr, kindptr);
+}
+
+void
+set_gdbarch_remote_breakpoint_from_pc (struct gdbarch *gdbarch,
+                                       gdbarch_remote_breakpoint_from_pc_ftype remote_breakpoint_from_pc)
+{
+  gdbarch->remote_breakpoint_from_pc = remote_breakpoint_from_pc;
+}
+

 int
 gdbarch_adjust_breakpoint_address_p (struct gdbarch *gdbarch)
 {
 int
 gdbarch_adjust_breakpoint_address_p (struct gdbarch *gdbarch)
 {


@@ -2145,7 +2699,7 @@ gdbarch_memory_insert_breakpoint (struct gdbarch *gdbarch, struct bp_target_info
   gdb_assert (gdbarch->memory_insert_breakpoint != NULL);
   if (gdbarch_debug >= 2)
     fprintf_unfiltered (gdb_stdlog, "gdbarch_memory_insert_breakpoint called\n");
   gdb_assert (gdbarch->memory_insert_breakpoint != NULL);
   if (gdbarch_debug >= 2)
     fprintf_unfiltered (gdb_stdlog, "gdbarch_memory_insert_breakpoint called\n");

-  return gdbarch->memory_insert_breakpoint (bp_tgt);
+  return gdbarch->memory_insert_breakpoint (gdbarch, bp_tgt);

 }
 
 void
 }
 
 void


@@ -2162,7 +2716,7 @@ gdbarch_memory_remove_breakpoint (struct gdbarch *gdbarch, struct bp_target_info
   gdb_assert (gdbarch->memory_remove_breakpoint != NULL);
   if (gdbarch_debug >= 2)
     fprintf_unfiltered (gdb_stdlog, "gdbarch_memory_remove_breakpoint called\n");
   gdb_assert (gdbarch->memory_remove_breakpoint != NULL);
   if (gdbarch_debug >= 2)
     fprintf_unfiltered (gdb_stdlog, "gdbarch_memory_remove_breakpoint called\n");

-  return gdbarch->memory_remove_breakpoint (bp_tgt);
+  return gdbarch->memory_remove_breakpoint (gdbarch, bp_tgt);

 }
 
 void
 }
 
 void


@@ -2417,7 +2971,7 @@ gdbarch_addr_bits_remove (struct gdbarch *gdbarch, CORE_ADDR addr)
   gdb_assert (gdbarch->addr_bits_remove != NULL);
   if (gdbarch_debug >= 2)
     fprintf_unfiltered (gdb_stdlog, "gdbarch_addr_bits_remove called\n");
   gdb_assert (gdbarch->addr_bits_remove != NULL);
   if (gdbarch_debug >= 2)
     fprintf_unfiltered (gdb_stdlog, "gdbarch_addr_bits_remove called\n");

-  return gdbarch->addr_bits_remove (addr);
+  return gdbarch->addr_bits_remove (gdbarch, addr);

 }
 
 void
 }
 
 void


@@ -2434,7 +2988,7 @@ gdbarch_smash_text_address (struct gdbarch *gdbarch, CORE_ADDR addr)
   gdb_assert (gdbarch->smash_text_address != NULL);
   if (gdbarch_debug >= 2)
     fprintf_unfiltered (gdb_stdlog, "gdbarch_smash_text_address called\n");
   gdb_assert (gdbarch->smash_text_address != NULL);
   if (gdbarch_debug >= 2)
     fprintf_unfiltered (gdb_stdlog, "gdbarch_smash_text_address called\n");

-  return gdbarch->smash_text_address (addr);
+  return gdbarch->smash_text_address (gdbarch, addr);

 }
 
 void
 }
 
 void


@@ -2544,13 +3098,13 @@ set_gdbarch_skip_solib_resolver (struct gdbarch *gdbarch,
 }
 
 int
 }
 
 int

-gdbarch_in_solib_return_trampoline (struct gdbarch *gdbarch, CORE_ADDR pc, char *name)
+gdbarch_in_solib_return_trampoline (struct gdbarch *gdbarch, CORE_ADDR pc, const char *name)

 {
   gdb_assert (gdbarch != NULL);
   gdb_assert (gdbarch->in_solib_return_trampoline != NULL);
   if (gdbarch_debug >= 2)
     fprintf_unfiltered (gdb_stdlog, "gdbarch_in_solib_return_trampoline called\n");
 {
   gdb_assert (gdbarch != NULL);
   gdb_assert (gdbarch->in_solib_return_trampoline != NULL);
   if (gdbarch_debug >= 2)
     fprintf_unfiltered (gdb_stdlog, "gdbarch_in_solib_return_trampoline called\n");

-  return gdbarch->in_solib_return_trampoline (pc, name);
+  return gdbarch->in_solib_return_trampoline (gdbarch, pc, name);

 }
 
 void
 }
 
 void


@@ -2577,23 +3131,6 @@ set_gdbarch_in_function_epilogue_p (struct gdbarch *gdbarch,
   gdbarch->in_function_epilogue_p = in_function_epilogue_p;
 }
 
   gdbarch->in_function_epilogue_p = in_function_epilogue_p;
 }
 

-char *
-gdbarch_construct_inferior_arguments (struct gdbarch *gdbarch, int argc, char **argv)
-{
-  gdb_assert (gdbarch != NULL);
-  gdb_assert (gdbarch->construct_inferior_arguments != NULL);
-  if (gdbarch_debug >= 2)
-    fprintf_unfiltered (gdb_stdlog, "gdbarch_construct_inferior_arguments called\n");
-  return gdbarch->construct_inferior_arguments (gdbarch, argc, argv);
-}
-
-void
-set_gdbarch_construct_inferior_arguments (struct gdbarch *gdbarch,
-                                          gdbarch_construct_inferior_arguments_ftype construct_inferior_arguments)
-{
-  gdbarch->construct_inferior_arguments = construct_inferior_arguments;
-}
-

 void
 gdbarch_elf_make_msymbol_special (struct gdbarch *gdbarch, asymbol *sym, struct minimal_symbol *msym)
 {
 void
 gdbarch_elf_make_msymbol_special (struct gdbarch *gdbarch, asymbol *sym, struct minimal_symbol *msym)
 {


@@ -2628,31 +3165,14 @@ set_gdbarch_coff_make_msymbol_special (struct gdbarch *gdbarch,
   gdbarch->coff_make_msymbol_special = coff_make_msymbol_special;
 }
 
   gdbarch->coff_make_msymbol_special = coff_make_msymbol_special;
 }
 

-const char *
-gdbarch_name_of_malloc (struct gdbarch *gdbarch)
+int
+gdbarch_cannot_step_breakpoint (struct gdbarch *gdbarch)

 {
   gdb_assert (gdbarch != NULL);
 {
   gdb_assert (gdbarch != NULL);

-  /* Skip verify of name_of_malloc, invalid_p == 0 */
+  /* Skip verify of cannot_step_breakpoint, invalid_p == 0 */

   if (gdbarch_debug >= 2)
   if (gdbarch_debug >= 2)

-    fprintf_unfiltered (gdb_stdlog, "gdbarch_name_of_malloc called\n");
-  return gdbarch->name_of_malloc;
-}
-
-void
-set_gdbarch_name_of_malloc (struct gdbarch *gdbarch,
-                            const char * name_of_malloc)
-{
-  gdbarch->name_of_malloc = name_of_malloc;
-}
-
-int
-gdbarch_cannot_step_breakpoint (struct gdbarch *gdbarch)
-{
-  gdb_assert (gdbarch != NULL);
-  /* Skip verify of cannot_step_breakpoint, invalid_p == 0 */
-  if (gdbarch_debug >= 2)
-    fprintf_unfiltered (gdb_stdlog, "gdbarch_cannot_step_breakpoint called\n");
-  return gdbarch->cannot_step_breakpoint;
+    fprintf_unfiltered (gdb_stdlog, "gdbarch_cannot_step_breakpoint called\n");
+  return gdbarch->cannot_step_breakpoint;

 }
 
 void
 }
 
 void


@@ -2816,6 +3336,70 @@ set_gdbarch_regset_from_core_section (struct gdbarch *gdbarch,
   gdbarch->regset_from_core_section = regset_from_core_section;
 }
 
   gdbarch->regset_from_core_section = regset_from_core_section;
 }
 

+struct core_regset_section *
+gdbarch_core_regset_sections (struct gdbarch *gdbarch)
+{
+  gdb_assert (gdbarch != NULL);
+  if (gdbarch_debug >= 2)
+    fprintf_unfiltered (gdb_stdlog, "gdbarch_core_regset_sections called\n");
+  return gdbarch->core_regset_sections;
+}
+
+void
+set_gdbarch_core_regset_sections (struct gdbarch *gdbarch,
+                                  struct core_regset_section * core_regset_sections)
+{
+  gdbarch->core_regset_sections = core_regset_sections;
+}
+
+int
+gdbarch_make_corefile_notes_p (struct gdbarch *gdbarch)
+{
+  gdb_assert (gdbarch != NULL);
+  return gdbarch->make_corefile_notes != NULL;
+}
+
+char *
+gdbarch_make_corefile_notes (struct gdbarch *gdbarch, bfd *obfd, int *note_size)
+{
+  gdb_assert (gdbarch != NULL);
+  gdb_assert (gdbarch->make_corefile_notes != NULL);
+  if (gdbarch_debug >= 2)
+    fprintf_unfiltered (gdb_stdlog, "gdbarch_make_corefile_notes called\n");
+  return gdbarch->make_corefile_notes (gdbarch, obfd, note_size);
+}
+
+void
+set_gdbarch_make_corefile_notes (struct gdbarch *gdbarch,
+                                 gdbarch_make_corefile_notes_ftype make_corefile_notes)
+{
+  gdbarch->make_corefile_notes = make_corefile_notes;
+}
+
+int
+gdbarch_find_memory_regions_p (struct gdbarch *gdbarch)
+{
+  gdb_assert (gdbarch != NULL);
+  return gdbarch->find_memory_regions != NULL;
+}
+
+int
+gdbarch_find_memory_regions (struct gdbarch *gdbarch, find_memory_region_ftype func, void *data)
+{
+  gdb_assert (gdbarch != NULL);
+  gdb_assert (gdbarch->find_memory_regions != NULL);
+  if (gdbarch_debug >= 2)
+    fprintf_unfiltered (gdb_stdlog, "gdbarch_find_memory_regions called\n");
+  return gdbarch->find_memory_regions (gdbarch, func, data);
+}
+
+void
+set_gdbarch_find_memory_regions (struct gdbarch *gdbarch,
+                                 gdbarch_find_memory_regions_ftype find_memory_regions)
+{
+  gdbarch->find_memory_regions = find_memory_regions;
+}
+

 int
 gdbarch_core_xfer_shared_libraries_p (struct gdbarch *gdbarch)
 {
 int
 gdbarch_core_xfer_shared_libraries_p (struct gdbarch *gdbarch)
 {


@@ -2840,6 +3424,55 @@ set_gdbarch_core_xfer_shared_libraries (struct gdbarch *gdbarch,
   gdbarch->core_xfer_shared_libraries = core_xfer_shared_libraries;
 }
 
   gdbarch->core_xfer_shared_libraries = core_xfer_shared_libraries;
 }
 

+int
+gdbarch_core_pid_to_str_p (struct gdbarch *gdbarch)
+{
+  gdb_assert (gdbarch != NULL);
+  return gdbarch->core_pid_to_str != NULL;
+}
+
+char *
+gdbarch_core_pid_to_str (struct gdbarch *gdbarch, ptid_t ptid)
+{
+  gdb_assert (gdbarch != NULL);
+  gdb_assert (gdbarch->core_pid_to_str != NULL);
+  if (gdbarch_debug >= 2)
+    fprintf_unfiltered (gdb_stdlog, "gdbarch_core_pid_to_str called\n");
+  return gdbarch->core_pid_to_str (gdbarch, ptid);
+}
+
+void
+set_gdbarch_core_pid_to_str (struct gdbarch *gdbarch,
+                             gdbarch_core_pid_to_str_ftype core_pid_to_str)
+{
+  gdbarch->core_pid_to_str = core_pid_to_str;
+}
+
+int
+gdbarch_gcore_bfd_target_p (struct gdbarch *gdbarch)
+{
+  gdb_assert (gdbarch != NULL);
+  return gdbarch->gcore_bfd_target != 0;
+}
+
+const char *
+gdbarch_gcore_bfd_target (struct gdbarch *gdbarch)
+{
+  gdb_assert (gdbarch != NULL);
+  /* Check variable changed from pre-default.  */
+  gdb_assert (gdbarch->gcore_bfd_target != 0);
+  if (gdbarch_debug >= 2)
+    fprintf_unfiltered (gdb_stdlog, "gdbarch_gcore_bfd_target called\n");
+  return gdbarch->gcore_bfd_target;
+}
+
+void
+set_gdbarch_gcore_bfd_target (struct gdbarch *gdbarch,
+                              const char * gcore_bfd_target)
+{
+  gdbarch->gcore_bfd_target = gcore_bfd_target;
+}
+

 int
 gdbarch_vtable_function_descriptors (struct gdbarch *gdbarch)
 {
 int
 gdbarch_vtable_function_descriptors (struct gdbarch *gdbarch)
 {


@@ -2898,6 +3531,156 @@ set_gdbarch_skip_permanent_breakpoint (struct gdbarch *gdbarch,
   gdbarch->skip_permanent_breakpoint = skip_permanent_breakpoint;
 }
 
   gdbarch->skip_permanent_breakpoint = skip_permanent_breakpoint;
 }
 

+int
+gdbarch_max_insn_length_p (struct gdbarch *gdbarch)
+{
+  gdb_assert (gdbarch != NULL);
+  return gdbarch->max_insn_length != 0;
+}
+
+ULONGEST
+gdbarch_max_insn_length (struct gdbarch *gdbarch)
+{
+  gdb_assert (gdbarch != NULL);
+  /* Check variable changed from pre-default.  */
+  gdb_assert (gdbarch->max_insn_length != 0);
+  if (gdbarch_debug >= 2)
+    fprintf_unfiltered (gdb_stdlog, "gdbarch_max_insn_length called\n");
+  return gdbarch->max_insn_length;
+}
+
+void
+set_gdbarch_max_insn_length (struct gdbarch *gdbarch,
+                             ULONGEST max_insn_length)
+{
+  gdbarch->max_insn_length = max_insn_length;
+}
+
+int
+gdbarch_displaced_step_copy_insn_p (struct gdbarch *gdbarch)
+{
+  gdb_assert (gdbarch != NULL);
+  return gdbarch->displaced_step_copy_insn != NULL;
+}
+
+struct displaced_step_closure *
+gdbarch_displaced_step_copy_insn (struct gdbarch *gdbarch, CORE_ADDR from, CORE_ADDR to, struct regcache *regs)
+{
+  gdb_assert (gdbarch != NULL);
+  gdb_assert (gdbarch->displaced_step_copy_insn != NULL);
+  if (gdbarch_debug >= 2)
+    fprintf_unfiltered (gdb_stdlog, "gdbarch_displaced_step_copy_insn called\n");
+  return gdbarch->displaced_step_copy_insn (gdbarch, from, to, regs);
+}
+
+void
+set_gdbarch_displaced_step_copy_insn (struct gdbarch *gdbarch,
+                                      gdbarch_displaced_step_copy_insn_ftype displaced_step_copy_insn)
+{
+  gdbarch->displaced_step_copy_insn = displaced_step_copy_insn;
+}
+
+int
+gdbarch_displaced_step_hw_singlestep (struct gdbarch *gdbarch, struct displaced_step_closure *closure)
+{
+  gdb_assert (gdbarch != NULL);
+  gdb_assert (gdbarch->displaced_step_hw_singlestep != NULL);
+  if (gdbarch_debug >= 2)
+    fprintf_unfiltered (gdb_stdlog, "gdbarch_displaced_step_hw_singlestep called\n");
+  return gdbarch->displaced_step_hw_singlestep (gdbarch, closure);
+}
+
+void
+set_gdbarch_displaced_step_hw_singlestep (struct gdbarch *gdbarch,
+                                          gdbarch_displaced_step_hw_singlestep_ftype displaced_step_hw_singlestep)
+{
+  gdbarch->displaced_step_hw_singlestep = displaced_step_hw_singlestep;
+}
+
+int
+gdbarch_displaced_step_fixup_p (struct gdbarch *gdbarch)
+{
+  gdb_assert (gdbarch != NULL);
+  return gdbarch->displaced_step_fixup != NULL;
+}
+
+void
+gdbarch_displaced_step_fixup (struct gdbarch *gdbarch, struct displaced_step_closure *closure, CORE_ADDR from, CORE_ADDR to, struct regcache *regs)
+{
+  gdb_assert (gdbarch != NULL);
+  gdb_assert (gdbarch->displaced_step_fixup != NULL);
+  /* Do not check predicate: gdbarch->displaced_step_fixup != NULL, allow call.  */
+  if (gdbarch_debug >= 2)
+    fprintf_unfiltered (gdb_stdlog, "gdbarch_displaced_step_fixup called\n");
+  gdbarch->displaced_step_fixup (gdbarch, closure, from, to, regs);
+}
+
+void
+set_gdbarch_displaced_step_fixup (struct gdbarch *gdbarch,
+                                  gdbarch_displaced_step_fixup_ftype displaced_step_fixup)
+{
+  gdbarch->displaced_step_fixup = displaced_step_fixup;
+}
+
+void
+gdbarch_displaced_step_free_closure (struct gdbarch *gdbarch, struct displaced_step_closure *closure)
+{
+  gdb_assert (gdbarch != NULL);
+  gdb_assert (gdbarch->displaced_step_free_closure != NULL);
+  if (gdbarch_debug >= 2)
+    fprintf_unfiltered (gdb_stdlog, "gdbarch_displaced_step_free_closure called\n");
+  gdbarch->displaced_step_free_closure (gdbarch, closure);
+}
+
+void
+set_gdbarch_displaced_step_free_closure (struct gdbarch *gdbarch,
+                                         gdbarch_displaced_step_free_closure_ftype displaced_step_free_closure)
+{
+  gdbarch->displaced_step_free_closure = displaced_step_free_closure;
+}
+
+CORE_ADDR
+gdbarch_displaced_step_location (struct gdbarch *gdbarch)
+{
+  gdb_assert (gdbarch != NULL);
+  gdb_assert (gdbarch->displaced_step_location != NULL);
+  if (gdbarch_debug >= 2)
+    fprintf_unfiltered (gdb_stdlog, "gdbarch_displaced_step_location called\n");
+  return gdbarch->displaced_step_location (gdbarch);
+}
+
+void
+set_gdbarch_displaced_step_location (struct gdbarch *gdbarch,
+                                     gdbarch_displaced_step_location_ftype displaced_step_location)
+{
+  gdbarch->displaced_step_location = displaced_step_location;
+}
+
+int
+gdbarch_relocate_instruction_p (struct gdbarch *gdbarch)
+{
+  gdb_assert (gdbarch != NULL);
+  return gdbarch->relocate_instruction != NULL;
+}
+
+void
+gdbarch_relocate_instruction (struct gdbarch *gdbarch, CORE_ADDR *to, CORE_ADDR from)
+{
+  gdb_assert (gdbarch != NULL);
+  gdb_assert (gdbarch->relocate_instruction != NULL);
+  /* Do not check predicate: gdbarch->relocate_instruction != NULL, allow call.  */
+  if (gdbarch_debug >= 2)
+    fprintf_unfiltered (gdb_stdlog, "gdbarch_relocate_instruction called\n");
+  gdbarch->relocate_instruction (gdbarch, to, from);
+}
+
+void
+set_gdbarch_relocate_instruction (struct gdbarch *gdbarch,
+                                  gdbarch_relocate_instruction_ftype relocate_instruction)
+{
+  gdbarch->relocate_instruction = relocate_instruction;
+}
+

 int
 gdbarch_overlay_update_p (struct gdbarch *gdbarch)
 {
 int
 gdbarch_overlay_update_p (struct gdbarch *gdbarch)
 {


@@ -2953,8 +3736,8 @@ gdbarch_static_transform_name_p (struct gdbarch *gdbarch)
   return gdbarch->static_transform_name != NULL;
 }
 
   return gdbarch->static_transform_name != NULL;
 }
 

-char *
-gdbarch_static_transform_name (struct gdbarch *gdbarch, char *name)
+const char *
+gdbarch_static_transform_name (struct gdbarch *gdbarch, const char *name)

 {
   gdb_assert (gdbarch != NULL);
   gdb_assert (gdbarch->static_transform_name != NULL);
 {
   gdb_assert (gdbarch != NULL);
   gdb_assert (gdbarch->static_transform_name != NULL);


@@ -2987,9 +3770,530 @@ set_gdbarch_sofun_address_maybe_missing (struct gdbarch *gdbarch,
   gdbarch->sofun_address_maybe_missing = sofun_address_maybe_missing;
 }
 
   gdbarch->sofun_address_maybe_missing = sofun_address_maybe_missing;
 }
 

+int
+gdbarch_process_record_p (struct gdbarch *gdbarch)
+{
+  gdb_assert (gdbarch != NULL);
+  return gdbarch->process_record != NULL;
+}
+
+int
+gdbarch_process_record (struct gdbarch *gdbarch, struct regcache *regcache, CORE_ADDR addr)
+{
+  gdb_assert (gdbarch != NULL);
+  gdb_assert (gdbarch->process_record != NULL);
+  if (gdbarch_debug >= 2)
+    fprintf_unfiltered (gdb_stdlog, "gdbarch_process_record called\n");
+  return gdbarch->process_record (gdbarch, regcache, addr);
+}
+
+void
+set_gdbarch_process_record (struct gdbarch *gdbarch,
+                            gdbarch_process_record_ftype process_record)
+{
+  gdbarch->process_record = process_record;
+}
+
+int
+gdbarch_process_record_signal_p (struct gdbarch *gdbarch)
+{
+  gdb_assert (gdbarch != NULL);
+  return gdbarch->process_record_signal != NULL;
+}
+
+int
+gdbarch_process_record_signal (struct gdbarch *gdbarch, struct regcache *regcache, enum gdb_signal signal)
+{
+  gdb_assert (gdbarch != NULL);
+  gdb_assert (gdbarch->process_record_signal != NULL);
+  if (gdbarch_debug >= 2)
+    fprintf_unfiltered (gdb_stdlog, "gdbarch_process_record_signal called\n");
+  return gdbarch->process_record_signal (gdbarch, regcache, signal);
+}
+
+void
+set_gdbarch_process_record_signal (struct gdbarch *gdbarch,
+                                   gdbarch_process_record_signal_ftype process_record_signal)
+{
+  gdbarch->process_record_signal = process_record_signal;
+}
+
+int
+gdbarch_gdb_signal_from_target_p (struct gdbarch *gdbarch)
+{
+  gdb_assert (gdbarch != NULL);
+  return gdbarch->gdb_signal_from_target != NULL;
+}
+
+enum gdb_signal
+gdbarch_gdb_signal_from_target (struct gdbarch *gdbarch, int signo)
+{
+  gdb_assert (gdbarch != NULL);
+  gdb_assert (gdbarch->gdb_signal_from_target != NULL);
+  if (gdbarch_debug >= 2)
+    fprintf_unfiltered (gdb_stdlog, "gdbarch_gdb_signal_from_target called\n");
+  return gdbarch->gdb_signal_from_target (gdbarch, signo);
+}
+
+void
+set_gdbarch_gdb_signal_from_target (struct gdbarch *gdbarch,
+                                    gdbarch_gdb_signal_from_target_ftype gdb_signal_from_target)
+{
+  gdbarch->gdb_signal_from_target = gdb_signal_from_target;
+}
+
+int
+gdbarch_get_siginfo_type_p (struct gdbarch *gdbarch)
+{
+  gdb_assert (gdbarch != NULL);
+  return gdbarch->get_siginfo_type != NULL;
+}
+
+struct type *
+gdbarch_get_siginfo_type (struct gdbarch *gdbarch)
+{
+  gdb_assert (gdbarch != NULL);
+  gdb_assert (gdbarch->get_siginfo_type != NULL);
+  if (gdbarch_debug >= 2)
+    fprintf_unfiltered (gdb_stdlog, "gdbarch_get_siginfo_type called\n");
+  return gdbarch->get_siginfo_type (gdbarch);
+}
+
+void
+set_gdbarch_get_siginfo_type (struct gdbarch *gdbarch,
+                              gdbarch_get_siginfo_type_ftype get_siginfo_type)
+{
+  gdbarch->get_siginfo_type = get_siginfo_type;
+}
+
+int
+gdbarch_record_special_symbol_p (struct gdbarch *gdbarch)
+{
+  gdb_assert (gdbarch != NULL);
+  return gdbarch->record_special_symbol != NULL;
+}
+
+void
+gdbarch_record_special_symbol (struct gdbarch *gdbarch, struct objfile *objfile, asymbol *sym)
+{
+  gdb_assert (gdbarch != NULL);
+  gdb_assert (gdbarch->record_special_symbol != NULL);
+  if (gdbarch_debug >= 2)
+    fprintf_unfiltered (gdb_stdlog, "gdbarch_record_special_symbol called\n");
+  gdbarch->record_special_symbol (gdbarch, objfile, sym);
+}
+
+void
+set_gdbarch_record_special_symbol (struct gdbarch *gdbarch,
+                                   gdbarch_record_special_symbol_ftype record_special_symbol)
+{
+  gdbarch->record_special_symbol = record_special_symbol;
+}
+
+int
+gdbarch_get_syscall_number_p (struct gdbarch *gdbarch)
+{
+  gdb_assert (gdbarch != NULL);
+  return gdbarch->get_syscall_number != NULL;
+}
+
+LONGEST
+gdbarch_get_syscall_number (struct gdbarch *gdbarch, ptid_t ptid)
+{
+  gdb_assert (gdbarch != NULL);
+  gdb_assert (gdbarch->get_syscall_number != NULL);
+  if (gdbarch_debug >= 2)
+    fprintf_unfiltered (gdb_stdlog, "gdbarch_get_syscall_number called\n");
+  return gdbarch->get_syscall_number (gdbarch, ptid);
+}
+
+void
+set_gdbarch_get_syscall_number (struct gdbarch *gdbarch,
+                                gdbarch_get_syscall_number_ftype get_syscall_number)
+{
+  gdbarch->get_syscall_number = get_syscall_number;
+}
+
+const char *
+gdbarch_stap_integer_prefix (struct gdbarch *gdbarch)
+{
+  gdb_assert (gdbarch != NULL);
+  /* Skip verify of stap_integer_prefix, invalid_p == 0 */
+  if (gdbarch_debug >= 2)
+    fprintf_unfiltered (gdb_stdlog, "gdbarch_stap_integer_prefix called\n");
+  return gdbarch->stap_integer_prefix;
+}
+
+void
+set_gdbarch_stap_integer_prefix (struct gdbarch *gdbarch,
+                                 const char * stap_integer_prefix)
+{
+  gdbarch->stap_integer_prefix = stap_integer_prefix;
+}
+
+const char *
+gdbarch_stap_integer_suffix (struct gdbarch *gdbarch)
+{
+  gdb_assert (gdbarch != NULL);
+  /* Skip verify of stap_integer_suffix, invalid_p == 0 */
+  if (gdbarch_debug >= 2)
+    fprintf_unfiltered (gdb_stdlog, "gdbarch_stap_integer_suffix called\n");
+  return gdbarch->stap_integer_suffix;
+}
+
+void
+set_gdbarch_stap_integer_suffix (struct gdbarch *gdbarch,
+                                 const char * stap_integer_suffix)
+{
+  gdbarch->stap_integer_suffix = stap_integer_suffix;
+}
+
+const char *
+gdbarch_stap_register_prefix (struct gdbarch *gdbarch)
+{
+  gdb_assert (gdbarch != NULL);
+  /* Skip verify of stap_register_prefix, invalid_p == 0 */
+  if (gdbarch_debug >= 2)
+    fprintf_unfiltered (gdb_stdlog, "gdbarch_stap_register_prefix called\n");
+  return gdbarch->stap_register_prefix;
+}
+
+void
+set_gdbarch_stap_register_prefix (struct gdbarch *gdbarch,
+                                  const char * stap_register_prefix)
+{
+  gdbarch->stap_register_prefix = stap_register_prefix;
+}
+
+const char *
+gdbarch_stap_register_suffix (struct gdbarch *gdbarch)
+{
+  gdb_assert (gdbarch != NULL);
+  /* Skip verify of stap_register_suffix, invalid_p == 0 */
+  if (gdbarch_debug >= 2)
+    fprintf_unfiltered (gdb_stdlog, "gdbarch_stap_register_suffix called\n");
+  return gdbarch->stap_register_suffix;
+}
+
+void
+set_gdbarch_stap_register_suffix (struct gdbarch *gdbarch,
+                                  const char * stap_register_suffix)
+{
+  gdbarch->stap_register_suffix = stap_register_suffix;
+}
+
+const char *
+gdbarch_stap_register_indirection_prefix (struct gdbarch *gdbarch)
+{
+  gdb_assert (gdbarch != NULL);
+  /* Skip verify of stap_register_indirection_prefix, invalid_p == 0 */
+  if (gdbarch_debug >= 2)
+    fprintf_unfiltered (gdb_stdlog, "gdbarch_stap_register_indirection_prefix called\n");
+  return gdbarch->stap_register_indirection_prefix;
+}
+
+void
+set_gdbarch_stap_register_indirection_prefix (struct gdbarch *gdbarch,
+                                              const char * stap_register_indirection_prefix)
+{
+  gdbarch->stap_register_indirection_prefix = stap_register_indirection_prefix;
+}
+
+const char *
+gdbarch_stap_register_indirection_suffix (struct gdbarch *gdbarch)
+{
+  gdb_assert (gdbarch != NULL);
+  /* Skip verify of stap_register_indirection_suffix, invalid_p == 0 */
+  if (gdbarch_debug >= 2)
+    fprintf_unfiltered (gdb_stdlog, "gdbarch_stap_register_indirection_suffix called\n");
+  return gdbarch->stap_register_indirection_suffix;
+}
+
+void
+set_gdbarch_stap_register_indirection_suffix (struct gdbarch *gdbarch,
+                                              const char * stap_register_indirection_suffix)
+{
+  gdbarch->stap_register_indirection_suffix = stap_register_indirection_suffix;
+}
+
+const char *
+gdbarch_stap_gdb_register_prefix (struct gdbarch *gdbarch)
+{
+  gdb_assert (gdbarch != NULL);
+  /* Skip verify of stap_gdb_register_prefix, invalid_p == 0 */
+  if (gdbarch_debug >= 2)
+    fprintf_unfiltered (gdb_stdlog, "gdbarch_stap_gdb_register_prefix called\n");
+  return gdbarch->stap_gdb_register_prefix;
+}
+
+void
+set_gdbarch_stap_gdb_register_prefix (struct gdbarch *gdbarch,
+                                      const char * stap_gdb_register_prefix)
+{
+  gdbarch->stap_gdb_register_prefix = stap_gdb_register_prefix;
+}
+
+const char *
+gdbarch_stap_gdb_register_suffix (struct gdbarch *gdbarch)
+{
+  gdb_assert (gdbarch != NULL);
+  /* Skip verify of stap_gdb_register_suffix, invalid_p == 0 */
+  if (gdbarch_debug >= 2)
+    fprintf_unfiltered (gdb_stdlog, "gdbarch_stap_gdb_register_suffix called\n");
+  return gdbarch->stap_gdb_register_suffix;
+}
+
+void
+set_gdbarch_stap_gdb_register_suffix (struct gdbarch *gdbarch,
+                                      const char * stap_gdb_register_suffix)
+{
+  gdbarch->stap_gdb_register_suffix = stap_gdb_register_suffix;
+}
+
+int
+gdbarch_stap_is_single_operand_p (struct gdbarch *gdbarch)
+{
+  gdb_assert (gdbarch != NULL);
+  return gdbarch->stap_is_single_operand != NULL;
+}
+
+int
+gdbarch_stap_is_single_operand (struct gdbarch *gdbarch, const char *s)
+{
+  gdb_assert (gdbarch != NULL);
+  gdb_assert (gdbarch->stap_is_single_operand != NULL);
+  if (gdbarch_debug >= 2)
+    fprintf_unfiltered (gdb_stdlog, "gdbarch_stap_is_single_operand called\n");
+  return gdbarch->stap_is_single_operand (gdbarch, s);
+}
+
+void
+set_gdbarch_stap_is_single_operand (struct gdbarch *gdbarch,
+                                    gdbarch_stap_is_single_operand_ftype stap_is_single_operand)
+{
+  gdbarch->stap_is_single_operand = stap_is_single_operand;
+}
+
+int
+gdbarch_stap_parse_special_token_p (struct gdbarch *gdbarch)
+{
+  gdb_assert (gdbarch != NULL);
+  return gdbarch->stap_parse_special_token != NULL;
+}
+
+int
+gdbarch_stap_parse_special_token (struct gdbarch *gdbarch, struct stap_parse_info *p)
+{
+  gdb_assert (gdbarch != NULL);
+  gdb_assert (gdbarch->stap_parse_special_token != NULL);
+  if (gdbarch_debug >= 2)
+    fprintf_unfiltered (gdb_stdlog, "gdbarch_stap_parse_special_token called\n");
+  return gdbarch->stap_parse_special_token (gdbarch, p);
+}
+
+void
+set_gdbarch_stap_parse_special_token (struct gdbarch *gdbarch,
+                                      gdbarch_stap_parse_special_token_ftype stap_parse_special_token)
+{
+  gdbarch->stap_parse_special_token = stap_parse_special_token;
+}
+
+int
+gdbarch_has_global_solist (struct gdbarch *gdbarch)
+{
+  gdb_assert (gdbarch != NULL);
+  /* Skip verify of has_global_solist, invalid_p == 0 */
+  if (gdbarch_debug >= 2)
+    fprintf_unfiltered (gdb_stdlog, "gdbarch_has_global_solist called\n");
+  return gdbarch->has_global_solist;
+}
+
+void
+set_gdbarch_has_global_solist (struct gdbarch *gdbarch,
+                               int has_global_solist)
+{
+  gdbarch->has_global_solist = has_global_solist;
+}
+
+int
+gdbarch_has_global_breakpoints (struct gdbarch *gdbarch)
+{
+  gdb_assert (gdbarch != NULL);
+  /* Skip verify of has_global_breakpoints, invalid_p == 0 */
+  if (gdbarch_debug >= 2)
+    fprintf_unfiltered (gdb_stdlog, "gdbarch_has_global_breakpoints called\n");
+  return gdbarch->has_global_breakpoints;
+}
+
+void
+set_gdbarch_has_global_breakpoints (struct gdbarch *gdbarch,
+                                    int has_global_breakpoints)
+{
+  gdbarch->has_global_breakpoints = has_global_breakpoints;
+}
+
+int
+gdbarch_has_shared_address_space (struct gdbarch *gdbarch)
+{
+  gdb_assert (gdbarch != NULL);
+  gdb_assert (gdbarch->has_shared_address_space != NULL);
+  if (gdbarch_debug >= 2)
+    fprintf_unfiltered (gdb_stdlog, "gdbarch_has_shared_address_space called\n");
+  return gdbarch->has_shared_address_space (gdbarch);
+}
+
+void
+set_gdbarch_has_shared_address_space (struct gdbarch *gdbarch,
+                                      gdbarch_has_shared_address_space_ftype has_shared_address_space)
+{
+  gdbarch->has_shared_address_space = has_shared_address_space;
+}
+
+int
+gdbarch_fast_tracepoint_valid_at (struct gdbarch *gdbarch, CORE_ADDR addr, int *isize, char **msg)
+{
+  gdb_assert (gdbarch != NULL);
+  gdb_assert (gdbarch->fast_tracepoint_valid_at != NULL);
+  if (gdbarch_debug >= 2)
+    fprintf_unfiltered (gdb_stdlog, "gdbarch_fast_tracepoint_valid_at called\n");
+  return gdbarch->fast_tracepoint_valid_at (gdbarch, addr, isize, msg);
+}
+
+void
+set_gdbarch_fast_tracepoint_valid_at (struct gdbarch *gdbarch,
+                                      gdbarch_fast_tracepoint_valid_at_ftype fast_tracepoint_valid_at)
+{
+  gdbarch->fast_tracepoint_valid_at = fast_tracepoint_valid_at;
+}
+
+const char *
+gdbarch_auto_charset (struct gdbarch *gdbarch)
+{
+  gdb_assert (gdbarch != NULL);
+  gdb_assert (gdbarch->auto_charset != NULL);
+  if (gdbarch_debug >= 2)
+    fprintf_unfiltered (gdb_stdlog, "gdbarch_auto_charset called\n");
+  return gdbarch->auto_charset ();
+}
+
+void
+set_gdbarch_auto_charset (struct gdbarch *gdbarch,
+                          gdbarch_auto_charset_ftype auto_charset)
+{
+  gdbarch->auto_charset = auto_charset;
+}
+
+const char *
+gdbarch_auto_wide_charset (struct gdbarch *gdbarch)
+{
+  gdb_assert (gdbarch != NULL);
+  gdb_assert (gdbarch->auto_wide_charset != NULL);
+  if (gdbarch_debug >= 2)
+    fprintf_unfiltered (gdb_stdlog, "gdbarch_auto_wide_charset called\n");
+  return gdbarch->auto_wide_charset ();
+}
+
+void
+set_gdbarch_auto_wide_charset (struct gdbarch *gdbarch,
+                               gdbarch_auto_wide_charset_ftype auto_wide_charset)
+{
+  gdbarch->auto_wide_charset = auto_wide_charset;
+}
+
+const char *
+gdbarch_solib_symbols_extension (struct gdbarch *gdbarch)
+{
+  gdb_assert (gdbarch != NULL);
+  if (gdbarch_debug >= 2)
+    fprintf_unfiltered (gdb_stdlog, "gdbarch_solib_symbols_extension called\n");
+  return gdbarch->solib_symbols_extension;
+}
+
+void
+set_gdbarch_solib_symbols_extension (struct gdbarch *gdbarch,
+                                     const char * solib_symbols_extension)
+{
+  gdbarch->solib_symbols_extension = solib_symbols_extension;
+}
+
+int
+gdbarch_has_dos_based_file_system (struct gdbarch *gdbarch)
+{
+  gdb_assert (gdbarch != NULL);
+  /* Skip verify of has_dos_based_file_system, invalid_p == 0 */
+  if (gdbarch_debug >= 2)
+    fprintf_unfiltered (gdb_stdlog, "gdbarch_has_dos_based_file_system called\n");
+  return gdbarch->has_dos_based_file_system;
+}
+
+void
+set_gdbarch_has_dos_based_file_system (struct gdbarch *gdbarch,
+                                       int has_dos_based_file_system)
+{
+  gdbarch->has_dos_based_file_system = has_dos_based_file_system;
+}
+
+void
+gdbarch_gen_return_address (struct gdbarch *gdbarch, struct agent_expr *ax, struct axs_value *value, CORE_ADDR scope)
+{
+  gdb_assert (gdbarch != NULL);
+  gdb_assert (gdbarch->gen_return_address != NULL);
+  if (gdbarch_debug >= 2)
+    fprintf_unfiltered (gdb_stdlog, "gdbarch_gen_return_address called\n");
+  gdbarch->gen_return_address (gdbarch, ax, value, scope);
+}
+
+void
+set_gdbarch_gen_return_address (struct gdbarch *gdbarch,
+                                gdbarch_gen_return_address_ftype gen_return_address)
+{
+  gdbarch->gen_return_address = gen_return_address;
+}
+
+int
+gdbarch_info_proc_p (struct gdbarch *gdbarch)
+{
+  gdb_assert (gdbarch != NULL);
+  return gdbarch->info_proc != NULL;
+}
+
+void
+gdbarch_info_proc (struct gdbarch *gdbarch, char *args, enum info_proc_what what)
+{
+  gdb_assert (gdbarch != NULL);
+  gdb_assert (gdbarch->info_proc != NULL);
+  if (gdbarch_debug >= 2)
+    fprintf_unfiltered (gdb_stdlog, "gdbarch_info_proc called\n");
+  gdbarch->info_proc (gdbarch, args, what);
+}
+
+void
+set_gdbarch_info_proc (struct gdbarch *gdbarch,
+                       gdbarch_info_proc_ftype info_proc)
+{
+  gdbarch->info_proc = info_proc;
+}
+
+void
+gdbarch_iterate_over_objfiles_in_search_order (struct gdbarch *gdbarch, iterate_over_objfiles_in_search_order_cb_ftype *cb, void *cb_data, struct objfile *current_objfile)
+{
+  gdb_assert (gdbarch != NULL);
+  gdb_assert (gdbarch->iterate_over_objfiles_in_search_order != NULL);
+  if (gdbarch_debug >= 2)
+    fprintf_unfiltered (gdb_stdlog, "gdbarch_iterate_over_objfiles_in_search_order called\n");
+  gdbarch->iterate_over_objfiles_in_search_order (gdbarch, cb, cb_data, current_objfile);
+}
+
+void
+set_gdbarch_iterate_over_objfiles_in_search_order (struct gdbarch *gdbarch,
+                                                   gdbarch_iterate_over_objfiles_in_search_order_ftype iterate_over_objfiles_in_search_order)
+{
+  gdbarch->iterate_over_objfiles_in_search_order = iterate_over_objfiles_in_search_order;
+}
+

 
 /* Keep a registry of per-architecture data-pointers required by GDB
 
 /* Keep a registry of per-architecture data-pointers required by GDB

-   modules. */
+   modules.  */

 
 struct gdbarch_data
 {
 
 struct gdbarch_data
 {


@@ -3021,7 +4325,8 @@ gdbarch_data_register (gdbarch_data_pre_init_ftype *pre_init,
                       gdbarch_data_post_init_ftype *post_init)
 {
   struct gdbarch_data_registration **curr;
                       gdbarch_data_post_init_ftype *post_init)
 {
   struct gdbarch_data_registration **curr;

-  /* Append the new registraration.  */
+
+  /* Append the new registration.  */

   for (curr = &gdbarch_data_registry.registrations;
        (*curr) != NULL;
        curr = &(*curr)->next);
   for (curr = &gdbarch_data_registry.registrations;
        (*curr) != NULL;
        curr = &(*curr)->next);


@@ -3047,7 +4352,7 @@ gdbarch_data_register_post_init (gdbarch_data_post_init_ftype *post_init)
   return gdbarch_data_register (NULL, post_init);
 }
 
   return gdbarch_data_register (NULL, post_init);
 }
 

-/* Create/delete the gdbarch data vector. */
+/* Create/delete the gdbarch data vector.  */

 
 static void
 alloc_gdbarch_data (struct gdbarch *gdbarch)
 
 static void
 alloc_gdbarch_data (struct gdbarch *gdbarch)


@@ -3058,7 +4363,7 @@ alloc_gdbarch_data (struct gdbarch *gdbarch)
 }
 
 /* Initialize the current value of the specified per-architecture
 }
 
 /* Initialize the current value of the specified per-architecture

-   data-pointer. */
+   data-pointer.  */

 
 void
 deprecated_set_gdbarch_data (struct gdbarch *gdbarch,
 
 void
 deprecated_set_gdbarch_data (struct gdbarch *gdbarch,


@@ -3072,7 +4377,7 @@ deprecated_set_gdbarch_data (struct gdbarch *gdbarch,
 }
 
 /* Return the current value of the specified per-architecture
 }
 
 /* Return the current value of the specified per-architecture

-   data-pointer. */
+   data-pointer.  */

 
 void *
 gdbarch_data (struct gdbarch *gdbarch, struct gdbarch_data *data)
 
 void *
 gdbarch_data (struct gdbarch *gdbarch, struct gdbarch_data *data)


@@ -3111,7 +4416,7 @@ gdbarch_data (struct gdbarch *gdbarch, struct gdbarch_data *data)
 }
 
 
 }
 
 

-/* Keep a registry of the architectures known by GDB. */
+/* Keep a registry of the architectures known by GDB.  */

 
 struct gdbarch_registration
 {
 
 struct gdbarch_registration
 {


@@ -3136,11 +4441,11 @@ const char **
 gdbarch_printable_names (void)
 {
   /* Accumulate a list of names based on the registed list of
 gdbarch_printable_names (void)
 {
   /* Accumulate a list of names based on the registed list of

-     architectures. */
-  enum bfd_architecture a;
+     architectures.  */

   int nr_arches = 0;
   const char **arches = NULL;
   struct gdbarch_registration *rego;
   int nr_arches = 0;
   const char **arches = NULL;
   struct gdbarch_registration *rego;

+

   for (rego = gdbarch_registry;
        rego != NULL;
        rego = rego->next)
   for (rego = gdbarch_registry;
        rego != NULL;
        rego = rego->next)


@@ -3169,29 +4474,32 @@ gdbarch_register (enum bfd_architecture bfd_architecture,
 {
   struct gdbarch_registration **curr;
   const struct bfd_arch_info *bfd_arch_info;
 {
   struct gdbarch_registration **curr;
   const struct bfd_arch_info *bfd_arch_info;

+

   /* Check that BFD recognizes this architecture */
   bfd_arch_info = bfd_lookup_arch (bfd_architecture, 0);
   if (bfd_arch_info == NULL)
     {
       internal_error (__FILE__, __LINE__,
   /* Check that BFD recognizes this architecture */
   bfd_arch_info = bfd_lookup_arch (bfd_architecture, 0);
   if (bfd_arch_info == NULL)
     {
       internal_error (__FILE__, __LINE__,

-                      _("gdbarch: Attempt to register unknown architecture (%d)"),
+                      _("gdbarch: Attempt to register "
+                       "unknown architecture (%d)"),

                       bfd_architecture);
     }
                       bfd_architecture);
     }

-  /* Check that we haven't seen this architecture before */
+  /* Check that we haven't seen this architecture before.  */

   for (curr = &gdbarch_registry;
        (*curr) != NULL;
        curr = &(*curr)->next)
     {
       if (bfd_architecture == (*curr)->bfd_architecture)
        internal_error (__FILE__, __LINE__,
   for (curr = &gdbarch_registry;
        (*curr) != NULL;
        curr = &(*curr)->next)
     {
       if (bfd_architecture == (*curr)->bfd_architecture)
        internal_error (__FILE__, __LINE__,

-                        _("gdbarch: Duplicate registraration of architecture (%s)"),
+                        _("gdbarch: Duplicate registration "
+                         "of architecture (%s)"),

                        bfd_arch_info->printable_name);
     }
   /* log it */
   if (gdbarch_debug)
                        bfd_arch_info->printable_name);
     }
   /* log it */
   if (gdbarch_debug)

-    fprintf_unfiltered (gdb_stdlog, "register_gdbarch_init (%s, 0x%08lx)\n",
+    fprintf_unfiltered (gdb_stdlog, "register_gdbarch_init (%s, %s)\n",

                        bfd_arch_info->printable_name,
                        bfd_arch_info->printable_name,

-                       (long) init);
+                       host_address_to_string (init));

   /* Append it */
   (*curr) = XMALLOC (struct gdbarch_registration);
   (*curr)->bfd_architecture = bfd_architecture;
   /* Append it */
   (*curr) = XMALLOC (struct gdbarch_registration);
   (*curr)->bfd_architecture = bfd_architecture;


@@ -3232,49 +4540,44 @@ gdbarch_list_lookup_by_info (struct gdbarch_list *arches,
 
 
 /* Find an architecture that matches the specified INFO.  Create a new
 
 
 /* Find an architecture that matches the specified INFO.  Create a new

-   architecture if needed.  Return that new architecture.  Assumes
-   that there is no current architecture.  */
+   architecture if needed.  Return that new architecture.  */

 
 

-static struct gdbarch *
-find_arch_by_info (struct gdbarch_info info)
+struct gdbarch *
+gdbarch_find_by_info (struct gdbarch_info info)

 {
   struct gdbarch *new_gdbarch;
   struct gdbarch_registration *rego;
 
 {
   struct gdbarch *new_gdbarch;
   struct gdbarch_registration *rego;
 

-  /* The existing architecture has been swapped out - all this code
-     works from a clean slate.  */
-  gdb_assert (current_gdbarch == NULL);
-

   /* Fill in missing parts of the INFO struct using a number of
      sources: "set ..."; INFOabfd supplied; and the global
      defaults.  */
   gdbarch_info_fill (&info);
 
   /* Fill in missing parts of the INFO struct using a number of
      sources: "set ..."; INFOabfd supplied; and the global
      defaults.  */
   gdbarch_info_fill (&info);
 

-  /* Must have found some sort of architecture. */
+  /* Must have found some sort of architecture.  */

   gdb_assert (info.bfd_arch_info != NULL);
 
   if (gdbarch_debug)
     {
       fprintf_unfiltered (gdb_stdlog,
   gdb_assert (info.bfd_arch_info != NULL);
 
   if (gdbarch_debug)
     {
       fprintf_unfiltered (gdb_stdlog,

-                         "find_arch_by_info: info.bfd_arch_info %s\n",
+                         "gdbarch_find_by_info: info.bfd_arch_info %s\n",

                          (info.bfd_arch_info != NULL
                           ? info.bfd_arch_info->printable_name
                           : "(null)"));
       fprintf_unfiltered (gdb_stdlog,
                          (info.bfd_arch_info != NULL
                           ? info.bfd_arch_info->printable_name
                           : "(null)"));
       fprintf_unfiltered (gdb_stdlog,

-                         "find_arch_by_info: info.byte_order %d (%s)\n",
+                         "gdbarch_find_by_info: info.byte_order %d (%s)\n",

                          info.byte_order,
                          (info.byte_order == BFD_ENDIAN_BIG ? "big"
                           : info.byte_order == BFD_ENDIAN_LITTLE ? "little"
                           : "default"));
       fprintf_unfiltered (gdb_stdlog,
                          info.byte_order,
                          (info.byte_order == BFD_ENDIAN_BIG ? "big"
                           : info.byte_order == BFD_ENDIAN_LITTLE ? "little"
                           : "default"));
       fprintf_unfiltered (gdb_stdlog,

-                         "find_arch_by_info: info.osabi %d (%s)\n",
+                         "gdbarch_find_by_info: info.osabi %d (%s)\n",

                          info.osabi, gdbarch_osabi_name (info.osabi));
       fprintf_unfiltered (gdb_stdlog,
                          info.osabi, gdbarch_osabi_name (info.osabi));
       fprintf_unfiltered (gdb_stdlog,

-                         "find_arch_by_info: info.abfd 0x%lx\n",
-                         (long) info.abfd);
+                         "gdbarch_find_by_info: info.abfd %s\n",
+                         host_address_to_string (info.abfd));

       fprintf_unfiltered (gdb_stdlog,
       fprintf_unfiltered (gdb_stdlog,

-                         "find_arch_by_info: info.tdep_info 0x%lx\n",
-                         (long) info.tdep_info);
+                         "gdbarch_find_by_info: info.tdep_info %s\n",
+                         host_address_to_string (info.tdep_info));

     }
 
   /* Find the tdep code that knows about this architecture.  */
     }
 
   /* Find the tdep code that knows about this architecture.  */


@@ -3286,7 +4589,7 @@ find_arch_by_info (struct gdbarch_info info)
   if (rego == NULL)
     {
       if (gdbarch_debug)
   if (rego == NULL)
     {
       if (gdbarch_debug)

-       fprintf_unfiltered (gdb_stdlog, "find_arch_by_info: "
+       fprintf_unfiltered (gdb_stdlog, "gdbarch_find_by_info: "

                            "No matching architecture\n");
       return 0;
     }
                            "No matching architecture\n");
       return 0;
     }


@@ -3299,7 +4602,7 @@ find_arch_by_info (struct gdbarch_info info)
   if (new_gdbarch == NULL)
     {
       if (gdbarch_debug)
   if (new_gdbarch == NULL)
     {
       if (gdbarch_debug)

-       fprintf_unfiltered (gdb_stdlog, "find_arch_by_info: "
+       fprintf_unfiltered (gdb_stdlog, "gdbarch_find_by_info: "

                            "Target rejected architecture\n");
       return NULL;
     }
                            "Target rejected architecture\n");
       return NULL;
     }


@@ -3312,9 +4615,9 @@ find_arch_by_info (struct gdbarch_info info)
       struct gdbarch_list **list;
       struct gdbarch_list *this;
       if (gdbarch_debug)
       struct gdbarch_list **list;
       struct gdbarch_list *this;
       if (gdbarch_debug)

-       fprintf_unfiltered (gdb_stdlog, "find_arch_by_info: "
-                           "Previous architecture 0x%08lx (%s) selected\n",
-                           (long) new_gdbarch,
+       fprintf_unfiltered (gdb_stdlog, "gdbarch_find_by_info: "
+                           "Previous architecture %s (%s) selected\n",
+                           host_address_to_string (new_gdbarch),

                            new_gdbarch->bfd_arch_info->printable_name);
       /* Find the existing arch in the list.  */
       for (list = &rego->arches;
                            new_gdbarch->bfd_arch_info->printable_name);
       /* Find the existing arch in the list.  */
       for (list = &rego->arches;


@@ -3334,9 +4637,9 @@ find_arch_by_info (struct gdbarch_info info)
 
   /* It's a new architecture.  */
   if (gdbarch_debug)
 
   /* It's a new architecture.  */
   if (gdbarch_debug)

-    fprintf_unfiltered (gdb_stdlog, "find_arch_by_info: "
-                       "New architecture 0x%08lx (%s) selected\n",
-                       (long) new_gdbarch,
+    fprintf_unfiltered (gdb_stdlog, "gdbarch_find_by_info: "
+                       "New architecture %s (%s) selected\n",
+                       host_address_to_string (new_gdbarch),

                        new_gdbarch->bfd_arch_info->printable_name);
   
   /* Insert the new architecture into the front of the architecture
                        new_gdbarch->bfd_arch_info->printable_name);
   
   /* Insert the new architecture into the front of the architecture


@@ -3360,41 +4663,24 @@ find_arch_by_info (struct gdbarch_info info)
   return new_gdbarch;
 }
 
   return new_gdbarch;
 }
 

-struct gdbarch *
-gdbarch_find_by_info (struct gdbarch_info info)
-{
-  struct gdbarch *new_gdbarch;
-
-  /* Save the previously selected architecture, setting the global to
-     NULL.  This stops things like gdbarch->init() trying to use the
-     previous architecture's configuration.  The previous architecture
-     may not even be of the same architecture family.  The most recent
-     architecture of the same family is found at the head of the
-     rego->arches list.  */
-  struct gdbarch *old_gdbarch = current_gdbarch;
-  current_gdbarch = NULL;
-
-  /* Find the specified architecture.  */
-  new_gdbarch = find_arch_by_info (info);
-
-  /* Restore the existing architecture.  */
-  gdb_assert (current_gdbarch == NULL);
-  current_gdbarch = old_gdbarch;
-
-  return new_gdbarch;
-}
-

 /* Make the specified architecture current.  */
 
 void
 /* Make the specified architecture current.  */
 
 void

-deprecated_current_gdbarch_select_hack (struct gdbarch *new_gdbarch)
+deprecated_target_gdbarch_select_hack (struct gdbarch *new_gdbarch)

 {
   gdb_assert (new_gdbarch != NULL);
 {
   gdb_assert (new_gdbarch != NULL);

-  gdb_assert (current_gdbarch != NULL);

   gdb_assert (new_gdbarch->initialized_p);
   gdb_assert (new_gdbarch->initialized_p);

-  current_gdbarch = new_gdbarch;
-  architecture_changed_event ();
-  reinit_frame_cache ();
+  current_inferior ()->gdbarch = new_gdbarch;
+  observer_notify_architecture_changed (new_gdbarch);
+  registers_changed ();
+}
+
+/* Return the current inferior's arch.  */
+
+struct gdbarch *
+target_gdbarch (void)
+{
+  return current_inferior ()->gdbarch;

 }
 
 extern void _initialize_gdbarch (void);
 }
 
 extern void _initialize_gdbarch (void);


@@ -3402,9 +4688,7 @@ extern void _initialize_gdbarch (void);
 void
 _initialize_gdbarch (void)
 {
 void
 _initialize_gdbarch (void)
 {

-  struct cmd_list_element *c;
-
-  add_setshow_zinteger_cmd ("arch", class_maintenance, &gdbarch_debug, _("\
+  add_setshow_zuinteger_cmd ("arch", class_maintenance, &gdbarch_debug, _("\

 Set architecture debugging."), _("\
 Show architecture debugging."), _("\
 When non-zero, architecture debugging is enabled."),
 Set architecture debugging."), _("\
 Show architecture debugging."), _("\
 When non-zero, architecture debugging is enabled."),