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