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