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