gdb/gdbarch.c

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