gdb/gdbarch.c

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