gdb/gdbarch.c

   1 /* *INDENT-OFF* */ /* THIS FILE IS GENERATED */
   2
   3 /* Dynamic architecture support for GDB, the GNU debugger.
   4
   5    Copyright 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005 Free
   6    Software Foundation, Inc.
   7
   8    This file is part of GDB.
   9
  10    This program is free software; you can redistribute it and/or modify
  11    it under the terms of the GNU General Public License as published by
  12    the Free Software Foundation; either version 2 of the License, or
  13    (at your option) any later version.
  14
  15    This program is distributed in the hope that it will be useful,
  16    but WITHOUT ANY WARRANTY; without even the implied warranty of
  17    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18    GNU General Public License for more details.
  19
  20    You should have received a copy of the GNU General Public License
  21    along with this program; if not, write to the Free Software
  22    Foundation, Inc., 59 Temple Place - Suite 330,
  23    Boston, MA 02111-1307, USA.  */
  24
  25 /* This file was created with the aid of ``gdbarch.sh''.
  26
  27    The Bourne shell script ``gdbarch.sh'' creates the files
  28    ``new-gdbarch.c'' and ``new-gdbarch.h and then compares them
  29    against the existing ``gdbarch.[hc]''.  Any differences found
  30    being reported.
  31
  32    If editing this file, please also run gdbarch.sh and merge any
  33    changes into that script. Conversely, when making sweeping changes
  34    to this file, modifying gdbarch.sh and using its output may prove
  35    easier. */
  36
  37
  38 #include "defs.h"
  39 #include "arch-utils.h"
  40
  41 #include "gdbcmd.h"
  42 #include "inferior.h" /* enum CALL_DUMMY_LOCATION et.al. */
  43 #include "symcat.h"
  44
  45 #include "floatformat.h"
  46
  47 #include "gdb_assert.h"
  48 #include "gdb_string.h"
  49 #include "gdb-events.h"
  50 #include "reggroups.h"
  51 #include "osabi.h"
  52 #include "gdb_obstack.h"
  53
  54 /* Static function declarations */
  55
  56 static void alloc_gdbarch_data (struct gdbarch *);
  57
  58 /* Non-zero if we want to trace architecture code.  */
  59
  60 #ifndef GDBARCH_DEBUG
  61 #define GDBARCH_DEBUG 0
  62 #endif
  63 int gdbarch_debug = GDBARCH_DEBUG;
  64
  65 static const char *
  66 pformat (const struct floatformat *format)
  67 {
  68   if (format == NULL)
  69     return "(null)";
  70   else
  71     return  format->name;
  72 }
  73
  74
  75 /* Maintain the struct gdbarch object */
  76
  77 struct gdbarch
  78 {
  79   /* Has this architecture been fully initialized?  */
  80   int initialized_p;
  81
  82   /* An obstack bound to the lifetime of the architecture.  */
  83   struct obstack *obstack;
  84
  85   /* basic architectural information */
  86   const struct bfd_arch_info * bfd_arch_info;
  87   int byte_order;
  88   enum gdb_osabi osabi;
  89
  90   /* target specific vector. */
  91   struct gdbarch_tdep *tdep;
  92   gdbarch_dump_tdep_ftype *dump_tdep;
  93
  94   /* per-architecture data-pointers */
  95   unsigned nr_data;
  96   void **data;
  97
  98   /* per-architecture swap-regions */
  99   struct gdbarch_swap *swap;
 100
 101   /* Multi-arch values.
 102
 103      When extending this structure you must:
 104
 105      Add the field below.
 106
 107      Declare set/get functions and define the corresponding
 108      macro in gdbarch.h.
 109
 110      gdbarch_alloc(): If zero/NULL is not a suitable default,
 111      initialize the new field.
 112
 113      verify_gdbarch(): Confirm that the target updated the field
 114      correctly.
 115
 116      gdbarch_dump(): Add a fprintf_unfiltered call so that the new
 117      field is dumped out
 118
 119      ``startup_gdbarch()'': Append an initial value to the static
 120      variable (base values on the host's c-type system).
 121
 122      get_gdbarch(): Implement the set/get functions (probably using
 123      the macro's as shortcuts).
 124
 125      */
 126
 127   int short_bit;
 128   int int_bit;
 129   int long_bit;
 130   int long_long_bit;
 131   int float_bit;
 132   const struct floatformat * float_format;
 133   int double_bit;
 134   const struct floatformat * double_format;
 135   int long_double_bit;
 136   const struct floatformat * long_double_format;
 137   int ptr_bit;
 138   int addr_bit;
 139   int bfd_vma_bit;
 140   int char_signed;
 141   gdbarch_read_pc_ftype *read_pc;
 142   gdbarch_write_pc_ftype *write_pc;
 143   gdbarch_read_sp_ftype *read_sp;
 144   gdbarch_virtual_frame_pointer_ftype *virtual_frame_pointer;
 145   gdbarch_pseudo_register_read_ftype *pseudo_register_read;
 146   gdbarch_pseudo_register_write_ftype *pseudo_register_write;
 147   int num_regs;
 148   int num_pseudo_regs;
 149   int sp_regnum;
 150   int pc_regnum;
 151   int ps_regnum;
 152   int fp0_regnum;
 153   gdbarch_stab_reg_to_regnum_ftype *stab_reg_to_regnum;
 154   gdbarch_ecoff_reg_to_regnum_ftype *ecoff_reg_to_regnum;
 155   gdbarch_dwarf_reg_to_regnum_ftype *dwarf_reg_to_regnum;
 156   gdbarch_sdb_reg_to_regnum_ftype *sdb_reg_to_regnum;
 157   gdbarch_dwarf2_reg_to_regnum_ftype *dwarf2_reg_to_regnum;
 158   gdbarch_register_name_ftype *register_name;
 159   gdbarch_register_type_ftype *register_type;
 160   gdbarch_deprecated_register_byte_ftype *deprecated_register_byte;
 161   gdbarch_unwind_dummy_id_ftype *unwind_dummy_id;
 162   int deprecated_fp_regnum;
 163   gdbarch_push_dummy_call_ftype *push_dummy_call;
 164   gdbarch_deprecated_push_arguments_ftype *deprecated_push_arguments;
 165   int deprecated_register_size;
 166   int call_dummy_location;
 167   gdbarch_push_dummy_code_ftype *push_dummy_code;
 168   gdbarch_print_registers_info_ftype *print_registers_info;
 169   gdbarch_print_float_info_ftype *print_float_info;
 170   gdbarch_print_vector_info_ftype *print_vector_info;
 171   gdbarch_register_sim_regno_ftype *register_sim_regno;
 172   gdbarch_register_bytes_ok_ftype *register_bytes_ok;
 173   gdbarch_cannot_fetch_register_ftype *cannot_fetch_register;
 174   gdbarch_cannot_store_register_ftype *cannot_store_register;
 175   gdbarch_get_longjmp_target_ftype *get_longjmp_target;
 176   int believe_pcc_promotion;
 177   gdbarch_convert_register_p_ftype *convert_register_p;
 178   gdbarch_register_to_value_ftype *register_to_value;
 179   gdbarch_value_to_register_ftype *value_to_register;
 180   gdbarch_pointer_to_address_ftype *pointer_to_address;
 181   gdbarch_address_to_pointer_ftype *address_to_pointer;
 182   gdbarch_integer_to_address_ftype *integer_to_address;
 183   gdbarch_deprecated_store_struct_return_ftype *deprecated_store_struct_return;
 184   gdbarch_return_value_ftype *return_value;
 185   gdbarch_extract_return_value_ftype *extract_return_value;
 186   gdbarch_store_return_value_ftype *store_return_value;
 187   gdbarch_deprecated_extract_return_value_ftype *deprecated_extract_return_value;
 188   gdbarch_deprecated_store_return_value_ftype *deprecated_store_return_value;
 189   gdbarch_deprecated_use_struct_convention_ftype *deprecated_use_struct_convention;
 190   gdbarch_deprecated_extract_struct_value_address_ftype *deprecated_extract_struct_value_address;
 191   gdbarch_skip_prologue_ftype *skip_prologue;
 192   gdbarch_inner_than_ftype *inner_than;
 193   gdbarch_breakpoint_from_pc_ftype *breakpoint_from_pc;
 194   gdbarch_adjust_breakpoint_address_ftype *adjust_breakpoint_address;
 195   gdbarch_memory_insert_breakpoint_ftype *memory_insert_breakpoint;
 196   gdbarch_memory_remove_breakpoint_ftype *memory_remove_breakpoint;
 197   CORE_ADDR decr_pc_after_break;
 198   CORE_ADDR deprecated_function_start_offset;
 199   gdbarch_remote_translate_xfer_address_ftype *remote_translate_xfer_address;
 200   CORE_ADDR frame_args_skip;
 201   gdbarch_unwind_pc_ftype *unwind_pc;
 202   gdbarch_unwind_sp_ftype *unwind_sp;
 203   gdbarch_deprecated_saved_pc_after_call_ftype *deprecated_saved_pc_after_call;
 204   gdbarch_frame_num_args_ftype *frame_num_args;
 205   gdbarch_deprecated_stack_align_ftype *deprecated_stack_align;
 206   gdbarch_frame_align_ftype *frame_align;
 207   gdbarch_deprecated_reg_struct_has_addr_ftype *deprecated_reg_struct_has_addr;
 208   gdbarch_stabs_argument_has_addr_ftype *stabs_argument_has_addr;
 209   int frame_red_zone_size;
 210   gdbarch_convert_from_func_ptr_addr_ftype *convert_from_func_ptr_addr;
 211   gdbarch_addr_bits_remove_ftype *addr_bits_remove;
 212   gdbarch_smash_text_address_ftype *smash_text_address;
 213   gdbarch_software_single_step_ftype *software_single_step;
 214   gdbarch_single_step_through_delay_ftype *single_step_through_delay;
 215   gdbarch_print_insn_ftype *print_insn;
 216   gdbarch_skip_trampoline_code_ftype *skip_trampoline_code;
 217   gdbarch_skip_solib_resolver_ftype *skip_solib_resolver;
 218   gdbarch_in_solib_return_trampoline_ftype *in_solib_return_trampoline;
 219   gdbarch_in_function_epilogue_p_ftype *in_function_epilogue_p;
 220   gdbarch_construct_inferior_arguments_ftype *construct_inferior_arguments;
 221   gdbarch_elf_make_msymbol_special_ftype *elf_make_msymbol_special;
 222   gdbarch_coff_make_msymbol_special_ftype *coff_make_msymbol_special;
 223   const char * name_of_malloc;
 224   int cannot_step_breakpoint;
 225   int have_nonsteppable_watchpoint;
 226   gdbarch_address_class_type_flags_ftype *address_class_type_flags;
 227   gdbarch_address_class_type_flags_to_name_ftype *address_class_type_flags_to_name;
 228   gdbarch_address_class_name_to_type_flags_ftype *address_class_name_to_type_flags;
 229   gdbarch_register_reggroup_p_ftype *register_reggroup_p;
 230   gdbarch_fetch_pointer_argument_ftype *fetch_pointer_argument;
 231   gdbarch_regset_from_core_section_ftype *regset_from_core_section;
 232 };
 233
 234
 235 /* The default architecture uses host values (for want of a better
 236    choice). */
 237
 238 extern const struct bfd_arch_info bfd_default_arch_struct;
 239
 240 struct gdbarch startup_gdbarch =
 241 {
 242   1, /* Always initialized.  */
 243   NULL, /* The obstack.  */
 244   /* basic architecture information */
 245   &bfd_default_arch_struct,  /* bfd_arch_info */
 246   BFD_ENDIAN_BIG,  /* byte_order */
 247   GDB_OSABI_UNKNOWN,  /* osabi */
 248   /* target specific vector and its dump routine */
 249   NULL, NULL,
 250   /*per-architecture data-pointers and swap regions */
 251   0, NULL, NULL,
 252   /* Multi-arch values */
 253   8 * sizeof (short),  /* short_bit */
 254   8 * sizeof (int),  /* int_bit */
 255   8 * sizeof (long),  /* long_bit */
 256   8 * sizeof (LONGEST),  /* long_long_bit */
 257   8 * sizeof (float),  /* float_bit */
 258   0,  /* float_format */
 259   8 * sizeof (double),  /* double_bit */
 260   0,  /* double_format */
 261   8 * sizeof (long double),  /* long_double_bit */
 262   0,  /* long_double_format */
 263   8 * sizeof (void*),  /* ptr_bit */
 264   8 * sizeof (void*),  /* addr_bit */
 265   8 * sizeof (void*),  /* bfd_vma_bit */
 266   1,  /* char_signed */
 267   0,  /* read_pc */
 268   0,  /* write_pc */
 269   0,  /* read_sp */
 270   0,  /* virtual_frame_pointer */
 271   0,  /* pseudo_register_read */
 272   0,  /* pseudo_register_write */
 273   0,  /* num_regs */
 274   0,  /* num_pseudo_regs */
 275   -1,  /* sp_regnum */
 276   -1,  /* pc_regnum */
 277   -1,  /* ps_regnum */
 278   0,  /* fp0_regnum */
 279   0,  /* stab_reg_to_regnum */
 280   0,  /* ecoff_reg_to_regnum */
 281   0,  /* dwarf_reg_to_regnum */
 282   0,  /* sdb_reg_to_regnum */
 283   0,  /* dwarf2_reg_to_regnum */
 284   0,  /* register_name */
 285   0,  /* register_type */
 286   generic_register_byte,  /* deprecated_register_byte */
 287   0,  /* unwind_dummy_id */
 288   -1,  /* deprecated_fp_regnum */
 289   0,  /* push_dummy_call */
 290   0,  /* deprecated_push_arguments */
 291   0,  /* deprecated_register_size */
 292   0,  /* call_dummy_location */
 293   0,  /* push_dummy_code */
 294   default_print_registers_info,  /* print_registers_info */
 295   0,  /* print_float_info */
 296   0,  /* print_vector_info */
 297   0,  /* register_sim_regno */
 298   0,  /* register_bytes_ok */
 299   0,  /* cannot_fetch_register */
 300   0,  /* cannot_store_register */
 301   0,  /* get_longjmp_target */
 302   0,  /* believe_pcc_promotion */
 303   0,  /* convert_register_p */
 304   0,  /* register_to_value */
 305   0,  /* value_to_register */
 306   0,  /* pointer_to_address */
 307   0,  /* address_to_pointer */
 308   0,  /* integer_to_address */
 309   0,  /* deprecated_store_struct_return */
 310   0,  /* return_value */
 311   0,  /* extract_return_value */
 312   0,  /* store_return_value */
 313   0,  /* deprecated_extract_return_value */
 314   0,  /* deprecated_store_return_value */
 315   0,  /* deprecated_use_struct_convention */
 316   0,  /* deprecated_extract_struct_value_address */
 317   0,  /* skip_prologue */
 318   0,  /* inner_than */
 319   0,  /* breakpoint_from_pc */
 320   0,  /* adjust_breakpoint_address */
 321   0,  /* memory_insert_breakpoint */
 322   0,  /* memory_remove_breakpoint */
 323   0,  /* decr_pc_after_break */
 324   0,  /* deprecated_function_start_offset */
 325   generic_remote_translate_xfer_address,  /* remote_translate_xfer_address */
 326   0,  /* frame_args_skip */
 327   0,  /* unwind_pc */
 328   0,  /* unwind_sp */
 329   0,  /* deprecated_saved_pc_after_call */
 330   0,  /* frame_num_args */
 331   0,  /* deprecated_stack_align */
 332   0,  /* frame_align */
 333   0,  /* deprecated_reg_struct_has_addr */
 334   default_stabs_argument_has_addr,  /* stabs_argument_has_addr */
 335   0,  /* frame_red_zone_size */
 336   convert_from_func_ptr_addr_identity,  /* convert_from_func_ptr_addr */
 337   0,  /* addr_bits_remove */
 338   0,  /* smash_text_address */
 339   0,  /* software_single_step */
 340   0,  /* single_step_through_delay */
 341   0,  /* print_insn */
 342   0,  /* skip_trampoline_code */
 343   generic_skip_solib_resolver,  /* skip_solib_resolver */
 344   0,  /* in_solib_return_trampoline */
 345   generic_in_function_epilogue_p,  /* in_function_epilogue_p */
 346   construct_inferior_arguments,  /* construct_inferior_arguments */
 347   0,  /* elf_make_msymbol_special */
 348   0,  /* coff_make_msymbol_special */
 349   "malloc",  /* name_of_malloc */
 350   0,  /* cannot_step_breakpoint */
 351   0,  /* have_nonsteppable_watchpoint */
 352   0,  /* address_class_type_flags */
 353   0,  /* address_class_type_flags_to_name */
 354   0,  /* address_class_name_to_type_flags */
 355   default_register_reggroup_p,  /* register_reggroup_p */
 356   0,  /* fetch_pointer_argument */
 357   0,  /* regset_from_core_section */
 358   /* startup_gdbarch() */
 359 };
 360
 361 struct gdbarch *current_gdbarch = &startup_gdbarch;
 362
 363 /* Create a new ``struct gdbarch'' based on information provided by
 364    ``struct gdbarch_info''. */
 365
 366 struct gdbarch *
 367 gdbarch_alloc (const struct gdbarch_info *info,
 368                struct gdbarch_tdep *tdep)
 369 {
 370   /* NOTE: The new architecture variable is named ``current_gdbarch''
 371      so that macros such as TARGET_DOUBLE_BIT, when expanded, refer to
 372      the current local architecture and not the previous global
 373      architecture.  This ensures that the new architectures initial
 374      values are not influenced by the previous architecture.  Once
 375      everything is parameterised with gdbarch, this will go away.  */
 376   struct gdbarch *current_gdbarch;
 377
 378   /* Create an obstack for allocating all the per-architecture memory,
 379      then use that to allocate the architecture vector.  */
 380   struct obstack *obstack = XMALLOC (struct obstack);
 381   obstack_init (obstack);
 382   current_gdbarch = obstack_alloc (obstack, sizeof (*current_gdbarch));
 383   memset (current_gdbarch, 0, sizeof (*current_gdbarch));
 384   current_gdbarch->obstack = obstack;
 385
 386   alloc_gdbarch_data (current_gdbarch);
 387
 388   current_gdbarch->tdep = tdep;
 389
 390   current_gdbarch->bfd_arch_info = info->bfd_arch_info;
 391   current_gdbarch->byte_order = info->byte_order;
 392   current_gdbarch->osabi = info->osabi;
 393
 394   /* Force the explicit initialization of these. */
 395   current_gdbarch->short_bit = 2*TARGET_CHAR_BIT;
 396   current_gdbarch->int_bit = 4*TARGET_CHAR_BIT;
 397   current_gdbarch->long_bit = 4*TARGET_CHAR_BIT;
 398   current_gdbarch->long_long_bit = 2*TARGET_LONG_BIT;
 399   current_gdbarch->float_bit = 4*TARGET_CHAR_BIT;
 400   current_gdbarch->double_bit = 8*TARGET_CHAR_BIT;
 401   current_gdbarch->long_double_bit = 8*TARGET_CHAR_BIT;
 402   current_gdbarch->ptr_bit = TARGET_INT_BIT;
 403   current_gdbarch->bfd_vma_bit = TARGET_ARCHITECTURE->bits_per_address;
 404   current_gdbarch->char_signed = -1;
 405   current_gdbarch->write_pc = generic_target_write_pc;
 406   current_gdbarch->virtual_frame_pointer = legacy_virtual_frame_pointer;
 407   current_gdbarch->num_regs = -1;
 408   current_gdbarch->sp_regnum = -1;
 409   current_gdbarch->pc_regnum = -1;
 410   current_gdbarch->ps_regnum = -1;
 411   current_gdbarch->fp0_regnum = -1;
 412   current_gdbarch->stab_reg_to_regnum = no_op_reg_to_regnum;
 413   current_gdbarch->ecoff_reg_to_regnum = no_op_reg_to_regnum;
 414   current_gdbarch->dwarf_reg_to_regnum = no_op_reg_to_regnum;
 415   current_gdbarch->sdb_reg_to_regnum = no_op_reg_to_regnum;
 416   current_gdbarch->dwarf2_reg_to_regnum = no_op_reg_to_regnum;
 417   current_gdbarch->deprecated_register_byte = generic_register_byte;
 418   current_gdbarch->deprecated_fp_regnum = -1;
 419   current_gdbarch->call_dummy_location = AT_ENTRY_POINT;
 420   current_gdbarch->print_registers_info = default_print_registers_info;
 421   current_gdbarch->register_sim_regno = legacy_register_sim_regno;
 422   current_gdbarch->cannot_fetch_register = cannot_register_not;
 423   current_gdbarch->cannot_store_register = cannot_register_not;
 424   current_gdbarch->convert_register_p = generic_convert_register_p;
 425   current_gdbarch->pointer_to_address = unsigned_pointer_to_address;
 426   current_gdbarch->address_to_pointer = unsigned_address_to_pointer;
 427   current_gdbarch->return_value = legacy_return_value;
 428   current_gdbarch->extract_return_value = legacy_extract_return_value;
 429   current_gdbarch->store_return_value = legacy_store_return_value;
 430   current_gdbarch->deprecated_use_struct_convention = generic_use_struct_convention;
 431   current_gdbarch->memory_insert_breakpoint = default_memory_insert_breakpoint;
 432   current_gdbarch->memory_remove_breakpoint = default_memory_remove_breakpoint;
 433   current_gdbarch->remote_translate_xfer_address = generic_remote_translate_xfer_address;
 434   current_gdbarch->stabs_argument_has_addr = default_stabs_argument_has_addr;
 435   current_gdbarch->convert_from_func_ptr_addr = convert_from_func_ptr_addr_identity;
 436   current_gdbarch->addr_bits_remove = core_addr_identity;
 437   current_gdbarch->smash_text_address = core_addr_identity;
 438   current_gdbarch->skip_trampoline_code = generic_skip_trampoline_code;
 439   current_gdbarch->skip_solib_resolver = generic_skip_solib_resolver;
 440   current_gdbarch->in_solib_return_trampoline = generic_in_solib_return_trampoline;
 441   current_gdbarch->in_function_epilogue_p = generic_in_function_epilogue_p;
 442   current_gdbarch->construct_inferior_arguments = construct_inferior_arguments;
 443   current_gdbarch->elf_make_msymbol_special = default_elf_make_msymbol_special;
 444   current_gdbarch->coff_make_msymbol_special = default_coff_make_msymbol_special;
 445   current_gdbarch->name_of_malloc = "malloc";
 446   current_gdbarch->register_reggroup_p = default_register_reggroup_p;
 447   /* gdbarch_alloc() */
 448
 449   return current_gdbarch;
 450 }
 451
 452
 453 /* Allocate extra space using the per-architecture obstack.  */
 454
 455 void *
 456 gdbarch_obstack_zalloc (struct gdbarch *arch, long size)
 457 {
 458   void *data = obstack_alloc (arch->obstack, size);
 459   memset (data, 0, size);
 460   return data;
 461 }
 462
 463
 464 /* Free a gdbarch struct.  This should never happen in normal
 465    operation --- once you've created a gdbarch, you keep it around.
 466    However, if an architecture's init function encounters an error
 467    building the structure, it may need to clean up a partially
 468    constructed gdbarch.  */
 469
 470 void
 471 gdbarch_free (struct gdbarch *arch)
 472 {
 473   struct obstack *obstack;
 474   gdb_assert (arch != NULL);
 475   gdb_assert (!arch->initialized_p);
 476   obstack = arch->obstack;
 477   obstack_free (obstack, 0); /* Includes the ARCH.  */
 478   xfree (obstack);
 479 }
 480
 481
 482 /* Ensure that all values in a GDBARCH are reasonable.  */
 483
 484 /* NOTE/WARNING: The parameter is called ``current_gdbarch'' so that it
 485    just happens to match the global variable ``current_gdbarch''.  That
 486    way macros refering to that variable get the local and not the global
 487    version - ulgh.  Once everything is parameterised with gdbarch, this
 488    will go away. */
 489
 490 static void
 491 verify_gdbarch (struct gdbarch *current_gdbarch)
 492 {
 493   struct ui_file *log;
 494   struct cleanup *cleanups;
 495   long dummy;
 496   char *buf;
 497   log = mem_fileopen ();
 498   cleanups = make_cleanup_ui_file_delete (log);
 499   /* fundamental */
 500   if (current_gdbarch->byte_order == BFD_ENDIAN_UNKNOWN)
 501     fprintf_unfiltered (log, "\n\tbyte-order");
 502   if (current_gdbarch->bfd_arch_info == NULL)
 503     fprintf_unfiltered (log, "\n\tbfd_arch_info");
 504   /* Check those that need to be defined for the given multi-arch level. */
 505   /* Skip verify of short_bit, invalid_p == 0 */
 506   /* Skip verify of int_bit, invalid_p == 0 */
 507   /* Skip verify of long_bit, invalid_p == 0 */
 508   /* Skip verify of long_long_bit, invalid_p == 0 */
 509   /* Skip verify of float_bit, invalid_p == 0 */
 510   if (current_gdbarch->float_format == 0)
 511     current_gdbarch->float_format = default_float_format (current_gdbarch);
 512   /* Skip verify of double_bit, invalid_p == 0 */
 513   if (current_gdbarch->double_format == 0)
 514     current_gdbarch->double_format = default_double_format (current_gdbarch);
 515   /* Skip verify of long_double_bit, invalid_p == 0 */
 516   if (current_gdbarch->long_double_format == 0)
 517     current_gdbarch->long_double_format = default_double_format (current_gdbarch);
 518   /* Skip verify of ptr_bit, invalid_p == 0 */
 519   if (current_gdbarch->addr_bit == 0)
 520     current_gdbarch->addr_bit = TARGET_PTR_BIT;
 521   /* Skip verify of bfd_vma_bit, invalid_p == 0 */
 522   if (current_gdbarch->char_signed == -1)
 523     current_gdbarch->char_signed = 1;
 524   /* Skip verify of read_pc, has predicate */
 525   /* Skip verify of write_pc, invalid_p == 0 */
 526   /* Skip verify of read_sp, has predicate */
 527   /* Skip verify of virtual_frame_pointer, invalid_p == 0 */
 528   /* Skip verify of pseudo_register_read, has predicate */
 529   /* Skip verify of pseudo_register_write, has predicate */
 530   if (current_gdbarch->num_regs == -1)
 531     fprintf_unfiltered (log, "\n\tnum_regs");
 532   /* Skip verify of num_pseudo_regs, invalid_p == 0 */
 533   /* Skip verify of sp_regnum, invalid_p == 0 */
 534   /* Skip verify of pc_regnum, invalid_p == 0 */
 535   /* Skip verify of ps_regnum, invalid_p == 0 */
 536   /* Skip verify of fp0_regnum, invalid_p == 0 */
 537   /* Skip verify of stab_reg_to_regnum, invalid_p == 0 */
 538   /* Skip verify of ecoff_reg_to_regnum, invalid_p == 0 */
 539   /* Skip verify of dwarf_reg_to_regnum, invalid_p == 0 */
 540   /* Skip verify of sdb_reg_to_regnum, invalid_p == 0 */
 541   /* Skip verify of dwarf2_reg_to_regnum, invalid_p == 0 */
 542   /* Skip verify of register_type, has predicate */
 543   /* Skip verify of deprecated_register_byte, has predicate */
 544   /* Skip verify of unwind_dummy_id, has predicate */
 545   /* Skip verify of deprecated_fp_regnum, invalid_p == 0 */
 546   /* Skip verify of push_dummy_call, has predicate */
 547   /* Skip verify of deprecated_push_arguments, has predicate */
 548   /* Skip verify of call_dummy_location, invalid_p == 0 */
 549   /* Skip verify of push_dummy_code, has predicate */
 550   /* Skip verify of print_registers_info, invalid_p == 0 */
 551   /* Skip verify of print_float_info, has predicate */
 552   /* Skip verify of print_vector_info, has predicate */
 553   /* Skip verify of register_sim_regno, invalid_p == 0 */
 554   /* Skip verify of register_bytes_ok, has predicate */
 555   /* Skip verify of cannot_fetch_register, invalid_p == 0 */
 556   /* Skip verify of cannot_store_register, invalid_p == 0 */
 557   /* Skip verify of get_longjmp_target, has predicate */
 558   /* Skip verify of convert_register_p, invalid_p == 0 */
 559   /* Skip verify of pointer_to_address, invalid_p == 0 */
 560   /* Skip verify of address_to_pointer, invalid_p == 0 */
 561   /* Skip verify of integer_to_address, has predicate */
 562   /* Skip verify of deprecated_store_struct_return, has predicate */
 563   /* Skip verify of return_value, has predicate */
 564   /* Skip verify of extract_return_value, invalid_p == 0 */
 565   /* Skip verify of store_return_value, invalid_p == 0 */
 566   /* Skip verify of deprecated_use_struct_convention, invalid_p == 0 */
 567   /* Skip verify of deprecated_extract_struct_value_address, has predicate */
 568   if (current_gdbarch->skip_prologue == 0)
 569     fprintf_unfiltered (log, "\n\tskip_prologue");
 570   if (current_gdbarch->inner_than == 0)
 571     fprintf_unfiltered (log, "\n\tinner_than");
 572   if (current_gdbarch->breakpoint_from_pc == 0)
 573     fprintf_unfiltered (log, "\n\tbreakpoint_from_pc");
 574   /* Skip verify of adjust_breakpoint_address, has predicate */
 575   /* Skip verify of memory_insert_breakpoint, invalid_p == 0 */
 576   /* Skip verify of memory_remove_breakpoint, invalid_p == 0 */
 577   /* Skip verify of decr_pc_after_break, invalid_p == 0 */
 578   /* Skip verify of deprecated_function_start_offset, invalid_p == 0 */
 579   /* Skip verify of remote_translate_xfer_address, invalid_p == 0 */
 580   /* Skip verify of frame_args_skip, invalid_p == 0 */
 581   /* Skip verify of unwind_pc, has predicate */
 582   /* Skip verify of unwind_sp, has predicate */
 583   /* Skip verify of deprecated_saved_pc_after_call, has predicate */
 584   /* Skip verify of frame_num_args, has predicate */
 585   /* Skip verify of deprecated_stack_align, has predicate */
 586   /* Skip verify of frame_align, has predicate */
 587   /* Skip verify of deprecated_reg_struct_has_addr, has predicate */
 588   /* Skip verify of stabs_argument_has_addr, invalid_p == 0 */
 589   /* Skip verify of convert_from_func_ptr_addr, invalid_p == 0 */
 590   /* Skip verify of addr_bits_remove, invalid_p == 0 */
 591   /* Skip verify of smash_text_address, invalid_p == 0 */
 592   /* Skip verify of software_single_step, has predicate */
 593   /* Skip verify of single_step_through_delay, has predicate */
 594   if (current_gdbarch->print_insn == 0)
 595     fprintf_unfiltered (log, "\n\tprint_insn");
 596   /* Skip verify of skip_trampoline_code, invalid_p == 0 */
 597   /* Skip verify of skip_solib_resolver, invalid_p == 0 */
 598   /* Skip verify of in_solib_return_trampoline, invalid_p == 0 */
 599   /* Skip verify of in_function_epilogue_p, invalid_p == 0 */
 600   /* Skip verify of construct_inferior_arguments, invalid_p == 0 */
 601   /* Skip verify of elf_make_msymbol_special, invalid_p == 0 */
 602   /* Skip verify of coff_make_msymbol_special, invalid_p == 0 */
 603   /* Skip verify of name_of_malloc, invalid_p == 0 */
 604   /* Skip verify of cannot_step_breakpoint, invalid_p == 0 */
 605   /* Skip verify of have_nonsteppable_watchpoint, invalid_p == 0 */
 606   /* Skip verify of address_class_type_flags, has predicate */
 607   /* Skip verify of address_class_type_flags_to_name, has predicate */
 608   /* Skip verify of address_class_name_to_type_flags, has predicate */
 609   /* Skip verify of register_reggroup_p, invalid_p == 0 */
 610   /* Skip verify of fetch_pointer_argument, has predicate */
 611   /* Skip verify of regset_from_core_section, has predicate */
 612   buf = ui_file_xstrdup (log, &dummy);
 613   make_cleanup (xfree, buf);
 614   if (strlen (buf) > 0)
 615     internal_error (__FILE__, __LINE__,
 616                     "verify_gdbarch: the following are invalid ...%s",
 617                     buf);
 618   do_cleanups (cleanups);
 619 }
 620
 621
 622 /* Print out the details of the current architecture. */
 623
 624 /* NOTE/WARNING: The parameter is called ``current_gdbarch'' so that it
 625    just happens to match the global variable ``current_gdbarch''.  That
 626    way macros refering to that variable get the local and not the global
 627    version - ulgh.  Once everything is parameterised with gdbarch, this
 628    will go away. */
 629
 630 void
 631 gdbarch_dump (struct gdbarch *current_gdbarch, struct ui_file *file)
 632 {
 633   const char *gdb_xm_file = "<not-defined>";
 634   const char *gdb_nm_file = "<not-defined>";
 635   const char *gdb_tm_file = "<not-defined>";
 636 #if defined (GDB_XM_FILE)
 637   gdb_xm_file = GDB_XM_FILE;
 638 #endif
 639   fprintf_unfiltered (file,
 640                       "gdbarch_dump: GDB_XM_FILE = %s\n",
 641                       gdb_xm_file);
 642 #if defined (GDB_NM_FILE)
 643   gdb_nm_file = GDB_NM_FILE;
 644 #endif
 645   fprintf_unfiltered (file,
 646                       "gdbarch_dump: GDB_NM_FILE = %s\n",
 647                       gdb_nm_file);
 648 #if defined (GDB_TM_FILE)
 649   gdb_tm_file = GDB_TM_FILE;
 650 #endif
 651   fprintf_unfiltered (file,
 652                       "gdbarch_dump: GDB_TM_FILE = %s\n",
 653                       gdb_tm_file);
 654 #ifdef TARGET_ADDR_BIT
 655   fprintf_unfiltered (file,
 656                       "gdbarch_dump: TARGET_ADDR_BIT # %s\n",
 657                       XSTRING (TARGET_ADDR_BIT));
 658 #endif
 659   fprintf_unfiltered (file,
 660                       "gdbarch_dump: addr_bit = %s\n",
 661                       paddr_d (current_gdbarch->addr_bit));
 662 #ifdef ADDR_BITS_REMOVE
 663   fprintf_unfiltered (file,
 664                       "gdbarch_dump: %s # %s\n",
 665                       "ADDR_BITS_REMOVE(addr)",
 666                       XSTRING (ADDR_BITS_REMOVE (addr)));
 667 #endif
 668   fprintf_unfiltered (file,
 669                       "gdbarch_dump: addr_bits_remove = <0x%lx>\n",
 670                       (long) current_gdbarch->addr_bits_remove);
 671   fprintf_unfiltered (file,
 672                       "gdbarch_dump: gdbarch_address_class_name_to_type_flags_p() = %d\n",
 673                       gdbarch_address_class_name_to_type_flags_p (current_gdbarch));
 674   fprintf_unfiltered (file,
 675                       "gdbarch_dump: address_class_name_to_type_flags = <0x%lx>\n",
 676                       (long) current_gdbarch->address_class_name_to_type_flags);
 677 #ifdef ADDRESS_CLASS_TYPE_FLAGS_P
 678   fprintf_unfiltered (file,
 679                       "gdbarch_dump: %s # %s\n",
 680                       "ADDRESS_CLASS_TYPE_FLAGS_P()",
 681                       XSTRING (ADDRESS_CLASS_TYPE_FLAGS_P ()));
 682 #endif
 683   fprintf_unfiltered (file,
 684                       "gdbarch_dump: gdbarch_address_class_type_flags_p() = %d\n",
 685                       gdbarch_address_class_type_flags_p (current_gdbarch));
 686 #ifdef ADDRESS_CLASS_TYPE_FLAGS
 687   fprintf_unfiltered (file,
 688                       "gdbarch_dump: %s # %s\n",
 689                       "ADDRESS_CLASS_TYPE_FLAGS(byte_size, dwarf2_addr_class)",
 690                       XSTRING (ADDRESS_CLASS_TYPE_FLAGS (byte_size, dwarf2_addr_class)));
 691 #endif
 692   fprintf_unfiltered (file,
 693                       "gdbarch_dump: address_class_type_flags = <0x%lx>\n",
 694                       (long) current_gdbarch->address_class_type_flags);
 695   fprintf_unfiltered (file,
 696                       "gdbarch_dump: gdbarch_address_class_type_flags_to_name_p() = %d\n",
 697                       gdbarch_address_class_type_flags_to_name_p (current_gdbarch));
 698   fprintf_unfiltered (file,
 699                       "gdbarch_dump: address_class_type_flags_to_name = <0x%lx>\n",
 700                       (long) current_gdbarch->address_class_type_flags_to_name);
 701 #ifdef ADDRESS_TO_POINTER
 702   fprintf_unfiltered (file,
 703                       "gdbarch_dump: %s # %s\n",
 704                       "ADDRESS_TO_POINTER(type, buf, addr)",
 705                       XSTRING (ADDRESS_TO_POINTER (type, buf, addr)));
 706 #endif
 707   fprintf_unfiltered (file,
 708                       "gdbarch_dump: address_to_pointer = <0x%lx>\n",
 709                       (long) current_gdbarch->address_to_pointer);
 710   fprintf_unfiltered (file,
 711                       "gdbarch_dump: gdbarch_adjust_breakpoint_address_p() = %d\n",
 712                       gdbarch_adjust_breakpoint_address_p (current_gdbarch));
 713   fprintf_unfiltered (file,
 714                       "gdbarch_dump: adjust_breakpoint_address = <0x%lx>\n",
 715                       (long) current_gdbarch->adjust_breakpoint_address);
 716 #ifdef BELIEVE_PCC_PROMOTION
 717   fprintf_unfiltered (file,
 718                       "gdbarch_dump: BELIEVE_PCC_PROMOTION # %s\n",
 719                       XSTRING (BELIEVE_PCC_PROMOTION));
 720 #endif
 721   fprintf_unfiltered (file,
 722                       "gdbarch_dump: believe_pcc_promotion = %s\n",
 723                       paddr_d (current_gdbarch->believe_pcc_promotion));
 724 #ifdef TARGET_ARCHITECTURE
 725   fprintf_unfiltered (file,
 726                       "gdbarch_dump: TARGET_ARCHITECTURE # %s\n",
 727                       XSTRING (TARGET_ARCHITECTURE));
 728 #endif
 729   fprintf_unfiltered (file,
 730                       "gdbarch_dump: bfd_arch_info = %s\n",
 731                       TARGET_ARCHITECTURE->printable_name);
 732 #ifdef TARGET_BFD_VMA_BIT
 733   fprintf_unfiltered (file,
 734                       "gdbarch_dump: TARGET_BFD_VMA_BIT # %s\n",
 735                       XSTRING (TARGET_BFD_VMA_BIT));
 736 #endif
 737   fprintf_unfiltered (file,
 738                       "gdbarch_dump: bfd_vma_bit = %s\n",
 739                       paddr_d (current_gdbarch->bfd_vma_bit));
 740 #ifdef BREAKPOINT_FROM_PC
 741   fprintf_unfiltered (file,
 742                       "gdbarch_dump: %s # %s\n",
 743                       "BREAKPOINT_FROM_PC(pcptr, lenptr)",
 744                       XSTRING (BREAKPOINT_FROM_PC (pcptr, lenptr)));
 745 #endif
 746   fprintf_unfiltered (file,
 747                       "gdbarch_dump: breakpoint_from_pc = <0x%lx>\n",
 748                       (long) current_gdbarch->breakpoint_from_pc);
 749 #ifdef TARGET_BYTE_ORDER
 750   fprintf_unfiltered (file,
 751                       "gdbarch_dump: TARGET_BYTE_ORDER # %s\n",
 752                       XSTRING (TARGET_BYTE_ORDER));
 753 #endif
 754   fprintf_unfiltered (file,
 755                       "gdbarch_dump: byte_order = %s\n",
 756                       paddr_d (current_gdbarch->byte_order));
 757 #ifdef CALL_DUMMY_LOCATION
 758   fprintf_unfiltered (file,
 759                       "gdbarch_dump: CALL_DUMMY_LOCATION # %s\n",
 760                       XSTRING (CALL_DUMMY_LOCATION));
 761 #endif
 762   fprintf_unfiltered (file,
 763                       "gdbarch_dump: call_dummy_location = %s\n",
 764                       paddr_d (current_gdbarch->call_dummy_location));
 765 #ifdef CANNOT_FETCH_REGISTER
 766   fprintf_unfiltered (file,
 767                       "gdbarch_dump: %s # %s\n",
 768                       "CANNOT_FETCH_REGISTER(regnum)",
 769                       XSTRING (CANNOT_FETCH_REGISTER (regnum)));
 770 #endif
 771   fprintf_unfiltered (file,
 772                       "gdbarch_dump: cannot_fetch_register = <0x%lx>\n",
 773                       (long) current_gdbarch->cannot_fetch_register);
 774 #ifdef CANNOT_STEP_BREAKPOINT
 775   fprintf_unfiltered (file,
 776                       "gdbarch_dump: CANNOT_STEP_BREAKPOINT # %s\n",
 777                       XSTRING (CANNOT_STEP_BREAKPOINT));
 778 #endif
 779   fprintf_unfiltered (file,
 780                       "gdbarch_dump: cannot_step_breakpoint = %s\n",
 781                       paddr_d (current_gdbarch->cannot_step_breakpoint));
 782 #ifdef CANNOT_STORE_REGISTER
 783   fprintf_unfiltered (file,
 784                       "gdbarch_dump: %s # %s\n",
 785                       "CANNOT_STORE_REGISTER(regnum)",
 786                       XSTRING (CANNOT_STORE_REGISTER (regnum)));
 787 #endif
 788   fprintf_unfiltered (file,
 789                       "gdbarch_dump: cannot_store_register = <0x%lx>\n",
 790                       (long) current_gdbarch->cannot_store_register);
 791 #ifdef TARGET_CHAR_SIGNED
 792   fprintf_unfiltered (file,
 793                       "gdbarch_dump: TARGET_CHAR_SIGNED # %s\n",
 794                       XSTRING (TARGET_CHAR_SIGNED));
 795 #endif
 796   fprintf_unfiltered (file,
 797                       "gdbarch_dump: char_signed = %s\n",
 798                       paddr_d (current_gdbarch->char_signed));
 799 #ifdef COFF_MAKE_MSYMBOL_SPECIAL
 800   fprintf_unfiltered (file,
 801                       "gdbarch_dump: %s # %s\n",
 802                       "COFF_MAKE_MSYMBOL_SPECIAL(val, msym)",
 803                       XSTRING (COFF_MAKE_MSYMBOL_SPECIAL (val, msym)));
 804 #endif
 805   fprintf_unfiltered (file,
 806                       "gdbarch_dump: coff_make_msymbol_special = <0x%lx>\n",
 807                       (long) current_gdbarch->coff_make_msymbol_special);
 808   fprintf_unfiltered (file,
 809                       "gdbarch_dump: construct_inferior_arguments = <0x%lx>\n",
 810                       (long) current_gdbarch->construct_inferior_arguments);
 811   fprintf_unfiltered (file,
 812                       "gdbarch_dump: convert_from_func_ptr_addr = <0x%lx>\n",
 813                       (long) current_gdbarch->convert_from_func_ptr_addr);
 814 #ifdef CONVERT_REGISTER_P
 815   fprintf_unfiltered (file,
 816                       "gdbarch_dump: %s # %s\n",
 817                       "CONVERT_REGISTER_P(regnum, type)",
 818                       XSTRING (CONVERT_REGISTER_P (regnum, type)));
 819 #endif
 820   fprintf_unfiltered (file,
 821                       "gdbarch_dump: convert_register_p = <0x%lx>\n",
 822                       (long) current_gdbarch->convert_register_p);
 823 #ifdef DECR_PC_AFTER_BREAK
 824   fprintf_unfiltered (file,
 825                       "gdbarch_dump: DECR_PC_AFTER_BREAK # %s\n",
 826                       XSTRING (DECR_PC_AFTER_BREAK));
 827 #endif
 828   fprintf_unfiltered (file,
 829                       "gdbarch_dump: decr_pc_after_break = 0x%s\n",
 830                       paddr_nz (current_gdbarch->decr_pc_after_break));
 831 #ifdef DEPRECATED_EXTRACT_RETURN_VALUE
 832   fprintf_unfiltered (file,
 833                       "gdbarch_dump: %s # %s\n",
 834                       "DEPRECATED_EXTRACT_RETURN_VALUE(type, regbuf, valbuf)",
 835                       XSTRING (DEPRECATED_EXTRACT_RETURN_VALUE (type, regbuf, valbuf)));
 836 #endif
 837   fprintf_unfiltered (file,
 838                       "gdbarch_dump: deprecated_extract_return_value = <0x%lx>\n",
 839                       (long) current_gdbarch->deprecated_extract_return_value);
 840 #ifdef DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS_P
 841   fprintf_unfiltered (file,
 842                       "gdbarch_dump: %s # %s\n",
 843                       "DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS_P()",
 844                       XSTRING (DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS_P ()));
 845 #endif
 846   fprintf_unfiltered (file,
 847                       "gdbarch_dump: gdbarch_deprecated_extract_struct_value_address_p() = %d\n",
 848                       gdbarch_deprecated_extract_struct_value_address_p (current_gdbarch));
 849 #ifdef DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS
 850   fprintf_unfiltered (file,
 851                       "gdbarch_dump: %s # %s\n",
 852                       "DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS(regcache)",
 853                       XSTRING (DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS (regcache)));
 854 #endif
 855   fprintf_unfiltered (file,
 856                       "gdbarch_dump: deprecated_extract_struct_value_address = <0x%lx>\n",
 857                       (long) current_gdbarch->deprecated_extract_struct_value_address);
 858 #ifdef DEPRECATED_FP_REGNUM
 859   fprintf_unfiltered (file,
 860                       "gdbarch_dump: DEPRECATED_FP_REGNUM # %s\n",
 861                       XSTRING (DEPRECATED_FP_REGNUM));
 862 #endif
 863   fprintf_unfiltered (file,
 864                       "gdbarch_dump: deprecated_fp_regnum = %s\n",
 865                       paddr_d (current_gdbarch->deprecated_fp_regnum));
 866 #ifdef DEPRECATED_FUNCTION_START_OFFSET
 867   fprintf_unfiltered (file,
 868                       "gdbarch_dump: DEPRECATED_FUNCTION_START_OFFSET # %s\n",
 869                       XSTRING (DEPRECATED_FUNCTION_START_OFFSET));
 870 #endif
 871   fprintf_unfiltered (file,
 872                       "gdbarch_dump: deprecated_function_start_offset = 0x%s\n",
 873                       paddr_nz (current_gdbarch->deprecated_function_start_offset));
 874 #ifdef DEPRECATED_PUSH_ARGUMENTS_P
 875   fprintf_unfiltered (file,
 876                       "gdbarch_dump: %s # %s\n",
 877                       "DEPRECATED_PUSH_ARGUMENTS_P()",
 878                       XSTRING (DEPRECATED_PUSH_ARGUMENTS_P ()));
 879 #endif
 880   fprintf_unfiltered (file,
 881                       "gdbarch_dump: gdbarch_deprecated_push_arguments_p() = %d\n",
 882                       gdbarch_deprecated_push_arguments_p (current_gdbarch));
 883 #ifdef DEPRECATED_PUSH_ARGUMENTS
 884   fprintf_unfiltered (file,
 885                       "gdbarch_dump: %s # %s\n",
 886                       "DEPRECATED_PUSH_ARGUMENTS(nargs, args, sp, struct_return, struct_addr)",
 887                       XSTRING (DEPRECATED_PUSH_ARGUMENTS (nargs, args, sp, struct_return, struct_addr)));
 888 #endif
 889   fprintf_unfiltered (file,
 890                       "gdbarch_dump: deprecated_push_arguments = <0x%lx>\n",
 891                       (long) current_gdbarch->deprecated_push_arguments);
 892 #ifdef DEPRECATED_REG_STRUCT_HAS_ADDR_P
 893   fprintf_unfiltered (file,
 894                       "gdbarch_dump: %s # %s\n",
 895                       "DEPRECATED_REG_STRUCT_HAS_ADDR_P()",
 896                       XSTRING (DEPRECATED_REG_STRUCT_HAS_ADDR_P ()));
 897 #endif
 898   fprintf_unfiltered (file,
 899                       "gdbarch_dump: gdbarch_deprecated_reg_struct_has_addr_p() = %d\n",
 900                       gdbarch_deprecated_reg_struct_has_addr_p (current_gdbarch));
 901 #ifdef DEPRECATED_REG_STRUCT_HAS_ADDR
 902   fprintf_unfiltered (file,
 903                       "gdbarch_dump: %s # %s\n",
 904                       "DEPRECATED_REG_STRUCT_HAS_ADDR(gcc_p, type)",
 905                       XSTRING (DEPRECATED_REG_STRUCT_HAS_ADDR (gcc_p, type)));
 906 #endif
 907   fprintf_unfiltered (file,
 908                       "gdbarch_dump: deprecated_reg_struct_has_addr = <0x%lx>\n",
 909                       (long) current_gdbarch->deprecated_reg_struct_has_addr);
 910 #ifdef DEPRECATED_REGISTER_BYTE_P
 911   fprintf_unfiltered (file,
 912                       "gdbarch_dump: %s # %s\n",
 913                       "DEPRECATED_REGISTER_BYTE_P()",
 914                       XSTRING (DEPRECATED_REGISTER_BYTE_P ()));
 915 #endif
 916   fprintf_unfiltered (file,
 917                       "gdbarch_dump: gdbarch_deprecated_register_byte_p() = %d\n",
 918                       gdbarch_deprecated_register_byte_p (current_gdbarch));
 919 #ifdef DEPRECATED_REGISTER_BYTE
 920   fprintf_unfiltered (file,
 921                       "gdbarch_dump: %s # %s\n",
 922                       "DEPRECATED_REGISTER_BYTE(reg_nr)",
 923                       XSTRING (DEPRECATED_REGISTER_BYTE (reg_nr)));
 924 #endif
 925   fprintf_unfiltered (file,
 926                       "gdbarch_dump: deprecated_register_byte = <0x%lx>\n",
 927                       (long) current_gdbarch->deprecated_register_byte);
 928 #ifdef DEPRECATED_REGISTER_SIZE
 929   fprintf_unfiltered (file,
 930                       "gdbarch_dump: DEPRECATED_REGISTER_SIZE # %s\n",
 931                       XSTRING (DEPRECATED_REGISTER_SIZE));
 932 #endif
 933   fprintf_unfiltered (file,
 934                       "gdbarch_dump: deprecated_register_size = %s\n",
 935                       paddr_d (current_gdbarch->deprecated_register_size));
 936 #ifdef DEPRECATED_SAVED_PC_AFTER_CALL_P
 937   fprintf_unfiltered (file,
 938                       "gdbarch_dump: %s # %s\n",
 939                       "DEPRECATED_SAVED_PC_AFTER_CALL_P()",
 940                       XSTRING (DEPRECATED_SAVED_PC_AFTER_CALL_P ()));
 941 #endif
 942   fprintf_unfiltered (file,
 943                       "gdbarch_dump: gdbarch_deprecated_saved_pc_after_call_p() = %d\n",
 944                       gdbarch_deprecated_saved_pc_after_call_p (current_gdbarch));
 945 #ifdef DEPRECATED_SAVED_PC_AFTER_CALL
 946   fprintf_unfiltered (file,
 947                       "gdbarch_dump: %s # %s\n",
 948                       "DEPRECATED_SAVED_PC_AFTER_CALL(frame)",
 949                       XSTRING (DEPRECATED_SAVED_PC_AFTER_CALL (frame)));
 950 #endif
 951   fprintf_unfiltered (file,
 952                       "gdbarch_dump: deprecated_saved_pc_after_call = <0x%lx>\n",
 953                       (long) current_gdbarch->deprecated_saved_pc_after_call);
 954 #ifdef DEPRECATED_STACK_ALIGN_P
 955   fprintf_unfiltered (file,
 956                       "gdbarch_dump: %s # %s\n",
 957                       "DEPRECATED_STACK_ALIGN_P()",
 958                       XSTRING (DEPRECATED_STACK_ALIGN_P ()));
 959 #endif
 960   fprintf_unfiltered (file,
 961                       "gdbarch_dump: gdbarch_deprecated_stack_align_p() = %d\n",
 962                       gdbarch_deprecated_stack_align_p (current_gdbarch));
 963 #ifdef DEPRECATED_STACK_ALIGN
 964   fprintf_unfiltered (file,
 965                       "gdbarch_dump: %s # %s\n",
 966                       "DEPRECATED_STACK_ALIGN(sp)",
 967                       XSTRING (DEPRECATED_STACK_ALIGN (sp)));
 968 #endif
 969   fprintf_unfiltered (file,
 970                       "gdbarch_dump: deprecated_stack_align = <0x%lx>\n",
 971                       (long) current_gdbarch->deprecated_stack_align);
 972 #ifdef DEPRECATED_STORE_RETURN_VALUE
 973   fprintf_unfiltered (file,
 974                       "gdbarch_dump: %s # %s\n",
 975                       "DEPRECATED_STORE_RETURN_VALUE(type, valbuf)",
 976                       XSTRING (DEPRECATED_STORE_RETURN_VALUE (type, valbuf)));
 977 #endif
 978   fprintf_unfiltered (file,
 979                       "gdbarch_dump: deprecated_store_return_value = <0x%lx>\n",
 980                       (long) current_gdbarch->deprecated_store_return_value);
 981 #ifdef DEPRECATED_STORE_STRUCT_RETURN_P
 982   fprintf_unfiltered (file,
 983                       "gdbarch_dump: %s # %s\n",
 984                       "DEPRECATED_STORE_STRUCT_RETURN_P()",
 985                       XSTRING (DEPRECATED_STORE_STRUCT_RETURN_P ()));
 986 #endif
 987   fprintf_unfiltered (file,
 988                       "gdbarch_dump: gdbarch_deprecated_store_struct_return_p() = %d\n",
 989                       gdbarch_deprecated_store_struct_return_p (current_gdbarch));
 990 #ifdef DEPRECATED_STORE_STRUCT_RETURN
 991   fprintf_unfiltered (file,
 992                       "gdbarch_dump: %s # %s\n",
 993                       "DEPRECATED_STORE_STRUCT_RETURN(addr, sp)",
 994                       XSTRING (DEPRECATED_STORE_STRUCT_RETURN (addr, sp)));
 995 #endif
 996   fprintf_unfiltered (file,
 997                       "gdbarch_dump: deprecated_store_struct_return = <0x%lx>\n",
 998                       (long) current_gdbarch->deprecated_store_struct_return);
 999 #ifdef DEPRECATED_USE_STRUCT_CONVENTION
1000   fprintf_unfiltered (file,
1001                       "gdbarch_dump: %s # %s\n",
1002                       "DEPRECATED_USE_STRUCT_CONVENTION(gcc_p, value_type)",
1003                       XSTRING (DEPRECATED_USE_STRUCT_CONVENTION (gcc_p, value_type)));
1004 #endif
1005   fprintf_unfiltered (file,
1006                       "gdbarch_dump: deprecated_use_struct_convention = <0x%lx>\n",
1007                       (long) current_gdbarch->deprecated_use_struct_convention);
1008 #ifdef TARGET_DOUBLE_BIT
1009   fprintf_unfiltered (file,
1010                       "gdbarch_dump: TARGET_DOUBLE_BIT # %s\n",
1011                       XSTRING (TARGET_DOUBLE_BIT));
1012 #endif
1013   fprintf_unfiltered (file,
1014                       "gdbarch_dump: double_bit = %s\n",
1015                       paddr_d (current_gdbarch->double_bit));
1016 #ifdef TARGET_DOUBLE_FORMAT
1017   fprintf_unfiltered (file,
1018                       "gdbarch_dump: TARGET_DOUBLE_FORMAT # %s\n",
1019                       XSTRING (TARGET_DOUBLE_FORMAT));
1020 #endif
1021   fprintf_unfiltered (file,
1022                       "gdbarch_dump: double_format = %s\n",
1023                       pformat (current_gdbarch->double_format));
1024 #ifdef DWARF2_REG_TO_REGNUM
1025   fprintf_unfiltered (file,
1026                       "gdbarch_dump: %s # %s\n",
1027                       "DWARF2_REG_TO_REGNUM(dwarf2_regnr)",
1028                       XSTRING (DWARF2_REG_TO_REGNUM (dwarf2_regnr)));
1029 #endif
1030   fprintf_unfiltered (file,
1031                       "gdbarch_dump: dwarf2_reg_to_regnum = <0x%lx>\n",
1032                       (long) current_gdbarch->dwarf2_reg_to_regnum);
1033 #ifdef DWARF_REG_TO_REGNUM
1034   fprintf_unfiltered (file,
1035                       "gdbarch_dump: %s # %s\n",
1036                       "DWARF_REG_TO_REGNUM(dwarf_regnr)",
1037                       XSTRING (DWARF_REG_TO_REGNUM (dwarf_regnr)));
1038 #endif
1039   fprintf_unfiltered (file,
1040                       "gdbarch_dump: dwarf_reg_to_regnum = <0x%lx>\n",
1041                       (long) current_gdbarch->dwarf_reg_to_regnum);
1042 #ifdef ECOFF_REG_TO_REGNUM
1043   fprintf_unfiltered (file,
1044                       "gdbarch_dump: %s # %s\n",
1045                       "ECOFF_REG_TO_REGNUM(ecoff_regnr)",
1046                       XSTRING (ECOFF_REG_TO_REGNUM (ecoff_regnr)));
1047 #endif
1048   fprintf_unfiltered (file,
1049                       "gdbarch_dump: ecoff_reg_to_regnum = <0x%lx>\n",
1050                       (long) current_gdbarch->ecoff_reg_to_regnum);
1051 #ifdef ELF_MAKE_MSYMBOL_SPECIAL
1052   fprintf_unfiltered (file,
1053                       "gdbarch_dump: %s # %s\n",
1054                       "ELF_MAKE_MSYMBOL_SPECIAL(sym, msym)",
1055                       XSTRING (ELF_MAKE_MSYMBOL_SPECIAL (sym, msym)));
1056 #endif
1057   fprintf_unfiltered (file,
1058                       "gdbarch_dump: elf_make_msymbol_special = <0x%lx>\n",
1059                       (long) current_gdbarch->elf_make_msymbol_special);
1060 #ifdef EXTRACT_RETURN_VALUE
1061   fprintf_unfiltered (file,
1062                       "gdbarch_dump: %s # %s\n",
1063                       "EXTRACT_RETURN_VALUE(type, regcache, valbuf)",
1064                       XSTRING (EXTRACT_RETURN_VALUE (type, regcache, valbuf)));
1065 #endif
1066   fprintf_unfiltered (file,
1067                       "gdbarch_dump: extract_return_value = <0x%lx>\n",
1068                       (long) current_gdbarch->extract_return_value);
1069 #ifdef FETCH_POINTER_ARGUMENT_P
1070   fprintf_unfiltered (file,
1071                       "gdbarch_dump: %s # %s\n",
1072                       "FETCH_POINTER_ARGUMENT_P()",
1073                       XSTRING (FETCH_POINTER_ARGUMENT_P ()));
1074 #endif
1075   fprintf_unfiltered (file,
1076                       "gdbarch_dump: gdbarch_fetch_pointer_argument_p() = %d\n",
1077                       gdbarch_fetch_pointer_argument_p (current_gdbarch));
1078 #ifdef FETCH_POINTER_ARGUMENT
1079   fprintf_unfiltered (file,
1080                       "gdbarch_dump: %s # %s\n",
1081                       "FETCH_POINTER_ARGUMENT(frame, argi, type)",
1082                       XSTRING (FETCH_POINTER_ARGUMENT (frame, argi, type)));
1083 #endif
1084   fprintf_unfiltered (file,
1085                       "gdbarch_dump: fetch_pointer_argument = <0x%lx>\n",
1086                       (long) current_gdbarch->fetch_pointer_argument);
1087 #ifdef TARGET_FLOAT_BIT
1088   fprintf_unfiltered (file,
1089                       "gdbarch_dump: TARGET_FLOAT_BIT # %s\n",
1090                       XSTRING (TARGET_FLOAT_BIT));
1091 #endif
1092   fprintf_unfiltered (file,
1093                       "gdbarch_dump: float_bit = %s\n",
1094                       paddr_d (current_gdbarch->float_bit));
1095 #ifdef TARGET_FLOAT_FORMAT
1096   fprintf_unfiltered (file,
1097                       "gdbarch_dump: TARGET_FLOAT_FORMAT # %s\n",
1098                       XSTRING (TARGET_FLOAT_FORMAT));
1099 #endif
1100   fprintf_unfiltered (file,
1101                       "gdbarch_dump: float_format = %s\n",
1102                       pformat (current_gdbarch->float_format));
1103 #ifdef FP0_REGNUM
1104   fprintf_unfiltered (file,
1105                       "gdbarch_dump: FP0_REGNUM # %s\n",
1106                       XSTRING (FP0_REGNUM));
1107 #endif
1108   fprintf_unfiltered (file,
1109                       "gdbarch_dump: fp0_regnum = %s\n",
1110                       paddr_d (current_gdbarch->fp0_regnum));
1111   fprintf_unfiltered (file,
1112                       "gdbarch_dump: gdbarch_frame_align_p() = %d\n",
1113                       gdbarch_frame_align_p (current_gdbarch));
1114   fprintf_unfiltered (file,
1115                       "gdbarch_dump: frame_align = <0x%lx>\n",
1116                       (long) current_gdbarch->frame_align);
1117 #ifdef FRAME_ARGS_SKIP
1118   fprintf_unfiltered (file,
1119                       "gdbarch_dump: FRAME_ARGS_SKIP # %s\n",
1120                       XSTRING (FRAME_ARGS_SKIP));
1121 #endif
1122   fprintf_unfiltered (file,
1123                       "gdbarch_dump: frame_args_skip = 0x%s\n",
1124                       paddr_nz (current_gdbarch->frame_args_skip));
1125 #ifdef FRAME_NUM_ARGS_P
1126   fprintf_unfiltered (file,
1127                       "gdbarch_dump: %s # %s\n",
1128                       "FRAME_NUM_ARGS_P()",
1129                       XSTRING (FRAME_NUM_ARGS_P ()));
1130 #endif
1131   fprintf_unfiltered (file,
1132                       "gdbarch_dump: gdbarch_frame_num_args_p() = %d\n",
1133                       gdbarch_frame_num_args_p (current_gdbarch));
1134 #ifdef FRAME_NUM_ARGS
1135   fprintf_unfiltered (file,
1136                       "gdbarch_dump: %s # %s\n",
1137                       "FRAME_NUM_ARGS(frame)",
1138                       XSTRING (FRAME_NUM_ARGS (frame)));
1139 #endif
1140   fprintf_unfiltered (file,
1141                       "gdbarch_dump: frame_num_args = <0x%lx>\n",
1142                       (long) current_gdbarch->frame_num_args);
1143 #ifdef FRAME_RED_ZONE_SIZE
1144   fprintf_unfiltered (file,
1145                       "gdbarch_dump: FRAME_RED_ZONE_SIZE # %s\n",
1146                       XSTRING (FRAME_RED_ZONE_SIZE));
1147 #endif
1148   fprintf_unfiltered (file,
1149                       "gdbarch_dump: frame_red_zone_size = %s\n",
1150                       paddr_d (current_gdbarch->frame_red_zone_size));
1151 #ifdef GET_LONGJMP_TARGET_P
1152   fprintf_unfiltered (file,
1153                       "gdbarch_dump: %s # %s\n",
1154                       "GET_LONGJMP_TARGET_P()",
1155                       XSTRING (GET_LONGJMP_TARGET_P ()));
1156 #endif
1157   fprintf_unfiltered (file,
1158                       "gdbarch_dump: gdbarch_get_longjmp_target_p() = %d\n",
1159                       gdbarch_get_longjmp_target_p (current_gdbarch));
1160 #ifdef GET_LONGJMP_TARGET
1161   fprintf_unfiltered (file,
1162                       "gdbarch_dump: %s # %s\n",
1163                       "GET_LONGJMP_TARGET(pc)",
1164                       XSTRING (GET_LONGJMP_TARGET (pc)));
1165 #endif
1166   fprintf_unfiltered (file,
1167                       "gdbarch_dump: get_longjmp_target = <0x%lx>\n",
1168                       (long) current_gdbarch->get_longjmp_target);
1169 #ifdef HAVE_NONSTEPPABLE_WATCHPOINT
1170   fprintf_unfiltered (file,
1171                       "gdbarch_dump: HAVE_NONSTEPPABLE_WATCHPOINT # %s\n",
1172                       XSTRING (HAVE_NONSTEPPABLE_WATCHPOINT));
1173 #endif
1174   fprintf_unfiltered (file,
1175                       "gdbarch_dump: have_nonsteppable_watchpoint = %s\n",
1176                       paddr_d (current_gdbarch->have_nonsteppable_watchpoint));
1177   fprintf_unfiltered (file,
1178                       "gdbarch_dump: in_function_epilogue_p = <0x%lx>\n",
1179                       (long) current_gdbarch->in_function_epilogue_p);
1180 #ifdef IN_SOLIB_RETURN_TRAMPOLINE
1181   fprintf_unfiltered (file,
1182                       "gdbarch_dump: %s # %s\n",
1183                       "IN_SOLIB_RETURN_TRAMPOLINE(pc, name)",
1184                       XSTRING (IN_SOLIB_RETURN_TRAMPOLINE (pc, name)));
1185 #endif
1186   fprintf_unfiltered (file,
1187                       "gdbarch_dump: in_solib_return_trampoline = <0x%lx>\n",
1188                       (long) current_gdbarch->in_solib_return_trampoline);
1189 #ifdef INNER_THAN
1190   fprintf_unfiltered (file,
1191                       "gdbarch_dump: %s # %s\n",
1192                       "INNER_THAN(lhs, rhs)",
1193                       XSTRING (INNER_THAN (lhs, rhs)));
1194 #endif
1195   fprintf_unfiltered (file,
1196                       "gdbarch_dump: inner_than = <0x%lx>\n",
1197                       (long) current_gdbarch->inner_than);
1198 #ifdef TARGET_INT_BIT
1199   fprintf_unfiltered (file,
1200                       "gdbarch_dump: TARGET_INT_BIT # %s\n",
1201                       XSTRING (TARGET_INT_BIT));
1202 #endif
1203   fprintf_unfiltered (file,
1204                       "gdbarch_dump: int_bit = %s\n",
1205                       paddr_d (current_gdbarch->int_bit));
1206   fprintf_unfiltered (file,
1207                       "gdbarch_dump: gdbarch_integer_to_address_p() = %d\n",
1208                       gdbarch_integer_to_address_p (current_gdbarch));
1209   fprintf_unfiltered (file,
1210                       "gdbarch_dump: integer_to_address = <0x%lx>\n",
1211                       (long) current_gdbarch->integer_to_address);
1212 #ifdef TARGET_LONG_BIT
1213   fprintf_unfiltered (file,
1214                       "gdbarch_dump: TARGET_LONG_BIT # %s\n",
1215                       XSTRING (TARGET_LONG_BIT));
1216 #endif
1217   fprintf_unfiltered (file,
1218                       "gdbarch_dump: long_bit = %s\n",
1219                       paddr_d (current_gdbarch->long_bit));
1220 #ifdef TARGET_LONG_DOUBLE_BIT
1221   fprintf_unfiltered (file,
1222                       "gdbarch_dump: TARGET_LONG_DOUBLE_BIT # %s\n",
1223                       XSTRING (TARGET_LONG_DOUBLE_BIT));
1224 #endif
1225   fprintf_unfiltered (file,
1226                       "gdbarch_dump: long_double_bit = %s\n",
1227                       paddr_d (current_gdbarch->long_double_bit));
1228 #ifdef TARGET_LONG_DOUBLE_FORMAT
1229   fprintf_unfiltered (file,
1230                       "gdbarch_dump: TARGET_LONG_DOUBLE_FORMAT # %s\n",
1231                       XSTRING (TARGET_LONG_DOUBLE_FORMAT));
1232 #endif
1233   fprintf_unfiltered (file,
1234                       "gdbarch_dump: long_double_format = %s\n",
1235                       pformat (current_gdbarch->long_double_format));
1236 #ifdef TARGET_LONG_LONG_BIT
1237   fprintf_unfiltered (file,
1238                       "gdbarch_dump: TARGET_LONG_LONG_BIT # %s\n",
1239                       XSTRING (TARGET_LONG_LONG_BIT));
1240 #endif
1241   fprintf_unfiltered (file,
1242                       "gdbarch_dump: long_long_bit = %s\n",
1243                       paddr_d (current_gdbarch->long_long_bit));
1244 #ifdef MEMORY_INSERT_BREAKPOINT
1245   fprintf_unfiltered (file,
1246                       "gdbarch_dump: %s # %s\n",
1247                       "MEMORY_INSERT_BREAKPOINT(addr, contents_cache)",
1248                       XSTRING (MEMORY_INSERT_BREAKPOINT (addr, contents_cache)));
1249 #endif
1250   fprintf_unfiltered (file,
1251                       "gdbarch_dump: memory_insert_breakpoint = <0x%lx>\n",
1252                       (long) current_gdbarch->memory_insert_breakpoint);
1253 #ifdef MEMORY_REMOVE_BREAKPOINT
1254   fprintf_unfiltered (file,
1255                       "gdbarch_dump: %s # %s\n",
1256                       "MEMORY_REMOVE_BREAKPOINT(addr, contents_cache)",
1257                       XSTRING (MEMORY_REMOVE_BREAKPOINT (addr, contents_cache)));
1258 #endif
1259   fprintf_unfiltered (file,
1260                       "gdbarch_dump: memory_remove_breakpoint = <0x%lx>\n",
1261                       (long) current_gdbarch->memory_remove_breakpoint);
1262 #ifdef NAME_OF_MALLOC
1263   fprintf_unfiltered (file,
1264                       "gdbarch_dump: NAME_OF_MALLOC # %s\n",
1265                       XSTRING (NAME_OF_MALLOC));
1266 #endif
1267   fprintf_unfiltered (file,
1268                       "gdbarch_dump: name_of_malloc = %s\n",
1269                       NAME_OF_MALLOC);
1270 #ifdef NUM_PSEUDO_REGS
1271   fprintf_unfiltered (file,
1272                       "gdbarch_dump: NUM_PSEUDO_REGS # %s\n",
1273                       XSTRING (NUM_PSEUDO_REGS));
1274 #endif
1275   fprintf_unfiltered (file,
1276                       "gdbarch_dump: num_pseudo_regs = %s\n",
1277                       paddr_d (current_gdbarch->num_pseudo_regs));
1278 #ifdef NUM_REGS
1279   fprintf_unfiltered (file,
1280                       "gdbarch_dump: NUM_REGS # %s\n",
1281                       XSTRING (NUM_REGS));
1282 #endif
1283   fprintf_unfiltered (file,
1284                       "gdbarch_dump: num_regs = %s\n",
1285                       paddr_d (current_gdbarch->num_regs));
1286 #ifdef TARGET_OSABI
1287   fprintf_unfiltered (file,
1288                       "gdbarch_dump: TARGET_OSABI # %s\n",
1289                       XSTRING (TARGET_OSABI));
1290 #endif
1291   fprintf_unfiltered (file,
1292                       "gdbarch_dump: osabi = %s\n",
1293                       paddr_d (current_gdbarch->osabi));
1294 #ifdef PC_REGNUM
1295   fprintf_unfiltered (file,
1296                       "gdbarch_dump: PC_REGNUM # %s\n",
1297                       XSTRING (PC_REGNUM));
1298 #endif
1299   fprintf_unfiltered (file,
1300                       "gdbarch_dump: pc_regnum = %s\n",
1301                       paddr_d (current_gdbarch->pc_regnum));
1302 #ifdef POINTER_TO_ADDRESS
1303   fprintf_unfiltered (file,
1304                       "gdbarch_dump: %s # %s\n",
1305                       "POINTER_TO_ADDRESS(type, buf)",
1306                       XSTRING (POINTER_TO_ADDRESS (type, buf)));
1307 #endif
1308   fprintf_unfiltered (file,
1309                       "gdbarch_dump: pointer_to_address = <0x%lx>\n",
1310                       (long) current_gdbarch->pointer_to_address);
1311   fprintf_unfiltered (file,
1312                       "gdbarch_dump: gdbarch_print_float_info_p() = %d\n",
1313                       gdbarch_print_float_info_p (current_gdbarch));
1314   fprintf_unfiltered (file,
1315                       "gdbarch_dump: print_float_info = <0x%lx>\n",
1316                       (long) current_gdbarch->print_float_info);
1317 #ifdef TARGET_PRINT_INSN
1318   fprintf_unfiltered (file,
1319                       "gdbarch_dump: %s # %s\n",
1320                       "TARGET_PRINT_INSN(vma, info)",
1321                       XSTRING (TARGET_PRINT_INSN (vma, info)));
1322 #endif
1323   fprintf_unfiltered (file,
1324                       "gdbarch_dump: print_insn = <0x%lx>\n",
1325                       (long) current_gdbarch->print_insn);
1326   fprintf_unfiltered (file,
1327                       "gdbarch_dump: print_registers_info = <0x%lx>\n",
1328                       (long) current_gdbarch->print_registers_info);
1329   fprintf_unfiltered (file,
1330                       "gdbarch_dump: gdbarch_print_vector_info_p() = %d\n",
1331                       gdbarch_print_vector_info_p (current_gdbarch));
1332   fprintf_unfiltered (file,
1333                       "gdbarch_dump: print_vector_info = <0x%lx>\n",
1334                       (long) current_gdbarch->print_vector_info);
1335 #ifdef PS_REGNUM
1336   fprintf_unfiltered (file,
1337                       "gdbarch_dump: PS_REGNUM # %s\n",
1338                       XSTRING (PS_REGNUM));
1339 #endif
1340   fprintf_unfiltered (file,
1341                       "gdbarch_dump: ps_regnum = %s\n",
1342                       paddr_d (current_gdbarch->ps_regnum));
1343   fprintf_unfiltered (file,
1344                       "gdbarch_dump: gdbarch_pseudo_register_read_p() = %d\n",
1345                       gdbarch_pseudo_register_read_p (current_gdbarch));
1346   fprintf_unfiltered (file,
1347                       "gdbarch_dump: pseudo_register_read = <0x%lx>\n",
1348                       (long) current_gdbarch->pseudo_register_read);
1349   fprintf_unfiltered (file,
1350                       "gdbarch_dump: gdbarch_pseudo_register_write_p() = %d\n",
1351                       gdbarch_pseudo_register_write_p (current_gdbarch));
1352   fprintf_unfiltered (file,
1353                       "gdbarch_dump: pseudo_register_write = <0x%lx>\n",
1354                       (long) current_gdbarch->pseudo_register_write);
1355 #ifdef TARGET_PTR_BIT
1356   fprintf_unfiltered (file,
1357                       "gdbarch_dump: TARGET_PTR_BIT # %s\n",
1358                       XSTRING (TARGET_PTR_BIT));
1359 #endif
1360   fprintf_unfiltered (file,
1361                       "gdbarch_dump: ptr_bit = %s\n",
1362                       paddr_d (current_gdbarch->ptr_bit));
1363   fprintf_unfiltered (file,
1364                       "gdbarch_dump: gdbarch_push_dummy_call_p() = %d\n",
1365                       gdbarch_push_dummy_call_p (current_gdbarch));
1366   fprintf_unfiltered (file,
1367                       "gdbarch_dump: push_dummy_call = <0x%lx>\n",
1368                       (long) current_gdbarch->push_dummy_call);
1369   fprintf_unfiltered (file,
1370                       "gdbarch_dump: gdbarch_push_dummy_code_p() = %d\n",
1371                       gdbarch_push_dummy_code_p (current_gdbarch));
1372   fprintf_unfiltered (file,
1373                       "gdbarch_dump: push_dummy_code = <0x%lx>\n",
1374                       (long) current_gdbarch->push_dummy_code);
1375 #ifdef TARGET_READ_PC_P
1376   fprintf_unfiltered (file,
1377                       "gdbarch_dump: %s # %s\n",
1378                       "TARGET_READ_PC_P()",
1379                       XSTRING (TARGET_READ_PC_P ()));
1380 #endif
1381   fprintf_unfiltered (file,
1382                       "gdbarch_dump: gdbarch_read_pc_p() = %d\n",
1383                       gdbarch_read_pc_p (current_gdbarch));
1384 #ifdef TARGET_READ_PC
1385   fprintf_unfiltered (file,
1386                       "gdbarch_dump: %s # %s\n",
1387                       "TARGET_READ_PC(ptid)",
1388                       XSTRING (TARGET_READ_PC (ptid)));
1389 #endif
1390   fprintf_unfiltered (file,
1391                       "gdbarch_dump: read_pc = <0x%lx>\n",
1392                       (long) current_gdbarch->read_pc);
1393 #ifdef TARGET_READ_SP_P
1394   fprintf_unfiltered (file,
1395                       "gdbarch_dump: %s # %s\n",
1396                       "TARGET_READ_SP_P()",
1397                       XSTRING (TARGET_READ_SP_P ()));
1398 #endif
1399   fprintf_unfiltered (file,
1400                       "gdbarch_dump: gdbarch_read_sp_p() = %d\n",
1401                       gdbarch_read_sp_p (current_gdbarch));
1402 #ifdef TARGET_READ_SP
1403   fprintf_unfiltered (file,
1404                       "gdbarch_dump: %s # %s\n",
1405                       "TARGET_READ_SP()",
1406                       XSTRING (TARGET_READ_SP ()));
1407 #endif
1408   fprintf_unfiltered (file,
1409                       "gdbarch_dump: read_sp = <0x%lx>\n",
1410                       (long) current_gdbarch->read_sp);
1411 #ifdef REGISTER_BYTES_OK_P
1412   fprintf_unfiltered (file,
1413                       "gdbarch_dump: %s # %s\n",
1414                       "REGISTER_BYTES_OK_P()",
1415                       XSTRING (REGISTER_BYTES_OK_P ()));
1416 #endif
1417   fprintf_unfiltered (file,
1418                       "gdbarch_dump: gdbarch_register_bytes_ok_p() = %d\n",
1419                       gdbarch_register_bytes_ok_p (current_gdbarch));
1420 #ifdef REGISTER_BYTES_OK
1421   fprintf_unfiltered (file,
1422                       "gdbarch_dump: %s # %s\n",
1423                       "REGISTER_BYTES_OK(nr_bytes)",
1424                       XSTRING (REGISTER_BYTES_OK (nr_bytes)));
1425 #endif
1426   fprintf_unfiltered (file,
1427                       "gdbarch_dump: register_bytes_ok = <0x%lx>\n",
1428                       (long) current_gdbarch->register_bytes_ok);
1429 #ifdef REGISTER_NAME
1430   fprintf_unfiltered (file,
1431                       "gdbarch_dump: %s # %s\n",
1432                       "REGISTER_NAME(regnr)",
1433                       XSTRING (REGISTER_NAME (regnr)));
1434 #endif
1435   fprintf_unfiltered (file,
1436                       "gdbarch_dump: register_name = <0x%lx>\n",
1437                       (long) current_gdbarch->register_name);
1438   fprintf_unfiltered (file,
1439                       "gdbarch_dump: register_reggroup_p = <0x%lx>\n",
1440                       (long) current_gdbarch->register_reggroup_p);
1441 #ifdef REGISTER_SIM_REGNO
1442   fprintf_unfiltered (file,
1443                       "gdbarch_dump: %s # %s\n",
1444                       "REGISTER_SIM_REGNO(reg_nr)",
1445                       XSTRING (REGISTER_SIM_REGNO (reg_nr)));
1446 #endif
1447   fprintf_unfiltered (file,
1448                       "gdbarch_dump: register_sim_regno = <0x%lx>\n",
1449                       (long) current_gdbarch->register_sim_regno);
1450 #ifdef REGISTER_TO_VALUE
1451   fprintf_unfiltered (file,
1452                       "gdbarch_dump: %s # %s\n",
1453                       "REGISTER_TO_VALUE(frame, regnum, type, buf)",
1454                       XSTRING (REGISTER_TO_VALUE (frame, regnum, type, buf)));
1455 #endif
1456   fprintf_unfiltered (file,
1457                       "gdbarch_dump: register_to_value = <0x%lx>\n",
1458                       (long) current_gdbarch->register_to_value);
1459   fprintf_unfiltered (file,
1460                       "gdbarch_dump: gdbarch_register_type_p() = %d\n",
1461                       gdbarch_register_type_p (current_gdbarch));
1462   fprintf_unfiltered (file,
1463                       "gdbarch_dump: register_type = <0x%lx>\n",
1464                       (long) current_gdbarch->register_type);
1465   fprintf_unfiltered (file,
1466                       "gdbarch_dump: gdbarch_regset_from_core_section_p() = %d\n",
1467                       gdbarch_regset_from_core_section_p (current_gdbarch));
1468   fprintf_unfiltered (file,
1469                       "gdbarch_dump: regset_from_core_section = <0x%lx>\n",
1470                       (long) current_gdbarch->regset_from_core_section);
1471   fprintf_unfiltered (file,
1472                       "gdbarch_dump: remote_translate_xfer_address = <0x%lx>\n",
1473                       (long) current_gdbarch->remote_translate_xfer_address);
1474   fprintf_unfiltered (file,
1475                       "gdbarch_dump: gdbarch_return_value_p() = %d\n",
1476                       gdbarch_return_value_p (current_gdbarch));
1477   fprintf_unfiltered (file,
1478                       "gdbarch_dump: return_value = <0x%lx>\n",
1479                       (long) current_gdbarch->return_value);
1480 #ifdef SDB_REG_TO_REGNUM
1481   fprintf_unfiltered (file,
1482                       "gdbarch_dump: %s # %s\n",
1483                       "SDB_REG_TO_REGNUM(sdb_regnr)",
1484                       XSTRING (SDB_REG_TO_REGNUM (sdb_regnr)));
1485 #endif
1486   fprintf_unfiltered (file,
1487                       "gdbarch_dump: sdb_reg_to_regnum = <0x%lx>\n",
1488                       (long) current_gdbarch->sdb_reg_to_regnum);
1489 #ifdef TARGET_SHORT_BIT
1490   fprintf_unfiltered (file,
1491                       "gdbarch_dump: TARGET_SHORT_BIT # %s\n",
1492                       XSTRING (TARGET_SHORT_BIT));
1493 #endif
1494   fprintf_unfiltered (file,
1495                       "gdbarch_dump: short_bit = %s\n",
1496                       paddr_d (current_gdbarch->short_bit));
1497   fprintf_unfiltered (file,
1498                       "gdbarch_dump: gdbarch_single_step_through_delay_p() = %d\n",
1499                       gdbarch_single_step_through_delay_p (current_gdbarch));
1500   fprintf_unfiltered (file,
1501                       "gdbarch_dump: single_step_through_delay = <0x%lx>\n",
1502                       (long) current_gdbarch->single_step_through_delay);
1503 #ifdef SKIP_PROLOGUE
1504   fprintf_unfiltered (file,
1505                       "gdbarch_dump: %s # %s\n",
1506                       "SKIP_PROLOGUE(ip)",
1507                       XSTRING (SKIP_PROLOGUE (ip)));
1508 #endif
1509   fprintf_unfiltered (file,
1510                       "gdbarch_dump: skip_prologue = <0x%lx>\n",
1511                       (long) current_gdbarch->skip_prologue);
1512   fprintf_unfiltered (file,
1513                       "gdbarch_dump: skip_solib_resolver = <0x%lx>\n",
1514                       (long) current_gdbarch->skip_solib_resolver);
1515 #ifdef SKIP_TRAMPOLINE_CODE
1516   fprintf_unfiltered (file,
1517                       "gdbarch_dump: %s # %s\n",
1518                       "SKIP_TRAMPOLINE_CODE(pc)",
1519                       XSTRING (SKIP_TRAMPOLINE_CODE (pc)));
1520 #endif
1521   fprintf_unfiltered (file,
1522                       "gdbarch_dump: skip_trampoline_code = <0x%lx>\n",
1523                       (long) current_gdbarch->skip_trampoline_code);
1524 #ifdef SMASH_TEXT_ADDRESS
1525   fprintf_unfiltered (file,
1526                       "gdbarch_dump: %s # %s\n",
1527                       "SMASH_TEXT_ADDRESS(addr)",
1528                       XSTRING (SMASH_TEXT_ADDRESS (addr)));
1529 #endif
1530   fprintf_unfiltered (file,
1531                       "gdbarch_dump: smash_text_address = <0x%lx>\n",
1532                       (long) current_gdbarch->smash_text_address);
1533 #ifdef SOFTWARE_SINGLE_STEP_P
1534   fprintf_unfiltered (file,
1535                       "gdbarch_dump: %s # %s\n",
1536                       "SOFTWARE_SINGLE_STEP_P()",
1537                       XSTRING (SOFTWARE_SINGLE_STEP_P ()));
1538 #endif
1539   fprintf_unfiltered (file,
1540                       "gdbarch_dump: gdbarch_software_single_step_p() = %d\n",
1541                       gdbarch_software_single_step_p (current_gdbarch));
1542 #ifdef SOFTWARE_SINGLE_STEP
1543   fprintf_unfiltered (file,
1544                       "gdbarch_dump: %s # %s\n",
1545                       "SOFTWARE_SINGLE_STEP(sig, insert_breakpoints_p)",
1546                       XSTRING (SOFTWARE_SINGLE_STEP (sig, insert_breakpoints_p)));
1547 #endif
1548   fprintf_unfiltered (file,
1549                       "gdbarch_dump: software_single_step = <0x%lx>\n",
1550                       (long) current_gdbarch->software_single_step);
1551 #ifdef SP_REGNUM
1552   fprintf_unfiltered (file,
1553                       "gdbarch_dump: SP_REGNUM # %s\n",
1554                       XSTRING (SP_REGNUM));
1555 #endif
1556   fprintf_unfiltered (file,
1557                       "gdbarch_dump: sp_regnum = %s\n",
1558                       paddr_d (current_gdbarch->sp_regnum));
1559 #ifdef STAB_REG_TO_REGNUM
1560   fprintf_unfiltered (file,
1561                       "gdbarch_dump: %s # %s\n",
1562                       "STAB_REG_TO_REGNUM(stab_regnr)",
1563                       XSTRING (STAB_REG_TO_REGNUM (stab_regnr)));
1564 #endif
1565   fprintf_unfiltered (file,
1566                       "gdbarch_dump: stab_reg_to_regnum = <0x%lx>\n",
1567                       (long) current_gdbarch->stab_reg_to_regnum);
1568   fprintf_unfiltered (file,
1569                       "gdbarch_dump: stabs_argument_has_addr = <0x%lx>\n",
1570                       (long) current_gdbarch->stabs_argument_has_addr);
1571 #ifdef STORE_RETURN_VALUE
1572   fprintf_unfiltered (file,
1573                       "gdbarch_dump: %s # %s\n",
1574                       "STORE_RETURN_VALUE(type, regcache, valbuf)",
1575                       XSTRING (STORE_RETURN_VALUE (type, regcache, valbuf)));
1576 #endif
1577   fprintf_unfiltered (file,
1578                       "gdbarch_dump: store_return_value = <0x%lx>\n",
1579                       (long) current_gdbarch->store_return_value);
1580   fprintf_unfiltered (file,
1581                       "gdbarch_dump: gdbarch_unwind_dummy_id_p() = %d\n",
1582                       gdbarch_unwind_dummy_id_p (current_gdbarch));
1583   fprintf_unfiltered (file,
1584                       "gdbarch_dump: unwind_dummy_id = <0x%lx>\n",
1585                       (long) current_gdbarch->unwind_dummy_id);
1586   fprintf_unfiltered (file,
1587                       "gdbarch_dump: gdbarch_unwind_pc_p() = %d\n",
1588                       gdbarch_unwind_pc_p (current_gdbarch));
1589   fprintf_unfiltered (file,
1590                       "gdbarch_dump: unwind_pc = <0x%lx>\n",
1591                       (long) current_gdbarch->unwind_pc);
1592   fprintf_unfiltered (file,
1593                       "gdbarch_dump: gdbarch_unwind_sp_p() = %d\n",
1594                       gdbarch_unwind_sp_p (current_gdbarch));
1595   fprintf_unfiltered (file,
1596                       "gdbarch_dump: unwind_sp = <0x%lx>\n",
1597                       (long) current_gdbarch->unwind_sp);
1598 #ifdef VALUE_TO_REGISTER
1599   fprintf_unfiltered (file,
1600                       "gdbarch_dump: %s # %s\n",
1601                       "VALUE_TO_REGISTER(frame, regnum, type, buf)",
1602                       XSTRING (VALUE_TO_REGISTER (frame, regnum, type, buf)));
1603 #endif
1604   fprintf_unfiltered (file,
1605                       "gdbarch_dump: value_to_register = <0x%lx>\n",
1606                       (long) current_gdbarch->value_to_register);
1607 #ifdef TARGET_VIRTUAL_FRAME_POINTER
1608   fprintf_unfiltered (file,
1609                       "gdbarch_dump: %s # %s\n",
1610                       "TARGET_VIRTUAL_FRAME_POINTER(pc, frame_regnum, frame_offset)",
1611                       XSTRING (TARGET_VIRTUAL_FRAME_POINTER (pc, frame_regnum, frame_offset)));
1612 #endif
1613   fprintf_unfiltered (file,
1614                       "gdbarch_dump: virtual_frame_pointer = <0x%lx>\n",
1615                       (long) current_gdbarch->virtual_frame_pointer);
1616 #ifdef TARGET_WRITE_PC
1617   fprintf_unfiltered (file,
1618                       "gdbarch_dump: %s # %s\n",
1619                       "TARGET_WRITE_PC(val, ptid)",
1620                       XSTRING (TARGET_WRITE_PC (val, ptid)));
1621 #endif
1622   fprintf_unfiltered (file,
1623                       "gdbarch_dump: write_pc = <0x%lx>\n",
1624                       (long) current_gdbarch->write_pc);
1625   if (current_gdbarch->dump_tdep != NULL)
1626     current_gdbarch->dump_tdep (current_gdbarch, file);
1627 }
1628
1629 struct gdbarch_tdep *
1630 gdbarch_tdep (struct gdbarch *gdbarch)
1631 {
1632   if (gdbarch_debug >= 2)
1633     fprintf_unfiltered (gdb_stdlog, "gdbarch_tdep called\n");
1634   return gdbarch->tdep;
1635 }
1636
1637
1638 const struct bfd_arch_info *
1639 gdbarch_bfd_arch_info (struct gdbarch *gdbarch)
1640 {
1641   gdb_assert (gdbarch != NULL);
1642   if (gdbarch_debug >= 2)
1643     fprintf_unfiltered (gdb_stdlog, "gdbarch_bfd_arch_info called\n");
1644   return gdbarch->bfd_arch_info;
1645 }
1646
1647 int
1648 gdbarch_byte_order (struct gdbarch *gdbarch)
1649 {
1650   gdb_assert (gdbarch != NULL);
1651   if (gdbarch_debug >= 2)
1652     fprintf_unfiltered (gdb_stdlog, "gdbarch_byte_order called\n");
1653   return gdbarch->byte_order;
1654 }
1655
1656 enum gdb_osabi
1657 gdbarch_osabi (struct gdbarch *gdbarch)
1658 {
1659   gdb_assert (gdbarch != NULL);
1660   if (gdbarch_debug >= 2)
1661     fprintf_unfiltered (gdb_stdlog, "gdbarch_osabi called\n");
1662   return gdbarch->osabi;
1663 }
1664
1665 int
1666 gdbarch_short_bit (struct gdbarch *gdbarch)
1667 {
1668   gdb_assert (gdbarch != NULL);
1669   /* Skip verify of short_bit, invalid_p == 0 */
1670   if (gdbarch_debug >= 2)
1671     fprintf_unfiltered (gdb_stdlog, "gdbarch_short_bit called\n");
1672   return gdbarch->short_bit;
1673 }
1674
1675 void
1676 set_gdbarch_short_bit (struct gdbarch *gdbarch,
1677                        int short_bit)
1678 {
1679   gdbarch->short_bit = short_bit;
1680 }
1681
1682 int
1683 gdbarch_int_bit (struct gdbarch *gdbarch)
1684 {
1685   gdb_assert (gdbarch != NULL);
1686   /* Skip verify of int_bit, invalid_p == 0 */
1687   if (gdbarch_debug >= 2)
1688     fprintf_unfiltered (gdb_stdlog, "gdbarch_int_bit called\n");
1689   return gdbarch->int_bit;
1690 }
1691
1692 void
1693 set_gdbarch_int_bit (struct gdbarch *gdbarch,
1694                      int int_bit)
1695 {
1696   gdbarch->int_bit = int_bit;
1697 }
1698
1699 int
1700 gdbarch_long_bit (struct gdbarch *gdbarch)
1701 {
1702   gdb_assert (gdbarch != NULL);
1703   /* Skip verify of long_bit, invalid_p == 0 */
1704   if (gdbarch_debug >= 2)
1705     fprintf_unfiltered (gdb_stdlog, "gdbarch_long_bit called\n");
1706   return gdbarch->long_bit;
1707 }
1708
1709 void
1710 set_gdbarch_long_bit (struct gdbarch *gdbarch,
1711                       int long_bit)
1712 {
1713   gdbarch->long_bit = long_bit;
1714 }
1715
1716 int
1717 gdbarch_long_long_bit (struct gdbarch *gdbarch)
1718 {
1719   gdb_assert (gdbarch != NULL);
1720   /* Skip verify of long_long_bit, invalid_p == 0 */
1721   if (gdbarch_debug >= 2)
1722     fprintf_unfiltered (gdb_stdlog, "gdbarch_long_long_bit called\n");
1723   return gdbarch->long_long_bit;
1724 }
1725
1726 void
1727 set_gdbarch_long_long_bit (struct gdbarch *gdbarch,
1728                            int long_long_bit)
1729 {
1730   gdbarch->long_long_bit = long_long_bit;
1731 }
1732
1733 int
1734 gdbarch_float_bit (struct gdbarch *gdbarch)
1735 {
1736   gdb_assert (gdbarch != NULL);
1737   /* Skip verify of float_bit, invalid_p == 0 */
1738   if (gdbarch_debug >= 2)
1739     fprintf_unfiltered (gdb_stdlog, "gdbarch_float_bit called\n");
1740   return gdbarch->float_bit;
1741 }
1742
1743 void
1744 set_gdbarch_float_bit (struct gdbarch *gdbarch,
1745                        int float_bit)
1746 {
1747   gdbarch->float_bit = float_bit;
1748 }
1749
1750 const struct floatformat *
1751 gdbarch_float_format (struct gdbarch *gdbarch)
1752 {
1753   gdb_assert (gdbarch != NULL);
1754   if (gdbarch_debug >= 2)
1755     fprintf_unfiltered (gdb_stdlog, "gdbarch_float_format called\n");
1756   return gdbarch->float_format;
1757 }
1758
1759 void
1760 set_gdbarch_float_format (struct gdbarch *gdbarch,
1761                           const struct floatformat * float_format)
1762 {
1763   gdbarch->float_format = float_format;
1764 }
1765
1766 int
1767 gdbarch_double_bit (struct gdbarch *gdbarch)
1768 {
1769   gdb_assert (gdbarch != NULL);
1770   /* Skip verify of double_bit, invalid_p == 0 */
1771   if (gdbarch_debug >= 2)
1772     fprintf_unfiltered (gdb_stdlog, "gdbarch_double_bit called\n");
1773   return gdbarch->double_bit;
1774 }
1775
1776 void
1777 set_gdbarch_double_bit (struct gdbarch *gdbarch,
1778                         int double_bit)
1779 {
1780   gdbarch->double_bit = double_bit;
1781 }
1782
1783 const struct floatformat *
1784 gdbarch_double_format (struct gdbarch *gdbarch)
1785 {
1786   gdb_assert (gdbarch != NULL);
1787   if (gdbarch_debug >= 2)
1788     fprintf_unfiltered (gdb_stdlog, "gdbarch_double_format called\n");
1789   return gdbarch->double_format;
1790 }
1791
1792 void
1793 set_gdbarch_double_format (struct gdbarch *gdbarch,
1794                            const struct floatformat * double_format)
1795 {
1796   gdbarch->double_format = double_format;
1797 }
1798
1799 int
1800 gdbarch_long_double_bit (struct gdbarch *gdbarch)
1801 {
1802   gdb_assert (gdbarch != NULL);
1803   /* Skip verify of long_double_bit, invalid_p == 0 */
1804   if (gdbarch_debug >= 2)
1805     fprintf_unfiltered (gdb_stdlog, "gdbarch_long_double_bit called\n");
1806   return gdbarch->long_double_bit;
1807 }
1808
1809 void
1810 set_gdbarch_long_double_bit (struct gdbarch *gdbarch,
1811                              int long_double_bit)
1812 {
1813   gdbarch->long_double_bit = long_double_bit;
1814 }
1815
1816 const struct floatformat *
1817 gdbarch_long_double_format (struct gdbarch *gdbarch)
1818 {
1819   gdb_assert (gdbarch != NULL);
1820   if (gdbarch_debug >= 2)
1821     fprintf_unfiltered (gdb_stdlog, "gdbarch_long_double_format called\n");
1822   return gdbarch->long_double_format;
1823 }
1824
1825 void
1826 set_gdbarch_long_double_format (struct gdbarch *gdbarch,
1827                                 const struct floatformat * long_double_format)
1828 {
1829   gdbarch->long_double_format = long_double_format;
1830 }
1831
1832 int
1833 gdbarch_ptr_bit (struct gdbarch *gdbarch)
1834 {
1835   gdb_assert (gdbarch != NULL);
1836   /* Skip verify of ptr_bit, invalid_p == 0 */
1837   if (gdbarch_debug >= 2)
1838     fprintf_unfiltered (gdb_stdlog, "gdbarch_ptr_bit called\n");
1839   return gdbarch->ptr_bit;
1840 }
1841
1842 void
1843 set_gdbarch_ptr_bit (struct gdbarch *gdbarch,
1844                      int ptr_bit)
1845 {
1846   gdbarch->ptr_bit = ptr_bit;
1847 }
1848
1849 int
1850 gdbarch_addr_bit (struct gdbarch *gdbarch)
1851 {
1852   gdb_assert (gdbarch != NULL);
1853   /* Check variable changed from pre-default.  */
1854   gdb_assert (gdbarch->addr_bit != 0);
1855   if (gdbarch_debug >= 2)
1856     fprintf_unfiltered (gdb_stdlog, "gdbarch_addr_bit called\n");
1857   return gdbarch->addr_bit;
1858 }
1859
1860 void
1861 set_gdbarch_addr_bit (struct gdbarch *gdbarch,
1862                       int addr_bit)
1863 {
1864   gdbarch->addr_bit = addr_bit;
1865 }
1866
1867 int
1868 gdbarch_bfd_vma_bit (struct gdbarch *gdbarch)
1869 {
1870   gdb_assert (gdbarch != NULL);
1871   /* Skip verify of bfd_vma_bit, invalid_p == 0 */
1872   if (gdbarch_debug >= 2)
1873     fprintf_unfiltered (gdb_stdlog, "gdbarch_bfd_vma_bit called\n");
1874   return gdbarch->bfd_vma_bit;
1875 }
1876
1877 void
1878 set_gdbarch_bfd_vma_bit (struct gdbarch *gdbarch,
1879                          int bfd_vma_bit)
1880 {
1881   gdbarch->bfd_vma_bit = bfd_vma_bit;
1882 }
1883
1884 int
1885 gdbarch_char_signed (struct gdbarch *gdbarch)
1886 {
1887   gdb_assert (gdbarch != NULL);
1888   /* Check variable changed from pre-default.  */
1889   gdb_assert (gdbarch->char_signed != -1);
1890   if (gdbarch_debug >= 2)
1891     fprintf_unfiltered (gdb_stdlog, "gdbarch_char_signed called\n");
1892   return gdbarch->char_signed;
1893 }
1894
1895 void
1896 set_gdbarch_char_signed (struct gdbarch *gdbarch,
1897                          int char_signed)
1898 {
1899   gdbarch->char_signed = char_signed;
1900 }
1901
1902 int
1903 gdbarch_read_pc_p (struct gdbarch *gdbarch)
1904 {
1905   gdb_assert (gdbarch != NULL);
1906   return gdbarch->read_pc != NULL;
1907 }
1908
1909 CORE_ADDR
1910 gdbarch_read_pc (struct gdbarch *gdbarch, ptid_t ptid)
1911 {
1912   gdb_assert (gdbarch != NULL);
1913   gdb_assert (gdbarch->read_pc != NULL);
1914   if (gdbarch_debug >= 2)
1915     fprintf_unfiltered (gdb_stdlog, "gdbarch_read_pc called\n");
1916   return gdbarch->read_pc (ptid);
1917 }
1918
1919 void
1920 set_gdbarch_read_pc (struct gdbarch *gdbarch,
1921                      gdbarch_read_pc_ftype read_pc)
1922 {
1923   gdbarch->read_pc = read_pc;
1924 }
1925
1926 void
1927 gdbarch_write_pc (struct gdbarch *gdbarch, CORE_ADDR val, ptid_t ptid)
1928 {
1929   gdb_assert (gdbarch != NULL);
1930   gdb_assert (gdbarch->write_pc != NULL);
1931   if (gdbarch_debug >= 2)
1932     fprintf_unfiltered (gdb_stdlog, "gdbarch_write_pc called\n");
1933   gdbarch->write_pc (val, ptid);
1934 }
1935
1936 void
1937 set_gdbarch_write_pc (struct gdbarch *gdbarch,
1938                       gdbarch_write_pc_ftype write_pc)
1939 {
1940   gdbarch->write_pc = write_pc;
1941 }
1942
1943 int
1944 gdbarch_read_sp_p (struct gdbarch *gdbarch)
1945 {
1946   gdb_assert (gdbarch != NULL);
1947   return gdbarch->read_sp != NULL;
1948 }
1949
1950 CORE_ADDR
1951 gdbarch_read_sp (struct gdbarch *gdbarch)
1952 {
1953   gdb_assert (gdbarch != NULL);
1954   gdb_assert (gdbarch->read_sp != NULL);
1955   if (gdbarch_debug >= 2)
1956     fprintf_unfiltered (gdb_stdlog, "gdbarch_read_sp called\n");
1957   return gdbarch->read_sp ();
1958 }
1959
1960 void
1961 set_gdbarch_read_sp (struct gdbarch *gdbarch,
1962                      gdbarch_read_sp_ftype read_sp)
1963 {
1964   gdbarch->read_sp = read_sp;
1965 }
1966
1967 void
1968 gdbarch_virtual_frame_pointer (struct gdbarch *gdbarch, CORE_ADDR pc, int *frame_regnum, LONGEST *frame_offset)
1969 {
1970   gdb_assert (gdbarch != NULL);
1971   gdb_assert (gdbarch->virtual_frame_pointer != NULL);
1972   if (gdbarch_debug >= 2)
1973     fprintf_unfiltered (gdb_stdlog, "gdbarch_virtual_frame_pointer called\n");
1974   gdbarch->virtual_frame_pointer (pc, frame_regnum, frame_offset);
1975 }
1976
1977 void
1978 set_gdbarch_virtual_frame_pointer (struct gdbarch *gdbarch,
1979                                    gdbarch_virtual_frame_pointer_ftype virtual_frame_pointer)
1980 {
1981   gdbarch->virtual_frame_pointer = virtual_frame_pointer;
1982 }
1983
1984 int
1985 gdbarch_pseudo_register_read_p (struct gdbarch *gdbarch)
1986 {
1987   gdb_assert (gdbarch != NULL);
1988   return gdbarch->pseudo_register_read != NULL;
1989 }
1990
1991 void
1992 gdbarch_pseudo_register_read (struct gdbarch *gdbarch, struct regcache *regcache, int cookednum, void *buf)
1993 {
1994   gdb_assert (gdbarch != NULL);
1995   gdb_assert (gdbarch->pseudo_register_read != NULL);
1996   if (gdbarch_debug >= 2)
1997     fprintf_unfiltered (gdb_stdlog, "gdbarch_pseudo_register_read called\n");
1998   gdbarch->pseudo_register_read (gdbarch, regcache, cookednum, buf);
1999 }
2000
2001 void
2002 set_gdbarch_pseudo_register_read (struct gdbarch *gdbarch,
2003                                   gdbarch_pseudo_register_read_ftype pseudo_register_read)
2004 {
2005   gdbarch->pseudo_register_read = pseudo_register_read;
2006 }
2007
2008 int
2009 gdbarch_pseudo_register_write_p (struct gdbarch *gdbarch)
2010 {
2011   gdb_assert (gdbarch != NULL);
2012   return gdbarch->pseudo_register_write != NULL;
2013 }
2014
2015 void
2016 gdbarch_pseudo_register_write (struct gdbarch *gdbarch, struct regcache *regcache, int cookednum, const void *buf)
2017 {
2018   gdb_assert (gdbarch != NULL);
2019   gdb_assert (gdbarch->pseudo_register_write != NULL);
2020   if (gdbarch_debug >= 2)
2021     fprintf_unfiltered (gdb_stdlog, "gdbarch_pseudo_register_write called\n");
2022   gdbarch->pseudo_register_write (gdbarch, regcache, cookednum, buf);
2023 }
2024
2025 void
2026 set_gdbarch_pseudo_register_write (struct gdbarch *gdbarch,
2027                                    gdbarch_pseudo_register_write_ftype pseudo_register_write)
2028 {
2029   gdbarch->pseudo_register_write = pseudo_register_write;
2030 }
2031
2032 int
2033 gdbarch_num_regs (struct gdbarch *gdbarch)
2034 {
2035   gdb_assert (gdbarch != NULL);
2036   /* Check variable changed from pre-default.  */
2037   gdb_assert (gdbarch->num_regs != -1);
2038   if (gdbarch_debug >= 2)
2039     fprintf_unfiltered (gdb_stdlog, "gdbarch_num_regs called\n");
2040   return gdbarch->num_regs;
2041 }
2042
2043 void
2044 set_gdbarch_num_regs (struct gdbarch *gdbarch,
2045                       int num_regs)
2046 {
2047   gdbarch->num_regs = num_regs;
2048 }
2049
2050 int
2051 gdbarch_num_pseudo_regs (struct gdbarch *gdbarch)
2052 {
2053   gdb_assert (gdbarch != NULL);
2054   /* Skip verify of num_pseudo_regs, invalid_p == 0 */
2055   if (gdbarch_debug >= 2)
2056     fprintf_unfiltered (gdb_stdlog, "gdbarch_num_pseudo_regs called\n");
2057   return gdbarch->num_pseudo_regs;
2058 }
2059
2060 void
2061 set_gdbarch_num_pseudo_regs (struct gdbarch *gdbarch,
2062                              int num_pseudo_regs)
2063 {
2064   gdbarch->num_pseudo_regs = num_pseudo_regs;
2065 }
2066
2067 int
2068 gdbarch_sp_regnum (struct gdbarch *gdbarch)
2069 {
2070   gdb_assert (gdbarch != NULL);
2071   /* Skip verify of sp_regnum, invalid_p == 0 */
2072   if (gdbarch_debug >= 2)
2073     fprintf_unfiltered (gdb_stdlog, "gdbarch_sp_regnum called\n");
2074   return gdbarch->sp_regnum;
2075 }
2076
2077 void
2078 set_gdbarch_sp_regnum (struct gdbarch *gdbarch,
2079                        int sp_regnum)
2080 {
2081   gdbarch->sp_regnum = sp_regnum;
2082 }
2083
2084 int
2085 gdbarch_pc_regnum (struct gdbarch *gdbarch)
2086 {
2087   gdb_assert (gdbarch != NULL);
2088   /* Skip verify of pc_regnum, invalid_p == 0 */
2089   if (gdbarch_debug >= 2)
2090     fprintf_unfiltered (gdb_stdlog, "gdbarch_pc_regnum called\n");
2091   return gdbarch->pc_regnum;
2092 }
2093
2094 void
2095 set_gdbarch_pc_regnum (struct gdbarch *gdbarch,
2096                        int pc_regnum)
2097 {
2098   gdbarch->pc_regnum = pc_regnum;
2099 }
2100
2101 int
2102 gdbarch_ps_regnum (struct gdbarch *gdbarch)
2103 {
2104   gdb_assert (gdbarch != NULL);
2105   /* Skip verify of ps_regnum, invalid_p == 0 */
2106   if (gdbarch_debug >= 2)
2107     fprintf_unfiltered (gdb_stdlog, "gdbarch_ps_regnum called\n");
2108   return gdbarch->ps_regnum;
2109 }
2110
2111 void
2112 set_gdbarch_ps_regnum (struct gdbarch *gdbarch,
2113                        int ps_regnum)
2114 {
2115   gdbarch->ps_regnum = ps_regnum;
2116 }
2117
2118 int
2119 gdbarch_fp0_regnum (struct gdbarch *gdbarch)
2120 {
2121   gdb_assert (gdbarch != NULL);
2122   /* Skip verify of fp0_regnum, invalid_p == 0 */
2123   if (gdbarch_debug >= 2)
2124     fprintf_unfiltered (gdb_stdlog, "gdbarch_fp0_regnum called\n");
2125   return gdbarch->fp0_regnum;
2126 }
2127
2128 void
2129 set_gdbarch_fp0_regnum (struct gdbarch *gdbarch,
2130                         int fp0_regnum)
2131 {
2132   gdbarch->fp0_regnum = fp0_regnum;
2133 }
2134
2135 int
2136 gdbarch_stab_reg_to_regnum (struct gdbarch *gdbarch, int stab_regnr)
2137 {
2138   gdb_assert (gdbarch != NULL);
2139   gdb_assert (gdbarch->stab_reg_to_regnum != NULL);
2140   if (gdbarch_debug >= 2)
2141     fprintf_unfiltered (gdb_stdlog, "gdbarch_stab_reg_to_regnum called\n");
2142   return gdbarch->stab_reg_to_regnum (stab_regnr);
2143 }
2144
2145 void
2146 set_gdbarch_stab_reg_to_regnum (struct gdbarch *gdbarch,
2147                                 gdbarch_stab_reg_to_regnum_ftype stab_reg_to_regnum)
2148 {
2149   gdbarch->stab_reg_to_regnum = stab_reg_to_regnum;
2150 }
2151
2152 int
2153 gdbarch_ecoff_reg_to_regnum (struct gdbarch *gdbarch, int ecoff_regnr)
2154 {
2155   gdb_assert (gdbarch != NULL);
2156   gdb_assert (gdbarch->ecoff_reg_to_regnum != NULL);
2157   if (gdbarch_debug >= 2)
2158     fprintf_unfiltered (gdb_stdlog, "gdbarch_ecoff_reg_to_regnum called\n");
2159   return gdbarch->ecoff_reg_to_regnum (ecoff_regnr);
2160 }
2161
2162 void
2163 set_gdbarch_ecoff_reg_to_regnum (struct gdbarch *gdbarch,
2164                                  gdbarch_ecoff_reg_to_regnum_ftype ecoff_reg_to_regnum)
2165 {
2166   gdbarch->ecoff_reg_to_regnum = ecoff_reg_to_regnum;
2167 }
2168
2169 int
2170 gdbarch_dwarf_reg_to_regnum (struct gdbarch *gdbarch, int dwarf_regnr)
2171 {
2172   gdb_assert (gdbarch != NULL);
2173   gdb_assert (gdbarch->dwarf_reg_to_regnum != NULL);
2174   if (gdbarch_debug >= 2)
2175     fprintf_unfiltered (gdb_stdlog, "gdbarch_dwarf_reg_to_regnum called\n");
2176   return gdbarch->dwarf_reg_to_regnum (dwarf_regnr);
2177 }
2178
2179 void
2180 set_gdbarch_dwarf_reg_to_regnum (struct gdbarch *gdbarch,
2181                                  gdbarch_dwarf_reg_to_regnum_ftype dwarf_reg_to_regnum)
2182 {
2183   gdbarch->dwarf_reg_to_regnum = dwarf_reg_to_regnum;
2184 }
2185
2186 int
2187 gdbarch_sdb_reg_to_regnum (struct gdbarch *gdbarch, int sdb_regnr)
2188 {
2189   gdb_assert (gdbarch != NULL);
2190   gdb_assert (gdbarch->sdb_reg_to_regnum != NULL);
2191   if (gdbarch_debug >= 2)
2192     fprintf_unfiltered (gdb_stdlog, "gdbarch_sdb_reg_to_regnum called\n");
2193   return gdbarch->sdb_reg_to_regnum (sdb_regnr);
2194 }
2195
2196 void
2197 set_gdbarch_sdb_reg_to_regnum (struct gdbarch *gdbarch,
2198                                gdbarch_sdb_reg_to_regnum_ftype sdb_reg_to_regnum)
2199 {
2200   gdbarch->sdb_reg_to_regnum = sdb_reg_to_regnum;
2201 }
2202
2203 int
2204 gdbarch_dwarf2_reg_to_regnum (struct gdbarch *gdbarch, int dwarf2_regnr)
2205 {
2206   gdb_assert (gdbarch != NULL);
2207   gdb_assert (gdbarch->dwarf2_reg_to_regnum != NULL);
2208   if (gdbarch_debug >= 2)
2209     fprintf_unfiltered (gdb_stdlog, "gdbarch_dwarf2_reg_to_regnum called\n");
2210   return gdbarch->dwarf2_reg_to_regnum (dwarf2_regnr);
2211 }
2212
2213 void
2214 set_gdbarch_dwarf2_reg_to_regnum (struct gdbarch *gdbarch,
2215                                   gdbarch_dwarf2_reg_to_regnum_ftype dwarf2_reg_to_regnum)
2216 {
2217   gdbarch->dwarf2_reg_to_regnum = dwarf2_reg_to_regnum;
2218 }
2219
2220 const char *
2221 gdbarch_register_name (struct gdbarch *gdbarch, int regnr)
2222 {
2223   gdb_assert (gdbarch != NULL);
2224   gdb_assert (gdbarch->register_name != NULL);
2225   if (gdbarch_debug >= 2)
2226     fprintf_unfiltered (gdb_stdlog, "gdbarch_register_name called\n");
2227   return gdbarch->register_name (regnr);
2228 }
2229
2230 void
2231 set_gdbarch_register_name (struct gdbarch *gdbarch,
2232                            gdbarch_register_name_ftype register_name)
2233 {
2234   gdbarch->register_name = register_name;
2235 }
2236
2237 int
2238 gdbarch_register_type_p (struct gdbarch *gdbarch)
2239 {
2240   gdb_assert (gdbarch != NULL);
2241   return gdbarch->register_type != NULL;
2242 }
2243
2244 struct type *
2245 gdbarch_register_type (struct gdbarch *gdbarch, int reg_nr)
2246 {
2247   gdb_assert (gdbarch != NULL);
2248   gdb_assert (gdbarch->register_type != NULL);
2249   if (gdbarch_debug >= 2)
2250     fprintf_unfiltered (gdb_stdlog, "gdbarch_register_type called\n");
2251   return gdbarch->register_type (gdbarch, reg_nr);
2252 }
2253
2254 void
2255 set_gdbarch_register_type (struct gdbarch *gdbarch,
2256                            gdbarch_register_type_ftype register_type)
2257 {
2258   gdbarch->register_type = register_type;
2259 }
2260
2261 int
2262 gdbarch_deprecated_register_byte_p (struct gdbarch *gdbarch)
2263 {
2264   gdb_assert (gdbarch != NULL);
2265   return gdbarch->deprecated_register_byte != generic_register_byte;
2266 }
2267
2268 int
2269 gdbarch_deprecated_register_byte (struct gdbarch *gdbarch, int reg_nr)
2270 {
2271   gdb_assert (gdbarch != NULL);
2272   gdb_assert (gdbarch->deprecated_register_byte != NULL);
2273   /* Do not check predicate: gdbarch->deprecated_register_byte != generic_register_byte, allow call.  */
2274   if (gdbarch_debug >= 2)
2275     fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_register_byte called\n");
2276   return gdbarch->deprecated_register_byte (reg_nr);
2277 }
2278
2279 void
2280 set_gdbarch_deprecated_register_byte (struct gdbarch *gdbarch,
2281                                       gdbarch_deprecated_register_byte_ftype deprecated_register_byte)
2282 {
2283   gdbarch->deprecated_register_byte = deprecated_register_byte;
2284 }
2285
2286 int
2287 gdbarch_unwind_dummy_id_p (struct gdbarch *gdbarch)
2288 {
2289   gdb_assert (gdbarch != NULL);
2290   return gdbarch->unwind_dummy_id != NULL;
2291 }
2292
2293 struct frame_id
2294 gdbarch_unwind_dummy_id (struct gdbarch *gdbarch, struct frame_info *info)
2295 {
2296   gdb_assert (gdbarch != NULL);
2297   gdb_assert (gdbarch->unwind_dummy_id != NULL);
2298   if (gdbarch_debug >= 2)
2299     fprintf_unfiltered (gdb_stdlog, "gdbarch_unwind_dummy_id called\n");
2300   return gdbarch->unwind_dummy_id (gdbarch, info);
2301 }
2302
2303 void
2304 set_gdbarch_unwind_dummy_id (struct gdbarch *gdbarch,
2305                              gdbarch_unwind_dummy_id_ftype unwind_dummy_id)
2306 {
2307   gdbarch->unwind_dummy_id = unwind_dummy_id;
2308 }
2309
2310 int
2311 gdbarch_deprecated_fp_regnum (struct gdbarch *gdbarch)
2312 {
2313   gdb_assert (gdbarch != NULL);
2314   /* Skip verify of deprecated_fp_regnum, invalid_p == 0 */
2315   if (gdbarch_debug >= 2)
2316     fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_fp_regnum called\n");
2317   return gdbarch->deprecated_fp_regnum;
2318 }
2319
2320 void
2321 set_gdbarch_deprecated_fp_regnum (struct gdbarch *gdbarch,
2322                                   int deprecated_fp_regnum)
2323 {
2324   gdbarch->deprecated_fp_regnum = deprecated_fp_regnum;
2325 }
2326
2327 int
2328 gdbarch_push_dummy_call_p (struct gdbarch *gdbarch)
2329 {
2330   gdb_assert (gdbarch != NULL);
2331   return gdbarch->push_dummy_call != NULL;
2332 }
2333
2334 CORE_ADDR
2335 gdbarch_push_dummy_call (struct gdbarch *gdbarch, struct value *function, struct regcache *regcache, CORE_ADDR bp_addr, int nargs, struct value **args, CORE_ADDR sp, int struct_return, CORE_ADDR struct_addr)
2336 {
2337   gdb_assert (gdbarch != NULL);
2338   gdb_assert (gdbarch->push_dummy_call != NULL);
2339   if (gdbarch_debug >= 2)
2340     fprintf_unfiltered (gdb_stdlog, "gdbarch_push_dummy_call called\n");
2341   return gdbarch->push_dummy_call (gdbarch, function, regcache, bp_addr, nargs, args, sp, struct_return, struct_addr);
2342 }
2343
2344 void
2345 set_gdbarch_push_dummy_call (struct gdbarch *gdbarch,
2346                              gdbarch_push_dummy_call_ftype push_dummy_call)
2347 {
2348   gdbarch->push_dummy_call = push_dummy_call;
2349 }
2350
2351 int
2352 gdbarch_deprecated_push_arguments_p (struct gdbarch *gdbarch)
2353 {
2354   gdb_assert (gdbarch != NULL);
2355   return gdbarch->deprecated_push_arguments != NULL;
2356 }
2357
2358 CORE_ADDR
2359 gdbarch_deprecated_push_arguments (struct gdbarch *gdbarch, int nargs, struct value **args, CORE_ADDR sp, int struct_return, CORE_ADDR struct_addr)
2360 {
2361   gdb_assert (gdbarch != NULL);
2362   gdb_assert (gdbarch->deprecated_push_arguments != NULL);
2363   if (gdbarch_debug >= 2)
2364     fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_push_arguments called\n");
2365   return gdbarch->deprecated_push_arguments (nargs, args, sp, struct_return, struct_addr);
2366 }
2367
2368 void
2369 set_gdbarch_deprecated_push_arguments (struct gdbarch *gdbarch,
2370                                        gdbarch_deprecated_push_arguments_ftype deprecated_push_arguments)
2371 {
2372   gdbarch->deprecated_push_arguments = deprecated_push_arguments;
2373 }
2374
2375 int
2376 gdbarch_deprecated_register_size (struct gdbarch *gdbarch)
2377 {
2378   gdb_assert (gdbarch != NULL);
2379   if (gdbarch_debug >= 2)
2380     fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_register_size called\n");
2381   return gdbarch->deprecated_register_size;
2382 }
2383
2384 void
2385 set_gdbarch_deprecated_register_size (struct gdbarch *gdbarch,
2386                                       int deprecated_register_size)
2387 {
2388   gdbarch->deprecated_register_size = deprecated_register_size;
2389 }
2390
2391 int
2392 gdbarch_call_dummy_location (struct gdbarch *gdbarch)
2393 {
2394   gdb_assert (gdbarch != NULL);
2395   /* Skip verify of call_dummy_location, invalid_p == 0 */
2396   if (gdbarch_debug >= 2)
2397     fprintf_unfiltered (gdb_stdlog, "gdbarch_call_dummy_location called\n");
2398   return gdbarch->call_dummy_location;
2399 }
2400
2401 void
2402 set_gdbarch_call_dummy_location (struct gdbarch *gdbarch,
2403                                  int call_dummy_location)
2404 {
2405   gdbarch->call_dummy_location = call_dummy_location;
2406 }
2407
2408 int
2409 gdbarch_push_dummy_code_p (struct gdbarch *gdbarch)
2410 {
2411   gdb_assert (gdbarch != NULL);
2412   return gdbarch->push_dummy_code != NULL;
2413 }
2414
2415 CORE_ADDR
2416 gdbarch_push_dummy_code (struct gdbarch *gdbarch, CORE_ADDR sp, CORE_ADDR funaddr, int using_gcc, struct value **args, int nargs, struct type *value_type, CORE_ADDR *real_pc, CORE_ADDR *bp_addr)
2417 {
2418   gdb_assert (gdbarch != NULL);
2419   gdb_assert (gdbarch->push_dummy_code != NULL);
2420   if (gdbarch_debug >= 2)
2421     fprintf_unfiltered (gdb_stdlog, "gdbarch_push_dummy_code called\n");
2422   return gdbarch->push_dummy_code (gdbarch, sp, funaddr, using_gcc, args, nargs, value_type, real_pc, bp_addr);
2423 }
2424
2425 void
2426 set_gdbarch_push_dummy_code (struct gdbarch *gdbarch,
2427                              gdbarch_push_dummy_code_ftype push_dummy_code)
2428 {
2429   gdbarch->push_dummy_code = push_dummy_code;
2430 }
2431
2432 void
2433 gdbarch_print_registers_info (struct gdbarch *gdbarch, struct ui_file *file, struct frame_info *frame, int regnum, int all)
2434 {
2435   gdb_assert (gdbarch != NULL);
2436   gdb_assert (gdbarch->print_registers_info != NULL);
2437   if (gdbarch_debug >= 2)
2438     fprintf_unfiltered (gdb_stdlog, "gdbarch_print_registers_info called\n");
2439   gdbarch->print_registers_info (gdbarch, file, frame, regnum, all);
2440 }
2441
2442 void
2443 set_gdbarch_print_registers_info (struct gdbarch *gdbarch,
2444                                   gdbarch_print_registers_info_ftype print_registers_info)
2445 {
2446   gdbarch->print_registers_info = print_registers_info;
2447 }
2448
2449 int
2450 gdbarch_print_float_info_p (struct gdbarch *gdbarch)
2451 {
2452   gdb_assert (gdbarch != NULL);
2453   return gdbarch->print_float_info != NULL;
2454 }
2455
2456 void
2457 gdbarch_print_float_info (struct gdbarch *gdbarch, struct ui_file *file, struct frame_info *frame, const char *args)
2458 {
2459   gdb_assert (gdbarch != NULL);
2460   gdb_assert (gdbarch->print_float_info != NULL);
2461   if (gdbarch_debug >= 2)
2462     fprintf_unfiltered (gdb_stdlog, "gdbarch_print_float_info called\n");
2463   gdbarch->print_float_info (gdbarch, file, frame, args);
2464 }
2465
2466 void
2467 set_gdbarch_print_float_info (struct gdbarch *gdbarch,
2468                               gdbarch_print_float_info_ftype print_float_info)
2469 {
2470   gdbarch->print_float_info = print_float_info;
2471 }
2472
2473 int
2474 gdbarch_print_vector_info_p (struct gdbarch *gdbarch)
2475 {
2476   gdb_assert (gdbarch != NULL);
2477   return gdbarch->print_vector_info != NULL;
2478 }
2479
2480 void
2481 gdbarch_print_vector_info (struct gdbarch *gdbarch, struct ui_file *file, struct frame_info *frame, const char *args)
2482 {
2483   gdb_assert (gdbarch != NULL);
2484   gdb_assert (gdbarch->print_vector_info != NULL);
2485   if (gdbarch_debug >= 2)
2486     fprintf_unfiltered (gdb_stdlog, "gdbarch_print_vector_info called\n");
2487   gdbarch->print_vector_info (gdbarch, file, frame, args);
2488 }
2489
2490 void
2491 set_gdbarch_print_vector_info (struct gdbarch *gdbarch,
2492                                gdbarch_print_vector_info_ftype print_vector_info)
2493 {
2494   gdbarch->print_vector_info = print_vector_info;
2495 }
2496
2497 int
2498 gdbarch_register_sim_regno (struct gdbarch *gdbarch, int reg_nr)
2499 {
2500   gdb_assert (gdbarch != NULL);
2501   gdb_assert (gdbarch->register_sim_regno != NULL);
2502   if (gdbarch_debug >= 2)
2503     fprintf_unfiltered (gdb_stdlog, "gdbarch_register_sim_regno called\n");
2504   return gdbarch->register_sim_regno (reg_nr);
2505 }
2506
2507 void
2508 set_gdbarch_register_sim_regno (struct gdbarch *gdbarch,
2509                                 gdbarch_register_sim_regno_ftype register_sim_regno)
2510 {
2511   gdbarch->register_sim_regno = register_sim_regno;
2512 }
2513
2514 int
2515 gdbarch_register_bytes_ok_p (struct gdbarch *gdbarch)
2516 {
2517   gdb_assert (gdbarch != NULL);
2518   return gdbarch->register_bytes_ok != NULL;
2519 }
2520
2521 int
2522 gdbarch_register_bytes_ok (struct gdbarch *gdbarch, long nr_bytes)
2523 {
2524   gdb_assert (gdbarch != NULL);
2525   gdb_assert (gdbarch->register_bytes_ok != NULL);
2526   if (gdbarch_debug >= 2)
2527     fprintf_unfiltered (gdb_stdlog, "gdbarch_register_bytes_ok called\n");
2528   return gdbarch->register_bytes_ok (nr_bytes);
2529 }
2530
2531 void
2532 set_gdbarch_register_bytes_ok (struct gdbarch *gdbarch,
2533                                gdbarch_register_bytes_ok_ftype register_bytes_ok)
2534 {
2535   gdbarch->register_bytes_ok = register_bytes_ok;
2536 }
2537
2538 int
2539 gdbarch_cannot_fetch_register (struct gdbarch *gdbarch, int regnum)
2540 {
2541   gdb_assert (gdbarch != NULL);
2542   gdb_assert (gdbarch->cannot_fetch_register != NULL);
2543   if (gdbarch_debug >= 2)
2544     fprintf_unfiltered (gdb_stdlog, "gdbarch_cannot_fetch_register called\n");
2545   return gdbarch->cannot_fetch_register (regnum);
2546 }
2547
2548 void
2549 set_gdbarch_cannot_fetch_register (struct gdbarch *gdbarch,
2550                                    gdbarch_cannot_fetch_register_ftype cannot_fetch_register)
2551 {
2552   gdbarch->cannot_fetch_register = cannot_fetch_register;
2553 }
2554
2555 int
2556 gdbarch_cannot_store_register (struct gdbarch *gdbarch, int regnum)
2557 {
2558   gdb_assert (gdbarch != NULL);
2559   gdb_assert (gdbarch->cannot_store_register != NULL);
2560   if (gdbarch_debug >= 2)
2561     fprintf_unfiltered (gdb_stdlog, "gdbarch_cannot_store_register called\n");
2562   return gdbarch->cannot_store_register (regnum);
2563 }
2564
2565 void
2566 set_gdbarch_cannot_store_register (struct gdbarch *gdbarch,
2567                                    gdbarch_cannot_store_register_ftype cannot_store_register)
2568 {
2569   gdbarch->cannot_store_register = cannot_store_register;
2570 }
2571
2572 int
2573 gdbarch_get_longjmp_target_p (struct gdbarch *gdbarch)
2574 {
2575   gdb_assert (gdbarch != NULL);
2576   return gdbarch->get_longjmp_target != NULL;
2577 }
2578
2579 int
2580 gdbarch_get_longjmp_target (struct gdbarch *gdbarch, CORE_ADDR *pc)
2581 {
2582   gdb_assert (gdbarch != NULL);
2583   gdb_assert (gdbarch->get_longjmp_target != NULL);
2584   if (gdbarch_debug >= 2)
2585     fprintf_unfiltered (gdb_stdlog, "gdbarch_get_longjmp_target called\n");
2586   return gdbarch->get_longjmp_target (pc);
2587 }
2588
2589 void
2590 set_gdbarch_get_longjmp_target (struct gdbarch *gdbarch,
2591                                 gdbarch_get_longjmp_target_ftype get_longjmp_target)
2592 {
2593   gdbarch->get_longjmp_target = get_longjmp_target;
2594 }
2595
2596 int
2597 gdbarch_believe_pcc_promotion (struct gdbarch *gdbarch)
2598 {
2599   gdb_assert (gdbarch != NULL);
2600   if (gdbarch_debug >= 2)
2601     fprintf_unfiltered (gdb_stdlog, "gdbarch_believe_pcc_promotion called\n");
2602   return gdbarch->believe_pcc_promotion;
2603 }
2604
2605 void
2606 set_gdbarch_believe_pcc_promotion (struct gdbarch *gdbarch,
2607                                    int believe_pcc_promotion)
2608 {
2609   gdbarch->believe_pcc_promotion = believe_pcc_promotion;
2610 }
2611
2612 int
2613 gdbarch_convert_register_p (struct gdbarch *gdbarch, int regnum, struct type *type)
2614 {
2615   gdb_assert (gdbarch != NULL);
2616   gdb_assert (gdbarch->convert_register_p != NULL);
2617   if (gdbarch_debug >= 2)
2618     fprintf_unfiltered (gdb_stdlog, "gdbarch_convert_register_p called\n");
2619   return gdbarch->convert_register_p (regnum, type);
2620 }
2621
2622 void
2623 set_gdbarch_convert_register_p (struct gdbarch *gdbarch,
2624                                 gdbarch_convert_register_p_ftype convert_register_p)
2625 {
2626   gdbarch->convert_register_p = convert_register_p;
2627 }
2628
2629 void
2630 gdbarch_register_to_value (struct gdbarch *gdbarch, struct frame_info *frame, int regnum, struct type *type, void *buf)
2631 {
2632   gdb_assert (gdbarch != NULL);
2633   gdb_assert (gdbarch->register_to_value != NULL);
2634   if (gdbarch_debug >= 2)
2635     fprintf_unfiltered (gdb_stdlog, "gdbarch_register_to_value called\n");
2636   gdbarch->register_to_value (frame, regnum, type, buf);
2637 }
2638
2639 void
2640 set_gdbarch_register_to_value (struct gdbarch *gdbarch,
2641                                gdbarch_register_to_value_ftype register_to_value)
2642 {
2643   gdbarch->register_to_value = register_to_value;
2644 }
2645
2646 void
2647 gdbarch_value_to_register (struct gdbarch *gdbarch, struct frame_info *frame, int regnum, struct type *type, const void *buf)
2648 {
2649   gdb_assert (gdbarch != NULL);
2650   gdb_assert (gdbarch->value_to_register != NULL);
2651   if (gdbarch_debug >= 2)
2652     fprintf_unfiltered (gdb_stdlog, "gdbarch_value_to_register called\n");
2653   gdbarch->value_to_register (frame, regnum, type, buf);
2654 }
2655
2656 void
2657 set_gdbarch_value_to_register (struct gdbarch *gdbarch,
2658                                gdbarch_value_to_register_ftype value_to_register)
2659 {
2660   gdbarch->value_to_register = value_to_register;
2661 }
2662
2663 CORE_ADDR
2664 gdbarch_pointer_to_address (struct gdbarch *gdbarch, struct type *type, const void *buf)
2665 {
2666   gdb_assert (gdbarch != NULL);
2667   gdb_assert (gdbarch->pointer_to_address != NULL);
2668   if (gdbarch_debug >= 2)
2669     fprintf_unfiltered (gdb_stdlog, "gdbarch_pointer_to_address called\n");
2670   return gdbarch->pointer_to_address (type, buf);
2671 }
2672
2673 void
2674 set_gdbarch_pointer_to_address (struct gdbarch *gdbarch,
2675                                 gdbarch_pointer_to_address_ftype pointer_to_address)
2676 {
2677   gdbarch->pointer_to_address = pointer_to_address;
2678 }
2679
2680 void
2681 gdbarch_address_to_pointer (struct gdbarch *gdbarch, struct type *type, void *buf, CORE_ADDR addr)
2682 {
2683   gdb_assert (gdbarch != NULL);
2684   gdb_assert (gdbarch->address_to_pointer != NULL);
2685   if (gdbarch_debug >= 2)
2686     fprintf_unfiltered (gdb_stdlog, "gdbarch_address_to_pointer called\n");
2687   gdbarch->address_to_pointer (type, buf, addr);
2688 }
2689
2690 void
2691 set_gdbarch_address_to_pointer (struct gdbarch *gdbarch,
2692                                 gdbarch_address_to_pointer_ftype address_to_pointer)
2693 {
2694   gdbarch->address_to_pointer = address_to_pointer;
2695 }
2696
2697 int
2698 gdbarch_integer_to_address_p (struct gdbarch *gdbarch)
2699 {
2700   gdb_assert (gdbarch != NULL);
2701   return gdbarch->integer_to_address != NULL;
2702 }
2703
2704 CORE_ADDR
2705 gdbarch_integer_to_address (struct gdbarch *gdbarch, struct type *type, const bfd_byte *buf)
2706 {
2707   gdb_assert (gdbarch != NULL);
2708   gdb_assert (gdbarch->integer_to_address != NULL);
2709   if (gdbarch_debug >= 2)
2710     fprintf_unfiltered (gdb_stdlog, "gdbarch_integer_to_address called\n");
2711   return gdbarch->integer_to_address (gdbarch, type, buf);
2712 }
2713
2714 void
2715 set_gdbarch_integer_to_address (struct gdbarch *gdbarch,
2716                                 gdbarch_integer_to_address_ftype integer_to_address)
2717 {
2718   gdbarch->integer_to_address = integer_to_address;
2719 }
2720
2721 int
2722 gdbarch_deprecated_store_struct_return_p (struct gdbarch *gdbarch)
2723 {
2724   gdb_assert (gdbarch != NULL);
2725   return gdbarch->deprecated_store_struct_return != NULL;
2726 }
2727
2728 void
2729 gdbarch_deprecated_store_struct_return (struct gdbarch *gdbarch, CORE_ADDR addr, CORE_ADDR sp)
2730 {
2731   gdb_assert (gdbarch != NULL);
2732   gdb_assert (gdbarch->deprecated_store_struct_return != NULL);
2733   if (gdbarch_debug >= 2)
2734     fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_store_struct_return called\n");
2735   gdbarch->deprecated_store_struct_return (addr, sp);
2736 }
2737
2738 void
2739 set_gdbarch_deprecated_store_struct_return (struct gdbarch *gdbarch,
2740                                             gdbarch_deprecated_store_struct_return_ftype deprecated_store_struct_return)
2741 {
2742   gdbarch->deprecated_store_struct_return = deprecated_store_struct_return;
2743 }
2744
2745 int
2746 gdbarch_return_value_p (struct gdbarch *gdbarch)
2747 {
2748   gdb_assert (gdbarch != NULL);
2749   return gdbarch->return_value != legacy_return_value;
2750 }
2751
2752 enum return_value_convention
2753 gdbarch_return_value (struct gdbarch *gdbarch, struct type *valtype, struct regcache *regcache, void *readbuf, const void *writebuf)
2754 {
2755   gdb_assert (gdbarch != NULL);
2756   gdb_assert (gdbarch->return_value != NULL);
2757   /* Do not check predicate: gdbarch->return_value != legacy_return_value, allow call.  */
2758   if (gdbarch_debug >= 2)
2759     fprintf_unfiltered (gdb_stdlog, "gdbarch_return_value called\n");
2760   return gdbarch->return_value (gdbarch, valtype, regcache, readbuf, writebuf);
2761 }
2762
2763 void
2764 set_gdbarch_return_value (struct gdbarch *gdbarch,
2765                           gdbarch_return_value_ftype return_value)
2766 {
2767   gdbarch->return_value = return_value;
2768 }
2769
2770 void
2771 gdbarch_extract_return_value (struct gdbarch *gdbarch, struct type *type, struct regcache *regcache, void *valbuf)
2772 {
2773   gdb_assert (gdbarch != NULL);
2774   gdb_assert (gdbarch->extract_return_value != NULL);
2775   if (gdbarch_debug >= 2)
2776     fprintf_unfiltered (gdb_stdlog, "gdbarch_extract_return_value called\n");
2777   gdbarch->extract_return_value (type, regcache, valbuf);
2778 }
2779
2780 void
2781 set_gdbarch_extract_return_value (struct gdbarch *gdbarch,
2782                                   gdbarch_extract_return_value_ftype extract_return_value)
2783 {
2784   gdbarch->extract_return_value = extract_return_value;
2785 }
2786
2787 void
2788 gdbarch_store_return_value (struct gdbarch *gdbarch, struct type *type, struct regcache *regcache, const void *valbuf)
2789 {
2790   gdb_assert (gdbarch != NULL);
2791   gdb_assert (gdbarch->store_return_value != NULL);
2792   if (gdbarch_debug >= 2)
2793     fprintf_unfiltered (gdb_stdlog, "gdbarch_store_return_value called\n");
2794   gdbarch->store_return_value (type, regcache, valbuf);
2795 }
2796
2797 void
2798 set_gdbarch_store_return_value (struct gdbarch *gdbarch,
2799                                 gdbarch_store_return_value_ftype store_return_value)
2800 {
2801   gdbarch->store_return_value = store_return_value;
2802 }
2803
2804 void
2805 gdbarch_deprecated_extract_return_value (struct gdbarch *gdbarch, struct type *type, char *regbuf, char *valbuf)
2806 {
2807   gdb_assert (gdbarch != NULL);
2808   gdb_assert (gdbarch->deprecated_extract_return_value != NULL);
2809   if (gdbarch_debug >= 2)
2810     fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_extract_return_value called\n");
2811   gdbarch->deprecated_extract_return_value (type, regbuf, valbuf);
2812 }
2813
2814 void
2815 set_gdbarch_deprecated_extract_return_value (struct gdbarch *gdbarch,
2816                                              gdbarch_deprecated_extract_return_value_ftype deprecated_extract_return_value)
2817 {
2818   gdbarch->deprecated_extract_return_value = deprecated_extract_return_value;
2819 }
2820
2821 void
2822 gdbarch_deprecated_store_return_value (struct gdbarch *gdbarch, struct type *type, char *valbuf)
2823 {
2824   gdb_assert (gdbarch != NULL);
2825   gdb_assert (gdbarch->deprecated_store_return_value != NULL);
2826   if (gdbarch_debug >= 2)
2827     fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_store_return_value called\n");
2828   gdbarch->deprecated_store_return_value (type, valbuf);
2829 }
2830
2831 void
2832 set_gdbarch_deprecated_store_return_value (struct gdbarch *gdbarch,
2833                                            gdbarch_deprecated_store_return_value_ftype deprecated_store_return_value)
2834 {
2835   gdbarch->deprecated_store_return_value = deprecated_store_return_value;
2836 }
2837
2838 int
2839 gdbarch_deprecated_use_struct_convention (struct gdbarch *gdbarch, int gcc_p, struct type *value_type)
2840 {
2841   gdb_assert (gdbarch != NULL);
2842   gdb_assert (gdbarch->deprecated_use_struct_convention != NULL);
2843   if (gdbarch_debug >= 2)
2844     fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_use_struct_convention called\n");
2845   return gdbarch->deprecated_use_struct_convention (gcc_p, value_type);
2846 }
2847
2848 void
2849 set_gdbarch_deprecated_use_struct_convention (struct gdbarch *gdbarch,
2850                                               gdbarch_deprecated_use_struct_convention_ftype deprecated_use_struct_convention)
2851 {
2852   gdbarch->deprecated_use_struct_convention = deprecated_use_struct_convention;
2853 }
2854
2855 int
2856 gdbarch_deprecated_extract_struct_value_address_p (struct gdbarch *gdbarch)
2857 {
2858   gdb_assert (gdbarch != NULL);
2859   return gdbarch->deprecated_extract_struct_value_address != NULL;
2860 }
2861
2862 CORE_ADDR
2863 gdbarch_deprecated_extract_struct_value_address (struct gdbarch *gdbarch, struct regcache *regcache)
2864 {
2865   gdb_assert (gdbarch != NULL);
2866   gdb_assert (gdbarch->deprecated_extract_struct_value_address != NULL);
2867   if (gdbarch_debug >= 2)
2868     fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_extract_struct_value_address called\n");
2869   return gdbarch->deprecated_extract_struct_value_address (regcache);
2870 }
2871
2872 void
2873 set_gdbarch_deprecated_extract_struct_value_address (struct gdbarch *gdbarch,
2874                                                      gdbarch_deprecated_extract_struct_value_address_ftype deprecated_extract_struct_value_address)
2875 {
2876   gdbarch->deprecated_extract_struct_value_address = deprecated_extract_struct_value_address;
2877 }
2878
2879 CORE_ADDR
2880 gdbarch_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR ip)
2881 {
2882   gdb_assert (gdbarch != NULL);
2883   gdb_assert (gdbarch->skip_prologue != NULL);
2884   if (gdbarch_debug >= 2)
2885     fprintf_unfiltered (gdb_stdlog, "gdbarch_skip_prologue called\n");
2886   return gdbarch->skip_prologue (ip);
2887 }
2888
2889 void
2890 set_gdbarch_skip_prologue (struct gdbarch *gdbarch,
2891                            gdbarch_skip_prologue_ftype skip_prologue)
2892 {
2893   gdbarch->skip_prologue = skip_prologue;
2894 }
2895
2896 int
2897 gdbarch_inner_than (struct gdbarch *gdbarch, CORE_ADDR lhs, CORE_ADDR rhs)
2898 {
2899   gdb_assert (gdbarch != NULL);
2900   gdb_assert (gdbarch->inner_than != NULL);
2901   if (gdbarch_debug >= 2)
2902     fprintf_unfiltered (gdb_stdlog, "gdbarch_inner_than called\n");
2903   return gdbarch->inner_than (lhs, rhs);
2904 }
2905
2906 void
2907 set_gdbarch_inner_than (struct gdbarch *gdbarch,
2908                         gdbarch_inner_than_ftype inner_than)
2909 {
2910   gdbarch->inner_than = inner_than;
2911 }
2912
2913 const unsigned char *
2914 gdbarch_breakpoint_from_pc (struct gdbarch *gdbarch, CORE_ADDR *pcptr, int *lenptr)
2915 {
2916   gdb_assert (gdbarch != NULL);
2917   gdb_assert (gdbarch->breakpoint_from_pc != NULL);
2918   if (gdbarch_debug >= 2)
2919     fprintf_unfiltered (gdb_stdlog, "gdbarch_breakpoint_from_pc called\n");
2920   return gdbarch->breakpoint_from_pc (pcptr, lenptr);
2921 }
2922
2923 void
2924 set_gdbarch_breakpoint_from_pc (struct gdbarch *gdbarch,
2925                                 gdbarch_breakpoint_from_pc_ftype breakpoint_from_pc)
2926 {
2927   gdbarch->breakpoint_from_pc = breakpoint_from_pc;
2928 }
2929
2930 int
2931 gdbarch_adjust_breakpoint_address_p (struct gdbarch *gdbarch)
2932 {
2933   gdb_assert (gdbarch != NULL);
2934   return gdbarch->adjust_breakpoint_address != NULL;
2935 }
2936
2937 CORE_ADDR
2938 gdbarch_adjust_breakpoint_address (struct gdbarch *gdbarch, CORE_ADDR bpaddr)
2939 {
2940   gdb_assert (gdbarch != NULL);
2941   gdb_assert (gdbarch->adjust_breakpoint_address != NULL);
2942   if (gdbarch_debug >= 2)
2943     fprintf_unfiltered (gdb_stdlog, "gdbarch_adjust_breakpoint_address called\n");
2944   return gdbarch->adjust_breakpoint_address (gdbarch, bpaddr);
2945 }
2946
2947 void
2948 set_gdbarch_adjust_breakpoint_address (struct gdbarch *gdbarch,
2949                                        gdbarch_adjust_breakpoint_address_ftype adjust_breakpoint_address)
2950 {
2951   gdbarch->adjust_breakpoint_address = adjust_breakpoint_address;
2952 }
2953
2954 int
2955 gdbarch_memory_insert_breakpoint (struct gdbarch *gdbarch, CORE_ADDR addr, char *contents_cache)
2956 {
2957   gdb_assert (gdbarch != NULL);
2958   gdb_assert (gdbarch->memory_insert_breakpoint != NULL);
2959   if (gdbarch_debug >= 2)
2960     fprintf_unfiltered (gdb_stdlog, "gdbarch_memory_insert_breakpoint called\n");
2961   return gdbarch->memory_insert_breakpoint (addr, contents_cache);
2962 }
2963
2964 void
2965 set_gdbarch_memory_insert_breakpoint (struct gdbarch *gdbarch,
2966                                       gdbarch_memory_insert_breakpoint_ftype memory_insert_breakpoint)
2967 {
2968   gdbarch->memory_insert_breakpoint = memory_insert_breakpoint;
2969 }
2970
2971 int
2972 gdbarch_memory_remove_breakpoint (struct gdbarch *gdbarch, CORE_ADDR addr, char *contents_cache)
2973 {
2974   gdb_assert (gdbarch != NULL);
2975   gdb_assert (gdbarch->memory_remove_breakpoint != NULL);
2976   if (gdbarch_debug >= 2)
2977     fprintf_unfiltered (gdb_stdlog, "gdbarch_memory_remove_breakpoint called\n");
2978   return gdbarch->memory_remove_breakpoint (addr, contents_cache);
2979 }
2980
2981 void
2982 set_gdbarch_memory_remove_breakpoint (struct gdbarch *gdbarch,
2983                                       gdbarch_memory_remove_breakpoint_ftype memory_remove_breakpoint)
2984 {
2985   gdbarch->memory_remove_breakpoint = memory_remove_breakpoint;
2986 }
2987
2988 CORE_ADDR
2989 gdbarch_decr_pc_after_break (struct gdbarch *gdbarch)
2990 {
2991   gdb_assert (gdbarch != NULL);
2992   /* Skip verify of decr_pc_after_break, invalid_p == 0 */
2993   if (gdbarch_debug >= 2)
2994     fprintf_unfiltered (gdb_stdlog, "gdbarch_decr_pc_after_break called\n");
2995   return gdbarch->decr_pc_after_break;
2996 }
2997
2998 void
2999 set_gdbarch_decr_pc_after_break (struct gdbarch *gdbarch,
3000                                  CORE_ADDR decr_pc_after_break)
3001 {
3002   gdbarch->decr_pc_after_break = decr_pc_after_break;
3003 }
3004
3005 CORE_ADDR
3006 gdbarch_deprecated_function_start_offset (struct gdbarch *gdbarch)
3007 {
3008   gdb_assert (gdbarch != NULL);
3009   /* Skip verify of deprecated_function_start_offset, invalid_p == 0 */
3010   if (gdbarch_debug >= 2)
3011     fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_function_start_offset called\n");
3012   return gdbarch->deprecated_function_start_offset;
3013 }
3014
3015 void
3016 set_gdbarch_deprecated_function_start_offset (struct gdbarch *gdbarch,
3017                                               CORE_ADDR deprecated_function_start_offset)
3018 {
3019   gdbarch->deprecated_function_start_offset = deprecated_function_start_offset;
3020 }
3021
3022 void
3023 gdbarch_remote_translate_xfer_address (struct gdbarch *gdbarch, struct regcache *regcache, CORE_ADDR gdb_addr, int gdb_len, CORE_ADDR *rem_addr, int *rem_len)
3024 {
3025   gdb_assert (gdbarch != NULL);
3026   gdb_assert (gdbarch->remote_translate_xfer_address != NULL);
3027   if (gdbarch_debug >= 2)
3028     fprintf_unfiltered (gdb_stdlog, "gdbarch_remote_translate_xfer_address called\n");
3029   gdbarch->remote_translate_xfer_address (gdbarch, regcache, gdb_addr, gdb_len, rem_addr, rem_len);
3030 }
3031
3032 void
3033 set_gdbarch_remote_translate_xfer_address (struct gdbarch *gdbarch,
3034                                            gdbarch_remote_translate_xfer_address_ftype remote_translate_xfer_address)
3035 {
3036   gdbarch->remote_translate_xfer_address = remote_translate_xfer_address;
3037 }
3038
3039 CORE_ADDR
3040 gdbarch_frame_args_skip (struct gdbarch *gdbarch)
3041 {
3042   gdb_assert (gdbarch != NULL);
3043   /* Skip verify of frame_args_skip, invalid_p == 0 */
3044   if (gdbarch_debug >= 2)
3045     fprintf_unfiltered (gdb_stdlog, "gdbarch_frame_args_skip called\n");
3046   return gdbarch->frame_args_skip;
3047 }
3048
3049 void
3050 set_gdbarch_frame_args_skip (struct gdbarch *gdbarch,
3051                              CORE_ADDR frame_args_skip)
3052 {
3053   gdbarch->frame_args_skip = frame_args_skip;
3054 }
3055
3056 int
3057 gdbarch_unwind_pc_p (struct gdbarch *gdbarch)
3058 {
3059   gdb_assert (gdbarch != NULL);
3060   return gdbarch->unwind_pc != NULL;
3061 }
3062
3063 CORE_ADDR
3064 gdbarch_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame)
3065 {
3066   gdb_assert (gdbarch != NULL);
3067   gdb_assert (gdbarch->unwind_pc != NULL);
3068   if (gdbarch_debug >= 2)
3069     fprintf_unfiltered (gdb_stdlog, "gdbarch_unwind_pc called\n");
3070   return gdbarch->unwind_pc (gdbarch, next_frame);
3071 }
3072
3073 void
3074 set_gdbarch_unwind_pc (struct gdbarch *gdbarch,
3075                        gdbarch_unwind_pc_ftype unwind_pc)
3076 {
3077   gdbarch->unwind_pc = unwind_pc;
3078 }
3079
3080 int
3081 gdbarch_unwind_sp_p (struct gdbarch *gdbarch)
3082 {
3083   gdb_assert (gdbarch != NULL);
3084   return gdbarch->unwind_sp != NULL;
3085 }
3086
3087 CORE_ADDR
3088 gdbarch_unwind_sp (struct gdbarch *gdbarch, struct frame_info *next_frame)
3089 {
3090   gdb_assert (gdbarch != NULL);
3091   gdb_assert (gdbarch->unwind_sp != NULL);
3092   if (gdbarch_debug >= 2)
3093     fprintf_unfiltered (gdb_stdlog, "gdbarch_unwind_sp called\n");
3094   return gdbarch->unwind_sp (gdbarch, next_frame);
3095 }
3096
3097 void
3098 set_gdbarch_unwind_sp (struct gdbarch *gdbarch,
3099                        gdbarch_unwind_sp_ftype unwind_sp)
3100 {
3101   gdbarch->unwind_sp = unwind_sp;
3102 }
3103
3104 int
3105 gdbarch_deprecated_saved_pc_after_call_p (struct gdbarch *gdbarch)
3106 {
3107   gdb_assert (gdbarch != NULL);
3108   return gdbarch->deprecated_saved_pc_after_call != NULL;
3109 }
3110
3111 CORE_ADDR
3112 gdbarch_deprecated_saved_pc_after_call (struct gdbarch *gdbarch, struct frame_info *frame)
3113 {
3114   gdb_assert (gdbarch != NULL);
3115   gdb_assert (gdbarch->deprecated_saved_pc_after_call != NULL);
3116   if (gdbarch_debug >= 2)
3117     fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_saved_pc_after_call called\n");
3118   return gdbarch->deprecated_saved_pc_after_call (frame);
3119 }
3120
3121 void
3122 set_gdbarch_deprecated_saved_pc_after_call (struct gdbarch *gdbarch,
3123                                             gdbarch_deprecated_saved_pc_after_call_ftype deprecated_saved_pc_after_call)
3124 {
3125   gdbarch->deprecated_saved_pc_after_call = deprecated_saved_pc_after_call;
3126 }
3127
3128 int
3129 gdbarch_frame_num_args_p (struct gdbarch *gdbarch)
3130 {
3131   gdb_assert (gdbarch != NULL);
3132   return gdbarch->frame_num_args != NULL;
3133 }
3134
3135 int
3136 gdbarch_frame_num_args (struct gdbarch *gdbarch, struct frame_info *frame)
3137 {
3138   gdb_assert (gdbarch != NULL);
3139   gdb_assert (gdbarch->frame_num_args != NULL);
3140   if (gdbarch_debug >= 2)
3141     fprintf_unfiltered (gdb_stdlog, "gdbarch_frame_num_args called\n");
3142   return gdbarch->frame_num_args (frame);
3143 }
3144
3145 void
3146 set_gdbarch_frame_num_args (struct gdbarch *gdbarch,
3147                             gdbarch_frame_num_args_ftype frame_num_args)
3148 {
3149   gdbarch->frame_num_args = frame_num_args;
3150 }
3151
3152 int
3153 gdbarch_deprecated_stack_align_p (struct gdbarch *gdbarch)
3154 {
3155   gdb_assert (gdbarch != NULL);
3156   return gdbarch->deprecated_stack_align != NULL;
3157 }
3158
3159 CORE_ADDR
3160 gdbarch_deprecated_stack_align (struct gdbarch *gdbarch, CORE_ADDR sp)
3161 {
3162   gdb_assert (gdbarch != NULL);
3163   gdb_assert (gdbarch->deprecated_stack_align != NULL);
3164   if (gdbarch_debug >= 2)
3165     fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_stack_align called\n");
3166   return gdbarch->deprecated_stack_align (sp);
3167 }
3168
3169 void
3170 set_gdbarch_deprecated_stack_align (struct gdbarch *gdbarch,
3171                                     gdbarch_deprecated_stack_align_ftype deprecated_stack_align)
3172 {
3173   gdbarch->deprecated_stack_align = deprecated_stack_align;
3174 }
3175
3176 int
3177 gdbarch_frame_align_p (struct gdbarch *gdbarch)
3178 {
3179   gdb_assert (gdbarch != NULL);
3180   return gdbarch->frame_align != NULL;
3181 }
3182
3183 CORE_ADDR
3184 gdbarch_frame_align (struct gdbarch *gdbarch, CORE_ADDR address)
3185 {
3186   gdb_assert (gdbarch != NULL);
3187   gdb_assert (gdbarch->frame_align != NULL);
3188   if (gdbarch_debug >= 2)
3189     fprintf_unfiltered (gdb_stdlog, "gdbarch_frame_align called\n");
3190   return gdbarch->frame_align (gdbarch, address);
3191 }
3192
3193 void
3194 set_gdbarch_frame_align (struct gdbarch *gdbarch,
3195                          gdbarch_frame_align_ftype frame_align)
3196 {
3197   gdbarch->frame_align = frame_align;
3198 }
3199
3200 int
3201 gdbarch_deprecated_reg_struct_has_addr_p (struct gdbarch *gdbarch)
3202 {
3203   gdb_assert (gdbarch != NULL);
3204   return gdbarch->deprecated_reg_struct_has_addr != NULL;
3205 }
3206
3207 int
3208 gdbarch_deprecated_reg_struct_has_addr (struct gdbarch *gdbarch, int gcc_p, struct type *type)
3209 {
3210   gdb_assert (gdbarch != NULL);
3211   gdb_assert (gdbarch->deprecated_reg_struct_has_addr != NULL);
3212   if (gdbarch_debug >= 2)
3213     fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_reg_struct_has_addr called\n");
3214   return gdbarch->deprecated_reg_struct_has_addr (gcc_p, type);
3215 }
3216
3217 void
3218 set_gdbarch_deprecated_reg_struct_has_addr (struct gdbarch *gdbarch,
3219                                             gdbarch_deprecated_reg_struct_has_addr_ftype deprecated_reg_struct_has_addr)
3220 {
3221   gdbarch->deprecated_reg_struct_has_addr = deprecated_reg_struct_has_addr;
3222 }
3223
3224 int
3225 gdbarch_stabs_argument_has_addr (struct gdbarch *gdbarch, struct type *type)
3226 {
3227   gdb_assert (gdbarch != NULL);
3228   gdb_assert (gdbarch->stabs_argument_has_addr != NULL);
3229   if (gdbarch_debug >= 2)
3230     fprintf_unfiltered (gdb_stdlog, "gdbarch_stabs_argument_has_addr called\n");
3231   return gdbarch->stabs_argument_has_addr (gdbarch, type);
3232 }
3233
3234 void
3235 set_gdbarch_stabs_argument_has_addr (struct gdbarch *gdbarch,
3236                                      gdbarch_stabs_argument_has_addr_ftype stabs_argument_has_addr)
3237 {
3238   gdbarch->stabs_argument_has_addr = stabs_argument_has_addr;
3239 }
3240
3241 int
3242 gdbarch_frame_red_zone_size (struct gdbarch *gdbarch)
3243 {
3244   gdb_assert (gdbarch != NULL);
3245   if (gdbarch_debug >= 2)
3246     fprintf_unfiltered (gdb_stdlog, "gdbarch_frame_red_zone_size called\n");
3247   return gdbarch->frame_red_zone_size;
3248 }
3249
3250 void
3251 set_gdbarch_frame_red_zone_size (struct gdbarch *gdbarch,
3252                                  int frame_red_zone_size)
3253 {
3254   gdbarch->frame_red_zone_size = frame_red_zone_size;
3255 }
3256
3257 CORE_ADDR
3258 gdbarch_convert_from_func_ptr_addr (struct gdbarch *gdbarch, CORE_ADDR addr, struct target_ops *targ)
3259 {
3260   gdb_assert (gdbarch != NULL);
3261   gdb_assert (gdbarch->convert_from_func_ptr_addr != NULL);
3262   if (gdbarch_debug >= 2)
3263     fprintf_unfiltered (gdb_stdlog, "gdbarch_convert_from_func_ptr_addr called\n");
3264   return gdbarch->convert_from_func_ptr_addr (gdbarch, addr, targ);
3265 }
3266
3267 void
3268 set_gdbarch_convert_from_func_ptr_addr (struct gdbarch *gdbarch,
3269                                         gdbarch_convert_from_func_ptr_addr_ftype convert_from_func_ptr_addr)
3270 {
3271   gdbarch->convert_from_func_ptr_addr = convert_from_func_ptr_addr;
3272 }
3273
3274 CORE_ADDR
3275 gdbarch_addr_bits_remove (struct gdbarch *gdbarch, CORE_ADDR addr)
3276 {
3277   gdb_assert (gdbarch != NULL);
3278   gdb_assert (gdbarch->addr_bits_remove != NULL);
3279   if (gdbarch_debug >= 2)
3280     fprintf_unfiltered (gdb_stdlog, "gdbarch_addr_bits_remove called\n");
3281   return gdbarch->addr_bits_remove (addr);
3282 }
3283
3284 void
3285 set_gdbarch_addr_bits_remove (struct gdbarch *gdbarch,
3286                               gdbarch_addr_bits_remove_ftype addr_bits_remove)
3287 {
3288   gdbarch->addr_bits_remove = addr_bits_remove;
3289 }
3290
3291 CORE_ADDR
3292 gdbarch_smash_text_address (struct gdbarch *gdbarch, CORE_ADDR addr)
3293 {
3294   gdb_assert (gdbarch != NULL);
3295   gdb_assert (gdbarch->smash_text_address != NULL);
3296   if (gdbarch_debug >= 2)
3297     fprintf_unfiltered (gdb_stdlog, "gdbarch_smash_text_address called\n");
3298   return gdbarch->smash_text_address (addr);
3299 }
3300
3301 void
3302 set_gdbarch_smash_text_address (struct gdbarch *gdbarch,
3303                                 gdbarch_smash_text_address_ftype smash_text_address)
3304 {
3305   gdbarch->smash_text_address = smash_text_address;
3306 }
3307
3308 int
3309 gdbarch_software_single_step_p (struct gdbarch *gdbarch)
3310 {
3311   gdb_assert (gdbarch != NULL);
3312   return gdbarch->software_single_step != NULL;
3313 }
3314
3315 void
3316 gdbarch_software_single_step (struct gdbarch *gdbarch, enum target_signal sig, int insert_breakpoints_p)
3317 {
3318   gdb_assert (gdbarch != NULL);
3319   gdb_assert (gdbarch->software_single_step != NULL);
3320   if (gdbarch_debug >= 2)
3321     fprintf_unfiltered (gdb_stdlog, "gdbarch_software_single_step called\n");
3322   gdbarch->software_single_step (sig, insert_breakpoints_p);
3323 }
3324
3325 void
3326 set_gdbarch_software_single_step (struct gdbarch *gdbarch,
3327                                   gdbarch_software_single_step_ftype software_single_step)
3328 {
3329   gdbarch->software_single_step = software_single_step;
3330 }
3331
3332 int
3333 gdbarch_single_step_through_delay_p (struct gdbarch *gdbarch)
3334 {
3335   gdb_assert (gdbarch != NULL);
3336   return gdbarch->single_step_through_delay != NULL;
3337 }
3338
3339 int
3340 gdbarch_single_step_through_delay (struct gdbarch *gdbarch, struct frame_info *frame)
3341 {
3342   gdb_assert (gdbarch != NULL);
3343   gdb_assert (gdbarch->single_step_through_delay != NULL);
3344   if (gdbarch_debug >= 2)
3345     fprintf_unfiltered (gdb_stdlog, "gdbarch_single_step_through_delay called\n");
3346   return gdbarch->single_step_through_delay (gdbarch, frame);
3347 }
3348
3349 void
3350 set_gdbarch_single_step_through_delay (struct gdbarch *gdbarch,
3351                                        gdbarch_single_step_through_delay_ftype single_step_through_delay)
3352 {
3353   gdbarch->single_step_through_delay = single_step_through_delay;
3354 }
3355
3356 int
3357 gdbarch_print_insn (struct gdbarch *gdbarch, bfd_vma vma, struct disassemble_info *info)
3358 {
3359   gdb_assert (gdbarch != NULL);
3360   gdb_assert (gdbarch->print_insn != NULL);
3361   if (gdbarch_debug >= 2)
3362     fprintf_unfiltered (gdb_stdlog, "gdbarch_print_insn called\n");
3363   return gdbarch->print_insn (vma, info);
3364 }
3365
3366 void
3367 set_gdbarch_print_insn (struct gdbarch *gdbarch,
3368                         gdbarch_print_insn_ftype print_insn)
3369 {
3370   gdbarch->print_insn = print_insn;
3371 }
3372
3373 CORE_ADDR
3374 gdbarch_skip_trampoline_code (struct gdbarch *gdbarch, CORE_ADDR pc)
3375 {
3376   gdb_assert (gdbarch != NULL);
3377   gdb_assert (gdbarch->skip_trampoline_code != NULL);
3378   if (gdbarch_debug >= 2)
3379     fprintf_unfiltered (gdb_stdlog, "gdbarch_skip_trampoline_code called\n");
3380   return gdbarch->skip_trampoline_code (pc);
3381 }
3382
3383 void
3384 set_gdbarch_skip_trampoline_code (struct gdbarch *gdbarch,
3385                                   gdbarch_skip_trampoline_code_ftype skip_trampoline_code)
3386 {
3387   gdbarch->skip_trampoline_code = skip_trampoline_code;
3388 }
3389
3390 CORE_ADDR
3391 gdbarch_skip_solib_resolver (struct gdbarch *gdbarch, CORE_ADDR pc)
3392 {
3393   gdb_assert (gdbarch != NULL);
3394   gdb_assert (gdbarch->skip_solib_resolver != NULL);
3395   if (gdbarch_debug >= 2)
3396     fprintf_unfiltered (gdb_stdlog, "gdbarch_skip_solib_resolver called\n");
3397   return gdbarch->skip_solib_resolver (gdbarch, pc);
3398 }
3399
3400 void
3401 set_gdbarch_skip_solib_resolver (struct gdbarch *gdbarch,
3402                                  gdbarch_skip_solib_resolver_ftype skip_solib_resolver)
3403 {
3404   gdbarch->skip_solib_resolver = skip_solib_resolver;
3405 }
3406
3407 int
3408 gdbarch_in_solib_return_trampoline (struct gdbarch *gdbarch, CORE_ADDR pc, char *name)
3409 {
3410   gdb_assert (gdbarch != NULL);
3411   gdb_assert (gdbarch->in_solib_return_trampoline != NULL);
3412   if (gdbarch_debug >= 2)
3413     fprintf_unfiltered (gdb_stdlog, "gdbarch_in_solib_return_trampoline called\n");
3414   return gdbarch->in_solib_return_trampoline (pc, name);
3415 }
3416
3417 void
3418 set_gdbarch_in_solib_return_trampoline (struct gdbarch *gdbarch,
3419                                         gdbarch_in_solib_return_trampoline_ftype in_solib_return_trampoline)
3420 {
3421   gdbarch->in_solib_return_trampoline = in_solib_return_trampoline;
3422 }
3423
3424 int
3425 gdbarch_in_function_epilogue_p (struct gdbarch *gdbarch, CORE_ADDR addr)
3426 {
3427   gdb_assert (gdbarch != NULL);
3428   gdb_assert (gdbarch->in_function_epilogue_p != NULL);
3429   if (gdbarch_debug >= 2)
3430     fprintf_unfiltered (gdb_stdlog, "gdbarch_in_function_epilogue_p called\n");
3431   return gdbarch->in_function_epilogue_p (gdbarch, addr);
3432 }
3433
3434 void
3435 set_gdbarch_in_function_epilogue_p (struct gdbarch *gdbarch,
3436                                     gdbarch_in_function_epilogue_p_ftype in_function_epilogue_p)
3437 {
3438   gdbarch->in_function_epilogue_p = in_function_epilogue_p;
3439 }
3440
3441 char *
3442 gdbarch_construct_inferior_arguments (struct gdbarch *gdbarch, int argc, char **argv)
3443 {
3444   gdb_assert (gdbarch != NULL);
3445   gdb_assert (gdbarch->construct_inferior_arguments != NULL);
3446   if (gdbarch_debug >= 2)
3447     fprintf_unfiltered (gdb_stdlog, "gdbarch_construct_inferior_arguments called\n");
3448   return gdbarch->construct_inferior_arguments (gdbarch, argc, argv);
3449 }
3450
3451 void
3452 set_gdbarch_construct_inferior_arguments (struct gdbarch *gdbarch,
3453                                           gdbarch_construct_inferior_arguments_ftype construct_inferior_arguments)
3454 {
3455   gdbarch->construct_inferior_arguments = construct_inferior_arguments;
3456 }
3457
3458 void
3459 gdbarch_elf_make_msymbol_special (struct gdbarch *gdbarch, asymbol *sym, struct minimal_symbol *msym)
3460 {
3461   gdb_assert (gdbarch != NULL);
3462   gdb_assert (gdbarch->elf_make_msymbol_special != NULL);
3463   if (gdbarch_debug >= 2)
3464     fprintf_unfiltered (gdb_stdlog, "gdbarch_elf_make_msymbol_special called\n");
3465   gdbarch->elf_make_msymbol_special (sym, msym);
3466 }
3467
3468 void
3469 set_gdbarch_elf_make_msymbol_special (struct gdbarch *gdbarch,
3470                                       gdbarch_elf_make_msymbol_special_ftype elf_make_msymbol_special)
3471 {
3472   gdbarch->elf_make_msymbol_special = elf_make_msymbol_special;
3473 }
3474
3475 void
3476 gdbarch_coff_make_msymbol_special (struct gdbarch *gdbarch, int val, struct minimal_symbol *msym)
3477 {
3478   gdb_assert (gdbarch != NULL);
3479   gdb_assert (gdbarch->coff_make_msymbol_special != NULL);
3480   if (gdbarch_debug >= 2)
3481     fprintf_unfiltered (gdb_stdlog, "gdbarch_coff_make_msymbol_special called\n");
3482   gdbarch->coff_make_msymbol_special (val, msym);
3483 }
3484
3485 void
3486 set_gdbarch_coff_make_msymbol_special (struct gdbarch *gdbarch,
3487                                        gdbarch_coff_make_msymbol_special_ftype coff_make_msymbol_special)
3488 {
3489   gdbarch->coff_make_msymbol_special = coff_make_msymbol_special;
3490 }
3491
3492 const char *
3493 gdbarch_name_of_malloc (struct gdbarch *gdbarch)
3494 {
3495   gdb_assert (gdbarch != NULL);
3496   /* Skip verify of name_of_malloc, invalid_p == 0 */
3497   if (gdbarch_debug >= 2)
3498     fprintf_unfiltered (gdb_stdlog, "gdbarch_name_of_malloc called\n");
3499   return gdbarch->name_of_malloc;
3500 }
3501
3502 void
3503 set_gdbarch_name_of_malloc (struct gdbarch *gdbarch,
3504                             const char * name_of_malloc)
3505 {
3506   gdbarch->name_of_malloc = name_of_malloc;
3507 }
3508
3509 int
3510 gdbarch_cannot_step_breakpoint (struct gdbarch *gdbarch)
3511 {
3512   gdb_assert (gdbarch != NULL);
3513   /* Skip verify of cannot_step_breakpoint, invalid_p == 0 */
3514   if (gdbarch_debug >= 2)
3515     fprintf_unfiltered (gdb_stdlog, "gdbarch_cannot_step_breakpoint called\n");
3516   return gdbarch->cannot_step_breakpoint;
3517 }
3518
3519 void
3520 set_gdbarch_cannot_step_breakpoint (struct gdbarch *gdbarch,
3521                                     int cannot_step_breakpoint)
3522 {
3523   gdbarch->cannot_step_breakpoint = cannot_step_breakpoint;
3524 }
3525
3526 int
3527 gdbarch_have_nonsteppable_watchpoint (struct gdbarch *gdbarch)
3528 {
3529   gdb_assert (gdbarch != NULL);
3530   /* Skip verify of have_nonsteppable_watchpoint, invalid_p == 0 */
3531   if (gdbarch_debug >= 2)
3532     fprintf_unfiltered (gdb_stdlog, "gdbarch_have_nonsteppable_watchpoint called\n");
3533   return gdbarch->have_nonsteppable_watchpoint;
3534 }
3535
3536 void
3537 set_gdbarch_have_nonsteppable_watchpoint (struct gdbarch *gdbarch,
3538                                           int have_nonsteppable_watchpoint)
3539 {
3540   gdbarch->have_nonsteppable_watchpoint = have_nonsteppable_watchpoint;
3541 }
3542
3543 int
3544 gdbarch_address_class_type_flags_p (struct gdbarch *gdbarch)
3545 {
3546   gdb_assert (gdbarch != NULL);
3547   return gdbarch->address_class_type_flags != NULL;
3548 }
3549
3550 int
3551 gdbarch_address_class_type_flags (struct gdbarch *gdbarch, int byte_size, int dwarf2_addr_class)
3552 {
3553   gdb_assert (gdbarch != NULL);
3554   gdb_assert (gdbarch->address_class_type_flags != NULL);
3555   if (gdbarch_debug >= 2)
3556     fprintf_unfiltered (gdb_stdlog, "gdbarch_address_class_type_flags called\n");
3557   return gdbarch->address_class_type_flags (byte_size, dwarf2_addr_class);
3558 }
3559
3560 void
3561 set_gdbarch_address_class_type_flags (struct gdbarch *gdbarch,
3562                                       gdbarch_address_class_type_flags_ftype address_class_type_flags)
3563 {
3564   gdbarch->address_class_type_flags = address_class_type_flags;
3565 }
3566
3567 int
3568 gdbarch_address_class_type_flags_to_name_p (struct gdbarch *gdbarch)
3569 {
3570   gdb_assert (gdbarch != NULL);
3571   return gdbarch->address_class_type_flags_to_name != NULL;
3572 }
3573
3574 const char *
3575 gdbarch_address_class_type_flags_to_name (struct gdbarch *gdbarch, int type_flags)
3576 {
3577   gdb_assert (gdbarch != NULL);
3578   gdb_assert (gdbarch->address_class_type_flags_to_name != NULL);
3579   if (gdbarch_debug >= 2)
3580     fprintf_unfiltered (gdb_stdlog, "gdbarch_address_class_type_flags_to_name called\n");
3581   return gdbarch->address_class_type_flags_to_name (gdbarch, type_flags);
3582 }
3583
3584 void
3585 set_gdbarch_address_class_type_flags_to_name (struct gdbarch *gdbarch,
3586                                               gdbarch_address_class_type_flags_to_name_ftype address_class_type_flags_to_name)
3587 {
3588   gdbarch->address_class_type_flags_to_name = address_class_type_flags_to_name;
3589 }
3590
3591 int
3592 gdbarch_address_class_name_to_type_flags_p (struct gdbarch *gdbarch)
3593 {
3594   gdb_assert (gdbarch != NULL);
3595   return gdbarch->address_class_name_to_type_flags != NULL;
3596 }
3597
3598 int
3599 gdbarch_address_class_name_to_type_flags (struct gdbarch *gdbarch, const char *name, int *type_flags_ptr)
3600 {
3601   gdb_assert (gdbarch != NULL);
3602   gdb_assert (gdbarch->address_class_name_to_type_flags != NULL);
3603   if (gdbarch_debug >= 2)
3604     fprintf_unfiltered (gdb_stdlog, "gdbarch_address_class_name_to_type_flags called\n");
3605   return gdbarch->address_class_name_to_type_flags (gdbarch, name, type_flags_ptr);
3606 }
3607
3608 void
3609 set_gdbarch_address_class_name_to_type_flags (struct gdbarch *gdbarch,
3610                                               gdbarch_address_class_name_to_type_flags_ftype address_class_name_to_type_flags)
3611 {
3612   gdbarch->address_class_name_to_type_flags = address_class_name_to_type_flags;
3613 }
3614
3615 int
3616 gdbarch_register_reggroup_p (struct gdbarch *gdbarch, int regnum, struct reggroup *reggroup)
3617 {
3618   gdb_assert (gdbarch != NULL);
3619   gdb_assert (gdbarch->register_reggroup_p != NULL);
3620   if (gdbarch_debug >= 2)
3621     fprintf_unfiltered (gdb_stdlog, "gdbarch_register_reggroup_p called\n");
3622   return gdbarch->register_reggroup_p (gdbarch, regnum, reggroup);
3623 }
3624
3625 void
3626 set_gdbarch_register_reggroup_p (struct gdbarch *gdbarch,
3627                                  gdbarch_register_reggroup_p_ftype register_reggroup_p)
3628 {
3629   gdbarch->register_reggroup_p = register_reggroup_p;
3630 }
3631
3632 int
3633 gdbarch_fetch_pointer_argument_p (struct gdbarch *gdbarch)
3634 {
3635   gdb_assert (gdbarch != NULL);
3636   return gdbarch->fetch_pointer_argument != NULL;
3637 }
3638
3639 CORE_ADDR
3640 gdbarch_fetch_pointer_argument (struct gdbarch *gdbarch, struct frame_info *frame, int argi, struct type *type)
3641 {
3642   gdb_assert (gdbarch != NULL);
3643   gdb_assert (gdbarch->fetch_pointer_argument != NULL);
3644   if (gdbarch_debug >= 2)
3645     fprintf_unfiltered (gdb_stdlog, "gdbarch_fetch_pointer_argument called\n");
3646   return gdbarch->fetch_pointer_argument (frame, argi, type);
3647 }
3648
3649 void
3650 set_gdbarch_fetch_pointer_argument (struct gdbarch *gdbarch,
3651                                     gdbarch_fetch_pointer_argument_ftype fetch_pointer_argument)
3652 {
3653   gdbarch->fetch_pointer_argument = fetch_pointer_argument;
3654 }
3655
3656 int
3657 gdbarch_regset_from_core_section_p (struct gdbarch *gdbarch)
3658 {
3659   gdb_assert (gdbarch != NULL);
3660   return gdbarch->regset_from_core_section != NULL;
3661 }
3662
3663 const struct regset *
3664 gdbarch_regset_from_core_section (struct gdbarch *gdbarch, const char *sect_name, size_t sect_size)
3665 {
3666   gdb_assert (gdbarch != NULL);
3667   gdb_assert (gdbarch->regset_from_core_section != NULL);
3668   if (gdbarch_debug >= 2)
3669     fprintf_unfiltered (gdb_stdlog, "gdbarch_regset_from_core_section called\n");
3670   return gdbarch->regset_from_core_section (gdbarch, sect_name, sect_size);
3671 }
3672
3673 void
3674 set_gdbarch_regset_from_core_section (struct gdbarch *gdbarch,
3675                                       gdbarch_regset_from_core_section_ftype regset_from_core_section)
3676 {
3677   gdbarch->regset_from_core_section = regset_from_core_section;
3678 }
3679
3680
3681 /* Keep a registry of per-architecture data-pointers required by GDB
3682    modules. */
3683
3684 struct gdbarch_data
3685 {
3686   unsigned index;
3687   int init_p;
3688   gdbarch_data_pre_init_ftype *pre_init;
3689   gdbarch_data_post_init_ftype *post_init;
3690 };
3691
3692 struct gdbarch_data_registration
3693 {
3694   struct gdbarch_data *data;
3695   struct gdbarch_data_registration *next;
3696 };
3697
3698 struct gdbarch_data_registry
3699 {
3700   unsigned nr;
3701   struct gdbarch_data_registration *registrations;
3702 };
3703
3704 struct gdbarch_data_registry gdbarch_data_registry =
3705 {
3706   0, NULL,
3707 };
3708
3709 static struct gdbarch_data *
3710 gdbarch_data_register (gdbarch_data_pre_init_ftype *pre_init,
3711                        gdbarch_data_post_init_ftype *post_init)
3712 {
3713   struct gdbarch_data_registration **curr;
3714   /* Append the new registraration.  */
3715   for (curr = &gdbarch_data_registry.registrations;
3716        (*curr) != NULL;
3717        curr = &(*curr)->next);
3718   (*curr) = XMALLOC (struct gdbarch_data_registration);
3719   (*curr)->next = NULL;
3720   (*curr)->data = XMALLOC (struct gdbarch_data);
3721   (*curr)->data->index = gdbarch_data_registry.nr++;
3722   (*curr)->data->pre_init = pre_init;
3723   (*curr)->data->post_init = post_init;
3724   (*curr)->data->init_p = 1;
3725   return (*curr)->data;
3726 }
3727
3728 struct gdbarch_data *
3729 gdbarch_data_register_pre_init (gdbarch_data_pre_init_ftype *pre_init)
3730 {
3731   return gdbarch_data_register (pre_init, NULL);
3732 }
3733
3734 struct gdbarch_data *
3735 gdbarch_data_register_post_init (gdbarch_data_post_init_ftype *post_init)
3736 {
3737   return gdbarch_data_register (NULL, post_init);
3738 }
3739
3740 /* Create/delete the gdbarch data vector. */
3741
3742 static void
3743 alloc_gdbarch_data (struct gdbarch *gdbarch)
3744 {
3745   gdb_assert (gdbarch->data == NULL);
3746   gdbarch->nr_data = gdbarch_data_registry.nr;
3747   gdbarch->data = GDBARCH_OBSTACK_CALLOC (gdbarch, gdbarch->nr_data, void *);
3748 }
3749
3750 /* Initialize the current value of the specified per-architecture
3751    data-pointer. */
3752
3753 void
3754 deprecated_set_gdbarch_data (struct gdbarch *gdbarch,
3755                              struct gdbarch_data *data,
3756                              void *pointer)
3757 {
3758   gdb_assert (data->index < gdbarch->nr_data);
3759   gdb_assert (gdbarch->data[data->index] == NULL);
3760   gdb_assert (data->pre_init == NULL);
3761   gdbarch->data[data->index] = pointer;
3762 }
3763
3764 /* Return the current value of the specified per-architecture
3765    data-pointer. */
3766
3767 void *
3768 gdbarch_data (struct gdbarch *gdbarch, struct gdbarch_data *data)
3769 {
3770   gdb_assert (data->index < gdbarch->nr_data);
3771   if (gdbarch->data[data->index] == NULL)
3772     {
3773       /* The data-pointer isn't initialized, call init() to get a
3774          value.  */
3775       if (data->pre_init != NULL)
3776         /* Mid architecture creation: pass just the obstack, and not
3777            the entire architecture, as that way it isn't possible for
3778            pre-init code to refer to undefined architecture
3779            fields.  */
3780         gdbarch->data[data->index] = data->pre_init (gdbarch->obstack);
3781       else if (gdbarch->initialized_p
3782                && data->post_init != NULL)
3783         /* Post architecture creation: pass the entire architecture
3784            (as all fields are valid), but be careful to also detect
3785            recursive references.  */
3786         {
3787           gdb_assert (data->init_p);
3788           data->init_p = 0;
3789           gdbarch->data[data->index] = data->post_init (gdbarch);
3790           data->init_p = 1;
3791         }
3792       else
3793         /* The architecture initialization hasn't completed - punt -
3794          hope that the caller knows what they are doing.  Once
3795          deprecated_set_gdbarch_data has been initialized, this can be
3796          changed to an internal error.  */
3797         return NULL;
3798       gdb_assert (gdbarch->data[data->index] != NULL);
3799     }
3800   return gdbarch->data[data->index];
3801 }
3802
3803
3804
3805 /* Keep a registry of swapped data required by GDB modules. */
3806
3807 struct gdbarch_swap
3808 {
3809   void *swap;
3810   struct gdbarch_swap_registration *source;
3811   struct gdbarch_swap *next;
3812 };
3813
3814 struct gdbarch_swap_registration
3815 {
3816   void *data;
3817   unsigned long sizeof_data;
3818   gdbarch_swap_ftype *init;
3819   struct gdbarch_swap_registration *next;
3820 };
3821
3822 struct gdbarch_swap_registry
3823 {
3824   int nr;
3825   struct gdbarch_swap_registration *registrations;
3826 };
3827
3828 struct gdbarch_swap_registry gdbarch_swap_registry =
3829 {
3830   0, NULL,
3831 };
3832
3833 void
3834 deprecated_register_gdbarch_swap (void *data,
3835                                   unsigned long sizeof_data,
3836                                   gdbarch_swap_ftype *init)
3837 {
3838   struct gdbarch_swap_registration **rego;
3839   for (rego = &gdbarch_swap_registry.registrations;
3840        (*rego) != NULL;
3841        rego = &(*rego)->next);
3842   (*rego) = XMALLOC (struct gdbarch_swap_registration);
3843   (*rego)->next = NULL;
3844   (*rego)->init = init;
3845   (*rego)->data = data;
3846   (*rego)->sizeof_data = sizeof_data;
3847 }
3848
3849 static void
3850 current_gdbarch_swap_init_hack (void)
3851 {
3852   struct gdbarch_swap_registration *rego;
3853   struct gdbarch_swap **curr = &current_gdbarch->swap;
3854   for (rego = gdbarch_swap_registry.registrations;
3855        rego != NULL;
3856        rego = rego->next)
3857     {
3858       if (rego->data != NULL)
3859         {
3860           (*curr) = GDBARCH_OBSTACK_ZALLOC (current_gdbarch,
3861                                             struct gdbarch_swap);
3862           (*curr)->source = rego;
3863           (*curr)->swap = gdbarch_obstack_zalloc (current_gdbarch,
3864                                                   rego->sizeof_data);
3865           (*curr)->next = NULL;
3866           curr = &(*curr)->next;
3867         }
3868       if (rego->init != NULL)
3869         rego->init ();
3870     }
3871 }
3872
3873 static struct gdbarch *
3874 current_gdbarch_swap_out_hack (void)
3875 {
3876   struct gdbarch *old_gdbarch = current_gdbarch;
3877   struct gdbarch_swap *curr;
3878
3879   gdb_assert (old_gdbarch != NULL);
3880   for (curr = old_gdbarch->swap;
3881        curr != NULL;
3882        curr = curr->next)
3883     {
3884       memcpy (curr->swap, curr->source->data, curr->source->sizeof_data);
3885       memset (curr->source->data, 0, curr->source->sizeof_data);
3886     }
3887   current_gdbarch = NULL;
3888   return old_gdbarch;
3889 }
3890
3891 static void
3892 current_gdbarch_swap_in_hack (struct gdbarch *new_gdbarch)
3893 {
3894   struct gdbarch_swap *curr;
3895
3896   gdb_assert (current_gdbarch == NULL);
3897   for (curr = new_gdbarch->swap;
3898        curr != NULL;
3899        curr = curr->next)
3900     memcpy (curr->source->data, curr->swap, curr->source->sizeof_data);
3901   current_gdbarch = new_gdbarch;
3902 }
3903
3904
3905 /* Keep a registry of the architectures known by GDB. */
3906
3907 struct gdbarch_registration
3908 {
3909   enum bfd_architecture bfd_architecture;
3910   gdbarch_init_ftype *init;
3911   gdbarch_dump_tdep_ftype *dump_tdep;
3912   struct gdbarch_list *arches;
3913   struct gdbarch_registration *next;
3914 };
3915
3916 static struct gdbarch_registration *gdbarch_registry = NULL;
3917
3918 static void
3919 append_name (const char ***buf, int *nr, const char *name)
3920 {
3921   *buf = xrealloc (*buf, sizeof (char**) * (*nr + 1));
3922   (*buf)[*nr] = name;
3923   *nr += 1;
3924 }
3925
3926 const char **
3927 gdbarch_printable_names (void)
3928 {
3929   /* Accumulate a list of names based on the registed list of
3930      architectures. */
3931   enum bfd_architecture a;
3932   int nr_arches = 0;
3933   const char **arches = NULL;
3934   struct gdbarch_registration *rego;
3935   for (rego = gdbarch_registry;
3936        rego != NULL;
3937        rego = rego->next)
3938     {
3939       const struct bfd_arch_info *ap;
3940       ap = bfd_lookup_arch (rego->bfd_architecture, 0);
3941       if (ap == NULL)
3942         internal_error (__FILE__, __LINE__,
3943                         "gdbarch_architecture_names: multi-arch unknown");
3944       do
3945         {
3946           append_name (&arches, &nr_arches, ap->printable_name);
3947           ap = ap->next;
3948         }
3949       while (ap != NULL);
3950     }
3951   append_name (&arches, &nr_arches, NULL);
3952   return arches;
3953 }
3954
3955
3956 void
3957 gdbarch_register (enum bfd_architecture bfd_architecture,
3958                   gdbarch_init_ftype *init,
3959                   gdbarch_dump_tdep_ftype *dump_tdep)
3960 {
3961   struct gdbarch_registration **curr;
3962   const struct bfd_arch_info *bfd_arch_info;
3963   /* Check that BFD recognizes this architecture */
3964   bfd_arch_info = bfd_lookup_arch (bfd_architecture, 0);
3965   if (bfd_arch_info == NULL)
3966     {
3967       internal_error (__FILE__, __LINE__,
3968                       "gdbarch: Attempt to register unknown architecture (%d)",
3969                       bfd_architecture);
3970     }
3971   /* Check that we haven't seen this architecture before */
3972   for (curr = &gdbarch_registry;
3973        (*curr) != NULL;
3974        curr = &(*curr)->next)
3975     {
3976       if (bfd_architecture == (*curr)->bfd_architecture)
3977         internal_error (__FILE__, __LINE__,
3978                         "gdbarch: Duplicate registraration of architecture (%s)",
3979                         bfd_arch_info->printable_name);
3980     }
3981   /* log it */
3982   if (gdbarch_debug)
3983     fprintf_unfiltered (gdb_stdlog, "register_gdbarch_init (%s, 0x%08lx)\n",
3984                         bfd_arch_info->printable_name,
3985                         (long) init);
3986   /* Append it */
3987   (*curr) = XMALLOC (struct gdbarch_registration);
3988   (*curr)->bfd_architecture = bfd_architecture;
3989   (*curr)->init = init;
3990   (*curr)->dump_tdep = dump_tdep;
3991   (*curr)->arches = NULL;
3992   (*curr)->next = NULL;
3993 }
3994
3995 void
3996 register_gdbarch_init (enum bfd_architecture bfd_architecture,
3997                        gdbarch_init_ftype *init)
3998 {
3999   gdbarch_register (bfd_architecture, init, NULL);
4000 }
4001
4002
4003 /* Look for an architecture using gdbarch_info.  Base search on only
4004    BFD_ARCH_INFO and BYTE_ORDER. */
4005
4006 struct gdbarch_list *
4007 gdbarch_list_lookup_by_info (struct gdbarch_list *arches,
4008                              const struct gdbarch_info *info)
4009 {
4010   for (; arches != NULL; arches = arches->next)
4011     {
4012       if (info->bfd_arch_info != arches->gdbarch->bfd_arch_info)
4013         continue;
4014       if (info->byte_order != arches->gdbarch->byte_order)
4015         continue;
4016       if (info->osabi != arches->gdbarch->osabi)
4017         continue;
4018       return arches;
4019     }
4020   return NULL;
4021 }
4022
4023
4024 /* Find an architecture that matches the specified INFO.  Create a new
4025    architecture if needed.  Return that new architecture.  Assumes
4026    that there is no current architecture.  */
4027
4028 static struct gdbarch *
4029 find_arch_by_info (struct gdbarch *old_gdbarch, struct gdbarch_info info)
4030 {
4031   struct gdbarch *new_gdbarch;
4032   struct gdbarch_registration *rego;
4033
4034   /* The existing architecture has been swapped out - all this code
4035      works from a clean slate.  */
4036   gdb_assert (current_gdbarch == NULL);
4037
4038   /* Fill in missing parts of the INFO struct using a number of
4039      sources: "set ..."; INFOabfd supplied; and the existing
4040      architecture.  */
4041   gdbarch_info_fill (old_gdbarch, &info);
4042
4043   /* Must have found some sort of architecture. */
4044   gdb_assert (info.bfd_arch_info != NULL);
4045
4046   if (gdbarch_debug)
4047     {
4048       fprintf_unfiltered (gdb_stdlog,
4049                           "find_arch_by_info: info.bfd_arch_info %s\n",
4050                           (info.bfd_arch_info != NULL
4051                            ? info.bfd_arch_info->printable_name
4052                            : "(null)"));
4053       fprintf_unfiltered (gdb_stdlog,
4054                           "find_arch_by_info: info.byte_order %d (%s)\n",
4055                           info.byte_order,
4056                           (info.byte_order == BFD_ENDIAN_BIG ? "big"
4057                            : info.byte_order == BFD_ENDIAN_LITTLE ? "little"
4058                            : "default"));
4059       fprintf_unfiltered (gdb_stdlog,
4060                           "find_arch_by_info: info.osabi %d (%s)\n",
4061                           info.osabi, gdbarch_osabi_name (info.osabi));
4062       fprintf_unfiltered (gdb_stdlog,
4063                           "find_arch_by_info: info.abfd 0x%lx\n",
4064                           (long) info.abfd);
4065       fprintf_unfiltered (gdb_stdlog,
4066                           "find_arch_by_info: info.tdep_info 0x%lx\n",
4067                           (long) info.tdep_info);
4068     }
4069
4070   /* Find the tdep code that knows about this architecture.  */
4071   for (rego = gdbarch_registry;
4072        rego != NULL;
4073        rego = rego->next)
4074     if (rego->bfd_architecture == info.bfd_arch_info->arch)
4075       break;
4076   if (rego == NULL)
4077     {
4078       if (gdbarch_debug)
4079         fprintf_unfiltered (gdb_stdlog, "find_arch_by_info: "
4080                             "No matching architecture\n");
4081       return 0;
4082     }
4083
4084   /* Ask the tdep code for an architecture that matches "info".  */
4085   new_gdbarch = rego->init (info, rego->arches);
4086
4087   /* Did the tdep code like it?  No.  Reject the change and revert to
4088      the old architecture.  */
4089   if (new_gdbarch == NULL)
4090     {
4091       if (gdbarch_debug)
4092         fprintf_unfiltered (gdb_stdlog, "find_arch_by_info: "
4093                             "Target rejected architecture\n");
4094       return NULL;
4095     }
4096
4097   /* Is this a pre-existing architecture (as determined by already
4098      being initialized)?  Move it to the front of the architecture
4099      list (keeping the list sorted Most Recently Used).  */
4100   if (new_gdbarch->initialized_p)
4101     {
4102       struct gdbarch_list **list;
4103       struct gdbarch_list *this;
4104       if (gdbarch_debug)
4105         fprintf_unfiltered (gdb_stdlog, "find_arch_by_info: "
4106                             "Previous architecture 0x%08lx (%s) selected\n",
4107                             (long) new_gdbarch,
4108                             new_gdbarch->bfd_arch_info->printable_name);
4109       /* Find the existing arch in the list.  */
4110       for (list = &rego->arches;
4111            (*list) != NULL && (*list)->gdbarch != new_gdbarch;
4112            list = &(*list)->next);
4113       /* It had better be in the list of architectures.  */
4114       gdb_assert ((*list) != NULL && (*list)->gdbarch == new_gdbarch);
4115       /* Unlink THIS.  */
4116       this = (*list);
4117       (*list) = this->next;
4118       /* Insert THIS at the front.  */
4119       this->next = rego->arches;
4120       rego->arches = this;
4121       /* Return it.  */
4122       return new_gdbarch;
4123     }
4124
4125   /* It's a new architecture.  */
4126   if (gdbarch_debug)
4127     fprintf_unfiltered (gdb_stdlog, "find_arch_by_info: "
4128                         "New architecture 0x%08lx (%s) selected\n",
4129                         (long) new_gdbarch,
4130                         new_gdbarch->bfd_arch_info->printable_name);
4131
4132   /* Insert the new architecture into the front of the architecture
4133      list (keep the list sorted Most Recently Used).  */
4134   {
4135     struct gdbarch_list *this = XMALLOC (struct gdbarch_list);
4136     this->next = rego->arches;
4137     this->gdbarch = new_gdbarch;
4138     rego->arches = this;
4139   }
4140
4141   /* Check that the newly installed architecture is valid.  Plug in
4142      any post init values.  */
4143   new_gdbarch->dump_tdep = rego->dump_tdep;
4144   verify_gdbarch (new_gdbarch);
4145   new_gdbarch->initialized_p = 1;
4146
4147   /* Initialize any per-architecture swap areas.  This phase requires
4148      a valid global CURRENT_GDBARCH.  Set it momentarially, and then
4149      swap the entire architecture out.  */
4150   current_gdbarch = new_gdbarch;
4151   current_gdbarch_swap_init_hack ();
4152   current_gdbarch_swap_out_hack ();
4153
4154   if (gdbarch_debug)
4155     gdbarch_dump (new_gdbarch, gdb_stdlog);
4156
4157   return new_gdbarch;
4158 }
4159
4160 struct gdbarch *
4161 gdbarch_find_by_info (struct gdbarch_info info)
4162 {
4163   /* Save the previously selected architecture, setting the global to
4164      NULL.  This stops things like gdbarch->init() trying to use the
4165      previous architecture's configuration.  The previous architecture
4166      may not even be of the same architecture family.  The most recent
4167      architecture of the same family is found at the head of the
4168      rego->arches list.  */
4169   struct gdbarch *old_gdbarch = current_gdbarch_swap_out_hack ();
4170
4171   /* Find the specified architecture.  */
4172   struct gdbarch *new_gdbarch = find_arch_by_info (old_gdbarch, info);
4173
4174   /* Restore the existing architecture.  */
4175   gdb_assert (current_gdbarch == NULL);
4176   current_gdbarch_swap_in_hack (old_gdbarch);
4177
4178   return new_gdbarch;
4179 }
4180
4181 /* Make the specified architecture current, swapping the existing one
4182    out.  */
4183
4184 void
4185 deprecated_current_gdbarch_select_hack (struct gdbarch *new_gdbarch)
4186 {
4187   gdb_assert (new_gdbarch != NULL);
4188   gdb_assert (current_gdbarch != NULL);
4189   gdb_assert (new_gdbarch->initialized_p);
4190   current_gdbarch_swap_out_hack ();
4191   current_gdbarch_swap_in_hack (new_gdbarch);
4192   architecture_changed_event ();
4193 }
4194
4195 extern void _initialize_gdbarch (void);
4196
4197 void
4198 _initialize_gdbarch (void)
4199 {
4200   struct cmd_list_element *c;
4201
4202   deprecated_add_show_from_set
4203     (add_set_cmd ("arch",
4204                   class_maintenance,
4205                   var_zinteger,
4206                   (char *)&gdbarch_debug,
4207                   "Set architecture debugging.\n\
4208 When non-zero, architecture debugging is enabled.", &setdebuglist),
4209      &showdebuglist);
4210   c = add_set_cmd ("archdebug",
4211                    class_maintenance,
4212                    var_zinteger,
4213                    (char *)&gdbarch_debug,
4214                    "Set architecture debugging.\n\
4215 When non-zero, architecture debugging is enabled.", &setlist);
4216
4217   deprecate_cmd (c, "set debug arch");
4218   deprecate_cmd (deprecated_add_show_from_set (c, &showlist), "show debug arch");
4219 }