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