gdb/gdbarch.c

   1 /* *INDENT-OFF* */ /* THIS FILE IS GENERATED */
   2
   3 /* Dynamic architecture support for GDB, the GNU debugger.
   4
   5    Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007
   6    Free Software Foundation, Inc.
   7
   8    This file is part of GDB.
   9
  10    This program is free software; you can redistribute it and/or modify
  11    it under the terms of the GNU General Public License as published by
  12    the Free Software Foundation; either version 3 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, see <http://www.gnu.org/licenses/>.  */
  22
  23 /* This file was created with the aid of ``gdbarch.sh''.
  24
  25    The Bourne shell script ``gdbarch.sh'' creates the files
  26    ``new-gdbarch.c'' and ``new-gdbarch.h and then compares them
  27    against the existing ``gdbarch.[hc]''.  Any differences found
  28    being reported.
  29
  30    If editing this file, please also run gdbarch.sh and merge any
  31    changes into that script. Conversely, when making sweeping changes
  32    to this file, modifying gdbarch.sh and using its output may prove
  33    easier. */
  34
  35
  36 #include "defs.h"
  37 #include "arch-utils.h"
  38
  39 #include "gdbcmd.h"
  40 #include "inferior.h"
  41 #include "symcat.h"
  42
  43 #include "floatformat.h"
  44
  45 #include "gdb_assert.h"
  46 #include "gdb_string.h"
  47 #include "gdb-events.h"
  48 #include "reggroups.h"
  49 #include "osabi.h"
  50 #include "gdb_obstack.h"
  51
  52 /* Static function declarations */
  53
  54 static void alloc_gdbarch_data (struct gdbarch *);
  55
  56 /* Non-zero if we want to trace architecture code.  */
  57
  58 #ifndef GDBARCH_DEBUG
  59 #define GDBARCH_DEBUG 0
  60 #endif
  61 int gdbarch_debug = GDBARCH_DEBUG;
  62 static void
  63 show_gdbarch_debug (struct ui_file *file, int from_tty,
  64                     struct cmd_list_element *c, const char *value)
  65 {
  66   fprintf_filtered (file, _("Architecture debugging is %s.\n"), value);
  67 }
  68
  69 static const char *
  70 pformat (const struct floatformat **format)
  71 {
  72   if (format == NULL)
  73     return "(null)";
  74   else
  75     /* Just print out one of them - this is only for diagnostics.  */
  76     return format[0]->name;
  77 }
  78
  79
  80 /* Maintain the struct gdbarch object */
  81
  82 struct gdbarch
  83 {
  84   /* Has this architecture been fully initialized?  */
  85   int initialized_p;
  86
  87   /* An obstack bound to the lifetime of the architecture.  */
  88   struct obstack *obstack;
  89
  90   /* basic architectural information */
  91   const struct bfd_arch_info * bfd_arch_info;
  92   int byte_order;
  93   enum gdb_osabi osabi;
  94   const struct target_desc * target_desc;
  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 char_signed;
 146   gdbarch_read_pc_ftype *read_pc;
 147   gdbarch_write_pc_ftype *write_pc;
 148   gdbarch_virtual_frame_pointer_ftype *virtual_frame_pointer;
 149   gdbarch_pseudo_register_read_ftype *pseudo_register_read;
 150   gdbarch_pseudo_register_write_ftype *pseudo_register_write;
 151   int num_regs;
 152   int num_pseudo_regs;
 153   int sp_regnum;
 154   int pc_regnum;
 155   int ps_regnum;
 156   int fp0_regnum;
 157   gdbarch_stab_reg_to_regnum_ftype *stab_reg_to_regnum;
 158   gdbarch_ecoff_reg_to_regnum_ftype *ecoff_reg_to_regnum;
 159   gdbarch_dwarf_reg_to_regnum_ftype *dwarf_reg_to_regnum;
 160   gdbarch_sdb_reg_to_regnum_ftype *sdb_reg_to_regnum;
 161   gdbarch_dwarf2_reg_to_regnum_ftype *dwarf2_reg_to_regnum;
 162   gdbarch_register_name_ftype *register_name;
 163   gdbarch_register_type_ftype *register_type;
 164   gdbarch_unwind_dummy_id_ftype *unwind_dummy_id;
 165   int deprecated_fp_regnum;
 166   gdbarch_push_dummy_call_ftype *push_dummy_call;
 167   int call_dummy_location;
 168   gdbarch_push_dummy_code_ftype *push_dummy_code;
 169   gdbarch_print_registers_info_ftype *print_registers_info;
 170   gdbarch_print_float_info_ftype *print_float_info;
 171   gdbarch_print_vector_info_ftype *print_vector_info;
 172   gdbarch_register_sim_regno_ftype *register_sim_regno;
 173   gdbarch_cannot_fetch_register_ftype *cannot_fetch_register;
 174   gdbarch_cannot_store_register_ftype *cannot_store_register;
 175   gdbarch_get_longjmp_target_ftype *get_longjmp_target;
 176   int believe_pcc_promotion;
 177   gdbarch_convert_register_p_ftype *convert_register_p;
 178   gdbarch_register_to_value_ftype *register_to_value;
 179   gdbarch_value_to_register_ftype *value_to_register;
 180   gdbarch_value_from_register_ftype *value_from_register;
 181   gdbarch_pointer_to_address_ftype *pointer_to_address;
 182   gdbarch_address_to_pointer_ftype *address_to_pointer;
 183   gdbarch_integer_to_address_ftype *integer_to_address;
 184   gdbarch_return_value_ftype *return_value;
 185   gdbarch_skip_prologue_ftype *skip_prologue;
 186   gdbarch_inner_than_ftype *inner_than;
 187   gdbarch_breakpoint_from_pc_ftype *breakpoint_from_pc;
 188   gdbarch_adjust_breakpoint_address_ftype *adjust_breakpoint_address;
 189   gdbarch_memory_insert_breakpoint_ftype *memory_insert_breakpoint;
 190   gdbarch_memory_remove_breakpoint_ftype *memory_remove_breakpoint;
 191   CORE_ADDR decr_pc_after_break;
 192   CORE_ADDR deprecated_function_start_offset;
 193   gdbarch_remote_register_number_ftype *remote_register_number;
 194   gdbarch_fetch_tls_load_module_address_ftype *fetch_tls_load_module_address;
 195   CORE_ADDR frame_args_skip;
 196   gdbarch_unwind_pc_ftype *unwind_pc;
 197   gdbarch_unwind_sp_ftype *unwind_sp;
 198   gdbarch_frame_num_args_ftype *frame_num_args;
 199   gdbarch_frame_align_ftype *frame_align;
 200   gdbarch_stabs_argument_has_addr_ftype *stabs_argument_has_addr;
 201   int frame_red_zone_size;
 202   gdbarch_convert_from_func_ptr_addr_ftype *convert_from_func_ptr_addr;
 203   gdbarch_addr_bits_remove_ftype *addr_bits_remove;
 204   gdbarch_smash_text_address_ftype *smash_text_address;
 205   gdbarch_software_single_step_ftype *software_single_step;
 206   gdbarch_single_step_through_delay_ftype *single_step_through_delay;
 207   gdbarch_print_insn_ftype *print_insn;
 208   gdbarch_skip_trampoline_code_ftype *skip_trampoline_code;
 209   gdbarch_skip_solib_resolver_ftype *skip_solib_resolver;
 210   gdbarch_in_solib_return_trampoline_ftype *in_solib_return_trampoline;
 211   gdbarch_in_function_epilogue_p_ftype *in_function_epilogue_p;
 212   gdbarch_construct_inferior_arguments_ftype *construct_inferior_arguments;
 213   gdbarch_elf_make_msymbol_special_ftype *elf_make_msymbol_special;
 214   gdbarch_coff_make_msymbol_special_ftype *coff_make_msymbol_special;
 215   const char * name_of_malloc;
 216   int cannot_step_breakpoint;
 217   int have_nonsteppable_watchpoint;
 218   gdbarch_address_class_type_flags_ftype *address_class_type_flags;
 219   gdbarch_address_class_type_flags_to_name_ftype *address_class_type_flags_to_name;
 220   gdbarch_address_class_name_to_type_flags_ftype *address_class_name_to_type_flags;
 221   gdbarch_register_reggroup_p_ftype *register_reggroup_p;
 222   gdbarch_fetch_pointer_argument_ftype *fetch_pointer_argument;
 223   gdbarch_regset_from_core_section_ftype *regset_from_core_section;
 224   gdbarch_core_xfer_shared_libraries_ftype *core_xfer_shared_libraries;
 225   int vtable_function_descriptors;
 226   int vbit_in_delta;
 227   gdbarch_skip_permanent_breakpoint_ftype *skip_permanent_breakpoint;
 228   gdbarch_overlay_update_ftype *overlay_update;
 229   gdbarch_core_read_description_ftype *core_read_description;
 230 };
 231
 232
 233 /* The default architecture uses host values (for want of a better
 234    choice). */
 235
 236 extern const struct bfd_arch_info bfd_default_arch_struct;
 237
 238 struct gdbarch startup_gdbarch =
 239 {
 240   1, /* Always initialized.  */
 241   NULL, /* The obstack.  */
 242   /* basic architecture information */
 243   &bfd_default_arch_struct,  /* bfd_arch_info */
 244   BFD_ENDIAN_BIG,  /* byte_order */
 245   GDB_OSABI_UNKNOWN,  /* osabi */
 246   0,  /* target_desc */
 247   /* target specific vector and its dump routine */
 248   NULL, NULL,
 249   /*per-architecture data-pointers and swap regions */
 250   0, NULL, NULL,
 251   /* Multi-arch values */
 252   8 * sizeof (short),  /* short_bit */
 253   8 * sizeof (int),  /* int_bit */
 254   8 * sizeof (long),  /* long_bit */
 255   8 * sizeof (LONGEST),  /* long_long_bit */
 256   8 * sizeof (float),  /* float_bit */
 257   0,  /* float_format */
 258   8 * sizeof (double),  /* double_bit */
 259   0,  /* double_format */
 260   8 * sizeof (long double),  /* long_double_bit */
 261   0,  /* long_double_format */
 262   8 * sizeof (void*),  /* ptr_bit */
 263   8 * sizeof (void*),  /* addr_bit */
 264   1,  /* char_signed */
 265   0,  /* read_pc */
 266   0,  /* write_pc */
 267   0,  /* virtual_frame_pointer */
 268   0,  /* pseudo_register_read */
 269   0,  /* pseudo_register_write */
 270   0,  /* num_regs */
 271   0,  /* num_pseudo_regs */
 272   -1,  /* sp_regnum */
 273   -1,  /* pc_regnum */
 274   -1,  /* ps_regnum */
 275   0,  /* fp0_regnum */
 276   0,  /* stab_reg_to_regnum */
 277   0,  /* ecoff_reg_to_regnum */
 278   0,  /* dwarf_reg_to_regnum */
 279   0,  /* sdb_reg_to_regnum */
 280   0,  /* dwarf2_reg_to_regnum */
 281   0,  /* register_name */
 282   0,  /* register_type */
 283   0,  /* unwind_dummy_id */
 284   -1,  /* deprecated_fp_regnum */
 285   0,  /* push_dummy_call */
 286   0,  /* call_dummy_location */
 287   0,  /* push_dummy_code */
 288   default_print_registers_info,  /* print_registers_info */
 289   0,  /* print_float_info */
 290   0,  /* print_vector_info */
 291   0,  /* register_sim_regno */
 292   0,  /* cannot_fetch_register */
 293   0,  /* cannot_store_register */
 294   0,  /* get_longjmp_target */
 295   0,  /* believe_pcc_promotion */
 296   0,  /* convert_register_p */
 297   0,  /* register_to_value */
 298   0,  /* value_to_register */
 299   0,  /* value_from_register */
 300   0,  /* pointer_to_address */
 301   0,  /* address_to_pointer */
 302   0,  /* integer_to_address */
 303   0,  /* return_value */
 304   0,  /* skip_prologue */
 305   0,  /* inner_than */
 306   0,  /* breakpoint_from_pc */
 307   0,  /* adjust_breakpoint_address */
 308   0,  /* memory_insert_breakpoint */
 309   0,  /* memory_remove_breakpoint */
 310   0,  /* decr_pc_after_break */
 311   0,  /* deprecated_function_start_offset */
 312   default_remote_register_number,  /* remote_register_number */
 313   0,  /* fetch_tls_load_module_address */
 314   0,  /* frame_args_skip */
 315   0,  /* unwind_pc */
 316   0,  /* unwind_sp */
 317   0,  /* frame_num_args */
 318   0,  /* frame_align */
 319   default_stabs_argument_has_addr,  /* stabs_argument_has_addr */
 320   0,  /* frame_red_zone_size */
 321   convert_from_func_ptr_addr_identity,  /* convert_from_func_ptr_addr */
 322   0,  /* addr_bits_remove */
 323   0,  /* smash_text_address */
 324   0,  /* software_single_step */
 325   0,  /* single_step_through_delay */
 326   0,  /* print_insn */
 327   0,  /* skip_trampoline_code */
 328   generic_skip_solib_resolver,  /* skip_solib_resolver */
 329   0,  /* in_solib_return_trampoline */
 330   generic_in_function_epilogue_p,  /* in_function_epilogue_p */
 331   construct_inferior_arguments,  /* construct_inferior_arguments */
 332   0,  /* elf_make_msymbol_special */
 333   0,  /* coff_make_msymbol_special */
 334   "malloc",  /* name_of_malloc */
 335   0,  /* cannot_step_breakpoint */
 336   0,  /* have_nonsteppable_watchpoint */
 337   0,  /* address_class_type_flags */
 338   0,  /* address_class_type_flags_to_name */
 339   0,  /* address_class_name_to_type_flags */
 340   default_register_reggroup_p,  /* register_reggroup_p */
 341   0,  /* fetch_pointer_argument */
 342   0,  /* regset_from_core_section */
 343   0,  /* core_xfer_shared_libraries */
 344   0,  /* vtable_function_descriptors */
 345   0,  /* vbit_in_delta */
 346   0,  /* skip_permanent_breakpoint */
 347   0,  /* overlay_update */
 348   0,  /* core_read_description */
 349   /* startup_gdbarch() */
 350 };
 351
 352 struct gdbarch *current_gdbarch = &startup_gdbarch;
 353
 354 /* Create a new ``struct gdbarch'' based on information provided by
 355    ``struct gdbarch_info''. */
 356
 357 struct gdbarch *
 358 gdbarch_alloc (const struct gdbarch_info *info,
 359                struct gdbarch_tdep *tdep)
 360 {
 361   /* NOTE: The new architecture variable is named ``current_gdbarch''
 362      so that macros such as TARGET_ARCHITECTURE, when expanded, refer to
 363      the current local architecture and not the previous global
 364      architecture.  This ensures that the new architectures initial
 365      values are not influenced by the previous architecture.  Once
 366      everything is parameterised with gdbarch, this will go away.  */
 367   struct gdbarch *current_gdbarch;
 368
 369   /* Create an obstack for allocating all the per-architecture memory,
 370      then use that to allocate the architecture vector.  */
 371   struct obstack *obstack = XMALLOC (struct obstack);
 372   obstack_init (obstack);
 373   current_gdbarch = obstack_alloc (obstack, sizeof (*current_gdbarch));
 374   memset (current_gdbarch, 0, sizeof (*current_gdbarch));
 375   current_gdbarch->obstack = obstack;
 376
 377   alloc_gdbarch_data (current_gdbarch);
 378
 379   current_gdbarch->tdep = tdep;
 380
 381   current_gdbarch->bfd_arch_info = info->bfd_arch_info;
 382   current_gdbarch->byte_order = info->byte_order;
 383   current_gdbarch->osabi = info->osabi;
 384   current_gdbarch->target_desc = info->target_desc;
 385
 386   /* Force the explicit initialization of these. */
 387   current_gdbarch->short_bit = 2*TARGET_CHAR_BIT;
 388   current_gdbarch->int_bit = 4*TARGET_CHAR_BIT;
 389   current_gdbarch->long_bit = 4*TARGET_CHAR_BIT;
 390   current_gdbarch->long_long_bit = 2*current_gdbarch->long_bit;
 391   current_gdbarch->float_bit = 4*TARGET_CHAR_BIT;
 392   current_gdbarch->double_bit = 8*TARGET_CHAR_BIT;
 393   current_gdbarch->long_double_bit = 8*TARGET_CHAR_BIT;
 394   current_gdbarch->ptr_bit = current_gdbarch->int_bit;
 395   current_gdbarch->char_signed = -1;
 396   current_gdbarch->virtual_frame_pointer = legacy_virtual_frame_pointer;
 397   current_gdbarch->num_regs = -1;
 398   current_gdbarch->sp_regnum = -1;
 399   current_gdbarch->pc_regnum = -1;
 400   current_gdbarch->ps_regnum = -1;
 401   current_gdbarch->fp0_regnum = -1;
 402   current_gdbarch->stab_reg_to_regnum = no_op_reg_to_regnum;
 403   current_gdbarch->ecoff_reg_to_regnum = no_op_reg_to_regnum;
 404   current_gdbarch->dwarf_reg_to_regnum = no_op_reg_to_regnum;
 405   current_gdbarch->sdb_reg_to_regnum = no_op_reg_to_regnum;
 406   current_gdbarch->dwarf2_reg_to_regnum = no_op_reg_to_regnum;
 407   current_gdbarch->deprecated_fp_regnum = -1;
 408   current_gdbarch->call_dummy_location = AT_ENTRY_POINT;
 409   current_gdbarch->print_registers_info = default_print_registers_info;
 410   current_gdbarch->register_sim_regno = legacy_register_sim_regno;
 411   current_gdbarch->cannot_fetch_register = cannot_register_not;
 412   current_gdbarch->cannot_store_register = cannot_register_not;
 413   current_gdbarch->convert_register_p = generic_convert_register_p;
 414   current_gdbarch->value_from_register = default_value_from_register;
 415   current_gdbarch->pointer_to_address = unsigned_pointer_to_address;
 416   current_gdbarch->address_to_pointer = unsigned_address_to_pointer;
 417   current_gdbarch->memory_insert_breakpoint = default_memory_insert_breakpoint;
 418   current_gdbarch->memory_remove_breakpoint = default_memory_remove_breakpoint;
 419   current_gdbarch->remote_register_number = default_remote_register_number;
 420   current_gdbarch->stabs_argument_has_addr = default_stabs_argument_has_addr;
 421   current_gdbarch->convert_from_func_ptr_addr = convert_from_func_ptr_addr_identity;
 422   current_gdbarch->addr_bits_remove = core_addr_identity;
 423   current_gdbarch->smash_text_address = core_addr_identity;
 424   current_gdbarch->skip_trampoline_code = generic_skip_trampoline_code;
 425   current_gdbarch->skip_solib_resolver = generic_skip_solib_resolver;
 426   current_gdbarch->in_solib_return_trampoline = generic_in_solib_return_trampoline;
 427   current_gdbarch->in_function_epilogue_p = generic_in_function_epilogue_p;
 428   current_gdbarch->construct_inferior_arguments = construct_inferior_arguments;
 429   current_gdbarch->elf_make_msymbol_special = default_elf_make_msymbol_special;
 430   current_gdbarch->coff_make_msymbol_special = default_coff_make_msymbol_special;
 431   current_gdbarch->name_of_malloc = "malloc";
 432   current_gdbarch->register_reggroup_p = default_register_reggroup_p;
 433   /* gdbarch_alloc() */
 434
 435   return current_gdbarch;
 436 }
 437
 438
 439 /* Allocate extra space using the per-architecture obstack.  */
 440
 441 void *
 442 gdbarch_obstack_zalloc (struct gdbarch *arch, long size)
 443 {
 444   void *data = obstack_alloc (arch->obstack, size);
 445   memset (data, 0, size);
 446   return data;
 447 }
 448
 449
 450 /* Free a gdbarch struct.  This should never happen in normal
 451    operation --- once you've created a gdbarch, you keep it around.
 452    However, if an architecture's init function encounters an error
 453    building the structure, it may need to clean up a partially
 454    constructed gdbarch.  */
 455
 456 void
 457 gdbarch_free (struct gdbarch *arch)
 458 {
 459   struct obstack *obstack;
 460   gdb_assert (arch != NULL);
 461   gdb_assert (!arch->initialized_p);
 462   obstack = arch->obstack;
 463   obstack_free (obstack, 0); /* Includes the ARCH.  */
 464   xfree (obstack);
 465 }
 466
 467
 468 /* Ensure that all values in a GDBARCH are reasonable.  */
 469
 470 /* NOTE/WARNING: The parameter is called ``current_gdbarch'' so that it
 471    just happens to match the global variable ``current_gdbarch''.  That
 472    way macros refering to that variable get the local and not the global
 473    version - ulgh.  Once everything is parameterised with gdbarch, this
 474    will go away. */
 475
 476 static void
 477 verify_gdbarch (struct gdbarch *current_gdbarch)
 478 {
 479   struct ui_file *log;
 480   struct cleanup *cleanups;
 481   long dummy;
 482   char *buf;
 483   log = mem_fileopen ();
 484   cleanups = make_cleanup_ui_file_delete (log);
 485   /* fundamental */
 486   if (current_gdbarch->byte_order == BFD_ENDIAN_UNKNOWN)
 487     fprintf_unfiltered (log, "\n\tbyte-order");
 488   if (current_gdbarch->bfd_arch_info == NULL)
 489     fprintf_unfiltered (log, "\n\tbfd_arch_info");
 490   /* Check those that need to be defined for the given multi-arch level. */
 491   /* Skip verify of short_bit, invalid_p == 0 */
 492   /* Skip verify of int_bit, invalid_p == 0 */
 493   /* Skip verify of long_bit, invalid_p == 0 */
 494   /* Skip verify of long_long_bit, invalid_p == 0 */
 495   /* Skip verify of float_bit, invalid_p == 0 */
 496   if (current_gdbarch->float_format == 0)
 497     current_gdbarch->float_format = floatformats_ieee_single;
 498   /* Skip verify of double_bit, invalid_p == 0 */
 499   if (current_gdbarch->double_format == 0)
 500     current_gdbarch->double_format = floatformats_ieee_double;
 501   /* Skip verify of long_double_bit, invalid_p == 0 */
 502   if (current_gdbarch->long_double_format == 0)
 503     current_gdbarch->long_double_format = floatformats_ieee_double;
 504   /* Skip verify of ptr_bit, invalid_p == 0 */
 505   if (current_gdbarch->addr_bit == 0)
 506     current_gdbarch->addr_bit = gdbarch_ptr_bit (current_gdbarch);
 507   if (current_gdbarch->char_signed == -1)
 508     current_gdbarch->char_signed = 1;
 509   /* Skip verify of read_pc, has predicate */
 510   /* Skip verify of write_pc, has predicate */
 511   /* Skip verify of virtual_frame_pointer, invalid_p == 0 */
 512   /* Skip verify of pseudo_register_read, has predicate */
 513   /* Skip verify of pseudo_register_write, has predicate */
 514   if (current_gdbarch->num_regs == -1)
 515     fprintf_unfiltered (log, "\n\tnum_regs");
 516   /* Skip verify of num_pseudo_regs, invalid_p == 0 */
 517   /* Skip verify of sp_regnum, invalid_p == 0 */
 518   /* Skip verify of pc_regnum, invalid_p == 0 */
 519   /* Skip verify of ps_regnum, invalid_p == 0 */
 520   /* Skip verify of fp0_regnum, invalid_p == 0 */
 521   /* Skip verify of stab_reg_to_regnum, invalid_p == 0 */
 522   /* Skip verify of ecoff_reg_to_regnum, invalid_p == 0 */
 523   /* Skip verify of dwarf_reg_to_regnum, invalid_p == 0 */
 524   /* Skip verify of sdb_reg_to_regnum, invalid_p == 0 */
 525   /* Skip verify of dwarf2_reg_to_regnum, invalid_p == 0 */
 526   /* Skip verify of register_type, has predicate */
 527   /* Skip verify of unwind_dummy_id, has predicate */
 528   /* Skip verify of deprecated_fp_regnum, invalid_p == 0 */
 529   /* Skip verify of push_dummy_call, has predicate */
 530   /* Skip verify of call_dummy_location, invalid_p == 0 */
 531   /* Skip verify of push_dummy_code, has predicate */
 532   /* Skip verify of print_registers_info, invalid_p == 0 */
 533   /* Skip verify of print_float_info, has predicate */
 534   /* Skip verify of print_vector_info, has predicate */
 535   /* Skip verify of register_sim_regno, invalid_p == 0 */
 536   /* Skip verify of cannot_fetch_register, invalid_p == 0 */
 537   /* Skip verify of cannot_store_register, invalid_p == 0 */
 538   /* Skip verify of get_longjmp_target, has predicate */
 539   /* Skip verify of convert_register_p, invalid_p == 0 */
 540   /* Skip verify of value_from_register, invalid_p == 0 */
 541   /* Skip verify of pointer_to_address, invalid_p == 0 */
 542   /* Skip verify of address_to_pointer, invalid_p == 0 */
 543   /* Skip verify of integer_to_address, has predicate */
 544   /* Skip verify of return_value, has predicate */
 545   if (current_gdbarch->skip_prologue == 0)
 546     fprintf_unfiltered (log, "\n\tskip_prologue");
 547   if (current_gdbarch->inner_than == 0)
 548     fprintf_unfiltered (log, "\n\tinner_than");
 549   if (current_gdbarch->breakpoint_from_pc == 0)
 550     fprintf_unfiltered (log, "\n\tbreakpoint_from_pc");
 551   /* Skip verify of adjust_breakpoint_address, has predicate */
 552   /* Skip verify of memory_insert_breakpoint, invalid_p == 0 */
 553   /* Skip verify of memory_remove_breakpoint, invalid_p == 0 */
 554   /* Skip verify of decr_pc_after_break, invalid_p == 0 */
 555   /* Skip verify of deprecated_function_start_offset, invalid_p == 0 */
 556   /* Skip verify of remote_register_number, invalid_p == 0 */
 557   /* Skip verify of fetch_tls_load_module_address, has predicate */
 558   /* Skip verify of frame_args_skip, invalid_p == 0 */
 559   /* Skip verify of unwind_pc, has predicate */
 560   /* Skip verify of unwind_sp, has predicate */
 561   /* Skip verify of frame_num_args, has predicate */
 562   /* Skip verify of frame_align, has predicate */
 563   /* Skip verify of stabs_argument_has_addr, invalid_p == 0 */
 564   /* Skip verify of convert_from_func_ptr_addr, invalid_p == 0 */
 565   /* Skip verify of addr_bits_remove, invalid_p == 0 */
 566   /* Skip verify of smash_text_address, invalid_p == 0 */
 567   /* Skip verify of software_single_step, has predicate */
 568   /* Skip verify of single_step_through_delay, has predicate */
 569   if (current_gdbarch->print_insn == 0)
 570     fprintf_unfiltered (log, "\n\tprint_insn");
 571   /* Skip verify of skip_trampoline_code, invalid_p == 0 */
 572   /* Skip verify of skip_solib_resolver, invalid_p == 0 */
 573   /* Skip verify of in_solib_return_trampoline, invalid_p == 0 */
 574   /* Skip verify of in_function_epilogue_p, invalid_p == 0 */
 575   /* Skip verify of construct_inferior_arguments, invalid_p == 0 */
 576   /* Skip verify of elf_make_msymbol_special, invalid_p == 0 */
 577   /* Skip verify of coff_make_msymbol_special, invalid_p == 0 */
 578   /* Skip verify of name_of_malloc, invalid_p == 0 */
 579   /* Skip verify of cannot_step_breakpoint, invalid_p == 0 */
 580   /* Skip verify of have_nonsteppable_watchpoint, invalid_p == 0 */
 581   /* Skip verify of address_class_type_flags, has predicate */
 582   /* Skip verify of address_class_type_flags_to_name, has predicate */
 583   /* Skip verify of address_class_name_to_type_flags, has predicate */
 584   /* Skip verify of register_reggroup_p, invalid_p == 0 */
 585   /* Skip verify of fetch_pointer_argument, has predicate */
 586   /* Skip verify of regset_from_core_section, has predicate */
 587   /* Skip verify of core_xfer_shared_libraries, has predicate */
 588   /* Skip verify of vtable_function_descriptors, invalid_p == 0 */
 589   /* Skip verify of vbit_in_delta, invalid_p == 0 */
 590   /* Skip verify of skip_permanent_breakpoint, has predicate */
 591   /* Skip verify of overlay_update, has predicate */
 592   /* Skip verify of core_read_description, has predicate */
 593   buf = ui_file_xstrdup (log, &dummy);
 594   make_cleanup (xfree, buf);
 595   if (strlen (buf) > 0)
 596     internal_error (__FILE__, __LINE__,
 597                     _("verify_gdbarch: the following are invalid ...%s"),
 598                     buf);
 599   do_cleanups (cleanups);
 600 }
 601
 602
 603 /* Print out the details of the current architecture. */
 604
 605 /* NOTE/WARNING: The parameter is called ``current_gdbarch'' so that it
 606    just happens to match the global variable ``current_gdbarch''.  That
 607    way macros refering to that variable get the local and not the global
 608    version - ulgh.  Once everything is parameterised with gdbarch, this
 609    will go away. */
 610
 611 void
 612 gdbarch_dump (struct gdbarch *current_gdbarch, struct ui_file *file)
 613 {
 614   const char *gdb_xm_file = "<not-defined>";
 615   const char *gdb_nm_file = "<not-defined>";
 616   const char *gdb_tm_file = "<not-defined>";
 617 #if defined (GDB_XM_FILE)
 618   gdb_xm_file = GDB_XM_FILE;
 619 #endif
 620   fprintf_unfiltered (file,
 621                       "gdbarch_dump: GDB_XM_FILE = %s\n",
 622                       gdb_xm_file);
 623 #if defined (GDB_NM_FILE)
 624   gdb_nm_file = GDB_NM_FILE;
 625 #endif
 626   fprintf_unfiltered (file,
 627                       "gdbarch_dump: GDB_NM_FILE = %s\n",
 628                       gdb_nm_file);
 629 #if defined (GDB_TM_FILE)
 630   gdb_tm_file = GDB_TM_FILE;
 631 #endif
 632   fprintf_unfiltered (file,
 633                       "gdbarch_dump: GDB_TM_FILE = %s\n",
 634                       gdb_tm_file);
 635   fprintf_unfiltered (file,
 636                       "gdbarch_dump: addr_bit = %s\n",
 637                       paddr_d (current_gdbarch->addr_bit));
 638   fprintf_unfiltered (file,
 639                       "gdbarch_dump: addr_bits_remove = <0x%lx>\n",
 640                       (long) current_gdbarch->addr_bits_remove);
 641   fprintf_unfiltered (file,
 642                       "gdbarch_dump: gdbarch_address_class_name_to_type_flags_p() = %d\n",
 643                       gdbarch_address_class_name_to_type_flags_p (current_gdbarch));
 644   fprintf_unfiltered (file,
 645                       "gdbarch_dump: address_class_name_to_type_flags = <0x%lx>\n",
 646                       (long) current_gdbarch->address_class_name_to_type_flags);
 647   fprintf_unfiltered (file,
 648                       "gdbarch_dump: gdbarch_address_class_type_flags_p() = %d\n",
 649                       gdbarch_address_class_type_flags_p (current_gdbarch));
 650   fprintf_unfiltered (file,
 651                       "gdbarch_dump: address_class_type_flags = <0x%lx>\n",
 652                       (long) current_gdbarch->address_class_type_flags);
 653   fprintf_unfiltered (file,
 654                       "gdbarch_dump: gdbarch_address_class_type_flags_to_name_p() = %d\n",
 655                       gdbarch_address_class_type_flags_to_name_p (current_gdbarch));
 656   fprintf_unfiltered (file,
 657                       "gdbarch_dump: address_class_type_flags_to_name = <0x%lx>\n",
 658                       (long) current_gdbarch->address_class_type_flags_to_name);
 659   fprintf_unfiltered (file,
 660                       "gdbarch_dump: address_to_pointer = <0x%lx>\n",
 661                       (long) current_gdbarch->address_to_pointer);
 662   fprintf_unfiltered (file,
 663                       "gdbarch_dump: gdbarch_adjust_breakpoint_address_p() = %d\n",
 664                       gdbarch_adjust_breakpoint_address_p (current_gdbarch));
 665   fprintf_unfiltered (file,
 666                       "gdbarch_dump: adjust_breakpoint_address = <0x%lx>\n",
 667                       (long) current_gdbarch->adjust_breakpoint_address);
 668   fprintf_unfiltered (file,
 669                       "gdbarch_dump: believe_pcc_promotion = %s\n",
 670                       paddr_d (current_gdbarch->believe_pcc_promotion));
 671   fprintf_unfiltered (file,
 672                       "gdbarch_dump: bfd_arch_info = %s\n",
 673                       gdbarch_bfd_arch_info (current_gdbarch)->printable_name);
 674   fprintf_unfiltered (file,
 675                       "gdbarch_dump: breakpoint_from_pc = <0x%lx>\n",
 676                       (long) current_gdbarch->breakpoint_from_pc);
 677   fprintf_unfiltered (file,
 678                       "gdbarch_dump: byte_order = %s\n",
 679                       paddr_d (current_gdbarch->byte_order));
 680   fprintf_unfiltered (file,
 681                       "gdbarch_dump: call_dummy_location = %s\n",
 682                       paddr_d (current_gdbarch->call_dummy_location));
 683   fprintf_unfiltered (file,
 684                       "gdbarch_dump: cannot_fetch_register = <0x%lx>\n",
 685                       (long) current_gdbarch->cannot_fetch_register);
 686   fprintf_unfiltered (file,
 687                       "gdbarch_dump: cannot_step_breakpoint = %s\n",
 688                       paddr_d (current_gdbarch->cannot_step_breakpoint));
 689   fprintf_unfiltered (file,
 690                       "gdbarch_dump: cannot_store_register = <0x%lx>\n",
 691                       (long) current_gdbarch->cannot_store_register);
 692   fprintf_unfiltered (file,
 693                       "gdbarch_dump: char_signed = %s\n",
 694                       paddr_d (current_gdbarch->char_signed));
 695   fprintf_unfiltered (file,
 696                       "gdbarch_dump: coff_make_msymbol_special = <0x%lx>\n",
 697                       (long) current_gdbarch->coff_make_msymbol_special);
 698   fprintf_unfiltered (file,
 699                       "gdbarch_dump: construct_inferior_arguments = <0x%lx>\n",
 700                       (long) current_gdbarch->construct_inferior_arguments);
 701   fprintf_unfiltered (file,
 702                       "gdbarch_dump: convert_from_func_ptr_addr = <0x%lx>\n",
 703                       (long) current_gdbarch->convert_from_func_ptr_addr);
 704   fprintf_unfiltered (file,
 705                       "gdbarch_dump: convert_register_p = <0x%lx>\n",
 706                       (long) current_gdbarch->convert_register_p);
 707   fprintf_unfiltered (file,
 708                       "gdbarch_dump: gdbarch_core_read_description_p() = %d\n",
 709                       gdbarch_core_read_description_p (current_gdbarch));
 710   fprintf_unfiltered (file,
 711                       "gdbarch_dump: core_read_description = <0x%lx>\n",
 712                       (long) current_gdbarch->core_read_description);
 713   fprintf_unfiltered (file,
 714                       "gdbarch_dump: gdbarch_core_xfer_shared_libraries_p() = %d\n",
 715                       gdbarch_core_xfer_shared_libraries_p (current_gdbarch));
 716   fprintf_unfiltered (file,
 717                       "gdbarch_dump: core_xfer_shared_libraries = <0x%lx>\n",
 718                       (long) current_gdbarch->core_xfer_shared_libraries);
 719   fprintf_unfiltered (file,
 720                       "gdbarch_dump: decr_pc_after_break = 0x%s\n",
 721                       paddr_nz (current_gdbarch->decr_pc_after_break));
 722   fprintf_unfiltered (file,
 723                       "gdbarch_dump: deprecated_fp_regnum = %s\n",
 724                       paddr_d (current_gdbarch->deprecated_fp_regnum));
 725   fprintf_unfiltered (file,
 726                       "gdbarch_dump: deprecated_function_start_offset = 0x%s\n",
 727                       paddr_nz (current_gdbarch->deprecated_function_start_offset));
 728   fprintf_unfiltered (file,
 729                       "gdbarch_dump: double_bit = %s\n",
 730                       paddr_d (current_gdbarch->double_bit));
 731   fprintf_unfiltered (file,
 732                       "gdbarch_dump: double_format = %s\n",
 733                       pformat (current_gdbarch->double_format));
 734   fprintf_unfiltered (file,
 735                       "gdbarch_dump: dwarf2_reg_to_regnum = <0x%lx>\n",
 736                       (long) current_gdbarch->dwarf2_reg_to_regnum);
 737   fprintf_unfiltered (file,
 738                       "gdbarch_dump: dwarf_reg_to_regnum = <0x%lx>\n",
 739                       (long) current_gdbarch->dwarf_reg_to_regnum);
 740   fprintf_unfiltered (file,
 741                       "gdbarch_dump: ecoff_reg_to_regnum = <0x%lx>\n",
 742                       (long) current_gdbarch->ecoff_reg_to_regnum);
 743   fprintf_unfiltered (file,
 744                       "gdbarch_dump: elf_make_msymbol_special = <0x%lx>\n",
 745                       (long) current_gdbarch->elf_make_msymbol_special);
 746   fprintf_unfiltered (file,
 747                       "gdbarch_dump: gdbarch_fetch_pointer_argument_p() = %d\n",
 748                       gdbarch_fetch_pointer_argument_p (current_gdbarch));
 749   fprintf_unfiltered (file,
 750                       "gdbarch_dump: fetch_pointer_argument = <0x%lx>\n",
 751                       (long) current_gdbarch->fetch_pointer_argument);
 752   fprintf_unfiltered (file,
 753                       "gdbarch_dump: gdbarch_fetch_tls_load_module_address_p() = %d\n",
 754                       gdbarch_fetch_tls_load_module_address_p (current_gdbarch));
 755   fprintf_unfiltered (file,
 756                       "gdbarch_dump: fetch_tls_load_module_address = <0x%lx>\n",
 757                       (long) current_gdbarch->fetch_tls_load_module_address);
 758   fprintf_unfiltered (file,
 759                       "gdbarch_dump: float_bit = %s\n",
 760                       paddr_d (current_gdbarch->float_bit));
 761   fprintf_unfiltered (file,
 762                       "gdbarch_dump: float_format = %s\n",
 763                       pformat (current_gdbarch->float_format));
 764   fprintf_unfiltered (file,
 765                       "gdbarch_dump: fp0_regnum = %s\n",
 766                       paddr_d (current_gdbarch->fp0_regnum));
 767   fprintf_unfiltered (file,
 768                       "gdbarch_dump: gdbarch_frame_align_p() = %d\n",
 769                       gdbarch_frame_align_p (current_gdbarch));
 770   fprintf_unfiltered (file,
 771                       "gdbarch_dump: frame_align = <0x%lx>\n",
 772                       (long) current_gdbarch->frame_align);
 773   fprintf_unfiltered (file,
 774                       "gdbarch_dump: frame_args_skip = 0x%s\n",
 775                       paddr_nz (current_gdbarch->frame_args_skip));
 776   fprintf_unfiltered (file,
 777                       "gdbarch_dump: gdbarch_frame_num_args_p() = %d\n",
 778                       gdbarch_frame_num_args_p (current_gdbarch));
 779   fprintf_unfiltered (file,
 780                       "gdbarch_dump: frame_num_args = <0x%lx>\n",
 781                       (long) current_gdbarch->frame_num_args);
 782   fprintf_unfiltered (file,
 783                       "gdbarch_dump: frame_red_zone_size = %s\n",
 784                       paddr_d (current_gdbarch->frame_red_zone_size));
 785   fprintf_unfiltered (file,
 786                       "gdbarch_dump: gdbarch_get_longjmp_target_p() = %d\n",
 787                       gdbarch_get_longjmp_target_p (current_gdbarch));
 788   fprintf_unfiltered (file,
 789                       "gdbarch_dump: get_longjmp_target = <0x%lx>\n",
 790                       (long) current_gdbarch->get_longjmp_target);
 791   fprintf_unfiltered (file,
 792                       "gdbarch_dump: have_nonsteppable_watchpoint = %s\n",
 793                       paddr_d (current_gdbarch->have_nonsteppable_watchpoint));
 794   fprintf_unfiltered (file,
 795                       "gdbarch_dump: in_function_epilogue_p = <0x%lx>\n",
 796                       (long) current_gdbarch->in_function_epilogue_p);
 797   fprintf_unfiltered (file,
 798                       "gdbarch_dump: in_solib_return_trampoline = <0x%lx>\n",
 799                       (long) current_gdbarch->in_solib_return_trampoline);
 800   fprintf_unfiltered (file,
 801                       "gdbarch_dump: inner_than = <0x%lx>\n",
 802                       (long) current_gdbarch->inner_than);
 803   fprintf_unfiltered (file,
 804                       "gdbarch_dump: int_bit = %s\n",
 805                       paddr_d (current_gdbarch->int_bit));
 806   fprintf_unfiltered (file,
 807                       "gdbarch_dump: gdbarch_integer_to_address_p() = %d\n",
 808                       gdbarch_integer_to_address_p (current_gdbarch));
 809   fprintf_unfiltered (file,
 810                       "gdbarch_dump: integer_to_address = <0x%lx>\n",
 811                       (long) current_gdbarch->integer_to_address);
 812   fprintf_unfiltered (file,
 813                       "gdbarch_dump: long_bit = %s\n",
 814                       paddr_d (current_gdbarch->long_bit));
 815   fprintf_unfiltered (file,
 816                       "gdbarch_dump: long_double_bit = %s\n",
 817                       paddr_d (current_gdbarch->long_double_bit));
 818   fprintf_unfiltered (file,
 819                       "gdbarch_dump: long_double_format = %s\n",
 820                       pformat (current_gdbarch->long_double_format));
 821   fprintf_unfiltered (file,
 822                       "gdbarch_dump: long_long_bit = %s\n",
 823                       paddr_d (current_gdbarch->long_long_bit));
 824   fprintf_unfiltered (file,
 825                       "gdbarch_dump: memory_insert_breakpoint = <0x%lx>\n",
 826                       (long) current_gdbarch->memory_insert_breakpoint);
 827   fprintf_unfiltered (file,
 828                       "gdbarch_dump: memory_remove_breakpoint = <0x%lx>\n",
 829                       (long) current_gdbarch->memory_remove_breakpoint);
 830   fprintf_unfiltered (file,
 831                       "gdbarch_dump: name_of_malloc = %s\n",
 832                       current_gdbarch->name_of_malloc);
 833   fprintf_unfiltered (file,
 834                       "gdbarch_dump: num_pseudo_regs = %s\n",
 835                       paddr_d (current_gdbarch->num_pseudo_regs));
 836   fprintf_unfiltered (file,
 837                       "gdbarch_dump: num_regs = %s\n",
 838                       paddr_d (current_gdbarch->num_regs));
 839   fprintf_unfiltered (file,
 840                       "gdbarch_dump: osabi = %s\n",
 841                       paddr_d (current_gdbarch->osabi));
 842   fprintf_unfiltered (file,
 843                       "gdbarch_dump: gdbarch_overlay_update_p() = %d\n",
 844                       gdbarch_overlay_update_p (current_gdbarch));
 845   fprintf_unfiltered (file,
 846                       "gdbarch_dump: overlay_update = <0x%lx>\n",
 847                       (long) current_gdbarch->overlay_update);
 848   fprintf_unfiltered (file,
 849                       "gdbarch_dump: pc_regnum = %s\n",
 850                       paddr_d (current_gdbarch->pc_regnum));
 851   fprintf_unfiltered (file,
 852                       "gdbarch_dump: pointer_to_address = <0x%lx>\n",
 853                       (long) current_gdbarch->pointer_to_address);
 854   fprintf_unfiltered (file,
 855                       "gdbarch_dump: gdbarch_print_float_info_p() = %d\n",
 856                       gdbarch_print_float_info_p (current_gdbarch));
 857   fprintf_unfiltered (file,
 858                       "gdbarch_dump: print_float_info = <0x%lx>\n",
 859                       (long) current_gdbarch->print_float_info);
 860   fprintf_unfiltered (file,
 861                       "gdbarch_dump: print_insn = <0x%lx>\n",
 862                       (long) current_gdbarch->print_insn);
 863   fprintf_unfiltered (file,
 864                       "gdbarch_dump: print_registers_info = <0x%lx>\n",
 865                       (long) current_gdbarch->print_registers_info);
 866   fprintf_unfiltered (file,
 867                       "gdbarch_dump: gdbarch_print_vector_info_p() = %d\n",
 868                       gdbarch_print_vector_info_p (current_gdbarch));
 869   fprintf_unfiltered (file,
 870                       "gdbarch_dump: print_vector_info = <0x%lx>\n",
 871                       (long) current_gdbarch->print_vector_info);
 872   fprintf_unfiltered (file,
 873                       "gdbarch_dump: ps_regnum = %s\n",
 874                       paddr_d (current_gdbarch->ps_regnum));
 875   fprintf_unfiltered (file,
 876                       "gdbarch_dump: gdbarch_pseudo_register_read_p() = %d\n",
 877                       gdbarch_pseudo_register_read_p (current_gdbarch));
 878   fprintf_unfiltered (file,
 879                       "gdbarch_dump: pseudo_register_read = <0x%lx>\n",
 880                       (long) current_gdbarch->pseudo_register_read);
 881   fprintf_unfiltered (file,
 882                       "gdbarch_dump: gdbarch_pseudo_register_write_p() = %d\n",
 883                       gdbarch_pseudo_register_write_p (current_gdbarch));
 884   fprintf_unfiltered (file,
 885                       "gdbarch_dump: pseudo_register_write = <0x%lx>\n",
 886                       (long) current_gdbarch->pseudo_register_write);
 887   fprintf_unfiltered (file,
 888                       "gdbarch_dump: ptr_bit = %s\n",
 889                       paddr_d (current_gdbarch->ptr_bit));
 890   fprintf_unfiltered (file,
 891                       "gdbarch_dump: gdbarch_push_dummy_call_p() = %d\n",
 892                       gdbarch_push_dummy_call_p (current_gdbarch));
 893   fprintf_unfiltered (file,
 894                       "gdbarch_dump: push_dummy_call = <0x%lx>\n",
 895                       (long) current_gdbarch->push_dummy_call);
 896   fprintf_unfiltered (file,
 897                       "gdbarch_dump: gdbarch_push_dummy_code_p() = %d\n",
 898                       gdbarch_push_dummy_code_p (current_gdbarch));
 899   fprintf_unfiltered (file,
 900                       "gdbarch_dump: push_dummy_code = <0x%lx>\n",
 901                       (long) current_gdbarch->push_dummy_code);
 902   fprintf_unfiltered (file,
 903                       "gdbarch_dump: gdbarch_read_pc_p() = %d\n",
 904                       gdbarch_read_pc_p (current_gdbarch));
 905   fprintf_unfiltered (file,
 906                       "gdbarch_dump: read_pc = <0x%lx>\n",
 907                       (long) current_gdbarch->read_pc);
 908   fprintf_unfiltered (file,
 909                       "gdbarch_dump: register_name = <0x%lx>\n",
 910                       (long) current_gdbarch->register_name);
 911   fprintf_unfiltered (file,
 912                       "gdbarch_dump: register_reggroup_p = <0x%lx>\n",
 913                       (long) current_gdbarch->register_reggroup_p);
 914   fprintf_unfiltered (file,
 915                       "gdbarch_dump: register_sim_regno = <0x%lx>\n",
 916                       (long) current_gdbarch->register_sim_regno);
 917   fprintf_unfiltered (file,
 918                       "gdbarch_dump: register_to_value = <0x%lx>\n",
 919                       (long) current_gdbarch->register_to_value);
 920   fprintf_unfiltered (file,
 921                       "gdbarch_dump: gdbarch_register_type_p() = %d\n",
 922                       gdbarch_register_type_p (current_gdbarch));
 923   fprintf_unfiltered (file,
 924                       "gdbarch_dump: register_type = <0x%lx>\n",
 925                       (long) current_gdbarch->register_type);
 926   fprintf_unfiltered (file,
 927                       "gdbarch_dump: gdbarch_regset_from_core_section_p() = %d\n",
 928                       gdbarch_regset_from_core_section_p (current_gdbarch));
 929   fprintf_unfiltered (file,
 930                       "gdbarch_dump: regset_from_core_section = <0x%lx>\n",
 931                       (long) current_gdbarch->regset_from_core_section);
 932   fprintf_unfiltered (file,
 933                       "gdbarch_dump: remote_register_number = <0x%lx>\n",
 934                       (long) current_gdbarch->remote_register_number);
 935   fprintf_unfiltered (file,
 936                       "gdbarch_dump: gdbarch_return_value_p() = %d\n",
 937                       gdbarch_return_value_p (current_gdbarch));
 938   fprintf_unfiltered (file,
 939                       "gdbarch_dump: return_value = <0x%lx>\n",
 940                       (long) current_gdbarch->return_value);
 941   fprintf_unfiltered (file,
 942                       "gdbarch_dump: sdb_reg_to_regnum = <0x%lx>\n",
 943                       (long) current_gdbarch->sdb_reg_to_regnum);
 944   fprintf_unfiltered (file,
 945                       "gdbarch_dump: short_bit = %s\n",
 946                       paddr_d (current_gdbarch->short_bit));
 947   fprintf_unfiltered (file,
 948                       "gdbarch_dump: gdbarch_single_step_through_delay_p() = %d\n",
 949                       gdbarch_single_step_through_delay_p (current_gdbarch));
 950   fprintf_unfiltered (file,
 951                       "gdbarch_dump: single_step_through_delay = <0x%lx>\n",
 952                       (long) current_gdbarch->single_step_through_delay);
 953   fprintf_unfiltered (file,
 954                       "gdbarch_dump: gdbarch_skip_permanent_breakpoint_p() = %d\n",
 955                       gdbarch_skip_permanent_breakpoint_p (current_gdbarch));
 956   fprintf_unfiltered (file,
 957                       "gdbarch_dump: skip_permanent_breakpoint = <0x%lx>\n",
 958                       (long) current_gdbarch->skip_permanent_breakpoint);
 959   fprintf_unfiltered (file,
 960                       "gdbarch_dump: skip_prologue = <0x%lx>\n",
 961                       (long) current_gdbarch->skip_prologue);
 962   fprintf_unfiltered (file,
 963                       "gdbarch_dump: skip_solib_resolver = <0x%lx>\n",
 964                       (long) current_gdbarch->skip_solib_resolver);
 965   fprintf_unfiltered (file,
 966                       "gdbarch_dump: skip_trampoline_code = <0x%lx>\n",
 967                       (long) current_gdbarch->skip_trampoline_code);
 968   fprintf_unfiltered (file,
 969                       "gdbarch_dump: smash_text_address = <0x%lx>\n",
 970                       (long) current_gdbarch->smash_text_address);
 971   fprintf_unfiltered (file,
 972                       "gdbarch_dump: gdbarch_software_single_step_p() = %d\n",
 973                       gdbarch_software_single_step_p (current_gdbarch));
 974   fprintf_unfiltered (file,
 975                       "gdbarch_dump: software_single_step = <0x%lx>\n",
 976                       (long) current_gdbarch->software_single_step);
 977   fprintf_unfiltered (file,
 978                       "gdbarch_dump: sp_regnum = %s\n",
 979                       paddr_d (current_gdbarch->sp_regnum));
 980   fprintf_unfiltered (file,
 981                       "gdbarch_dump: stab_reg_to_regnum = <0x%lx>\n",
 982                       (long) current_gdbarch->stab_reg_to_regnum);
 983   fprintf_unfiltered (file,
 984                       "gdbarch_dump: stabs_argument_has_addr = <0x%lx>\n",
 985                       (long) current_gdbarch->stabs_argument_has_addr);
 986   fprintf_unfiltered (file,
 987                       "gdbarch_dump: target_desc = %s\n",
 988                       paddr_d ((long) current_gdbarch->target_desc));
 989   fprintf_unfiltered (file,
 990                       "gdbarch_dump: gdbarch_unwind_dummy_id_p() = %d\n",
 991                       gdbarch_unwind_dummy_id_p (current_gdbarch));
 992   fprintf_unfiltered (file,
 993                       "gdbarch_dump: unwind_dummy_id = <0x%lx>\n",
 994                       (long) current_gdbarch->unwind_dummy_id);
 995   fprintf_unfiltered (file,
 996                       "gdbarch_dump: gdbarch_unwind_pc_p() = %d\n",
 997                       gdbarch_unwind_pc_p (current_gdbarch));
 998   fprintf_unfiltered (file,
 999                       "gdbarch_dump: unwind_pc = <0x%lx>\n",
1000                       (long) current_gdbarch->unwind_pc);
1001   fprintf_unfiltered (file,
1002                       "gdbarch_dump: gdbarch_unwind_sp_p() = %d\n",
1003                       gdbarch_unwind_sp_p (current_gdbarch));
1004   fprintf_unfiltered (file,
1005                       "gdbarch_dump: unwind_sp = <0x%lx>\n",
1006                       (long) current_gdbarch->unwind_sp);
1007   fprintf_unfiltered (file,
1008                       "gdbarch_dump: value_from_register = <0x%lx>\n",
1009                       (long) current_gdbarch->value_from_register);
1010   fprintf_unfiltered (file,
1011                       "gdbarch_dump: value_to_register = <0x%lx>\n",
1012                       (long) current_gdbarch->value_to_register);
1013   fprintf_unfiltered (file,
1014                       "gdbarch_dump: vbit_in_delta = %s\n",
1015                       paddr_d (current_gdbarch->vbit_in_delta));
1016   fprintf_unfiltered (file,
1017                       "gdbarch_dump: virtual_frame_pointer = <0x%lx>\n",
1018                       (long) current_gdbarch->virtual_frame_pointer);
1019   fprintf_unfiltered (file,
1020                       "gdbarch_dump: vtable_function_descriptors = %s\n",
1021                       paddr_d (current_gdbarch->vtable_function_descriptors));
1022   fprintf_unfiltered (file,
1023                       "gdbarch_dump: gdbarch_write_pc_p() = %d\n",
1024                       gdbarch_write_pc_p (current_gdbarch));
1025   fprintf_unfiltered (file,
1026                       "gdbarch_dump: write_pc = <0x%lx>\n",
1027                       (long) current_gdbarch->write_pc);
1028   if (current_gdbarch->dump_tdep != NULL)
1029     current_gdbarch->dump_tdep (current_gdbarch, file);
1030 }
1031
1032 struct gdbarch_tdep *
1033 gdbarch_tdep (struct gdbarch *gdbarch)
1034 {
1035   if (gdbarch_debug >= 2)
1036     fprintf_unfiltered (gdb_stdlog, "gdbarch_tdep called\n");
1037   return gdbarch->tdep;
1038 }
1039
1040
1041 const struct bfd_arch_info *
1042 gdbarch_bfd_arch_info (struct gdbarch *gdbarch)
1043 {
1044   gdb_assert (gdbarch != NULL);
1045   if (gdbarch_debug >= 2)
1046     fprintf_unfiltered (gdb_stdlog, "gdbarch_bfd_arch_info called\n");
1047   return gdbarch->bfd_arch_info;
1048 }
1049
1050 int
1051 gdbarch_byte_order (struct gdbarch *gdbarch)
1052 {
1053   gdb_assert (gdbarch != NULL);
1054   if (gdbarch_debug >= 2)
1055     fprintf_unfiltered (gdb_stdlog, "gdbarch_byte_order called\n");
1056   return gdbarch->byte_order;
1057 }
1058
1059 enum gdb_osabi
1060 gdbarch_osabi (struct gdbarch *gdbarch)
1061 {
1062   gdb_assert (gdbarch != NULL);
1063   if (gdbarch_debug >= 2)
1064     fprintf_unfiltered (gdb_stdlog, "gdbarch_osabi called\n");
1065   return gdbarch->osabi;
1066 }
1067
1068 const struct target_desc *
1069 gdbarch_target_desc (struct gdbarch *gdbarch)
1070 {
1071   gdb_assert (gdbarch != NULL);
1072   if (gdbarch_debug >= 2)
1073     fprintf_unfiltered (gdb_stdlog, "gdbarch_target_desc called\n");
1074   return gdbarch->target_desc;
1075 }
1076
1077 int
1078 gdbarch_short_bit (struct gdbarch *gdbarch)
1079 {
1080   gdb_assert (gdbarch != NULL);
1081   /* Skip verify of short_bit, invalid_p == 0 */
1082   if (gdbarch_debug >= 2)
1083     fprintf_unfiltered (gdb_stdlog, "gdbarch_short_bit called\n");
1084   return gdbarch->short_bit;
1085 }
1086
1087 void
1088 set_gdbarch_short_bit (struct gdbarch *gdbarch,
1089                        int short_bit)
1090 {
1091   gdbarch->short_bit = short_bit;
1092 }
1093
1094 int
1095 gdbarch_int_bit (struct gdbarch *gdbarch)
1096 {
1097   gdb_assert (gdbarch != NULL);
1098   /* Skip verify of int_bit, invalid_p == 0 */
1099   if (gdbarch_debug >= 2)
1100     fprintf_unfiltered (gdb_stdlog, "gdbarch_int_bit called\n");
1101   return gdbarch->int_bit;
1102 }
1103
1104 void
1105 set_gdbarch_int_bit (struct gdbarch *gdbarch,
1106                      int int_bit)
1107 {
1108   gdbarch->int_bit = int_bit;
1109 }
1110
1111 int
1112 gdbarch_long_bit (struct gdbarch *gdbarch)
1113 {
1114   gdb_assert (gdbarch != NULL);
1115   /* Skip verify of long_bit, invalid_p == 0 */
1116   if (gdbarch_debug >= 2)
1117     fprintf_unfiltered (gdb_stdlog, "gdbarch_long_bit called\n");
1118   return gdbarch->long_bit;
1119 }
1120
1121 void
1122 set_gdbarch_long_bit (struct gdbarch *gdbarch,
1123                       int long_bit)
1124 {
1125   gdbarch->long_bit = long_bit;
1126 }
1127
1128 int
1129 gdbarch_long_long_bit (struct gdbarch *gdbarch)
1130 {
1131   gdb_assert (gdbarch != NULL);
1132   /* Skip verify of long_long_bit, invalid_p == 0 */
1133   if (gdbarch_debug >= 2)
1134     fprintf_unfiltered (gdb_stdlog, "gdbarch_long_long_bit called\n");
1135   return gdbarch->long_long_bit;
1136 }
1137
1138 void
1139 set_gdbarch_long_long_bit (struct gdbarch *gdbarch,
1140                            int long_long_bit)
1141 {
1142   gdbarch->long_long_bit = long_long_bit;
1143 }
1144
1145 int
1146 gdbarch_float_bit (struct gdbarch *gdbarch)
1147 {
1148   gdb_assert (gdbarch != NULL);
1149   /* Skip verify of float_bit, invalid_p == 0 */
1150   if (gdbarch_debug >= 2)
1151     fprintf_unfiltered (gdb_stdlog, "gdbarch_float_bit called\n");
1152   return gdbarch->float_bit;
1153 }
1154
1155 void
1156 set_gdbarch_float_bit (struct gdbarch *gdbarch,
1157                        int float_bit)
1158 {
1159   gdbarch->float_bit = float_bit;
1160 }
1161
1162 const struct floatformat **
1163 gdbarch_float_format (struct gdbarch *gdbarch)
1164 {
1165   gdb_assert (gdbarch != NULL);
1166   if (gdbarch_debug >= 2)
1167     fprintf_unfiltered (gdb_stdlog, "gdbarch_float_format called\n");
1168   return gdbarch->float_format;
1169 }
1170
1171 void
1172 set_gdbarch_float_format (struct gdbarch *gdbarch,
1173                           const struct floatformat ** float_format)
1174 {
1175   gdbarch->float_format = float_format;
1176 }
1177
1178 int
1179 gdbarch_double_bit (struct gdbarch *gdbarch)
1180 {
1181   gdb_assert (gdbarch != NULL);
1182   /* Skip verify of double_bit, invalid_p == 0 */
1183   if (gdbarch_debug >= 2)
1184     fprintf_unfiltered (gdb_stdlog, "gdbarch_double_bit called\n");
1185   return gdbarch->double_bit;
1186 }
1187
1188 void
1189 set_gdbarch_double_bit (struct gdbarch *gdbarch,
1190                         int double_bit)
1191 {
1192   gdbarch->double_bit = double_bit;
1193 }
1194
1195 const struct floatformat **
1196 gdbarch_double_format (struct gdbarch *gdbarch)
1197 {
1198   gdb_assert (gdbarch != NULL);
1199   if (gdbarch_debug >= 2)
1200     fprintf_unfiltered (gdb_stdlog, "gdbarch_double_format called\n");
1201   return gdbarch->double_format;
1202 }
1203
1204 void
1205 set_gdbarch_double_format (struct gdbarch *gdbarch,
1206                            const struct floatformat ** double_format)
1207 {
1208   gdbarch->double_format = double_format;
1209 }
1210
1211 int
1212 gdbarch_long_double_bit (struct gdbarch *gdbarch)
1213 {
1214   gdb_assert (gdbarch != NULL);
1215   /* Skip verify of long_double_bit, invalid_p == 0 */
1216   if (gdbarch_debug >= 2)
1217     fprintf_unfiltered (gdb_stdlog, "gdbarch_long_double_bit called\n");
1218   return gdbarch->long_double_bit;
1219 }
1220
1221 void
1222 set_gdbarch_long_double_bit (struct gdbarch *gdbarch,
1223                              int long_double_bit)
1224 {
1225   gdbarch->long_double_bit = long_double_bit;
1226 }
1227
1228 const struct floatformat **
1229 gdbarch_long_double_format (struct gdbarch *gdbarch)
1230 {
1231   gdb_assert (gdbarch != NULL);
1232   if (gdbarch_debug >= 2)
1233     fprintf_unfiltered (gdb_stdlog, "gdbarch_long_double_format called\n");
1234   return gdbarch->long_double_format;
1235 }
1236
1237 void
1238 set_gdbarch_long_double_format (struct gdbarch *gdbarch,
1239                                 const struct floatformat ** long_double_format)
1240 {
1241   gdbarch->long_double_format = long_double_format;
1242 }
1243
1244 int
1245 gdbarch_ptr_bit (struct gdbarch *gdbarch)
1246 {
1247   gdb_assert (gdbarch != NULL);
1248   /* Skip verify of ptr_bit, invalid_p == 0 */
1249   if (gdbarch_debug >= 2)
1250     fprintf_unfiltered (gdb_stdlog, "gdbarch_ptr_bit called\n");
1251   return gdbarch->ptr_bit;
1252 }
1253
1254 void
1255 set_gdbarch_ptr_bit (struct gdbarch *gdbarch,
1256                      int ptr_bit)
1257 {
1258   gdbarch->ptr_bit = ptr_bit;
1259 }
1260
1261 int
1262 gdbarch_addr_bit (struct gdbarch *gdbarch)
1263 {
1264   gdb_assert (gdbarch != NULL);
1265   /* Check variable changed from pre-default.  */
1266   gdb_assert (gdbarch->addr_bit != 0);
1267   if (gdbarch_debug >= 2)
1268     fprintf_unfiltered (gdb_stdlog, "gdbarch_addr_bit called\n");
1269   return gdbarch->addr_bit;
1270 }
1271
1272 void
1273 set_gdbarch_addr_bit (struct gdbarch *gdbarch,
1274                       int addr_bit)
1275 {
1276   gdbarch->addr_bit = addr_bit;
1277 }
1278
1279 int
1280 gdbarch_char_signed (struct gdbarch *gdbarch)
1281 {
1282   gdb_assert (gdbarch != NULL);
1283   /* Check variable changed from pre-default.  */
1284   gdb_assert (gdbarch->char_signed != -1);
1285   if (gdbarch_debug >= 2)
1286     fprintf_unfiltered (gdb_stdlog, "gdbarch_char_signed called\n");
1287   return gdbarch->char_signed;
1288 }
1289
1290 void
1291 set_gdbarch_char_signed (struct gdbarch *gdbarch,
1292                          int char_signed)
1293 {
1294   gdbarch->char_signed = char_signed;
1295 }
1296
1297 int
1298 gdbarch_read_pc_p (struct gdbarch *gdbarch)
1299 {
1300   gdb_assert (gdbarch != NULL);
1301   return gdbarch->read_pc != NULL;
1302 }
1303
1304 CORE_ADDR
1305 gdbarch_read_pc (struct gdbarch *gdbarch, struct regcache *regcache)
1306 {
1307   gdb_assert (gdbarch != NULL);
1308   gdb_assert (gdbarch->read_pc != NULL);
1309   if (gdbarch_debug >= 2)
1310     fprintf_unfiltered (gdb_stdlog, "gdbarch_read_pc called\n");
1311   return gdbarch->read_pc (regcache);
1312 }
1313
1314 void
1315 set_gdbarch_read_pc (struct gdbarch *gdbarch,
1316                      gdbarch_read_pc_ftype read_pc)
1317 {
1318   gdbarch->read_pc = read_pc;
1319 }
1320
1321 int
1322 gdbarch_write_pc_p (struct gdbarch *gdbarch)
1323 {
1324   gdb_assert (gdbarch != NULL);
1325   return gdbarch->write_pc != NULL;
1326 }
1327
1328 void
1329 gdbarch_write_pc (struct gdbarch *gdbarch, struct regcache *regcache, CORE_ADDR val)
1330 {
1331   gdb_assert (gdbarch != NULL);
1332   gdb_assert (gdbarch->write_pc != NULL);
1333   if (gdbarch_debug >= 2)
1334     fprintf_unfiltered (gdb_stdlog, "gdbarch_write_pc called\n");
1335   gdbarch->write_pc (regcache, val);
1336 }
1337
1338 void
1339 set_gdbarch_write_pc (struct gdbarch *gdbarch,
1340                       gdbarch_write_pc_ftype write_pc)
1341 {
1342   gdbarch->write_pc = write_pc;
1343 }
1344
1345 void
1346 gdbarch_virtual_frame_pointer (struct gdbarch *gdbarch, CORE_ADDR pc, int *frame_regnum, LONGEST *frame_offset)
1347 {
1348   gdb_assert (gdbarch != NULL);
1349   gdb_assert (gdbarch->virtual_frame_pointer != NULL);
1350   if (gdbarch_debug >= 2)
1351     fprintf_unfiltered (gdb_stdlog, "gdbarch_virtual_frame_pointer called\n");
1352   gdbarch->virtual_frame_pointer (pc, frame_regnum, frame_offset);
1353 }
1354
1355 void
1356 set_gdbarch_virtual_frame_pointer (struct gdbarch *gdbarch,
1357                                    gdbarch_virtual_frame_pointer_ftype virtual_frame_pointer)
1358 {
1359   gdbarch->virtual_frame_pointer = virtual_frame_pointer;
1360 }
1361
1362 int
1363 gdbarch_pseudo_register_read_p (struct gdbarch *gdbarch)
1364 {
1365   gdb_assert (gdbarch != NULL);
1366   return gdbarch->pseudo_register_read != NULL;
1367 }
1368
1369 void
1370 gdbarch_pseudo_register_read (struct gdbarch *gdbarch, struct regcache *regcache, int cookednum, gdb_byte *buf)
1371 {
1372   gdb_assert (gdbarch != NULL);
1373   gdb_assert (gdbarch->pseudo_register_read != NULL);
1374   if (gdbarch_debug >= 2)
1375     fprintf_unfiltered (gdb_stdlog, "gdbarch_pseudo_register_read called\n");
1376   gdbarch->pseudo_register_read (gdbarch, regcache, cookednum, buf);
1377 }
1378
1379 void
1380 set_gdbarch_pseudo_register_read (struct gdbarch *gdbarch,
1381                                   gdbarch_pseudo_register_read_ftype pseudo_register_read)
1382 {
1383   gdbarch->pseudo_register_read = pseudo_register_read;
1384 }
1385
1386 int
1387 gdbarch_pseudo_register_write_p (struct gdbarch *gdbarch)
1388 {
1389   gdb_assert (gdbarch != NULL);
1390   return gdbarch->pseudo_register_write != NULL;
1391 }
1392
1393 void
1394 gdbarch_pseudo_register_write (struct gdbarch *gdbarch, struct regcache *regcache, int cookednum, const gdb_byte *buf)
1395 {
1396   gdb_assert (gdbarch != NULL);
1397   gdb_assert (gdbarch->pseudo_register_write != NULL);
1398   if (gdbarch_debug >= 2)
1399     fprintf_unfiltered (gdb_stdlog, "gdbarch_pseudo_register_write called\n");
1400   gdbarch->pseudo_register_write (gdbarch, regcache, cookednum, buf);
1401 }
1402
1403 void
1404 set_gdbarch_pseudo_register_write (struct gdbarch *gdbarch,
1405                                    gdbarch_pseudo_register_write_ftype pseudo_register_write)
1406 {
1407   gdbarch->pseudo_register_write = pseudo_register_write;
1408 }
1409
1410 int
1411 gdbarch_num_regs (struct gdbarch *gdbarch)
1412 {
1413   gdb_assert (gdbarch != NULL);
1414   /* Check variable changed from pre-default.  */
1415   gdb_assert (gdbarch->num_regs != -1);
1416   if (gdbarch_debug >= 2)
1417     fprintf_unfiltered (gdb_stdlog, "gdbarch_num_regs called\n");
1418   return gdbarch->num_regs;
1419 }
1420
1421 void
1422 set_gdbarch_num_regs (struct gdbarch *gdbarch,
1423                       int num_regs)
1424 {
1425   gdbarch->num_regs = num_regs;
1426 }
1427
1428 int
1429 gdbarch_num_pseudo_regs (struct gdbarch *gdbarch)
1430 {
1431   gdb_assert (gdbarch != NULL);
1432   /* Skip verify of num_pseudo_regs, invalid_p == 0 */
1433   if (gdbarch_debug >= 2)
1434     fprintf_unfiltered (gdb_stdlog, "gdbarch_num_pseudo_regs called\n");
1435   return gdbarch->num_pseudo_regs;
1436 }
1437
1438 void
1439 set_gdbarch_num_pseudo_regs (struct gdbarch *gdbarch,
1440                              int num_pseudo_regs)
1441 {
1442   gdbarch->num_pseudo_regs = num_pseudo_regs;
1443 }
1444
1445 int
1446 gdbarch_sp_regnum (struct gdbarch *gdbarch)
1447 {
1448   gdb_assert (gdbarch != NULL);
1449   /* Skip verify of sp_regnum, invalid_p == 0 */
1450   if (gdbarch_debug >= 2)
1451     fprintf_unfiltered (gdb_stdlog, "gdbarch_sp_regnum called\n");
1452   return gdbarch->sp_regnum;
1453 }
1454
1455 void
1456 set_gdbarch_sp_regnum (struct gdbarch *gdbarch,
1457                        int sp_regnum)
1458 {
1459   gdbarch->sp_regnum = sp_regnum;
1460 }
1461
1462 int
1463 gdbarch_pc_regnum (struct gdbarch *gdbarch)
1464 {
1465   gdb_assert (gdbarch != NULL);
1466   /* Skip verify of pc_regnum, invalid_p == 0 */
1467   if (gdbarch_debug >= 2)
1468     fprintf_unfiltered (gdb_stdlog, "gdbarch_pc_regnum called\n");
1469   return gdbarch->pc_regnum;
1470 }
1471
1472 void
1473 set_gdbarch_pc_regnum (struct gdbarch *gdbarch,
1474                        int pc_regnum)
1475 {
1476   gdbarch->pc_regnum = pc_regnum;
1477 }
1478
1479 int
1480 gdbarch_ps_regnum (struct gdbarch *gdbarch)
1481 {
1482   gdb_assert (gdbarch != NULL);
1483   /* Skip verify of ps_regnum, invalid_p == 0 */
1484   if (gdbarch_debug >= 2)
1485     fprintf_unfiltered (gdb_stdlog, "gdbarch_ps_regnum called\n");
1486   return gdbarch->ps_regnum;
1487 }
1488
1489 void
1490 set_gdbarch_ps_regnum (struct gdbarch *gdbarch,
1491                        int ps_regnum)
1492 {
1493   gdbarch->ps_regnum = ps_regnum;
1494 }
1495
1496 int
1497 gdbarch_fp0_regnum (struct gdbarch *gdbarch)
1498 {
1499   gdb_assert (gdbarch != NULL);
1500   /* Skip verify of fp0_regnum, invalid_p == 0 */
1501   if (gdbarch_debug >= 2)
1502     fprintf_unfiltered (gdb_stdlog, "gdbarch_fp0_regnum called\n");
1503   return gdbarch->fp0_regnum;
1504 }
1505
1506 void
1507 set_gdbarch_fp0_regnum (struct gdbarch *gdbarch,
1508                         int fp0_regnum)
1509 {
1510   gdbarch->fp0_regnum = fp0_regnum;
1511 }
1512
1513 int
1514 gdbarch_stab_reg_to_regnum (struct gdbarch *gdbarch, int stab_regnr)
1515 {
1516   gdb_assert (gdbarch != NULL);
1517   gdb_assert (gdbarch->stab_reg_to_regnum != NULL);
1518   if (gdbarch_debug >= 2)
1519     fprintf_unfiltered (gdb_stdlog, "gdbarch_stab_reg_to_regnum called\n");
1520   return gdbarch->stab_reg_to_regnum (stab_regnr);
1521 }
1522
1523 void
1524 set_gdbarch_stab_reg_to_regnum (struct gdbarch *gdbarch,
1525                                 gdbarch_stab_reg_to_regnum_ftype stab_reg_to_regnum)
1526 {
1527   gdbarch->stab_reg_to_regnum = stab_reg_to_regnum;
1528 }
1529
1530 int
1531 gdbarch_ecoff_reg_to_regnum (struct gdbarch *gdbarch, int ecoff_regnr)
1532 {
1533   gdb_assert (gdbarch != NULL);
1534   gdb_assert (gdbarch->ecoff_reg_to_regnum != NULL);
1535   if (gdbarch_debug >= 2)
1536     fprintf_unfiltered (gdb_stdlog, "gdbarch_ecoff_reg_to_regnum called\n");
1537   return gdbarch->ecoff_reg_to_regnum (ecoff_regnr);
1538 }
1539
1540 void
1541 set_gdbarch_ecoff_reg_to_regnum (struct gdbarch *gdbarch,
1542                                  gdbarch_ecoff_reg_to_regnum_ftype ecoff_reg_to_regnum)
1543 {
1544   gdbarch->ecoff_reg_to_regnum = ecoff_reg_to_regnum;
1545 }
1546
1547 int
1548 gdbarch_dwarf_reg_to_regnum (struct gdbarch *gdbarch, int dwarf_regnr)
1549 {
1550   gdb_assert (gdbarch != NULL);
1551   gdb_assert (gdbarch->dwarf_reg_to_regnum != NULL);
1552   if (gdbarch_debug >= 2)
1553     fprintf_unfiltered (gdb_stdlog, "gdbarch_dwarf_reg_to_regnum called\n");
1554   return gdbarch->dwarf_reg_to_regnum (dwarf_regnr);
1555 }
1556
1557 void
1558 set_gdbarch_dwarf_reg_to_regnum (struct gdbarch *gdbarch,
1559                                  gdbarch_dwarf_reg_to_regnum_ftype dwarf_reg_to_regnum)
1560 {
1561   gdbarch->dwarf_reg_to_regnum = dwarf_reg_to_regnum;
1562 }
1563
1564 int
1565 gdbarch_sdb_reg_to_regnum (struct gdbarch *gdbarch, int sdb_regnr)
1566 {
1567   gdb_assert (gdbarch != NULL);
1568   gdb_assert (gdbarch->sdb_reg_to_regnum != NULL);
1569   if (gdbarch_debug >= 2)
1570     fprintf_unfiltered (gdb_stdlog, "gdbarch_sdb_reg_to_regnum called\n");
1571   return gdbarch->sdb_reg_to_regnum (sdb_regnr);
1572 }
1573
1574 void
1575 set_gdbarch_sdb_reg_to_regnum (struct gdbarch *gdbarch,
1576                                gdbarch_sdb_reg_to_regnum_ftype sdb_reg_to_regnum)
1577 {
1578   gdbarch->sdb_reg_to_regnum = sdb_reg_to_regnum;
1579 }
1580
1581 int
1582 gdbarch_dwarf2_reg_to_regnum (struct gdbarch *gdbarch, int dwarf2_regnr)
1583 {
1584   gdb_assert (gdbarch != NULL);
1585   gdb_assert (gdbarch->dwarf2_reg_to_regnum != NULL);
1586   if (gdbarch_debug >= 2)
1587     fprintf_unfiltered (gdb_stdlog, "gdbarch_dwarf2_reg_to_regnum called\n");
1588   return gdbarch->dwarf2_reg_to_regnum (dwarf2_regnr);
1589 }
1590
1591 void
1592 set_gdbarch_dwarf2_reg_to_regnum (struct gdbarch *gdbarch,
1593                                   gdbarch_dwarf2_reg_to_regnum_ftype dwarf2_reg_to_regnum)
1594 {
1595   gdbarch->dwarf2_reg_to_regnum = dwarf2_reg_to_regnum;
1596 }
1597
1598 const char *
1599 gdbarch_register_name (struct gdbarch *gdbarch, int regnr)
1600 {
1601   gdb_assert (gdbarch != NULL);
1602   gdb_assert (gdbarch->register_name != NULL);
1603   if (gdbarch_debug >= 2)
1604     fprintf_unfiltered (gdb_stdlog, "gdbarch_register_name called\n");
1605   return gdbarch->register_name (regnr);
1606 }
1607
1608 void
1609 set_gdbarch_register_name (struct gdbarch *gdbarch,
1610                            gdbarch_register_name_ftype register_name)
1611 {
1612   gdbarch->register_name = register_name;
1613 }
1614
1615 int
1616 gdbarch_register_type_p (struct gdbarch *gdbarch)
1617 {
1618   gdb_assert (gdbarch != NULL);
1619   return gdbarch->register_type != NULL;
1620 }
1621
1622 struct type *
1623 gdbarch_register_type (struct gdbarch *gdbarch, int reg_nr)
1624 {
1625   gdb_assert (gdbarch != NULL);
1626   gdb_assert (gdbarch->register_type != NULL);
1627   if (gdbarch_debug >= 2)
1628     fprintf_unfiltered (gdb_stdlog, "gdbarch_register_type called\n");
1629   return gdbarch->register_type (gdbarch, reg_nr);
1630 }
1631
1632 void
1633 set_gdbarch_register_type (struct gdbarch *gdbarch,
1634                            gdbarch_register_type_ftype register_type)
1635 {
1636   gdbarch->register_type = register_type;
1637 }
1638
1639 int
1640 gdbarch_unwind_dummy_id_p (struct gdbarch *gdbarch)
1641 {
1642   gdb_assert (gdbarch != NULL);
1643   return gdbarch->unwind_dummy_id != NULL;
1644 }
1645
1646 struct frame_id
1647 gdbarch_unwind_dummy_id (struct gdbarch *gdbarch, struct frame_info *info)
1648 {
1649   gdb_assert (gdbarch != NULL);
1650   gdb_assert (gdbarch->unwind_dummy_id != NULL);
1651   if (gdbarch_debug >= 2)
1652     fprintf_unfiltered (gdb_stdlog, "gdbarch_unwind_dummy_id called\n");
1653   return gdbarch->unwind_dummy_id (gdbarch, info);
1654 }
1655
1656 void
1657 set_gdbarch_unwind_dummy_id (struct gdbarch *gdbarch,
1658                              gdbarch_unwind_dummy_id_ftype unwind_dummy_id)
1659 {
1660   gdbarch->unwind_dummy_id = unwind_dummy_id;
1661 }
1662
1663 int
1664 gdbarch_deprecated_fp_regnum (struct gdbarch *gdbarch)
1665 {
1666   gdb_assert (gdbarch != NULL);
1667   /* Skip verify of deprecated_fp_regnum, invalid_p == 0 */
1668   if (gdbarch_debug >= 2)
1669     fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_fp_regnum called\n");
1670   return gdbarch->deprecated_fp_regnum;
1671 }
1672
1673 void
1674 set_gdbarch_deprecated_fp_regnum (struct gdbarch *gdbarch,
1675                                   int deprecated_fp_regnum)
1676 {
1677   gdbarch->deprecated_fp_regnum = deprecated_fp_regnum;
1678 }
1679
1680 int
1681 gdbarch_push_dummy_call_p (struct gdbarch *gdbarch)
1682 {
1683   gdb_assert (gdbarch != NULL);
1684   return gdbarch->push_dummy_call != NULL;
1685 }
1686
1687 CORE_ADDR
1688 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)
1689 {
1690   gdb_assert (gdbarch != NULL);
1691   gdb_assert (gdbarch->push_dummy_call != NULL);
1692   if (gdbarch_debug >= 2)
1693     fprintf_unfiltered (gdb_stdlog, "gdbarch_push_dummy_call called\n");
1694   return gdbarch->push_dummy_call (gdbarch, function, regcache, bp_addr, nargs, args, sp, struct_return, struct_addr);
1695 }
1696
1697 void
1698 set_gdbarch_push_dummy_call (struct gdbarch *gdbarch,
1699                              gdbarch_push_dummy_call_ftype push_dummy_call)
1700 {
1701   gdbarch->push_dummy_call = push_dummy_call;
1702 }
1703
1704 int
1705 gdbarch_call_dummy_location (struct gdbarch *gdbarch)
1706 {
1707   gdb_assert (gdbarch != NULL);
1708   /* Skip verify of call_dummy_location, invalid_p == 0 */
1709   if (gdbarch_debug >= 2)
1710     fprintf_unfiltered (gdb_stdlog, "gdbarch_call_dummy_location called\n");
1711   return gdbarch->call_dummy_location;
1712 }
1713
1714 void
1715 set_gdbarch_call_dummy_location (struct gdbarch *gdbarch,
1716                                  int call_dummy_location)
1717 {
1718   gdbarch->call_dummy_location = call_dummy_location;
1719 }
1720
1721 int
1722 gdbarch_push_dummy_code_p (struct gdbarch *gdbarch)
1723 {
1724   gdb_assert (gdbarch != NULL);
1725   return gdbarch->push_dummy_code != NULL;
1726 }
1727
1728 CORE_ADDR
1729 gdbarch_push_dummy_code (struct gdbarch *gdbarch, CORE_ADDR sp, CORE_ADDR funaddr, struct value **args, int nargs, struct type *value_type, CORE_ADDR *real_pc, CORE_ADDR *bp_addr, struct regcache *regcache)
1730 {
1731   gdb_assert (gdbarch != NULL);
1732   gdb_assert (gdbarch->push_dummy_code != NULL);
1733   if (gdbarch_debug >= 2)
1734     fprintf_unfiltered (gdb_stdlog, "gdbarch_push_dummy_code called\n");
1735   return gdbarch->push_dummy_code (gdbarch, sp, funaddr, args, nargs, value_type, real_pc, bp_addr, regcache);
1736 }
1737
1738 void
1739 set_gdbarch_push_dummy_code (struct gdbarch *gdbarch,
1740                              gdbarch_push_dummy_code_ftype push_dummy_code)
1741 {
1742   gdbarch->push_dummy_code = push_dummy_code;
1743 }
1744
1745 void
1746 gdbarch_print_registers_info (struct gdbarch *gdbarch, struct ui_file *file, struct frame_info *frame, int regnum, int all)
1747 {
1748   gdb_assert (gdbarch != NULL);
1749   gdb_assert (gdbarch->print_registers_info != NULL);
1750   if (gdbarch_debug >= 2)
1751     fprintf_unfiltered (gdb_stdlog, "gdbarch_print_registers_info called\n");
1752   gdbarch->print_registers_info (gdbarch, file, frame, regnum, all);
1753 }
1754
1755 void
1756 set_gdbarch_print_registers_info (struct gdbarch *gdbarch,
1757                                   gdbarch_print_registers_info_ftype print_registers_info)
1758 {
1759   gdbarch->print_registers_info = print_registers_info;
1760 }
1761
1762 int
1763 gdbarch_print_float_info_p (struct gdbarch *gdbarch)
1764 {
1765   gdb_assert (gdbarch != NULL);
1766   return gdbarch->print_float_info != NULL;
1767 }
1768
1769 void
1770 gdbarch_print_float_info (struct gdbarch *gdbarch, struct ui_file *file, struct frame_info *frame, const char *args)
1771 {
1772   gdb_assert (gdbarch != NULL);
1773   gdb_assert (gdbarch->print_float_info != NULL);
1774   if (gdbarch_debug >= 2)
1775     fprintf_unfiltered (gdb_stdlog, "gdbarch_print_float_info called\n");
1776   gdbarch->print_float_info (gdbarch, file, frame, args);
1777 }
1778
1779 void
1780 set_gdbarch_print_float_info (struct gdbarch *gdbarch,
1781                               gdbarch_print_float_info_ftype print_float_info)
1782 {
1783   gdbarch->print_float_info = print_float_info;
1784 }
1785
1786 int
1787 gdbarch_print_vector_info_p (struct gdbarch *gdbarch)
1788 {
1789   gdb_assert (gdbarch != NULL);
1790   return gdbarch->print_vector_info != NULL;
1791 }
1792
1793 void
1794 gdbarch_print_vector_info (struct gdbarch *gdbarch, struct ui_file *file, struct frame_info *frame, const char *args)
1795 {
1796   gdb_assert (gdbarch != NULL);
1797   gdb_assert (gdbarch->print_vector_info != NULL);
1798   if (gdbarch_debug >= 2)
1799     fprintf_unfiltered (gdb_stdlog, "gdbarch_print_vector_info called\n");
1800   gdbarch->print_vector_info (gdbarch, file, frame, args);
1801 }
1802
1803 void
1804 set_gdbarch_print_vector_info (struct gdbarch *gdbarch,
1805                                gdbarch_print_vector_info_ftype print_vector_info)
1806 {
1807   gdbarch->print_vector_info = print_vector_info;
1808 }
1809
1810 int
1811 gdbarch_register_sim_regno (struct gdbarch *gdbarch, int reg_nr)
1812 {
1813   gdb_assert (gdbarch != NULL);
1814   gdb_assert (gdbarch->register_sim_regno != NULL);
1815   if (gdbarch_debug >= 2)
1816     fprintf_unfiltered (gdb_stdlog, "gdbarch_register_sim_regno called\n");
1817   return gdbarch->register_sim_regno (reg_nr);
1818 }
1819
1820 void
1821 set_gdbarch_register_sim_regno (struct gdbarch *gdbarch,
1822                                 gdbarch_register_sim_regno_ftype register_sim_regno)
1823 {
1824   gdbarch->register_sim_regno = register_sim_regno;
1825 }
1826
1827 int
1828 gdbarch_cannot_fetch_register (struct gdbarch *gdbarch, int regnum)
1829 {
1830   gdb_assert (gdbarch != NULL);
1831   gdb_assert (gdbarch->cannot_fetch_register != NULL);
1832   if (gdbarch_debug >= 2)
1833     fprintf_unfiltered (gdb_stdlog, "gdbarch_cannot_fetch_register called\n");
1834   return gdbarch->cannot_fetch_register (regnum);
1835 }
1836
1837 void
1838 set_gdbarch_cannot_fetch_register (struct gdbarch *gdbarch,
1839                                    gdbarch_cannot_fetch_register_ftype cannot_fetch_register)
1840 {
1841   gdbarch->cannot_fetch_register = cannot_fetch_register;
1842 }
1843
1844 int
1845 gdbarch_cannot_store_register (struct gdbarch *gdbarch, int regnum)
1846 {
1847   gdb_assert (gdbarch != NULL);
1848   gdb_assert (gdbarch->cannot_store_register != NULL);
1849   if (gdbarch_debug >= 2)
1850     fprintf_unfiltered (gdb_stdlog, "gdbarch_cannot_store_register called\n");
1851   return gdbarch->cannot_store_register (regnum);
1852 }
1853
1854 void
1855 set_gdbarch_cannot_store_register (struct gdbarch *gdbarch,
1856                                    gdbarch_cannot_store_register_ftype cannot_store_register)
1857 {
1858   gdbarch->cannot_store_register = cannot_store_register;
1859 }
1860
1861 int
1862 gdbarch_get_longjmp_target_p (struct gdbarch *gdbarch)
1863 {
1864   gdb_assert (gdbarch != NULL);
1865   return gdbarch->get_longjmp_target != NULL;
1866 }
1867
1868 int
1869 gdbarch_get_longjmp_target (struct gdbarch *gdbarch, struct frame_info *frame, CORE_ADDR *pc)
1870 {
1871   gdb_assert (gdbarch != NULL);
1872   gdb_assert (gdbarch->get_longjmp_target != NULL);
1873   if (gdbarch_debug >= 2)
1874     fprintf_unfiltered (gdb_stdlog, "gdbarch_get_longjmp_target called\n");
1875   return gdbarch->get_longjmp_target (frame, pc);
1876 }
1877
1878 void
1879 set_gdbarch_get_longjmp_target (struct gdbarch *gdbarch,
1880                                 gdbarch_get_longjmp_target_ftype get_longjmp_target)
1881 {
1882   gdbarch->get_longjmp_target = get_longjmp_target;
1883 }
1884
1885 int
1886 gdbarch_believe_pcc_promotion (struct gdbarch *gdbarch)
1887 {
1888   gdb_assert (gdbarch != NULL);
1889   if (gdbarch_debug >= 2)
1890     fprintf_unfiltered (gdb_stdlog, "gdbarch_believe_pcc_promotion called\n");
1891   return gdbarch->believe_pcc_promotion;
1892 }
1893
1894 void
1895 set_gdbarch_believe_pcc_promotion (struct gdbarch *gdbarch,
1896                                    int believe_pcc_promotion)
1897 {
1898   gdbarch->believe_pcc_promotion = believe_pcc_promotion;
1899 }
1900
1901 int
1902 gdbarch_convert_register_p (struct gdbarch *gdbarch, int regnum, struct type *type)
1903 {
1904   gdb_assert (gdbarch != NULL);
1905   gdb_assert (gdbarch->convert_register_p != NULL);
1906   if (gdbarch_debug >= 2)
1907     fprintf_unfiltered (gdb_stdlog, "gdbarch_convert_register_p called\n");
1908   return gdbarch->convert_register_p (regnum, type);
1909 }
1910
1911 void
1912 set_gdbarch_convert_register_p (struct gdbarch *gdbarch,
1913                                 gdbarch_convert_register_p_ftype convert_register_p)
1914 {
1915   gdbarch->convert_register_p = convert_register_p;
1916 }
1917
1918 void
1919 gdbarch_register_to_value (struct gdbarch *gdbarch, struct frame_info *frame, int regnum, struct type *type, gdb_byte *buf)
1920 {
1921   gdb_assert (gdbarch != NULL);
1922   gdb_assert (gdbarch->register_to_value != NULL);
1923   if (gdbarch_debug >= 2)
1924     fprintf_unfiltered (gdb_stdlog, "gdbarch_register_to_value called\n");
1925   gdbarch->register_to_value (frame, regnum, type, buf);
1926 }
1927
1928 void
1929 set_gdbarch_register_to_value (struct gdbarch *gdbarch,
1930                                gdbarch_register_to_value_ftype register_to_value)
1931 {
1932   gdbarch->register_to_value = register_to_value;
1933 }
1934
1935 void
1936 gdbarch_value_to_register (struct gdbarch *gdbarch, struct frame_info *frame, int regnum, struct type *type, const gdb_byte *buf)
1937 {
1938   gdb_assert (gdbarch != NULL);
1939   gdb_assert (gdbarch->value_to_register != NULL);
1940   if (gdbarch_debug >= 2)
1941     fprintf_unfiltered (gdb_stdlog, "gdbarch_value_to_register called\n");
1942   gdbarch->value_to_register (frame, regnum, type, buf);
1943 }
1944
1945 void
1946 set_gdbarch_value_to_register (struct gdbarch *gdbarch,
1947                                gdbarch_value_to_register_ftype value_to_register)
1948 {
1949   gdbarch->value_to_register = value_to_register;
1950 }
1951
1952 struct value *
1953 gdbarch_value_from_register (struct gdbarch *gdbarch, struct type *type, int regnum, struct frame_info *frame)
1954 {
1955   gdb_assert (gdbarch != NULL);
1956   gdb_assert (gdbarch->value_from_register != NULL);
1957   if (gdbarch_debug >= 2)
1958     fprintf_unfiltered (gdb_stdlog, "gdbarch_value_from_register called\n");
1959   return gdbarch->value_from_register (type, regnum, frame);
1960 }
1961
1962 void
1963 set_gdbarch_value_from_register (struct gdbarch *gdbarch,
1964                                  gdbarch_value_from_register_ftype value_from_register)
1965 {
1966   gdbarch->value_from_register = value_from_register;
1967 }
1968
1969 CORE_ADDR
1970 gdbarch_pointer_to_address (struct gdbarch *gdbarch, struct type *type, const gdb_byte *buf)
1971 {
1972   gdb_assert (gdbarch != NULL);
1973   gdb_assert (gdbarch->pointer_to_address != NULL);
1974   if (gdbarch_debug >= 2)
1975     fprintf_unfiltered (gdb_stdlog, "gdbarch_pointer_to_address called\n");
1976   return gdbarch->pointer_to_address (type, buf);
1977 }
1978
1979 void
1980 set_gdbarch_pointer_to_address (struct gdbarch *gdbarch,
1981                                 gdbarch_pointer_to_address_ftype pointer_to_address)
1982 {
1983   gdbarch->pointer_to_address = pointer_to_address;
1984 }
1985
1986 void
1987 gdbarch_address_to_pointer (struct gdbarch *gdbarch, struct type *type, gdb_byte *buf, CORE_ADDR addr)
1988 {
1989   gdb_assert (gdbarch != NULL);
1990   gdb_assert (gdbarch->address_to_pointer != NULL);
1991   if (gdbarch_debug >= 2)
1992     fprintf_unfiltered (gdb_stdlog, "gdbarch_address_to_pointer called\n");
1993   gdbarch->address_to_pointer (type, buf, addr);
1994 }
1995
1996 void
1997 set_gdbarch_address_to_pointer (struct gdbarch *gdbarch,
1998                                 gdbarch_address_to_pointer_ftype address_to_pointer)
1999 {
2000   gdbarch->address_to_pointer = address_to_pointer;
2001 }
2002
2003 int
2004 gdbarch_integer_to_address_p (struct gdbarch *gdbarch)
2005 {
2006   gdb_assert (gdbarch != NULL);
2007   return gdbarch->integer_to_address != NULL;
2008 }
2009
2010 CORE_ADDR
2011 gdbarch_integer_to_address (struct gdbarch *gdbarch, struct type *type, const gdb_byte *buf)
2012 {
2013   gdb_assert (gdbarch != NULL);
2014   gdb_assert (gdbarch->integer_to_address != NULL);
2015   if (gdbarch_debug >= 2)
2016     fprintf_unfiltered (gdb_stdlog, "gdbarch_integer_to_address called\n");
2017   return gdbarch->integer_to_address (gdbarch, type, buf);
2018 }
2019
2020 void
2021 set_gdbarch_integer_to_address (struct gdbarch *gdbarch,
2022                                 gdbarch_integer_to_address_ftype integer_to_address)
2023 {
2024   gdbarch->integer_to_address = integer_to_address;
2025 }
2026
2027 int
2028 gdbarch_return_value_p (struct gdbarch *gdbarch)
2029 {
2030   gdb_assert (gdbarch != NULL);
2031   return gdbarch->return_value != NULL;
2032 }
2033
2034 enum return_value_convention
2035 gdbarch_return_value (struct gdbarch *gdbarch, struct type *valtype, struct regcache *regcache, gdb_byte *readbuf, const gdb_byte *writebuf)
2036 {
2037   gdb_assert (gdbarch != NULL);
2038   gdb_assert (gdbarch->return_value != NULL);
2039   if (gdbarch_debug >= 2)
2040     fprintf_unfiltered (gdb_stdlog, "gdbarch_return_value called\n");
2041   return gdbarch->return_value (gdbarch, valtype, regcache, readbuf, writebuf);
2042 }
2043
2044 void
2045 set_gdbarch_return_value (struct gdbarch *gdbarch,
2046                           gdbarch_return_value_ftype return_value)
2047 {
2048   gdbarch->return_value = return_value;
2049 }
2050
2051 CORE_ADDR
2052 gdbarch_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR ip)
2053 {
2054   gdb_assert (gdbarch != NULL);
2055   gdb_assert (gdbarch->skip_prologue != NULL);
2056   if (gdbarch_debug >= 2)
2057     fprintf_unfiltered (gdb_stdlog, "gdbarch_skip_prologue called\n");
2058   return gdbarch->skip_prologue (ip);
2059 }
2060
2061 void
2062 set_gdbarch_skip_prologue (struct gdbarch *gdbarch,
2063                            gdbarch_skip_prologue_ftype skip_prologue)
2064 {
2065   gdbarch->skip_prologue = skip_prologue;
2066 }
2067
2068 int
2069 gdbarch_inner_than (struct gdbarch *gdbarch, CORE_ADDR lhs, CORE_ADDR rhs)
2070 {
2071   gdb_assert (gdbarch != NULL);
2072   gdb_assert (gdbarch->inner_than != NULL);
2073   if (gdbarch_debug >= 2)
2074     fprintf_unfiltered (gdb_stdlog, "gdbarch_inner_than called\n");
2075   return gdbarch->inner_than (lhs, rhs);
2076 }
2077
2078 void
2079 set_gdbarch_inner_than (struct gdbarch *gdbarch,
2080                         gdbarch_inner_than_ftype inner_than)
2081 {
2082   gdbarch->inner_than = inner_than;
2083 }
2084
2085 const gdb_byte *
2086 gdbarch_breakpoint_from_pc (struct gdbarch *gdbarch, CORE_ADDR *pcptr, int *lenptr)
2087 {
2088   gdb_assert (gdbarch != NULL);
2089   gdb_assert (gdbarch->breakpoint_from_pc != NULL);
2090   if (gdbarch_debug >= 2)
2091     fprintf_unfiltered (gdb_stdlog, "gdbarch_breakpoint_from_pc called\n");
2092   return gdbarch->breakpoint_from_pc (pcptr, lenptr);
2093 }
2094
2095 void
2096 set_gdbarch_breakpoint_from_pc (struct gdbarch *gdbarch,
2097                                 gdbarch_breakpoint_from_pc_ftype breakpoint_from_pc)
2098 {
2099   gdbarch->breakpoint_from_pc = breakpoint_from_pc;
2100 }
2101
2102 int
2103 gdbarch_adjust_breakpoint_address_p (struct gdbarch *gdbarch)
2104 {
2105   gdb_assert (gdbarch != NULL);
2106   return gdbarch->adjust_breakpoint_address != NULL;
2107 }
2108
2109 CORE_ADDR
2110 gdbarch_adjust_breakpoint_address (struct gdbarch *gdbarch, CORE_ADDR bpaddr)
2111 {
2112   gdb_assert (gdbarch != NULL);
2113   gdb_assert (gdbarch->adjust_breakpoint_address != NULL);
2114   if (gdbarch_debug >= 2)
2115     fprintf_unfiltered (gdb_stdlog, "gdbarch_adjust_breakpoint_address called\n");
2116   return gdbarch->adjust_breakpoint_address (gdbarch, bpaddr);
2117 }
2118
2119 void
2120 set_gdbarch_adjust_breakpoint_address (struct gdbarch *gdbarch,
2121                                        gdbarch_adjust_breakpoint_address_ftype adjust_breakpoint_address)
2122 {
2123   gdbarch->adjust_breakpoint_address = adjust_breakpoint_address;
2124 }
2125
2126 int
2127 gdbarch_memory_insert_breakpoint (struct gdbarch *gdbarch, struct bp_target_info *bp_tgt)
2128 {
2129   gdb_assert (gdbarch != NULL);
2130   gdb_assert (gdbarch->memory_insert_breakpoint != NULL);
2131   if (gdbarch_debug >= 2)
2132     fprintf_unfiltered (gdb_stdlog, "gdbarch_memory_insert_breakpoint called\n");
2133   return gdbarch->memory_insert_breakpoint (bp_tgt);
2134 }
2135
2136 void
2137 set_gdbarch_memory_insert_breakpoint (struct gdbarch *gdbarch,
2138                                       gdbarch_memory_insert_breakpoint_ftype memory_insert_breakpoint)
2139 {
2140   gdbarch->memory_insert_breakpoint = memory_insert_breakpoint;
2141 }
2142
2143 int
2144 gdbarch_memory_remove_breakpoint (struct gdbarch *gdbarch, struct bp_target_info *bp_tgt)
2145 {
2146   gdb_assert (gdbarch != NULL);
2147   gdb_assert (gdbarch->memory_remove_breakpoint != NULL);
2148   if (gdbarch_debug >= 2)
2149     fprintf_unfiltered (gdb_stdlog, "gdbarch_memory_remove_breakpoint called\n");
2150   return gdbarch->memory_remove_breakpoint (bp_tgt);
2151 }
2152
2153 void
2154 set_gdbarch_memory_remove_breakpoint (struct gdbarch *gdbarch,
2155                                       gdbarch_memory_remove_breakpoint_ftype memory_remove_breakpoint)
2156 {
2157   gdbarch->memory_remove_breakpoint = memory_remove_breakpoint;
2158 }
2159
2160 CORE_ADDR
2161 gdbarch_decr_pc_after_break (struct gdbarch *gdbarch)
2162 {
2163   gdb_assert (gdbarch != NULL);
2164   /* Skip verify of decr_pc_after_break, invalid_p == 0 */
2165   if (gdbarch_debug >= 2)
2166     fprintf_unfiltered (gdb_stdlog, "gdbarch_decr_pc_after_break called\n");
2167   return gdbarch->decr_pc_after_break;
2168 }
2169
2170 void
2171 set_gdbarch_decr_pc_after_break (struct gdbarch *gdbarch,
2172                                  CORE_ADDR decr_pc_after_break)
2173 {
2174   gdbarch->decr_pc_after_break = decr_pc_after_break;
2175 }
2176
2177 CORE_ADDR
2178 gdbarch_deprecated_function_start_offset (struct gdbarch *gdbarch)
2179 {
2180   gdb_assert (gdbarch != NULL);
2181   /* Skip verify of deprecated_function_start_offset, invalid_p == 0 */
2182   if (gdbarch_debug >= 2)
2183     fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_function_start_offset called\n");
2184   return gdbarch->deprecated_function_start_offset;
2185 }
2186
2187 void
2188 set_gdbarch_deprecated_function_start_offset (struct gdbarch *gdbarch,
2189                                               CORE_ADDR deprecated_function_start_offset)
2190 {
2191   gdbarch->deprecated_function_start_offset = deprecated_function_start_offset;
2192 }
2193
2194 int
2195 gdbarch_remote_register_number (struct gdbarch *gdbarch, int regno)
2196 {
2197   gdb_assert (gdbarch != NULL);
2198   gdb_assert (gdbarch->remote_register_number != NULL);
2199   if (gdbarch_debug >= 2)
2200     fprintf_unfiltered (gdb_stdlog, "gdbarch_remote_register_number called\n");
2201   return gdbarch->remote_register_number (gdbarch, regno);
2202 }
2203
2204 void
2205 set_gdbarch_remote_register_number (struct gdbarch *gdbarch,
2206                                     gdbarch_remote_register_number_ftype remote_register_number)
2207 {
2208   gdbarch->remote_register_number = remote_register_number;
2209 }
2210
2211 int
2212 gdbarch_fetch_tls_load_module_address_p (struct gdbarch *gdbarch)
2213 {
2214   gdb_assert (gdbarch != NULL);
2215   return gdbarch->fetch_tls_load_module_address != NULL;
2216 }
2217
2218 CORE_ADDR
2219 gdbarch_fetch_tls_load_module_address (struct gdbarch *gdbarch, struct objfile *objfile)
2220 {
2221   gdb_assert (gdbarch != NULL);
2222   gdb_assert (gdbarch->fetch_tls_load_module_address != NULL);
2223   if (gdbarch_debug >= 2)
2224     fprintf_unfiltered (gdb_stdlog, "gdbarch_fetch_tls_load_module_address called\n");
2225   return gdbarch->fetch_tls_load_module_address (objfile);
2226 }
2227
2228 void
2229 set_gdbarch_fetch_tls_load_module_address (struct gdbarch *gdbarch,
2230                                            gdbarch_fetch_tls_load_module_address_ftype fetch_tls_load_module_address)
2231 {
2232   gdbarch->fetch_tls_load_module_address = fetch_tls_load_module_address;
2233 }
2234
2235 CORE_ADDR
2236 gdbarch_frame_args_skip (struct gdbarch *gdbarch)
2237 {
2238   gdb_assert (gdbarch != NULL);
2239   /* Skip verify of frame_args_skip, invalid_p == 0 */
2240   if (gdbarch_debug >= 2)
2241     fprintf_unfiltered (gdb_stdlog, "gdbarch_frame_args_skip called\n");
2242   return gdbarch->frame_args_skip;
2243 }
2244
2245 void
2246 set_gdbarch_frame_args_skip (struct gdbarch *gdbarch,
2247                              CORE_ADDR frame_args_skip)
2248 {
2249   gdbarch->frame_args_skip = frame_args_skip;
2250 }
2251
2252 int
2253 gdbarch_unwind_pc_p (struct gdbarch *gdbarch)
2254 {
2255   gdb_assert (gdbarch != NULL);
2256   return gdbarch->unwind_pc != NULL;
2257 }
2258
2259 CORE_ADDR
2260 gdbarch_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame)
2261 {
2262   gdb_assert (gdbarch != NULL);
2263   gdb_assert (gdbarch->unwind_pc != NULL);
2264   if (gdbarch_debug >= 2)
2265     fprintf_unfiltered (gdb_stdlog, "gdbarch_unwind_pc called\n");
2266   return gdbarch->unwind_pc (gdbarch, next_frame);
2267 }
2268
2269 void
2270 set_gdbarch_unwind_pc (struct gdbarch *gdbarch,
2271                        gdbarch_unwind_pc_ftype unwind_pc)
2272 {
2273   gdbarch->unwind_pc = unwind_pc;
2274 }
2275
2276 int
2277 gdbarch_unwind_sp_p (struct gdbarch *gdbarch)
2278 {
2279   gdb_assert (gdbarch != NULL);
2280   return gdbarch->unwind_sp != NULL;
2281 }
2282
2283 CORE_ADDR
2284 gdbarch_unwind_sp (struct gdbarch *gdbarch, struct frame_info *next_frame)
2285 {
2286   gdb_assert (gdbarch != NULL);
2287   gdb_assert (gdbarch->unwind_sp != NULL);
2288   if (gdbarch_debug >= 2)
2289     fprintf_unfiltered (gdb_stdlog, "gdbarch_unwind_sp called\n");
2290   return gdbarch->unwind_sp (gdbarch, next_frame);
2291 }
2292
2293 void
2294 set_gdbarch_unwind_sp (struct gdbarch *gdbarch,
2295                        gdbarch_unwind_sp_ftype unwind_sp)
2296 {
2297   gdbarch->unwind_sp = unwind_sp;
2298 }
2299
2300 int
2301 gdbarch_frame_num_args_p (struct gdbarch *gdbarch)
2302 {
2303   gdb_assert (gdbarch != NULL);
2304   return gdbarch->frame_num_args != NULL;
2305 }
2306
2307 int
2308 gdbarch_frame_num_args (struct gdbarch *gdbarch, struct frame_info *frame)
2309 {
2310   gdb_assert (gdbarch != NULL);
2311   gdb_assert (gdbarch->frame_num_args != NULL);
2312   if (gdbarch_debug >= 2)
2313     fprintf_unfiltered (gdb_stdlog, "gdbarch_frame_num_args called\n");
2314   return gdbarch->frame_num_args (frame);
2315 }
2316
2317 void
2318 set_gdbarch_frame_num_args (struct gdbarch *gdbarch,
2319                             gdbarch_frame_num_args_ftype frame_num_args)
2320 {
2321   gdbarch->frame_num_args = frame_num_args;
2322 }
2323
2324 int
2325 gdbarch_frame_align_p (struct gdbarch *gdbarch)
2326 {
2327   gdb_assert (gdbarch != NULL);
2328   return gdbarch->frame_align != NULL;
2329 }
2330
2331 CORE_ADDR
2332 gdbarch_frame_align (struct gdbarch *gdbarch, CORE_ADDR address)
2333 {
2334   gdb_assert (gdbarch != NULL);
2335   gdb_assert (gdbarch->frame_align != NULL);
2336   if (gdbarch_debug >= 2)
2337     fprintf_unfiltered (gdb_stdlog, "gdbarch_frame_align called\n");
2338   return gdbarch->frame_align (gdbarch, address);
2339 }
2340
2341 void
2342 set_gdbarch_frame_align (struct gdbarch *gdbarch,
2343                          gdbarch_frame_align_ftype frame_align)
2344 {
2345   gdbarch->frame_align = frame_align;
2346 }
2347
2348 int
2349 gdbarch_stabs_argument_has_addr (struct gdbarch *gdbarch, struct type *type)
2350 {
2351   gdb_assert (gdbarch != NULL);
2352   gdb_assert (gdbarch->stabs_argument_has_addr != NULL);
2353   if (gdbarch_debug >= 2)
2354     fprintf_unfiltered (gdb_stdlog, "gdbarch_stabs_argument_has_addr called\n");
2355   return gdbarch->stabs_argument_has_addr (gdbarch, type);
2356 }
2357
2358 void
2359 set_gdbarch_stabs_argument_has_addr (struct gdbarch *gdbarch,
2360                                      gdbarch_stabs_argument_has_addr_ftype stabs_argument_has_addr)
2361 {
2362   gdbarch->stabs_argument_has_addr = stabs_argument_has_addr;
2363 }
2364
2365 int
2366 gdbarch_frame_red_zone_size (struct gdbarch *gdbarch)
2367 {
2368   gdb_assert (gdbarch != NULL);
2369   if (gdbarch_debug >= 2)
2370     fprintf_unfiltered (gdb_stdlog, "gdbarch_frame_red_zone_size called\n");
2371   return gdbarch->frame_red_zone_size;
2372 }
2373
2374 void
2375 set_gdbarch_frame_red_zone_size (struct gdbarch *gdbarch,
2376                                  int frame_red_zone_size)
2377 {
2378   gdbarch->frame_red_zone_size = frame_red_zone_size;
2379 }
2380
2381 CORE_ADDR
2382 gdbarch_convert_from_func_ptr_addr (struct gdbarch *gdbarch, CORE_ADDR addr, struct target_ops *targ)
2383 {
2384   gdb_assert (gdbarch != NULL);
2385   gdb_assert (gdbarch->convert_from_func_ptr_addr != NULL);
2386   if (gdbarch_debug >= 2)
2387     fprintf_unfiltered (gdb_stdlog, "gdbarch_convert_from_func_ptr_addr called\n");
2388   return gdbarch->convert_from_func_ptr_addr (gdbarch, addr, targ);
2389 }
2390
2391 void
2392 set_gdbarch_convert_from_func_ptr_addr (struct gdbarch *gdbarch,
2393                                         gdbarch_convert_from_func_ptr_addr_ftype convert_from_func_ptr_addr)
2394 {
2395   gdbarch->convert_from_func_ptr_addr = convert_from_func_ptr_addr;
2396 }
2397
2398 CORE_ADDR
2399 gdbarch_addr_bits_remove (struct gdbarch *gdbarch, CORE_ADDR addr)
2400 {
2401   gdb_assert (gdbarch != NULL);
2402   gdb_assert (gdbarch->addr_bits_remove != NULL);
2403   if (gdbarch_debug >= 2)
2404     fprintf_unfiltered (gdb_stdlog, "gdbarch_addr_bits_remove called\n");
2405   return gdbarch->addr_bits_remove (addr);
2406 }
2407
2408 void
2409 set_gdbarch_addr_bits_remove (struct gdbarch *gdbarch,
2410                               gdbarch_addr_bits_remove_ftype addr_bits_remove)
2411 {
2412   gdbarch->addr_bits_remove = addr_bits_remove;
2413 }
2414
2415 CORE_ADDR
2416 gdbarch_smash_text_address (struct gdbarch *gdbarch, CORE_ADDR addr)
2417 {
2418   gdb_assert (gdbarch != NULL);
2419   gdb_assert (gdbarch->smash_text_address != NULL);
2420   if (gdbarch_debug >= 2)
2421     fprintf_unfiltered (gdb_stdlog, "gdbarch_smash_text_address called\n");
2422   return gdbarch->smash_text_address (addr);
2423 }
2424
2425 void
2426 set_gdbarch_smash_text_address (struct gdbarch *gdbarch,
2427                                 gdbarch_smash_text_address_ftype smash_text_address)
2428 {
2429   gdbarch->smash_text_address = smash_text_address;
2430 }
2431
2432 int
2433 gdbarch_software_single_step_p (struct gdbarch *gdbarch)
2434 {
2435   gdb_assert (gdbarch != NULL);
2436   return gdbarch->software_single_step != NULL;
2437 }
2438
2439 int
2440 gdbarch_software_single_step (struct gdbarch *gdbarch, struct frame_info *frame)
2441 {
2442   gdb_assert (gdbarch != NULL);
2443   gdb_assert (gdbarch->software_single_step != NULL);
2444   if (gdbarch_debug >= 2)
2445     fprintf_unfiltered (gdb_stdlog, "gdbarch_software_single_step called\n");
2446   return gdbarch->software_single_step (frame);
2447 }
2448
2449 void
2450 set_gdbarch_software_single_step (struct gdbarch *gdbarch,
2451                                   gdbarch_software_single_step_ftype software_single_step)
2452 {
2453   gdbarch->software_single_step = software_single_step;
2454 }
2455
2456 int
2457 gdbarch_single_step_through_delay_p (struct gdbarch *gdbarch)
2458 {
2459   gdb_assert (gdbarch != NULL);
2460   return gdbarch->single_step_through_delay != NULL;
2461 }
2462
2463 int
2464 gdbarch_single_step_through_delay (struct gdbarch *gdbarch, struct frame_info *frame)
2465 {
2466   gdb_assert (gdbarch != NULL);
2467   gdb_assert (gdbarch->single_step_through_delay != NULL);
2468   if (gdbarch_debug >= 2)
2469     fprintf_unfiltered (gdb_stdlog, "gdbarch_single_step_through_delay called\n");
2470   return gdbarch->single_step_through_delay (gdbarch, frame);
2471 }
2472
2473 void
2474 set_gdbarch_single_step_through_delay (struct gdbarch *gdbarch,
2475                                        gdbarch_single_step_through_delay_ftype single_step_through_delay)
2476 {
2477   gdbarch->single_step_through_delay = single_step_through_delay;
2478 }
2479
2480 int
2481 gdbarch_print_insn (struct gdbarch *gdbarch, bfd_vma vma, struct disassemble_info *info)
2482 {
2483   gdb_assert (gdbarch != NULL);
2484   gdb_assert (gdbarch->print_insn != NULL);
2485   if (gdbarch_debug >= 2)
2486     fprintf_unfiltered (gdb_stdlog, "gdbarch_print_insn called\n");
2487   return gdbarch->print_insn (vma, info);
2488 }
2489
2490 void
2491 set_gdbarch_print_insn (struct gdbarch *gdbarch,
2492                         gdbarch_print_insn_ftype print_insn)
2493 {
2494   gdbarch->print_insn = print_insn;
2495 }
2496
2497 CORE_ADDR
2498 gdbarch_skip_trampoline_code (struct gdbarch *gdbarch, struct frame_info *frame, CORE_ADDR pc)
2499 {
2500   gdb_assert (gdbarch != NULL);
2501   gdb_assert (gdbarch->skip_trampoline_code != NULL);
2502   if (gdbarch_debug >= 2)
2503     fprintf_unfiltered (gdb_stdlog, "gdbarch_skip_trampoline_code called\n");
2504   return gdbarch->skip_trampoline_code (frame, pc);
2505 }
2506
2507 void
2508 set_gdbarch_skip_trampoline_code (struct gdbarch *gdbarch,
2509                                   gdbarch_skip_trampoline_code_ftype skip_trampoline_code)
2510 {
2511   gdbarch->skip_trampoline_code = skip_trampoline_code;
2512 }
2513
2514 CORE_ADDR
2515 gdbarch_skip_solib_resolver (struct gdbarch *gdbarch, CORE_ADDR pc)
2516 {
2517   gdb_assert (gdbarch != NULL);
2518   gdb_assert (gdbarch->skip_solib_resolver != NULL);
2519   if (gdbarch_debug >= 2)
2520     fprintf_unfiltered (gdb_stdlog, "gdbarch_skip_solib_resolver called\n");
2521   return gdbarch->skip_solib_resolver (gdbarch, pc);
2522 }
2523
2524 void
2525 set_gdbarch_skip_solib_resolver (struct gdbarch *gdbarch,
2526                                  gdbarch_skip_solib_resolver_ftype skip_solib_resolver)
2527 {
2528   gdbarch->skip_solib_resolver = skip_solib_resolver;
2529 }
2530
2531 int
2532 gdbarch_in_solib_return_trampoline (struct gdbarch *gdbarch, CORE_ADDR pc, char *name)
2533 {
2534   gdb_assert (gdbarch != NULL);
2535   gdb_assert (gdbarch->in_solib_return_trampoline != NULL);
2536   if (gdbarch_debug >= 2)
2537     fprintf_unfiltered (gdb_stdlog, "gdbarch_in_solib_return_trampoline called\n");
2538   return gdbarch->in_solib_return_trampoline (pc, name);
2539 }
2540
2541 void
2542 set_gdbarch_in_solib_return_trampoline (struct gdbarch *gdbarch,
2543                                         gdbarch_in_solib_return_trampoline_ftype in_solib_return_trampoline)
2544 {
2545   gdbarch->in_solib_return_trampoline = in_solib_return_trampoline;
2546 }
2547
2548 int
2549 gdbarch_in_function_epilogue_p (struct gdbarch *gdbarch, CORE_ADDR addr)
2550 {
2551   gdb_assert (gdbarch != NULL);
2552   gdb_assert (gdbarch->in_function_epilogue_p != NULL);
2553   if (gdbarch_debug >= 2)
2554     fprintf_unfiltered (gdb_stdlog, "gdbarch_in_function_epilogue_p called\n");
2555   return gdbarch->in_function_epilogue_p (gdbarch, addr);
2556 }
2557
2558 void
2559 set_gdbarch_in_function_epilogue_p (struct gdbarch *gdbarch,
2560                                     gdbarch_in_function_epilogue_p_ftype in_function_epilogue_p)
2561 {
2562   gdbarch->in_function_epilogue_p = in_function_epilogue_p;
2563 }
2564
2565 char *
2566 gdbarch_construct_inferior_arguments (struct gdbarch *gdbarch, int argc, char **argv)
2567 {
2568   gdb_assert (gdbarch != NULL);
2569   gdb_assert (gdbarch->construct_inferior_arguments != NULL);
2570   if (gdbarch_debug >= 2)
2571     fprintf_unfiltered (gdb_stdlog, "gdbarch_construct_inferior_arguments called\n");
2572   return gdbarch->construct_inferior_arguments (gdbarch, argc, argv);
2573 }
2574
2575 void
2576 set_gdbarch_construct_inferior_arguments (struct gdbarch *gdbarch,
2577                                           gdbarch_construct_inferior_arguments_ftype construct_inferior_arguments)
2578 {
2579   gdbarch->construct_inferior_arguments = construct_inferior_arguments;
2580 }
2581
2582 void
2583 gdbarch_elf_make_msymbol_special (struct gdbarch *gdbarch, asymbol *sym, struct minimal_symbol *msym)
2584 {
2585   gdb_assert (gdbarch != NULL);
2586   gdb_assert (gdbarch->elf_make_msymbol_special != NULL);
2587   if (gdbarch_debug >= 2)
2588     fprintf_unfiltered (gdb_stdlog, "gdbarch_elf_make_msymbol_special called\n");
2589   gdbarch->elf_make_msymbol_special (sym, msym);
2590 }
2591
2592 void
2593 set_gdbarch_elf_make_msymbol_special (struct gdbarch *gdbarch,
2594                                       gdbarch_elf_make_msymbol_special_ftype elf_make_msymbol_special)
2595 {
2596   gdbarch->elf_make_msymbol_special = elf_make_msymbol_special;
2597 }
2598
2599 void
2600 gdbarch_coff_make_msymbol_special (struct gdbarch *gdbarch, int val, struct minimal_symbol *msym)
2601 {
2602   gdb_assert (gdbarch != NULL);
2603   gdb_assert (gdbarch->coff_make_msymbol_special != NULL);
2604   if (gdbarch_debug >= 2)
2605     fprintf_unfiltered (gdb_stdlog, "gdbarch_coff_make_msymbol_special called\n");
2606   gdbarch->coff_make_msymbol_special (val, msym);
2607 }
2608
2609 void
2610 set_gdbarch_coff_make_msymbol_special (struct gdbarch *gdbarch,
2611                                        gdbarch_coff_make_msymbol_special_ftype coff_make_msymbol_special)
2612 {
2613   gdbarch->coff_make_msymbol_special = coff_make_msymbol_special;
2614 }
2615
2616 const char *
2617 gdbarch_name_of_malloc (struct gdbarch *gdbarch)
2618 {
2619   gdb_assert (gdbarch != NULL);
2620   /* Skip verify of name_of_malloc, invalid_p == 0 */
2621   if (gdbarch_debug >= 2)
2622     fprintf_unfiltered (gdb_stdlog, "gdbarch_name_of_malloc called\n");
2623   return gdbarch->name_of_malloc;
2624 }
2625
2626 void
2627 set_gdbarch_name_of_malloc (struct gdbarch *gdbarch,
2628                             const char * name_of_malloc)
2629 {
2630   gdbarch->name_of_malloc = name_of_malloc;
2631 }
2632
2633 int
2634 gdbarch_cannot_step_breakpoint (struct gdbarch *gdbarch)
2635 {
2636   gdb_assert (gdbarch != NULL);
2637   /* Skip verify of cannot_step_breakpoint, invalid_p == 0 */
2638   if (gdbarch_debug >= 2)
2639     fprintf_unfiltered (gdb_stdlog, "gdbarch_cannot_step_breakpoint called\n");
2640   return gdbarch->cannot_step_breakpoint;
2641 }
2642
2643 void
2644 set_gdbarch_cannot_step_breakpoint (struct gdbarch *gdbarch,
2645                                     int cannot_step_breakpoint)
2646 {
2647   gdbarch->cannot_step_breakpoint = cannot_step_breakpoint;
2648 }
2649
2650 int
2651 gdbarch_have_nonsteppable_watchpoint (struct gdbarch *gdbarch)
2652 {
2653   gdb_assert (gdbarch != NULL);
2654   /* Skip verify of have_nonsteppable_watchpoint, invalid_p == 0 */
2655   if (gdbarch_debug >= 2)
2656     fprintf_unfiltered (gdb_stdlog, "gdbarch_have_nonsteppable_watchpoint called\n");
2657   return gdbarch->have_nonsteppable_watchpoint;
2658 }
2659
2660 void
2661 set_gdbarch_have_nonsteppable_watchpoint (struct gdbarch *gdbarch,
2662                                           int have_nonsteppable_watchpoint)
2663 {
2664   gdbarch->have_nonsteppable_watchpoint = have_nonsteppable_watchpoint;
2665 }
2666
2667 int
2668 gdbarch_address_class_type_flags_p (struct gdbarch *gdbarch)
2669 {
2670   gdb_assert (gdbarch != NULL);
2671   return gdbarch->address_class_type_flags != NULL;
2672 }
2673
2674 int
2675 gdbarch_address_class_type_flags (struct gdbarch *gdbarch, int byte_size, int dwarf2_addr_class)
2676 {
2677   gdb_assert (gdbarch != NULL);
2678   gdb_assert (gdbarch->address_class_type_flags != NULL);
2679   if (gdbarch_debug >= 2)
2680     fprintf_unfiltered (gdb_stdlog, "gdbarch_address_class_type_flags called\n");
2681   return gdbarch->address_class_type_flags (byte_size, dwarf2_addr_class);
2682 }
2683
2684 void
2685 set_gdbarch_address_class_type_flags (struct gdbarch *gdbarch,
2686                                       gdbarch_address_class_type_flags_ftype address_class_type_flags)
2687 {
2688   gdbarch->address_class_type_flags = address_class_type_flags;
2689 }
2690
2691 int
2692 gdbarch_address_class_type_flags_to_name_p (struct gdbarch *gdbarch)
2693 {
2694   gdb_assert (gdbarch != NULL);
2695   return gdbarch->address_class_type_flags_to_name != NULL;
2696 }
2697
2698 const char *
2699 gdbarch_address_class_type_flags_to_name (struct gdbarch *gdbarch, int type_flags)
2700 {
2701   gdb_assert (gdbarch != NULL);
2702   gdb_assert (gdbarch->address_class_type_flags_to_name != NULL);
2703   if (gdbarch_debug >= 2)
2704     fprintf_unfiltered (gdb_stdlog, "gdbarch_address_class_type_flags_to_name called\n");
2705   return gdbarch->address_class_type_flags_to_name (gdbarch, type_flags);
2706 }
2707
2708 void
2709 set_gdbarch_address_class_type_flags_to_name (struct gdbarch *gdbarch,
2710                                               gdbarch_address_class_type_flags_to_name_ftype address_class_type_flags_to_name)
2711 {
2712   gdbarch->address_class_type_flags_to_name = address_class_type_flags_to_name;
2713 }
2714
2715 int
2716 gdbarch_address_class_name_to_type_flags_p (struct gdbarch *gdbarch)
2717 {
2718   gdb_assert (gdbarch != NULL);
2719   return gdbarch->address_class_name_to_type_flags != NULL;
2720 }
2721
2722 int
2723 gdbarch_address_class_name_to_type_flags (struct gdbarch *gdbarch, const char *name, int *type_flags_ptr)
2724 {
2725   gdb_assert (gdbarch != NULL);
2726   gdb_assert (gdbarch->address_class_name_to_type_flags != NULL);
2727   if (gdbarch_debug >= 2)
2728     fprintf_unfiltered (gdb_stdlog, "gdbarch_address_class_name_to_type_flags called\n");
2729   return gdbarch->address_class_name_to_type_flags (gdbarch, name, type_flags_ptr);
2730 }
2731
2732 void
2733 set_gdbarch_address_class_name_to_type_flags (struct gdbarch *gdbarch,
2734                                               gdbarch_address_class_name_to_type_flags_ftype address_class_name_to_type_flags)
2735 {
2736   gdbarch->address_class_name_to_type_flags = address_class_name_to_type_flags;
2737 }
2738
2739 int
2740 gdbarch_register_reggroup_p (struct gdbarch *gdbarch, int regnum, struct reggroup *reggroup)
2741 {
2742   gdb_assert (gdbarch != NULL);
2743   gdb_assert (gdbarch->register_reggroup_p != NULL);
2744   if (gdbarch_debug >= 2)
2745     fprintf_unfiltered (gdb_stdlog, "gdbarch_register_reggroup_p called\n");
2746   return gdbarch->register_reggroup_p (gdbarch, regnum, reggroup);
2747 }
2748
2749 void
2750 set_gdbarch_register_reggroup_p (struct gdbarch *gdbarch,
2751                                  gdbarch_register_reggroup_p_ftype register_reggroup_p)
2752 {
2753   gdbarch->register_reggroup_p = register_reggroup_p;
2754 }
2755
2756 int
2757 gdbarch_fetch_pointer_argument_p (struct gdbarch *gdbarch)
2758 {
2759   gdb_assert (gdbarch != NULL);
2760   return gdbarch->fetch_pointer_argument != NULL;
2761 }
2762
2763 CORE_ADDR
2764 gdbarch_fetch_pointer_argument (struct gdbarch *gdbarch, struct frame_info *frame, int argi, struct type *type)
2765 {
2766   gdb_assert (gdbarch != NULL);
2767   gdb_assert (gdbarch->fetch_pointer_argument != NULL);
2768   if (gdbarch_debug >= 2)
2769     fprintf_unfiltered (gdb_stdlog, "gdbarch_fetch_pointer_argument called\n");
2770   return gdbarch->fetch_pointer_argument (frame, argi, type);
2771 }
2772
2773 void
2774 set_gdbarch_fetch_pointer_argument (struct gdbarch *gdbarch,
2775                                     gdbarch_fetch_pointer_argument_ftype fetch_pointer_argument)
2776 {
2777   gdbarch->fetch_pointer_argument = fetch_pointer_argument;
2778 }
2779
2780 int
2781 gdbarch_regset_from_core_section_p (struct gdbarch *gdbarch)
2782 {
2783   gdb_assert (gdbarch != NULL);
2784   return gdbarch->regset_from_core_section != NULL;
2785 }
2786
2787 const struct regset *
2788 gdbarch_regset_from_core_section (struct gdbarch *gdbarch, const char *sect_name, size_t sect_size)
2789 {
2790   gdb_assert (gdbarch != NULL);
2791   gdb_assert (gdbarch->regset_from_core_section != NULL);
2792   if (gdbarch_debug >= 2)
2793     fprintf_unfiltered (gdb_stdlog, "gdbarch_regset_from_core_section called\n");
2794   return gdbarch->regset_from_core_section (gdbarch, sect_name, sect_size);
2795 }
2796
2797 void
2798 set_gdbarch_regset_from_core_section (struct gdbarch *gdbarch,
2799                                       gdbarch_regset_from_core_section_ftype regset_from_core_section)
2800 {
2801   gdbarch->regset_from_core_section = regset_from_core_section;
2802 }
2803
2804 int
2805 gdbarch_core_xfer_shared_libraries_p (struct gdbarch *gdbarch)
2806 {
2807   gdb_assert (gdbarch != NULL);
2808   return gdbarch->core_xfer_shared_libraries != NULL;
2809 }
2810
2811 LONGEST
2812 gdbarch_core_xfer_shared_libraries (struct gdbarch *gdbarch, gdb_byte *readbuf, ULONGEST offset, LONGEST len)
2813 {
2814   gdb_assert (gdbarch != NULL);
2815   gdb_assert (gdbarch->core_xfer_shared_libraries != NULL);
2816   if (gdbarch_debug >= 2)
2817     fprintf_unfiltered (gdb_stdlog, "gdbarch_core_xfer_shared_libraries called\n");
2818   return gdbarch->core_xfer_shared_libraries (gdbarch, readbuf, offset, len);
2819 }
2820
2821 void
2822 set_gdbarch_core_xfer_shared_libraries (struct gdbarch *gdbarch,
2823                                         gdbarch_core_xfer_shared_libraries_ftype core_xfer_shared_libraries)
2824 {
2825   gdbarch->core_xfer_shared_libraries = core_xfer_shared_libraries;
2826 }
2827
2828 int
2829 gdbarch_vtable_function_descriptors (struct gdbarch *gdbarch)
2830 {
2831   gdb_assert (gdbarch != NULL);
2832   /* Skip verify of vtable_function_descriptors, invalid_p == 0 */
2833   if (gdbarch_debug >= 2)
2834     fprintf_unfiltered (gdb_stdlog, "gdbarch_vtable_function_descriptors called\n");
2835   return gdbarch->vtable_function_descriptors;
2836 }
2837
2838 void
2839 set_gdbarch_vtable_function_descriptors (struct gdbarch *gdbarch,
2840                                          int vtable_function_descriptors)
2841 {
2842   gdbarch->vtable_function_descriptors = vtable_function_descriptors;
2843 }
2844
2845 int
2846 gdbarch_vbit_in_delta (struct gdbarch *gdbarch)
2847 {
2848   gdb_assert (gdbarch != NULL);
2849   /* Skip verify of vbit_in_delta, invalid_p == 0 */
2850   if (gdbarch_debug >= 2)
2851     fprintf_unfiltered (gdb_stdlog, "gdbarch_vbit_in_delta called\n");
2852   return gdbarch->vbit_in_delta;
2853 }
2854
2855 void
2856 set_gdbarch_vbit_in_delta (struct gdbarch *gdbarch,
2857                            int vbit_in_delta)
2858 {
2859   gdbarch->vbit_in_delta = vbit_in_delta;
2860 }
2861
2862 int
2863 gdbarch_skip_permanent_breakpoint_p (struct gdbarch *gdbarch)
2864 {
2865   gdb_assert (gdbarch != NULL);
2866   return gdbarch->skip_permanent_breakpoint != NULL;
2867 }
2868
2869 void
2870 gdbarch_skip_permanent_breakpoint (struct gdbarch *gdbarch, struct regcache *regcache)
2871 {
2872   gdb_assert (gdbarch != NULL);
2873   gdb_assert (gdbarch->skip_permanent_breakpoint != NULL);
2874   if (gdbarch_debug >= 2)
2875     fprintf_unfiltered (gdb_stdlog, "gdbarch_skip_permanent_breakpoint called\n");
2876   gdbarch->skip_permanent_breakpoint (regcache);
2877 }
2878
2879 void
2880 set_gdbarch_skip_permanent_breakpoint (struct gdbarch *gdbarch,
2881                                        gdbarch_skip_permanent_breakpoint_ftype skip_permanent_breakpoint)
2882 {
2883   gdbarch->skip_permanent_breakpoint = skip_permanent_breakpoint;
2884 }
2885
2886 int
2887 gdbarch_overlay_update_p (struct gdbarch *gdbarch)
2888 {
2889   gdb_assert (gdbarch != NULL);
2890   return gdbarch->overlay_update != NULL;
2891 }
2892
2893 void
2894 gdbarch_overlay_update (struct gdbarch *gdbarch, struct obj_section *osect)
2895 {
2896   gdb_assert (gdbarch != NULL);
2897   gdb_assert (gdbarch->overlay_update != NULL);
2898   if (gdbarch_debug >= 2)
2899     fprintf_unfiltered (gdb_stdlog, "gdbarch_overlay_update called\n");
2900   gdbarch->overlay_update (osect);
2901 }
2902
2903 void
2904 set_gdbarch_overlay_update (struct gdbarch *gdbarch,
2905                             gdbarch_overlay_update_ftype overlay_update)
2906 {
2907   gdbarch->overlay_update = overlay_update;
2908 }
2909
2910 int
2911 gdbarch_core_read_description_p (struct gdbarch *gdbarch)
2912 {
2913   gdb_assert (gdbarch != NULL);
2914   return gdbarch->core_read_description != NULL;
2915 }
2916
2917 const struct target_desc *
2918 gdbarch_core_read_description (struct gdbarch *gdbarch, struct target_ops *target, bfd *abfd)
2919 {
2920   gdb_assert (gdbarch != NULL);
2921   gdb_assert (gdbarch->core_read_description != NULL);
2922   if (gdbarch_debug >= 2)
2923     fprintf_unfiltered (gdb_stdlog, "gdbarch_core_read_description called\n");
2924   return gdbarch->core_read_description (gdbarch, target, abfd);
2925 }
2926
2927 void
2928 set_gdbarch_core_read_description (struct gdbarch *gdbarch,
2929                                    gdbarch_core_read_description_ftype core_read_description)
2930 {
2931   gdbarch->core_read_description = core_read_description;
2932 }
2933
2934
2935 /* Keep a registry of per-architecture data-pointers required by GDB
2936    modules. */
2937
2938 struct gdbarch_data
2939 {
2940   unsigned index;
2941   int init_p;
2942   gdbarch_data_pre_init_ftype *pre_init;
2943   gdbarch_data_post_init_ftype *post_init;
2944 };
2945
2946 struct gdbarch_data_registration
2947 {
2948   struct gdbarch_data *data;
2949   struct gdbarch_data_registration *next;
2950 };
2951
2952 struct gdbarch_data_registry
2953 {
2954   unsigned nr;
2955   struct gdbarch_data_registration *registrations;
2956 };
2957
2958 struct gdbarch_data_registry gdbarch_data_registry =
2959 {
2960   0, NULL,
2961 };
2962
2963 static struct gdbarch_data *
2964 gdbarch_data_register (gdbarch_data_pre_init_ftype *pre_init,
2965                        gdbarch_data_post_init_ftype *post_init)
2966 {
2967   struct gdbarch_data_registration **curr;
2968   /* Append the new registraration.  */
2969   for (curr = &gdbarch_data_registry.registrations;
2970        (*curr) != NULL;
2971        curr = &(*curr)->next);
2972   (*curr) = XMALLOC (struct gdbarch_data_registration);
2973   (*curr)->next = NULL;
2974   (*curr)->data = XMALLOC (struct gdbarch_data);
2975   (*curr)->data->index = gdbarch_data_registry.nr++;
2976   (*curr)->data->pre_init = pre_init;
2977   (*curr)->data->post_init = post_init;
2978   (*curr)->data->init_p = 1;
2979   return (*curr)->data;
2980 }
2981
2982 struct gdbarch_data *
2983 gdbarch_data_register_pre_init (gdbarch_data_pre_init_ftype *pre_init)
2984 {
2985   return gdbarch_data_register (pre_init, NULL);
2986 }
2987
2988 struct gdbarch_data *
2989 gdbarch_data_register_post_init (gdbarch_data_post_init_ftype *post_init)
2990 {
2991   return gdbarch_data_register (NULL, post_init);
2992 }
2993
2994 /* Create/delete the gdbarch data vector. */
2995
2996 static void
2997 alloc_gdbarch_data (struct gdbarch *gdbarch)
2998 {
2999   gdb_assert (gdbarch->data == NULL);
3000   gdbarch->nr_data = gdbarch_data_registry.nr;
3001   gdbarch->data = GDBARCH_OBSTACK_CALLOC (gdbarch, gdbarch->nr_data, void *);
3002 }
3003
3004 /* Initialize the current value of the specified per-architecture
3005    data-pointer. */
3006
3007 void
3008 deprecated_set_gdbarch_data (struct gdbarch *gdbarch,
3009                              struct gdbarch_data *data,
3010                              void *pointer)
3011 {
3012   gdb_assert (data->index < gdbarch->nr_data);
3013   gdb_assert (gdbarch->data[data->index] == NULL);
3014   gdb_assert (data->pre_init == NULL);
3015   gdbarch->data[data->index] = pointer;
3016 }
3017
3018 /* Return the current value of the specified per-architecture
3019    data-pointer. */
3020
3021 void *
3022 gdbarch_data (struct gdbarch *gdbarch, struct gdbarch_data *data)
3023 {
3024   gdb_assert (data->index < gdbarch->nr_data);
3025   if (gdbarch->data[data->index] == NULL)
3026     {
3027       /* The data-pointer isn't initialized, call init() to get a
3028          value.  */
3029       if (data->pre_init != NULL)
3030         /* Mid architecture creation: pass just the obstack, and not
3031            the entire architecture, as that way it isn't possible for
3032            pre-init code to refer to undefined architecture
3033            fields.  */
3034         gdbarch->data[data->index] = data->pre_init (gdbarch->obstack);
3035       else if (gdbarch->initialized_p
3036                && data->post_init != NULL)
3037         /* Post architecture creation: pass the entire architecture
3038            (as all fields are valid), but be careful to also detect
3039            recursive references.  */
3040         {
3041           gdb_assert (data->init_p);
3042           data->init_p = 0;
3043           gdbarch->data[data->index] = data->post_init (gdbarch);
3044           data->init_p = 1;
3045         }
3046       else
3047         /* The architecture initialization hasn't completed - punt -
3048          hope that the caller knows what they are doing.  Once
3049          deprecated_set_gdbarch_data has been initialized, this can be
3050          changed to an internal error.  */
3051         return NULL;
3052       gdb_assert (gdbarch->data[data->index] != NULL);
3053     }
3054   return gdbarch->data[data->index];
3055 }
3056
3057
3058 /* Keep a registry of the architectures known by GDB. */
3059
3060 struct gdbarch_registration
3061 {
3062   enum bfd_architecture bfd_architecture;
3063   gdbarch_init_ftype *init;
3064   gdbarch_dump_tdep_ftype *dump_tdep;
3065   struct gdbarch_list *arches;
3066   struct gdbarch_registration *next;
3067 };
3068
3069 static struct gdbarch_registration *gdbarch_registry = NULL;
3070
3071 static void
3072 append_name (const char ***buf, int *nr, const char *name)
3073 {
3074   *buf = xrealloc (*buf, sizeof (char**) * (*nr + 1));
3075   (*buf)[*nr] = name;
3076   *nr += 1;
3077 }
3078
3079 const char **
3080 gdbarch_printable_names (void)
3081 {
3082   /* Accumulate a list of names based on the registed list of
3083      architectures. */
3084   enum bfd_architecture a;
3085   int nr_arches = 0;
3086   const char **arches = NULL;
3087   struct gdbarch_registration *rego;
3088   for (rego = gdbarch_registry;
3089        rego != NULL;
3090        rego = rego->next)
3091     {
3092       const struct bfd_arch_info *ap;
3093       ap = bfd_lookup_arch (rego->bfd_architecture, 0);
3094       if (ap == NULL)
3095         internal_error (__FILE__, __LINE__,
3096                         _("gdbarch_architecture_names: multi-arch unknown"));
3097       do
3098         {
3099           append_name (&arches, &nr_arches, ap->printable_name);
3100           ap = ap->next;
3101         }
3102       while (ap != NULL);
3103     }
3104   append_name (&arches, &nr_arches, NULL);
3105   return arches;
3106 }
3107
3108
3109 void
3110 gdbarch_register (enum bfd_architecture bfd_architecture,
3111                   gdbarch_init_ftype *init,
3112                   gdbarch_dump_tdep_ftype *dump_tdep)
3113 {
3114   struct gdbarch_registration **curr;
3115   const struct bfd_arch_info *bfd_arch_info;
3116   /* Check that BFD recognizes this architecture */
3117   bfd_arch_info = bfd_lookup_arch (bfd_architecture, 0);
3118   if (bfd_arch_info == NULL)
3119     {
3120       internal_error (__FILE__, __LINE__,
3121                       _("gdbarch: Attempt to register unknown architecture (%d)"),
3122                       bfd_architecture);
3123     }
3124   /* Check that we haven't seen this architecture before */
3125   for (curr = &gdbarch_registry;
3126        (*curr) != NULL;
3127        curr = &(*curr)->next)
3128     {
3129       if (bfd_architecture == (*curr)->bfd_architecture)
3130         internal_error (__FILE__, __LINE__,
3131                         _("gdbarch: Duplicate registraration of architecture (%s)"),
3132                         bfd_arch_info->printable_name);
3133     }
3134   /* log it */
3135   if (gdbarch_debug)
3136     fprintf_unfiltered (gdb_stdlog, "register_gdbarch_init (%s, 0x%08lx)\n",
3137                         bfd_arch_info->printable_name,
3138                         (long) init);
3139   /* Append it */
3140   (*curr) = XMALLOC (struct gdbarch_registration);
3141   (*curr)->bfd_architecture = bfd_architecture;
3142   (*curr)->init = init;
3143   (*curr)->dump_tdep = dump_tdep;
3144   (*curr)->arches = NULL;
3145   (*curr)->next = NULL;
3146 }
3147
3148 void
3149 register_gdbarch_init (enum bfd_architecture bfd_architecture,
3150                        gdbarch_init_ftype *init)
3151 {
3152   gdbarch_register (bfd_architecture, init, NULL);
3153 }
3154
3155
3156 /* Look for an architecture using gdbarch_info.  */
3157
3158 struct gdbarch_list *
3159 gdbarch_list_lookup_by_info (struct gdbarch_list *arches,
3160                              const struct gdbarch_info *info)
3161 {
3162   for (; arches != NULL; arches = arches->next)
3163     {
3164       if (info->bfd_arch_info != arches->gdbarch->bfd_arch_info)
3165         continue;
3166       if (info->byte_order != arches->gdbarch->byte_order)
3167         continue;
3168       if (info->osabi != arches->gdbarch->osabi)
3169         continue;
3170       if (info->target_desc != arches->gdbarch->target_desc)
3171         continue;
3172       return arches;
3173     }
3174   return NULL;
3175 }
3176
3177
3178 /* Find an architecture that matches the specified INFO.  Create a new
3179    architecture if needed.  Return that new architecture.  Assumes
3180    that there is no current architecture.  */
3181
3182 static struct gdbarch *
3183 find_arch_by_info (struct gdbarch_info info)
3184 {
3185   struct gdbarch *new_gdbarch;
3186   struct gdbarch_registration *rego;
3187
3188   /* The existing architecture has been swapped out - all this code
3189      works from a clean slate.  */
3190   gdb_assert (current_gdbarch == NULL);
3191
3192   /* Fill in missing parts of the INFO struct using a number of
3193      sources: "set ..."; INFOabfd supplied; and the global
3194      defaults.  */
3195   gdbarch_info_fill (&info);
3196
3197   /* Must have found some sort of architecture. */
3198   gdb_assert (info.bfd_arch_info != NULL);
3199
3200   if (gdbarch_debug)
3201     {
3202       fprintf_unfiltered (gdb_stdlog,
3203                           "find_arch_by_info: info.bfd_arch_info %s\n",
3204                           (info.bfd_arch_info != NULL
3205                            ? info.bfd_arch_info->printable_name
3206                            : "(null)"));
3207       fprintf_unfiltered (gdb_stdlog,
3208                           "find_arch_by_info: info.byte_order %d (%s)\n",
3209                           info.byte_order,
3210                           (info.byte_order == BFD_ENDIAN_BIG ? "big"
3211                            : info.byte_order == BFD_ENDIAN_LITTLE ? "little"
3212                            : "default"));
3213       fprintf_unfiltered (gdb_stdlog,
3214                           "find_arch_by_info: info.osabi %d (%s)\n",
3215                           info.osabi, gdbarch_osabi_name (info.osabi));
3216       fprintf_unfiltered (gdb_stdlog,
3217                           "find_arch_by_info: info.abfd 0x%lx\n",
3218                           (long) info.abfd);
3219       fprintf_unfiltered (gdb_stdlog,
3220                           "find_arch_by_info: info.tdep_info 0x%lx\n",
3221                           (long) info.tdep_info);
3222     }
3223
3224   /* Find the tdep code that knows about this architecture.  */
3225   for (rego = gdbarch_registry;
3226        rego != NULL;
3227        rego = rego->next)
3228     if (rego->bfd_architecture == info.bfd_arch_info->arch)
3229       break;
3230   if (rego == NULL)
3231     {
3232       if (gdbarch_debug)
3233         fprintf_unfiltered (gdb_stdlog, "find_arch_by_info: "
3234                             "No matching architecture\n");
3235       return 0;
3236     }
3237
3238   /* Ask the tdep code for an architecture that matches "info".  */
3239   new_gdbarch = rego->init (info, rego->arches);
3240
3241   /* Did the tdep code like it?  No.  Reject the change and revert to
3242      the old architecture.  */
3243   if (new_gdbarch == NULL)
3244     {
3245       if (gdbarch_debug)
3246         fprintf_unfiltered (gdb_stdlog, "find_arch_by_info: "
3247                             "Target rejected architecture\n");
3248       return NULL;
3249     }
3250
3251   /* Is this a pre-existing architecture (as determined by already
3252      being initialized)?  Move it to the front of the architecture
3253      list (keeping the list sorted Most Recently Used).  */
3254   if (new_gdbarch->initialized_p)
3255     {
3256       struct gdbarch_list **list;
3257       struct gdbarch_list *this;
3258       if (gdbarch_debug)
3259         fprintf_unfiltered (gdb_stdlog, "find_arch_by_info: "
3260                             "Previous architecture 0x%08lx (%s) selected\n",
3261                             (long) new_gdbarch,
3262                             new_gdbarch->bfd_arch_info->printable_name);
3263       /* Find the existing arch in the list.  */
3264       for (list = &rego->arches;
3265            (*list) != NULL && (*list)->gdbarch != new_gdbarch;
3266            list = &(*list)->next);
3267       /* It had better be in the list of architectures.  */
3268       gdb_assert ((*list) != NULL && (*list)->gdbarch == new_gdbarch);
3269       /* Unlink THIS.  */
3270       this = (*list);
3271       (*list) = this->next;
3272       /* Insert THIS at the front.  */
3273       this->next = rego->arches;
3274       rego->arches = this;
3275       /* Return it.  */
3276       return new_gdbarch;
3277     }
3278
3279   /* It's a new architecture.  */
3280   if (gdbarch_debug)
3281     fprintf_unfiltered (gdb_stdlog, "find_arch_by_info: "
3282                         "New architecture 0x%08lx (%s) selected\n",
3283                         (long) new_gdbarch,
3284                         new_gdbarch->bfd_arch_info->printable_name);
3285
3286   /* Insert the new architecture into the front of the architecture
3287      list (keep the list sorted Most Recently Used).  */
3288   {
3289     struct gdbarch_list *this = XMALLOC (struct gdbarch_list);
3290     this->next = rego->arches;
3291     this->gdbarch = new_gdbarch;
3292     rego->arches = this;
3293   }
3294
3295   /* Check that the newly installed architecture is valid.  Plug in
3296      any post init values.  */
3297   new_gdbarch->dump_tdep = rego->dump_tdep;
3298   verify_gdbarch (new_gdbarch);
3299   new_gdbarch->initialized_p = 1;
3300
3301   if (gdbarch_debug)
3302     gdbarch_dump (new_gdbarch, gdb_stdlog);
3303
3304   return new_gdbarch;
3305 }
3306
3307 struct gdbarch *
3308 gdbarch_find_by_info (struct gdbarch_info info)
3309 {
3310   struct gdbarch *new_gdbarch;
3311
3312   /* Save the previously selected architecture, setting the global to
3313      NULL.  This stops things like gdbarch->init() trying to use the
3314      previous architecture's configuration.  The previous architecture
3315      may not even be of the same architecture family.  The most recent
3316      architecture of the same family is found at the head of the
3317      rego->arches list.  */
3318   struct gdbarch *old_gdbarch = current_gdbarch;
3319   current_gdbarch = NULL;
3320
3321   /* Find the specified architecture.  */
3322   new_gdbarch = find_arch_by_info (info);
3323
3324   /* Restore the existing architecture.  */
3325   gdb_assert (current_gdbarch == NULL);
3326   current_gdbarch = old_gdbarch;
3327
3328   return new_gdbarch;
3329 }
3330
3331 /* Make the specified architecture current.  */
3332
3333 void
3334 deprecated_current_gdbarch_select_hack (struct gdbarch *new_gdbarch)
3335 {
3336   gdb_assert (new_gdbarch != NULL);
3337   gdb_assert (current_gdbarch != NULL);
3338   gdb_assert (new_gdbarch->initialized_p);
3339   current_gdbarch = new_gdbarch;
3340   architecture_changed_event ();
3341   reinit_frame_cache ();
3342 }
3343
3344 extern void _initialize_gdbarch (void);
3345
3346 void
3347 _initialize_gdbarch (void)
3348 {
3349   struct cmd_list_element *c;
3350
3351   add_setshow_zinteger_cmd ("arch", class_maintenance, &gdbarch_debug, _("\
3352 Set architecture debugging."), _("\
3353 Show architecture debugging."), _("\
3354 When non-zero, architecture debugging is enabled."),
3355                             NULL,
3356                             show_gdbarch_debug,
3357                             &setdebuglist, &showdebuglist);
3358 }