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 #ifdef SMASH_TEXT_ADDRESS
1159   fprintf_unfiltered (file,
1160                       "gdbarch_dump: %s # %s\n",
1161                       "SMASH_TEXT_ADDRESS(addr)",
1162                       XSTRING (SMASH_TEXT_ADDRESS (addr)));
1163 #endif
1164   fprintf_unfiltered (file,
1165                       "gdbarch_dump: smash_text_address = <0x%lx>\n",
1166                       (long) current_gdbarch->smash_text_address);
1167 #ifdef SOFTWARE_SINGLE_STEP_P
1168   fprintf_unfiltered (file,
1169                       "gdbarch_dump: %s # %s\n",
1170                       "SOFTWARE_SINGLE_STEP_P()",
1171                       XSTRING (SOFTWARE_SINGLE_STEP_P ()));
1172 #endif
1173   fprintf_unfiltered (file,
1174                       "gdbarch_dump: gdbarch_software_single_step_p() = %d\n",
1175                       gdbarch_software_single_step_p (current_gdbarch));
1176 #ifdef SOFTWARE_SINGLE_STEP
1177   fprintf_unfiltered (file,
1178                       "gdbarch_dump: %s # %s\n",
1179                       "SOFTWARE_SINGLE_STEP(regcache)",
1180                       XSTRING (SOFTWARE_SINGLE_STEP (regcache)));
1181 #endif
1182   fprintf_unfiltered (file,
1183                       "gdbarch_dump: software_single_step = <0x%lx>\n",
1184                       (long) current_gdbarch->software_single_step);
1185 #ifdef SP_REGNUM
1186   fprintf_unfiltered (file,
1187                       "gdbarch_dump: SP_REGNUM # %s\n",
1188                       XSTRING (SP_REGNUM));
1189 #endif
1190   fprintf_unfiltered (file,
1191                       "gdbarch_dump: sp_regnum = %s\n",
1192                       paddr_d (current_gdbarch->sp_regnum));
1193 #ifdef STAB_REG_TO_REGNUM
1194   fprintf_unfiltered (file,
1195                       "gdbarch_dump: %s # %s\n",
1196                       "STAB_REG_TO_REGNUM(stab_regnr)",
1197                       XSTRING (STAB_REG_TO_REGNUM (stab_regnr)));
1198 #endif
1199   fprintf_unfiltered (file,
1200                       "gdbarch_dump: stab_reg_to_regnum = <0x%lx>\n",
1201                       (long) current_gdbarch->stab_reg_to_regnum);
1202   fprintf_unfiltered (file,
1203                       "gdbarch_dump: stabs_argument_has_addr = <0x%lx>\n",
1204                       (long) current_gdbarch->stabs_argument_has_addr);
1205 #ifdef STORE_RETURN_VALUE
1206   fprintf_unfiltered (file,
1207                       "gdbarch_dump: %s # %s\n",
1208                       "STORE_RETURN_VALUE(type, regcache, valbuf)",
1209                       XSTRING (STORE_RETURN_VALUE (type, regcache, valbuf)));
1210 #endif
1211   fprintf_unfiltered (file,
1212                       "gdbarch_dump: store_return_value = <0x%lx>\n",
1213                       (long) current_gdbarch->store_return_value);
1214   fprintf_unfiltered (file,
1215                       "gdbarch_dump: target_desc = %s\n",
1216                       paddr_d ((long) current_gdbarch->target_desc));
1217   fprintf_unfiltered (file,
1218                       "gdbarch_dump: gdbarch_unwind_dummy_id_p() = %d\n",
1219                       gdbarch_unwind_dummy_id_p (current_gdbarch));
1220   fprintf_unfiltered (file,
1221                       "gdbarch_dump: unwind_dummy_id = <0x%lx>\n",
1222                       (long) current_gdbarch->unwind_dummy_id);
1223   fprintf_unfiltered (file,
1224                       "gdbarch_dump: gdbarch_unwind_pc_p() = %d\n",
1225                       gdbarch_unwind_pc_p (current_gdbarch));
1226   fprintf_unfiltered (file,
1227                       "gdbarch_dump: unwind_pc = <0x%lx>\n",
1228                       (long) current_gdbarch->unwind_pc);
1229   fprintf_unfiltered (file,
1230                       "gdbarch_dump: gdbarch_unwind_sp_p() = %d\n",
1231                       gdbarch_unwind_sp_p (current_gdbarch));
1232   fprintf_unfiltered (file,
1233                       "gdbarch_dump: unwind_sp = <0x%lx>\n",
1234                       (long) current_gdbarch->unwind_sp);
1235   fprintf_unfiltered (file,
1236                       "gdbarch_dump: value_from_register = <0x%lx>\n",
1237                       (long) current_gdbarch->value_from_register);
1238   fprintf_unfiltered (file,
1239                       "gdbarch_dump: value_to_register = <0x%lx>\n",
1240                       (long) current_gdbarch->value_to_register);
1241   fprintf_unfiltered (file,
1242                       "gdbarch_dump: vbit_in_delta = %s\n",
1243                       paddr_d (current_gdbarch->vbit_in_delta));
1244   fprintf_unfiltered (file,
1245                       "gdbarch_dump: virtual_frame_pointer = <0x%lx>\n",
1246                       (long) current_gdbarch->virtual_frame_pointer);
1247   fprintf_unfiltered (file,
1248                       "gdbarch_dump: vtable_function_descriptors = %s\n",
1249                       paddr_d (current_gdbarch->vtable_function_descriptors));
1250 #ifdef TARGET_WRITE_PC
1251   fprintf_unfiltered (file,
1252                       "gdbarch_dump: %s # %s\n",
1253                       "TARGET_WRITE_PC(val, ptid)",
1254                       XSTRING (TARGET_WRITE_PC (val, ptid)));
1255 #endif
1256   fprintf_unfiltered (file,
1257                       "gdbarch_dump: write_pc = <0x%lx>\n",
1258                       (long) current_gdbarch->write_pc);
1259   if (current_gdbarch->dump_tdep != NULL)
1260     current_gdbarch->dump_tdep (current_gdbarch, file);
1261 }
1262
1263 struct gdbarch_tdep *
1264 gdbarch_tdep (struct gdbarch *gdbarch)
1265 {
1266   if (gdbarch_debug >= 2)
1267     fprintf_unfiltered (gdb_stdlog, "gdbarch_tdep called\n");
1268   return gdbarch->tdep;
1269 }
1270
1271
1272 const struct bfd_arch_info *
1273 gdbarch_bfd_arch_info (struct gdbarch *gdbarch)
1274 {
1275   gdb_assert (gdbarch != NULL);
1276   if (gdbarch_debug >= 2)
1277     fprintf_unfiltered (gdb_stdlog, "gdbarch_bfd_arch_info called\n");
1278   return gdbarch->bfd_arch_info;
1279 }
1280
1281 int
1282 gdbarch_byte_order (struct gdbarch *gdbarch)
1283 {
1284   gdb_assert (gdbarch != NULL);
1285   if (gdbarch_debug >= 2)
1286     fprintf_unfiltered (gdb_stdlog, "gdbarch_byte_order called\n");
1287   return gdbarch->byte_order;
1288 }
1289
1290 enum gdb_osabi
1291 gdbarch_osabi (struct gdbarch *gdbarch)
1292 {
1293   gdb_assert (gdbarch != NULL);
1294   if (gdbarch_debug >= 2)
1295     fprintf_unfiltered (gdb_stdlog, "gdbarch_osabi called\n");
1296   return gdbarch->osabi;
1297 }
1298
1299 const struct target_desc *
1300 gdbarch_target_desc (struct gdbarch *gdbarch)
1301 {
1302   gdb_assert (gdbarch != NULL);
1303   if (gdbarch_debug >= 2)
1304     fprintf_unfiltered (gdb_stdlog, "gdbarch_target_desc called\n");
1305   return gdbarch->target_desc;
1306 }
1307
1308 int
1309 gdbarch_short_bit (struct gdbarch *gdbarch)
1310 {
1311   gdb_assert (gdbarch != NULL);
1312   /* Skip verify of short_bit, invalid_p == 0 */
1313   if (gdbarch_debug >= 2)
1314     fprintf_unfiltered (gdb_stdlog, "gdbarch_short_bit called\n");
1315   return gdbarch->short_bit;
1316 }
1317
1318 void
1319 set_gdbarch_short_bit (struct gdbarch *gdbarch,
1320                        int short_bit)
1321 {
1322   gdbarch->short_bit = short_bit;
1323 }
1324
1325 int
1326 gdbarch_int_bit (struct gdbarch *gdbarch)
1327 {
1328   gdb_assert (gdbarch != NULL);
1329   /* Skip verify of int_bit, invalid_p == 0 */
1330   if (gdbarch_debug >= 2)
1331     fprintf_unfiltered (gdb_stdlog, "gdbarch_int_bit called\n");
1332   return gdbarch->int_bit;
1333 }
1334
1335 void
1336 set_gdbarch_int_bit (struct gdbarch *gdbarch,
1337                      int int_bit)
1338 {
1339   gdbarch->int_bit = int_bit;
1340 }
1341
1342 int
1343 gdbarch_long_bit (struct gdbarch *gdbarch)
1344 {
1345   gdb_assert (gdbarch != NULL);
1346   /* Skip verify of long_bit, invalid_p == 0 */
1347   if (gdbarch_debug >= 2)
1348     fprintf_unfiltered (gdb_stdlog, "gdbarch_long_bit called\n");
1349   return gdbarch->long_bit;
1350 }
1351
1352 void
1353 set_gdbarch_long_bit (struct gdbarch *gdbarch,
1354                       int long_bit)
1355 {
1356   gdbarch->long_bit = long_bit;
1357 }
1358
1359 int
1360 gdbarch_long_long_bit (struct gdbarch *gdbarch)
1361 {
1362   gdb_assert (gdbarch != NULL);
1363   /* Skip verify of long_long_bit, invalid_p == 0 */
1364   if (gdbarch_debug >= 2)
1365     fprintf_unfiltered (gdb_stdlog, "gdbarch_long_long_bit called\n");
1366   return gdbarch->long_long_bit;
1367 }
1368
1369 void
1370 set_gdbarch_long_long_bit (struct gdbarch *gdbarch,
1371                            int long_long_bit)
1372 {
1373   gdbarch->long_long_bit = long_long_bit;
1374 }
1375
1376 int
1377 gdbarch_float_bit (struct gdbarch *gdbarch)
1378 {
1379   gdb_assert (gdbarch != NULL);
1380   /* Skip verify of float_bit, invalid_p == 0 */
1381   if (gdbarch_debug >= 2)
1382     fprintf_unfiltered (gdb_stdlog, "gdbarch_float_bit called\n");
1383   return gdbarch->float_bit;
1384 }
1385
1386 void
1387 set_gdbarch_float_bit (struct gdbarch *gdbarch,
1388                        int float_bit)
1389 {
1390   gdbarch->float_bit = float_bit;
1391 }
1392
1393 const struct floatformat **
1394 gdbarch_float_format (struct gdbarch *gdbarch)
1395 {
1396   gdb_assert (gdbarch != NULL);
1397   if (gdbarch_debug >= 2)
1398     fprintf_unfiltered (gdb_stdlog, "gdbarch_float_format called\n");
1399   return gdbarch->float_format;
1400 }
1401
1402 void
1403 set_gdbarch_float_format (struct gdbarch *gdbarch,
1404                           const struct floatformat ** float_format)
1405 {
1406   gdbarch->float_format = float_format;
1407 }
1408
1409 int
1410 gdbarch_double_bit (struct gdbarch *gdbarch)
1411 {
1412   gdb_assert (gdbarch != NULL);
1413   /* Skip verify of double_bit, invalid_p == 0 */
1414   if (gdbarch_debug >= 2)
1415     fprintf_unfiltered (gdb_stdlog, "gdbarch_double_bit called\n");
1416   return gdbarch->double_bit;
1417 }
1418
1419 void
1420 set_gdbarch_double_bit (struct gdbarch *gdbarch,
1421                         int double_bit)
1422 {
1423   gdbarch->double_bit = double_bit;
1424 }
1425
1426 const struct floatformat **
1427 gdbarch_double_format (struct gdbarch *gdbarch)
1428 {
1429   gdb_assert (gdbarch != NULL);
1430   if (gdbarch_debug >= 2)
1431     fprintf_unfiltered (gdb_stdlog, "gdbarch_double_format called\n");
1432   return gdbarch->double_format;
1433 }
1434
1435 void
1436 set_gdbarch_double_format (struct gdbarch *gdbarch,
1437                            const struct floatformat ** double_format)
1438 {
1439   gdbarch->double_format = double_format;
1440 }
1441
1442 int
1443 gdbarch_long_double_bit (struct gdbarch *gdbarch)
1444 {
1445   gdb_assert (gdbarch != NULL);
1446   /* Skip verify of long_double_bit, invalid_p == 0 */
1447   if (gdbarch_debug >= 2)
1448     fprintf_unfiltered (gdb_stdlog, "gdbarch_long_double_bit called\n");
1449   return gdbarch->long_double_bit;
1450 }
1451
1452 void
1453 set_gdbarch_long_double_bit (struct gdbarch *gdbarch,
1454                              int long_double_bit)
1455 {
1456   gdbarch->long_double_bit = long_double_bit;
1457 }
1458
1459 const struct floatformat **
1460 gdbarch_long_double_format (struct gdbarch *gdbarch)
1461 {
1462   gdb_assert (gdbarch != NULL);
1463   if (gdbarch_debug >= 2)
1464     fprintf_unfiltered (gdb_stdlog, "gdbarch_long_double_format called\n");
1465   return gdbarch->long_double_format;
1466 }
1467
1468 void
1469 set_gdbarch_long_double_format (struct gdbarch *gdbarch,
1470                                 const struct floatformat ** long_double_format)
1471 {
1472   gdbarch->long_double_format = long_double_format;
1473 }
1474
1475 int
1476 gdbarch_ptr_bit (struct gdbarch *gdbarch)
1477 {
1478   gdb_assert (gdbarch != NULL);
1479   /* Skip verify of ptr_bit, invalid_p == 0 */
1480   if (gdbarch_debug >= 2)
1481     fprintf_unfiltered (gdb_stdlog, "gdbarch_ptr_bit called\n");
1482   return gdbarch->ptr_bit;
1483 }
1484
1485 void
1486 set_gdbarch_ptr_bit (struct gdbarch *gdbarch,
1487                      int ptr_bit)
1488 {
1489   gdbarch->ptr_bit = ptr_bit;
1490 }
1491
1492 int
1493 gdbarch_addr_bit (struct gdbarch *gdbarch)
1494 {
1495   gdb_assert (gdbarch != NULL);
1496   /* Check variable changed from pre-default.  */
1497   gdb_assert (gdbarch->addr_bit != 0);
1498   if (gdbarch_debug >= 2)
1499     fprintf_unfiltered (gdb_stdlog, "gdbarch_addr_bit called\n");
1500   return gdbarch->addr_bit;
1501 }
1502
1503 void
1504 set_gdbarch_addr_bit (struct gdbarch *gdbarch,
1505                       int addr_bit)
1506 {
1507   gdbarch->addr_bit = addr_bit;
1508 }
1509
1510 int
1511 gdbarch_bfd_vma_bit (struct gdbarch *gdbarch)
1512 {
1513   gdb_assert (gdbarch != NULL);
1514   /* Skip verify of bfd_vma_bit, invalid_p == 0 */
1515   if (gdbarch_debug >= 2)
1516     fprintf_unfiltered (gdb_stdlog, "gdbarch_bfd_vma_bit called\n");
1517   return gdbarch->bfd_vma_bit;
1518 }
1519
1520 void
1521 set_gdbarch_bfd_vma_bit (struct gdbarch *gdbarch,
1522                          int bfd_vma_bit)
1523 {
1524   gdbarch->bfd_vma_bit = bfd_vma_bit;
1525 }
1526
1527 int
1528 gdbarch_char_signed (struct gdbarch *gdbarch)
1529 {
1530   gdb_assert (gdbarch != NULL);
1531   /* Check variable changed from pre-default.  */
1532   gdb_assert (gdbarch->char_signed != -1);
1533   if (gdbarch_debug >= 2)
1534     fprintf_unfiltered (gdb_stdlog, "gdbarch_char_signed called\n");
1535   return gdbarch->char_signed;
1536 }
1537
1538 void
1539 set_gdbarch_char_signed (struct gdbarch *gdbarch,
1540                          int char_signed)
1541 {
1542   gdbarch->char_signed = char_signed;
1543 }
1544
1545 int
1546 gdbarch_read_pc_p (struct gdbarch *gdbarch)
1547 {
1548   gdb_assert (gdbarch != NULL);
1549   return gdbarch->read_pc != NULL;
1550 }
1551
1552 CORE_ADDR
1553 gdbarch_read_pc (struct gdbarch *gdbarch, ptid_t ptid)
1554 {
1555   gdb_assert (gdbarch != NULL);
1556   gdb_assert (gdbarch->read_pc != NULL);
1557   if (gdbarch_debug >= 2)
1558     fprintf_unfiltered (gdb_stdlog, "gdbarch_read_pc called\n");
1559   return gdbarch->read_pc (ptid);
1560 }
1561
1562 void
1563 set_gdbarch_read_pc (struct gdbarch *gdbarch,
1564                      gdbarch_read_pc_ftype read_pc)
1565 {
1566   gdbarch->read_pc = read_pc;
1567 }
1568
1569 void
1570 gdbarch_write_pc (struct gdbarch *gdbarch, CORE_ADDR val, ptid_t ptid)
1571 {
1572   gdb_assert (gdbarch != NULL);
1573   gdb_assert (gdbarch->write_pc != NULL);
1574   if (gdbarch_debug >= 2)
1575     fprintf_unfiltered (gdb_stdlog, "gdbarch_write_pc called\n");
1576   gdbarch->write_pc (val, ptid);
1577 }
1578
1579 void
1580 set_gdbarch_write_pc (struct gdbarch *gdbarch,
1581                       gdbarch_write_pc_ftype write_pc)
1582 {
1583   gdbarch->write_pc = write_pc;
1584 }
1585
1586 void
1587 gdbarch_virtual_frame_pointer (struct gdbarch *gdbarch, CORE_ADDR pc, int *frame_regnum, LONGEST *frame_offset)
1588 {
1589   gdb_assert (gdbarch != NULL);
1590   gdb_assert (gdbarch->virtual_frame_pointer != NULL);
1591   if (gdbarch_debug >= 2)
1592     fprintf_unfiltered (gdb_stdlog, "gdbarch_virtual_frame_pointer called\n");
1593   gdbarch->virtual_frame_pointer (pc, frame_regnum, frame_offset);
1594 }
1595
1596 void
1597 set_gdbarch_virtual_frame_pointer (struct gdbarch *gdbarch,
1598                                    gdbarch_virtual_frame_pointer_ftype virtual_frame_pointer)
1599 {
1600   gdbarch->virtual_frame_pointer = virtual_frame_pointer;
1601 }
1602
1603 int
1604 gdbarch_pseudo_register_read_p (struct gdbarch *gdbarch)
1605 {
1606   gdb_assert (gdbarch != NULL);
1607   return gdbarch->pseudo_register_read != NULL;
1608 }
1609
1610 void
1611 gdbarch_pseudo_register_read (struct gdbarch *gdbarch, struct regcache *regcache, int cookednum, gdb_byte *buf)
1612 {
1613   gdb_assert (gdbarch != NULL);
1614   gdb_assert (gdbarch->pseudo_register_read != NULL);
1615   if (gdbarch_debug >= 2)
1616     fprintf_unfiltered (gdb_stdlog, "gdbarch_pseudo_register_read called\n");
1617   gdbarch->pseudo_register_read (gdbarch, regcache, cookednum, buf);
1618 }
1619
1620 void
1621 set_gdbarch_pseudo_register_read (struct gdbarch *gdbarch,
1622                                   gdbarch_pseudo_register_read_ftype pseudo_register_read)
1623 {
1624   gdbarch->pseudo_register_read = pseudo_register_read;
1625 }
1626
1627 int
1628 gdbarch_pseudo_register_write_p (struct gdbarch *gdbarch)
1629 {
1630   gdb_assert (gdbarch != NULL);
1631   return gdbarch->pseudo_register_write != NULL;
1632 }
1633
1634 void
1635 gdbarch_pseudo_register_write (struct gdbarch *gdbarch, struct regcache *regcache, int cookednum, const gdb_byte *buf)
1636 {
1637   gdb_assert (gdbarch != NULL);
1638   gdb_assert (gdbarch->pseudo_register_write != NULL);
1639   if (gdbarch_debug >= 2)
1640     fprintf_unfiltered (gdb_stdlog, "gdbarch_pseudo_register_write called\n");
1641   gdbarch->pseudo_register_write (gdbarch, regcache, cookednum, buf);
1642 }
1643
1644 void
1645 set_gdbarch_pseudo_register_write (struct gdbarch *gdbarch,
1646                                    gdbarch_pseudo_register_write_ftype pseudo_register_write)
1647 {
1648   gdbarch->pseudo_register_write = pseudo_register_write;
1649 }
1650
1651 int
1652 gdbarch_num_regs (struct gdbarch *gdbarch)
1653 {
1654   gdb_assert (gdbarch != NULL);
1655   /* Check variable changed from pre-default.  */
1656   gdb_assert (gdbarch->num_regs != -1);
1657   if (gdbarch_debug >= 2)
1658     fprintf_unfiltered (gdb_stdlog, "gdbarch_num_regs called\n");
1659   return gdbarch->num_regs;
1660 }
1661
1662 void
1663 set_gdbarch_num_regs (struct gdbarch *gdbarch,
1664                       int num_regs)
1665 {
1666   gdbarch->num_regs = num_regs;
1667 }
1668
1669 int
1670 gdbarch_num_pseudo_regs (struct gdbarch *gdbarch)
1671 {
1672   gdb_assert (gdbarch != NULL);
1673   /* Skip verify of num_pseudo_regs, invalid_p == 0 */
1674   if (gdbarch_debug >= 2)
1675     fprintf_unfiltered (gdb_stdlog, "gdbarch_num_pseudo_regs called\n");
1676   return gdbarch->num_pseudo_regs;
1677 }
1678
1679 void
1680 set_gdbarch_num_pseudo_regs (struct gdbarch *gdbarch,
1681                              int num_pseudo_regs)
1682 {
1683   gdbarch->num_pseudo_regs = num_pseudo_regs;
1684 }
1685
1686 int
1687 gdbarch_sp_regnum (struct gdbarch *gdbarch)
1688 {
1689   gdb_assert (gdbarch != NULL);
1690   /* Skip verify of sp_regnum, invalid_p == 0 */
1691   if (gdbarch_debug >= 2)
1692     fprintf_unfiltered (gdb_stdlog, "gdbarch_sp_regnum called\n");
1693   return gdbarch->sp_regnum;
1694 }
1695
1696 void
1697 set_gdbarch_sp_regnum (struct gdbarch *gdbarch,
1698                        int sp_regnum)
1699 {
1700   gdbarch->sp_regnum = sp_regnum;
1701 }
1702
1703 int
1704 gdbarch_pc_regnum (struct gdbarch *gdbarch)
1705 {
1706   gdb_assert (gdbarch != NULL);
1707   /* Skip verify of pc_regnum, invalid_p == 0 */
1708   if (gdbarch_debug >= 2)
1709     fprintf_unfiltered (gdb_stdlog, "gdbarch_pc_regnum called\n");
1710   return gdbarch->pc_regnum;
1711 }
1712
1713 void
1714 set_gdbarch_pc_regnum (struct gdbarch *gdbarch,
1715                        int pc_regnum)
1716 {
1717   gdbarch->pc_regnum = pc_regnum;
1718 }
1719
1720 int
1721 gdbarch_ps_regnum (struct gdbarch *gdbarch)
1722 {
1723   gdb_assert (gdbarch != NULL);
1724   /* Skip verify of ps_regnum, invalid_p == 0 */
1725   if (gdbarch_debug >= 2)
1726     fprintf_unfiltered (gdb_stdlog, "gdbarch_ps_regnum called\n");
1727   return gdbarch->ps_regnum;
1728 }
1729
1730 void
1731 set_gdbarch_ps_regnum (struct gdbarch *gdbarch,
1732                        int ps_regnum)
1733 {
1734   gdbarch->ps_regnum = ps_regnum;
1735 }
1736
1737 int
1738 gdbarch_fp0_regnum (struct gdbarch *gdbarch)
1739 {
1740   gdb_assert (gdbarch != NULL);
1741   /* Skip verify of fp0_regnum, invalid_p == 0 */
1742   if (gdbarch_debug >= 2)
1743     fprintf_unfiltered (gdb_stdlog, "gdbarch_fp0_regnum called\n");
1744   return gdbarch->fp0_regnum;
1745 }
1746
1747 void
1748 set_gdbarch_fp0_regnum (struct gdbarch *gdbarch,
1749                         int fp0_regnum)
1750 {
1751   gdbarch->fp0_regnum = fp0_regnum;
1752 }
1753
1754 int
1755 gdbarch_stab_reg_to_regnum (struct gdbarch *gdbarch, int stab_regnr)
1756 {
1757   gdb_assert (gdbarch != NULL);
1758   gdb_assert (gdbarch->stab_reg_to_regnum != NULL);
1759   if (gdbarch_debug >= 2)
1760     fprintf_unfiltered (gdb_stdlog, "gdbarch_stab_reg_to_regnum called\n");
1761   return gdbarch->stab_reg_to_regnum (stab_regnr);
1762 }
1763
1764 void
1765 set_gdbarch_stab_reg_to_regnum (struct gdbarch *gdbarch,
1766                                 gdbarch_stab_reg_to_regnum_ftype stab_reg_to_regnum)
1767 {
1768   gdbarch->stab_reg_to_regnum = stab_reg_to_regnum;
1769 }
1770
1771 int
1772 gdbarch_ecoff_reg_to_regnum (struct gdbarch *gdbarch, int ecoff_regnr)
1773 {
1774   gdb_assert (gdbarch != NULL);
1775   gdb_assert (gdbarch->ecoff_reg_to_regnum != NULL);
1776   if (gdbarch_debug >= 2)
1777     fprintf_unfiltered (gdb_stdlog, "gdbarch_ecoff_reg_to_regnum called\n");
1778   return gdbarch->ecoff_reg_to_regnum (ecoff_regnr);
1779 }
1780
1781 void
1782 set_gdbarch_ecoff_reg_to_regnum (struct gdbarch *gdbarch,
1783                                  gdbarch_ecoff_reg_to_regnum_ftype ecoff_reg_to_regnum)
1784 {
1785   gdbarch->ecoff_reg_to_regnum = ecoff_reg_to_regnum;
1786 }
1787
1788 int
1789 gdbarch_dwarf_reg_to_regnum (struct gdbarch *gdbarch, int dwarf_regnr)
1790 {
1791   gdb_assert (gdbarch != NULL);
1792   gdb_assert (gdbarch->dwarf_reg_to_regnum != NULL);
1793   if (gdbarch_debug >= 2)
1794     fprintf_unfiltered (gdb_stdlog, "gdbarch_dwarf_reg_to_regnum called\n");
1795   return gdbarch->dwarf_reg_to_regnum (dwarf_regnr);
1796 }
1797
1798 void
1799 set_gdbarch_dwarf_reg_to_regnum (struct gdbarch *gdbarch,
1800                                  gdbarch_dwarf_reg_to_regnum_ftype dwarf_reg_to_regnum)
1801 {
1802   gdbarch->dwarf_reg_to_regnum = dwarf_reg_to_regnum;
1803 }
1804
1805 int
1806 gdbarch_sdb_reg_to_regnum (struct gdbarch *gdbarch, int sdb_regnr)
1807 {
1808   gdb_assert (gdbarch != NULL);
1809   gdb_assert (gdbarch->sdb_reg_to_regnum != NULL);
1810   if (gdbarch_debug >= 2)
1811     fprintf_unfiltered (gdb_stdlog, "gdbarch_sdb_reg_to_regnum called\n");
1812   return gdbarch->sdb_reg_to_regnum (sdb_regnr);
1813 }
1814
1815 void
1816 set_gdbarch_sdb_reg_to_regnum (struct gdbarch *gdbarch,
1817                                gdbarch_sdb_reg_to_regnum_ftype sdb_reg_to_regnum)
1818 {
1819   gdbarch->sdb_reg_to_regnum = sdb_reg_to_regnum;
1820 }
1821
1822 int
1823 gdbarch_dwarf2_reg_to_regnum (struct gdbarch *gdbarch, int dwarf2_regnr)
1824 {
1825   gdb_assert (gdbarch != NULL);
1826   gdb_assert (gdbarch->dwarf2_reg_to_regnum != NULL);
1827   if (gdbarch_debug >= 2)
1828     fprintf_unfiltered (gdb_stdlog, "gdbarch_dwarf2_reg_to_regnum called\n");
1829   return gdbarch->dwarf2_reg_to_regnum (dwarf2_regnr);
1830 }
1831
1832 void
1833 set_gdbarch_dwarf2_reg_to_regnum (struct gdbarch *gdbarch,
1834                                   gdbarch_dwarf2_reg_to_regnum_ftype dwarf2_reg_to_regnum)
1835 {
1836   gdbarch->dwarf2_reg_to_regnum = dwarf2_reg_to_regnum;
1837 }
1838
1839 const char *
1840 gdbarch_register_name (struct gdbarch *gdbarch, int regnr)
1841 {
1842   gdb_assert (gdbarch != NULL);
1843   gdb_assert (gdbarch->register_name != NULL);
1844   if (gdbarch_debug >= 2)
1845     fprintf_unfiltered (gdb_stdlog, "gdbarch_register_name called\n");
1846   return gdbarch->register_name (regnr);
1847 }
1848
1849 void
1850 set_gdbarch_register_name (struct gdbarch *gdbarch,
1851                            gdbarch_register_name_ftype register_name)
1852 {
1853   gdbarch->register_name = register_name;
1854 }
1855
1856 int
1857 gdbarch_register_type_p (struct gdbarch *gdbarch)
1858 {
1859   gdb_assert (gdbarch != NULL);
1860   return gdbarch->register_type != NULL;
1861 }
1862
1863 struct type *
1864 gdbarch_register_type (struct gdbarch *gdbarch, int reg_nr)
1865 {
1866   gdb_assert (gdbarch != NULL);
1867   gdb_assert (gdbarch->register_type != NULL);
1868   if (gdbarch_debug >= 2)
1869     fprintf_unfiltered (gdb_stdlog, "gdbarch_register_type called\n");
1870   return gdbarch->register_type (gdbarch, reg_nr);
1871 }
1872
1873 void
1874 set_gdbarch_register_type (struct gdbarch *gdbarch,
1875                            gdbarch_register_type_ftype register_type)
1876 {
1877   gdbarch->register_type = register_type;
1878 }
1879
1880 int
1881 gdbarch_unwind_dummy_id_p (struct gdbarch *gdbarch)
1882 {
1883   gdb_assert (gdbarch != NULL);
1884   return gdbarch->unwind_dummy_id != NULL;
1885 }
1886
1887 struct frame_id
1888 gdbarch_unwind_dummy_id (struct gdbarch *gdbarch, struct frame_info *info)
1889 {
1890   gdb_assert (gdbarch != NULL);
1891   gdb_assert (gdbarch->unwind_dummy_id != NULL);
1892   if (gdbarch_debug >= 2)
1893     fprintf_unfiltered (gdb_stdlog, "gdbarch_unwind_dummy_id called\n");
1894   return gdbarch->unwind_dummy_id (gdbarch, info);
1895 }
1896
1897 void
1898 set_gdbarch_unwind_dummy_id (struct gdbarch *gdbarch,
1899                              gdbarch_unwind_dummy_id_ftype unwind_dummy_id)
1900 {
1901   gdbarch->unwind_dummy_id = unwind_dummy_id;
1902 }
1903
1904 int
1905 gdbarch_deprecated_fp_regnum (struct gdbarch *gdbarch)
1906 {
1907   gdb_assert (gdbarch != NULL);
1908   /* Skip verify of deprecated_fp_regnum, invalid_p == 0 */
1909   if (gdbarch_debug >= 2)
1910     fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_fp_regnum called\n");
1911   return gdbarch->deprecated_fp_regnum;
1912 }
1913
1914 void
1915 set_gdbarch_deprecated_fp_regnum (struct gdbarch *gdbarch,
1916                                   int deprecated_fp_regnum)
1917 {
1918   gdbarch->deprecated_fp_regnum = deprecated_fp_regnum;
1919 }
1920
1921 int
1922 gdbarch_push_dummy_call_p (struct gdbarch *gdbarch)
1923 {
1924   gdb_assert (gdbarch != NULL);
1925   return gdbarch->push_dummy_call != NULL;
1926 }
1927
1928 CORE_ADDR
1929 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)
1930 {
1931   gdb_assert (gdbarch != NULL);
1932   gdb_assert (gdbarch->push_dummy_call != NULL);
1933   if (gdbarch_debug >= 2)
1934     fprintf_unfiltered (gdb_stdlog, "gdbarch_push_dummy_call called\n");
1935   return gdbarch->push_dummy_call (gdbarch, function, regcache, bp_addr, nargs, args, sp, struct_return, struct_addr);
1936 }
1937
1938 void
1939 set_gdbarch_push_dummy_call (struct gdbarch *gdbarch,
1940                              gdbarch_push_dummy_call_ftype push_dummy_call)
1941 {
1942   gdbarch->push_dummy_call = push_dummy_call;
1943 }
1944
1945 int
1946 gdbarch_deprecated_register_size (struct gdbarch *gdbarch)
1947 {
1948   gdb_assert (gdbarch != NULL);
1949   if (gdbarch_debug >= 2)
1950     fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_register_size called\n");
1951   return gdbarch->deprecated_register_size;
1952 }
1953
1954 void
1955 set_gdbarch_deprecated_register_size (struct gdbarch *gdbarch,
1956                                       int deprecated_register_size)
1957 {
1958   gdbarch->deprecated_register_size = deprecated_register_size;
1959 }
1960
1961 int
1962 gdbarch_call_dummy_location (struct gdbarch *gdbarch)
1963 {
1964   gdb_assert (gdbarch != NULL);
1965   /* Skip verify of call_dummy_location, invalid_p == 0 */
1966   if (gdbarch_debug >= 2)
1967     fprintf_unfiltered (gdb_stdlog, "gdbarch_call_dummy_location called\n");
1968   return gdbarch->call_dummy_location;
1969 }
1970
1971 void
1972 set_gdbarch_call_dummy_location (struct gdbarch *gdbarch,
1973                                  int call_dummy_location)
1974 {
1975   gdbarch->call_dummy_location = call_dummy_location;
1976 }
1977
1978 int
1979 gdbarch_push_dummy_code_p (struct gdbarch *gdbarch)
1980 {
1981   gdb_assert (gdbarch != NULL);
1982   return gdbarch->push_dummy_code != NULL;
1983 }
1984
1985 CORE_ADDR
1986 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)
1987 {
1988   gdb_assert (gdbarch != NULL);
1989   gdb_assert (gdbarch->push_dummy_code != NULL);
1990   if (gdbarch_debug >= 2)
1991     fprintf_unfiltered (gdb_stdlog, "gdbarch_push_dummy_code called\n");
1992   return gdbarch->push_dummy_code (gdbarch, sp, funaddr, using_gcc, args, nargs, value_type, real_pc, bp_addr);
1993 }
1994
1995 void
1996 set_gdbarch_push_dummy_code (struct gdbarch *gdbarch,
1997                              gdbarch_push_dummy_code_ftype push_dummy_code)
1998 {
1999   gdbarch->push_dummy_code = push_dummy_code;
2000 }
2001
2002 void
2003 gdbarch_print_registers_info (struct gdbarch *gdbarch, struct ui_file *file, struct frame_info *frame, int regnum, int all)
2004 {
2005   gdb_assert (gdbarch != NULL);
2006   gdb_assert (gdbarch->print_registers_info != NULL);
2007   if (gdbarch_debug >= 2)
2008     fprintf_unfiltered (gdb_stdlog, "gdbarch_print_registers_info called\n");
2009   gdbarch->print_registers_info (gdbarch, file, frame, regnum, all);
2010 }
2011
2012 void
2013 set_gdbarch_print_registers_info (struct gdbarch *gdbarch,
2014                                   gdbarch_print_registers_info_ftype print_registers_info)
2015 {
2016   gdbarch->print_registers_info = print_registers_info;
2017 }
2018
2019 int
2020 gdbarch_print_float_info_p (struct gdbarch *gdbarch)
2021 {
2022   gdb_assert (gdbarch != NULL);
2023   return gdbarch->print_float_info != NULL;
2024 }
2025
2026 void
2027 gdbarch_print_float_info (struct gdbarch *gdbarch, struct ui_file *file, struct frame_info *frame, const char *args)
2028 {
2029   gdb_assert (gdbarch != NULL);
2030   gdb_assert (gdbarch->print_float_info != NULL);
2031   if (gdbarch_debug >= 2)
2032     fprintf_unfiltered (gdb_stdlog, "gdbarch_print_float_info called\n");
2033   gdbarch->print_float_info (gdbarch, file, frame, args);
2034 }
2035
2036 void
2037 set_gdbarch_print_float_info (struct gdbarch *gdbarch,
2038                               gdbarch_print_float_info_ftype print_float_info)
2039 {
2040   gdbarch->print_float_info = print_float_info;
2041 }
2042
2043 int
2044 gdbarch_print_vector_info_p (struct gdbarch *gdbarch)
2045 {
2046   gdb_assert (gdbarch != NULL);
2047   return gdbarch->print_vector_info != NULL;
2048 }
2049
2050 void
2051 gdbarch_print_vector_info (struct gdbarch *gdbarch, struct ui_file *file, struct frame_info *frame, const char *args)
2052 {
2053   gdb_assert (gdbarch != NULL);
2054   gdb_assert (gdbarch->print_vector_info != NULL);
2055   if (gdbarch_debug >= 2)
2056     fprintf_unfiltered (gdb_stdlog, "gdbarch_print_vector_info called\n");
2057   gdbarch->print_vector_info (gdbarch, file, frame, args);
2058 }
2059
2060 void
2061 set_gdbarch_print_vector_info (struct gdbarch *gdbarch,
2062                                gdbarch_print_vector_info_ftype print_vector_info)
2063 {
2064   gdbarch->print_vector_info = print_vector_info;
2065 }
2066
2067 int
2068 gdbarch_register_sim_regno (struct gdbarch *gdbarch, int reg_nr)
2069 {
2070   gdb_assert (gdbarch != NULL);
2071   gdb_assert (gdbarch->register_sim_regno != NULL);
2072   if (gdbarch_debug >= 2)
2073     fprintf_unfiltered (gdb_stdlog, "gdbarch_register_sim_regno called\n");
2074   return gdbarch->register_sim_regno (reg_nr);
2075 }
2076
2077 void
2078 set_gdbarch_register_sim_regno (struct gdbarch *gdbarch,
2079                                 gdbarch_register_sim_regno_ftype register_sim_regno)
2080 {
2081   gdbarch->register_sim_regno = register_sim_regno;
2082 }
2083
2084 int
2085 gdbarch_cannot_fetch_register (struct gdbarch *gdbarch, int regnum)
2086 {
2087   gdb_assert (gdbarch != NULL);
2088   gdb_assert (gdbarch->cannot_fetch_register != NULL);
2089   if (gdbarch_debug >= 2)
2090     fprintf_unfiltered (gdb_stdlog, "gdbarch_cannot_fetch_register called\n");
2091   return gdbarch->cannot_fetch_register (regnum);
2092 }
2093
2094 void
2095 set_gdbarch_cannot_fetch_register (struct gdbarch *gdbarch,
2096                                    gdbarch_cannot_fetch_register_ftype cannot_fetch_register)
2097 {
2098   gdbarch->cannot_fetch_register = cannot_fetch_register;
2099 }
2100
2101 int
2102 gdbarch_cannot_store_register (struct gdbarch *gdbarch, int regnum)
2103 {
2104   gdb_assert (gdbarch != NULL);
2105   gdb_assert (gdbarch->cannot_store_register != NULL);
2106   if (gdbarch_debug >= 2)
2107     fprintf_unfiltered (gdb_stdlog, "gdbarch_cannot_store_register called\n");
2108   return gdbarch->cannot_store_register (regnum);
2109 }
2110
2111 void
2112 set_gdbarch_cannot_store_register (struct gdbarch *gdbarch,
2113                                    gdbarch_cannot_store_register_ftype cannot_store_register)
2114 {
2115   gdbarch->cannot_store_register = cannot_store_register;
2116 }
2117
2118 int
2119 gdbarch_get_longjmp_target_p (struct gdbarch *gdbarch)
2120 {
2121   gdb_assert (gdbarch != NULL);
2122   return gdbarch->get_longjmp_target != NULL;
2123 }
2124
2125 int
2126 gdbarch_get_longjmp_target (struct gdbarch *gdbarch, CORE_ADDR *pc)
2127 {
2128   gdb_assert (gdbarch != NULL);
2129   gdb_assert (gdbarch->get_longjmp_target != NULL);
2130   if (gdbarch_debug >= 2)
2131     fprintf_unfiltered (gdb_stdlog, "gdbarch_get_longjmp_target called\n");
2132   return gdbarch->get_longjmp_target (pc);
2133 }
2134
2135 void
2136 set_gdbarch_get_longjmp_target (struct gdbarch *gdbarch,
2137                                 gdbarch_get_longjmp_target_ftype get_longjmp_target)
2138 {
2139   gdbarch->get_longjmp_target = get_longjmp_target;
2140 }
2141
2142 int
2143 gdbarch_believe_pcc_promotion (struct gdbarch *gdbarch)
2144 {
2145   gdb_assert (gdbarch != NULL);
2146   if (gdbarch_debug >= 2)
2147     fprintf_unfiltered (gdb_stdlog, "gdbarch_believe_pcc_promotion called\n");
2148   return gdbarch->believe_pcc_promotion;
2149 }
2150
2151 void
2152 set_gdbarch_believe_pcc_promotion (struct gdbarch *gdbarch,
2153                                    int believe_pcc_promotion)
2154 {
2155   gdbarch->believe_pcc_promotion = believe_pcc_promotion;
2156 }
2157
2158 int
2159 gdbarch_convert_register_p (struct gdbarch *gdbarch, int regnum, struct type *type)
2160 {
2161   gdb_assert (gdbarch != NULL);
2162   gdb_assert (gdbarch->convert_register_p != NULL);
2163   if (gdbarch_debug >= 2)
2164     fprintf_unfiltered (gdb_stdlog, "gdbarch_convert_register_p called\n");
2165   return gdbarch->convert_register_p (regnum, type);
2166 }
2167
2168 void
2169 set_gdbarch_convert_register_p (struct gdbarch *gdbarch,
2170                                 gdbarch_convert_register_p_ftype convert_register_p)
2171 {
2172   gdbarch->convert_register_p = convert_register_p;
2173 }
2174
2175 void
2176 gdbarch_register_to_value (struct gdbarch *gdbarch, struct frame_info *frame, int regnum, struct type *type, gdb_byte *buf)
2177 {
2178   gdb_assert (gdbarch != NULL);
2179   gdb_assert (gdbarch->register_to_value != NULL);
2180   if (gdbarch_debug >= 2)
2181     fprintf_unfiltered (gdb_stdlog, "gdbarch_register_to_value called\n");
2182   gdbarch->register_to_value (frame, regnum, type, buf);
2183 }
2184
2185 void
2186 set_gdbarch_register_to_value (struct gdbarch *gdbarch,
2187                                gdbarch_register_to_value_ftype register_to_value)
2188 {
2189   gdbarch->register_to_value = register_to_value;
2190 }
2191
2192 void
2193 gdbarch_value_to_register (struct gdbarch *gdbarch, struct frame_info *frame, int regnum, struct type *type, const gdb_byte *buf)
2194 {
2195   gdb_assert (gdbarch != NULL);
2196   gdb_assert (gdbarch->value_to_register != NULL);
2197   if (gdbarch_debug >= 2)
2198     fprintf_unfiltered (gdb_stdlog, "gdbarch_value_to_register called\n");
2199   gdbarch->value_to_register (frame, regnum, type, buf);
2200 }
2201
2202 void
2203 set_gdbarch_value_to_register (struct gdbarch *gdbarch,
2204                                gdbarch_value_to_register_ftype value_to_register)
2205 {
2206   gdbarch->value_to_register = value_to_register;
2207 }
2208
2209 struct value *
2210 gdbarch_value_from_register (struct gdbarch *gdbarch, struct type *type, int regnum, struct frame_info *frame)
2211 {
2212   gdb_assert (gdbarch != NULL);
2213   gdb_assert (gdbarch->value_from_register != NULL);
2214   if (gdbarch_debug >= 2)
2215     fprintf_unfiltered (gdb_stdlog, "gdbarch_value_from_register called\n");
2216   return gdbarch->value_from_register (type, regnum, frame);
2217 }
2218
2219 void
2220 set_gdbarch_value_from_register (struct gdbarch *gdbarch,
2221                                  gdbarch_value_from_register_ftype value_from_register)
2222 {
2223   gdbarch->value_from_register = value_from_register;
2224 }
2225
2226 CORE_ADDR
2227 gdbarch_pointer_to_address (struct gdbarch *gdbarch, struct type *type, const gdb_byte *buf)
2228 {
2229   gdb_assert (gdbarch != NULL);
2230   gdb_assert (gdbarch->pointer_to_address != NULL);
2231   if (gdbarch_debug >= 2)
2232     fprintf_unfiltered (gdb_stdlog, "gdbarch_pointer_to_address called\n");
2233   return gdbarch->pointer_to_address (type, buf);
2234 }
2235
2236 void
2237 set_gdbarch_pointer_to_address (struct gdbarch *gdbarch,
2238                                 gdbarch_pointer_to_address_ftype pointer_to_address)
2239 {
2240   gdbarch->pointer_to_address = pointer_to_address;
2241 }
2242
2243 void
2244 gdbarch_address_to_pointer (struct gdbarch *gdbarch, struct type *type, gdb_byte *buf, CORE_ADDR addr)
2245 {
2246   gdb_assert (gdbarch != NULL);
2247   gdb_assert (gdbarch->address_to_pointer != NULL);
2248   if (gdbarch_debug >= 2)
2249     fprintf_unfiltered (gdb_stdlog, "gdbarch_address_to_pointer called\n");
2250   gdbarch->address_to_pointer (type, buf, addr);
2251 }
2252
2253 void
2254 set_gdbarch_address_to_pointer (struct gdbarch *gdbarch,
2255                                 gdbarch_address_to_pointer_ftype address_to_pointer)
2256 {
2257   gdbarch->address_to_pointer = address_to_pointer;
2258 }
2259
2260 int
2261 gdbarch_integer_to_address_p (struct gdbarch *gdbarch)
2262 {
2263   gdb_assert (gdbarch != NULL);
2264   return gdbarch->integer_to_address != NULL;
2265 }
2266
2267 CORE_ADDR
2268 gdbarch_integer_to_address (struct gdbarch *gdbarch, struct type *type, const gdb_byte *buf)
2269 {
2270   gdb_assert (gdbarch != NULL);
2271   gdb_assert (gdbarch->integer_to_address != NULL);
2272   if (gdbarch_debug >= 2)
2273     fprintf_unfiltered (gdb_stdlog, "gdbarch_integer_to_address called\n");
2274   return gdbarch->integer_to_address (gdbarch, type, buf);
2275 }
2276
2277 void
2278 set_gdbarch_integer_to_address (struct gdbarch *gdbarch,
2279                                 gdbarch_integer_to_address_ftype integer_to_address)
2280 {
2281   gdbarch->integer_to_address = integer_to_address;
2282 }
2283
2284 int
2285 gdbarch_return_value_p (struct gdbarch *gdbarch)
2286 {
2287   gdb_assert (gdbarch != NULL);
2288   return gdbarch->return_value != legacy_return_value;
2289 }
2290
2291 enum return_value_convention
2292 gdbarch_return_value (struct gdbarch *gdbarch, struct type *valtype, struct regcache *regcache, gdb_byte *readbuf, const gdb_byte *writebuf)
2293 {
2294   gdb_assert (gdbarch != NULL);
2295   gdb_assert (gdbarch->return_value != NULL);
2296   /* Do not check predicate: gdbarch->return_value != legacy_return_value, allow call.  */
2297   if (gdbarch_debug >= 2)
2298     fprintf_unfiltered (gdb_stdlog, "gdbarch_return_value called\n");
2299   return gdbarch->return_value (gdbarch, valtype, regcache, readbuf, writebuf);
2300 }
2301
2302 void
2303 set_gdbarch_return_value (struct gdbarch *gdbarch,
2304                           gdbarch_return_value_ftype return_value)
2305 {
2306   gdbarch->return_value = return_value;
2307 }
2308
2309 void
2310 gdbarch_extract_return_value (struct gdbarch *gdbarch, struct type *type, struct regcache *regcache, gdb_byte *valbuf)
2311 {
2312   gdb_assert (gdbarch != NULL);
2313   gdb_assert (gdbarch->extract_return_value != NULL);
2314   if (gdbarch_debug >= 2)
2315     fprintf_unfiltered (gdb_stdlog, "gdbarch_extract_return_value called\n");
2316   gdbarch->extract_return_value (type, regcache, valbuf);
2317 }
2318
2319 void
2320 set_gdbarch_extract_return_value (struct gdbarch *gdbarch,
2321                                   gdbarch_extract_return_value_ftype extract_return_value)
2322 {
2323   gdbarch->extract_return_value = extract_return_value;
2324 }
2325
2326 void
2327 gdbarch_store_return_value (struct gdbarch *gdbarch, struct type *type, struct regcache *regcache, const gdb_byte *valbuf)
2328 {
2329   gdb_assert (gdbarch != NULL);
2330   gdb_assert (gdbarch->store_return_value != NULL);
2331   if (gdbarch_debug >= 2)
2332     fprintf_unfiltered (gdb_stdlog, "gdbarch_store_return_value called\n");
2333   gdbarch->store_return_value (type, regcache, valbuf);
2334 }
2335
2336 void
2337 set_gdbarch_store_return_value (struct gdbarch *gdbarch,
2338                                 gdbarch_store_return_value_ftype store_return_value)
2339 {
2340   gdbarch->store_return_value = store_return_value;
2341 }
2342
2343 int
2344 gdbarch_deprecated_use_struct_convention (struct gdbarch *gdbarch, int gcc_p, struct type *value_type)
2345 {
2346   gdb_assert (gdbarch != NULL);
2347   gdb_assert (gdbarch->deprecated_use_struct_convention != NULL);
2348   if (gdbarch_debug >= 2)
2349     fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_use_struct_convention called\n");
2350   return gdbarch->deprecated_use_struct_convention (gcc_p, value_type);
2351 }
2352
2353 void
2354 set_gdbarch_deprecated_use_struct_convention (struct gdbarch *gdbarch,
2355                                               gdbarch_deprecated_use_struct_convention_ftype deprecated_use_struct_convention)
2356 {
2357   gdbarch->deprecated_use_struct_convention = deprecated_use_struct_convention;
2358 }
2359
2360 int
2361 gdbarch_deprecated_extract_struct_value_address_p (struct gdbarch *gdbarch)
2362 {
2363   gdb_assert (gdbarch != NULL);
2364   return gdbarch->deprecated_extract_struct_value_address != NULL;
2365 }
2366
2367 CORE_ADDR
2368 gdbarch_deprecated_extract_struct_value_address (struct gdbarch *gdbarch, struct regcache *regcache)
2369 {
2370   gdb_assert (gdbarch != NULL);
2371   gdb_assert (gdbarch->deprecated_extract_struct_value_address != NULL);
2372   if (gdbarch_debug >= 2)
2373     fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_extract_struct_value_address called\n");
2374   return gdbarch->deprecated_extract_struct_value_address (regcache);
2375 }
2376
2377 void
2378 set_gdbarch_deprecated_extract_struct_value_address (struct gdbarch *gdbarch,
2379                                                      gdbarch_deprecated_extract_struct_value_address_ftype deprecated_extract_struct_value_address)
2380 {
2381   gdbarch->deprecated_extract_struct_value_address = deprecated_extract_struct_value_address;
2382 }
2383
2384 CORE_ADDR
2385 gdbarch_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR ip)
2386 {
2387   gdb_assert (gdbarch != NULL);
2388   gdb_assert (gdbarch->skip_prologue != NULL);
2389   if (gdbarch_debug >= 2)
2390     fprintf_unfiltered (gdb_stdlog, "gdbarch_skip_prologue called\n");
2391   return gdbarch->skip_prologue (ip);
2392 }
2393
2394 void
2395 set_gdbarch_skip_prologue (struct gdbarch *gdbarch,
2396                            gdbarch_skip_prologue_ftype skip_prologue)
2397 {
2398   gdbarch->skip_prologue = skip_prologue;
2399 }
2400
2401 int
2402 gdbarch_inner_than (struct gdbarch *gdbarch, CORE_ADDR lhs, CORE_ADDR rhs)
2403 {
2404   gdb_assert (gdbarch != NULL);
2405   gdb_assert (gdbarch->inner_than != NULL);
2406   if (gdbarch_debug >= 2)
2407     fprintf_unfiltered (gdb_stdlog, "gdbarch_inner_than called\n");
2408   return gdbarch->inner_than (lhs, rhs);
2409 }
2410
2411 void
2412 set_gdbarch_inner_than (struct gdbarch *gdbarch,
2413                         gdbarch_inner_than_ftype inner_than)
2414 {
2415   gdbarch->inner_than = inner_than;
2416 }
2417
2418 const gdb_byte *
2419 gdbarch_breakpoint_from_pc (struct gdbarch *gdbarch, CORE_ADDR *pcptr, int *lenptr)
2420 {
2421   gdb_assert (gdbarch != NULL);
2422   gdb_assert (gdbarch->breakpoint_from_pc != NULL);
2423   if (gdbarch_debug >= 2)
2424     fprintf_unfiltered (gdb_stdlog, "gdbarch_breakpoint_from_pc called\n");
2425   return gdbarch->breakpoint_from_pc (pcptr, lenptr);
2426 }
2427
2428 void
2429 set_gdbarch_breakpoint_from_pc (struct gdbarch *gdbarch,
2430                                 gdbarch_breakpoint_from_pc_ftype breakpoint_from_pc)
2431 {
2432   gdbarch->breakpoint_from_pc = breakpoint_from_pc;
2433 }
2434
2435 int
2436 gdbarch_adjust_breakpoint_address_p (struct gdbarch *gdbarch)
2437 {
2438   gdb_assert (gdbarch != NULL);
2439   return gdbarch->adjust_breakpoint_address != NULL;
2440 }
2441
2442 CORE_ADDR
2443 gdbarch_adjust_breakpoint_address (struct gdbarch *gdbarch, CORE_ADDR bpaddr)
2444 {
2445   gdb_assert (gdbarch != NULL);
2446   gdb_assert (gdbarch->adjust_breakpoint_address != NULL);
2447   if (gdbarch_debug >= 2)
2448     fprintf_unfiltered (gdb_stdlog, "gdbarch_adjust_breakpoint_address called\n");
2449   return gdbarch->adjust_breakpoint_address (gdbarch, bpaddr);
2450 }
2451
2452 void
2453 set_gdbarch_adjust_breakpoint_address (struct gdbarch *gdbarch,
2454                                        gdbarch_adjust_breakpoint_address_ftype adjust_breakpoint_address)
2455 {
2456   gdbarch->adjust_breakpoint_address = adjust_breakpoint_address;
2457 }
2458
2459 int
2460 gdbarch_memory_insert_breakpoint (struct gdbarch *gdbarch, struct bp_target_info *bp_tgt)
2461 {
2462   gdb_assert (gdbarch != NULL);
2463   gdb_assert (gdbarch->memory_insert_breakpoint != NULL);
2464   if (gdbarch_debug >= 2)
2465     fprintf_unfiltered (gdb_stdlog, "gdbarch_memory_insert_breakpoint called\n");
2466   return gdbarch->memory_insert_breakpoint (bp_tgt);
2467 }
2468
2469 void
2470 set_gdbarch_memory_insert_breakpoint (struct gdbarch *gdbarch,
2471                                       gdbarch_memory_insert_breakpoint_ftype memory_insert_breakpoint)
2472 {
2473   gdbarch->memory_insert_breakpoint = memory_insert_breakpoint;
2474 }
2475
2476 int
2477 gdbarch_memory_remove_breakpoint (struct gdbarch *gdbarch, struct bp_target_info *bp_tgt)
2478 {
2479   gdb_assert (gdbarch != NULL);
2480   gdb_assert (gdbarch->memory_remove_breakpoint != NULL);
2481   if (gdbarch_debug >= 2)
2482     fprintf_unfiltered (gdb_stdlog, "gdbarch_memory_remove_breakpoint called\n");
2483   return gdbarch->memory_remove_breakpoint (bp_tgt);
2484 }
2485
2486 void
2487 set_gdbarch_memory_remove_breakpoint (struct gdbarch *gdbarch,
2488                                       gdbarch_memory_remove_breakpoint_ftype memory_remove_breakpoint)
2489 {
2490   gdbarch->memory_remove_breakpoint = memory_remove_breakpoint;
2491 }
2492
2493 CORE_ADDR
2494 gdbarch_decr_pc_after_break (struct gdbarch *gdbarch)
2495 {
2496   gdb_assert (gdbarch != NULL);
2497   /* Skip verify of decr_pc_after_break, invalid_p == 0 */
2498   if (gdbarch_debug >= 2)
2499     fprintf_unfiltered (gdb_stdlog, "gdbarch_decr_pc_after_break called\n");
2500   return gdbarch->decr_pc_after_break;
2501 }
2502
2503 void
2504 set_gdbarch_decr_pc_after_break (struct gdbarch *gdbarch,
2505                                  CORE_ADDR decr_pc_after_break)
2506 {
2507   gdbarch->decr_pc_after_break = decr_pc_after_break;
2508 }
2509
2510 CORE_ADDR
2511 gdbarch_deprecated_function_start_offset (struct gdbarch *gdbarch)
2512 {
2513   gdb_assert (gdbarch != NULL);
2514   /* Skip verify of deprecated_function_start_offset, invalid_p == 0 */
2515   if (gdbarch_debug >= 2)
2516     fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_function_start_offset called\n");
2517   return gdbarch->deprecated_function_start_offset;
2518 }
2519
2520 void
2521 set_gdbarch_deprecated_function_start_offset (struct gdbarch *gdbarch,
2522                                               CORE_ADDR deprecated_function_start_offset)
2523 {
2524   gdbarch->deprecated_function_start_offset = deprecated_function_start_offset;
2525 }
2526
2527 int
2528 gdbarch_remote_register_number (struct gdbarch *gdbarch, int regno)
2529 {
2530   gdb_assert (gdbarch != NULL);
2531   gdb_assert (gdbarch->remote_register_number != NULL);
2532   if (gdbarch_debug >= 2)
2533     fprintf_unfiltered (gdb_stdlog, "gdbarch_remote_register_number called\n");
2534   return gdbarch->remote_register_number (gdbarch, regno);
2535 }
2536
2537 void
2538 set_gdbarch_remote_register_number (struct gdbarch *gdbarch,
2539                                     gdbarch_remote_register_number_ftype remote_register_number)
2540 {
2541   gdbarch->remote_register_number = remote_register_number;
2542 }
2543
2544 int
2545 gdbarch_fetch_tls_load_module_address_p (struct gdbarch *gdbarch)
2546 {
2547   gdb_assert (gdbarch != NULL);
2548   return gdbarch->fetch_tls_load_module_address != NULL;
2549 }
2550
2551 CORE_ADDR
2552 gdbarch_fetch_tls_load_module_address (struct gdbarch *gdbarch, struct objfile *objfile)
2553 {
2554   gdb_assert (gdbarch != NULL);
2555   gdb_assert (gdbarch->fetch_tls_load_module_address != NULL);
2556   if (gdbarch_debug >= 2)
2557     fprintf_unfiltered (gdb_stdlog, "gdbarch_fetch_tls_load_module_address called\n");
2558   return gdbarch->fetch_tls_load_module_address (objfile);
2559 }
2560
2561 void
2562 set_gdbarch_fetch_tls_load_module_address (struct gdbarch *gdbarch,
2563                                            gdbarch_fetch_tls_load_module_address_ftype fetch_tls_load_module_address)
2564 {
2565   gdbarch->fetch_tls_load_module_address = fetch_tls_load_module_address;
2566 }
2567
2568 CORE_ADDR
2569 gdbarch_frame_args_skip (struct gdbarch *gdbarch)
2570 {
2571   gdb_assert (gdbarch != NULL);
2572   /* Skip verify of frame_args_skip, invalid_p == 0 */
2573   if (gdbarch_debug >= 2)
2574     fprintf_unfiltered (gdb_stdlog, "gdbarch_frame_args_skip called\n");
2575   return gdbarch->frame_args_skip;
2576 }
2577
2578 void
2579 set_gdbarch_frame_args_skip (struct gdbarch *gdbarch,
2580                              CORE_ADDR frame_args_skip)
2581 {
2582   gdbarch->frame_args_skip = frame_args_skip;
2583 }
2584
2585 int
2586 gdbarch_unwind_pc_p (struct gdbarch *gdbarch)
2587 {
2588   gdb_assert (gdbarch != NULL);
2589   return gdbarch->unwind_pc != NULL;
2590 }
2591
2592 CORE_ADDR
2593 gdbarch_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame)
2594 {
2595   gdb_assert (gdbarch != NULL);
2596   gdb_assert (gdbarch->unwind_pc != NULL);
2597   if (gdbarch_debug >= 2)
2598     fprintf_unfiltered (gdb_stdlog, "gdbarch_unwind_pc called\n");
2599   return gdbarch->unwind_pc (gdbarch, next_frame);
2600 }
2601
2602 void
2603 set_gdbarch_unwind_pc (struct gdbarch *gdbarch,
2604                        gdbarch_unwind_pc_ftype unwind_pc)
2605 {
2606   gdbarch->unwind_pc = unwind_pc;
2607 }
2608
2609 int
2610 gdbarch_unwind_sp_p (struct gdbarch *gdbarch)
2611 {
2612   gdb_assert (gdbarch != NULL);
2613   return gdbarch->unwind_sp != NULL;
2614 }
2615
2616 CORE_ADDR
2617 gdbarch_unwind_sp (struct gdbarch *gdbarch, struct frame_info *next_frame)
2618 {
2619   gdb_assert (gdbarch != NULL);
2620   gdb_assert (gdbarch->unwind_sp != NULL);
2621   if (gdbarch_debug >= 2)
2622     fprintf_unfiltered (gdb_stdlog, "gdbarch_unwind_sp called\n");
2623   return gdbarch->unwind_sp (gdbarch, next_frame);
2624 }
2625
2626 void
2627 set_gdbarch_unwind_sp (struct gdbarch *gdbarch,
2628                        gdbarch_unwind_sp_ftype unwind_sp)
2629 {
2630   gdbarch->unwind_sp = unwind_sp;
2631 }
2632
2633 int
2634 gdbarch_frame_num_args_p (struct gdbarch *gdbarch)
2635 {
2636   gdb_assert (gdbarch != NULL);
2637   return gdbarch->frame_num_args != NULL;
2638 }
2639
2640 int
2641 gdbarch_frame_num_args (struct gdbarch *gdbarch, struct frame_info *frame)
2642 {
2643   gdb_assert (gdbarch != NULL);
2644   gdb_assert (gdbarch->frame_num_args != NULL);
2645   if (gdbarch_debug >= 2)
2646     fprintf_unfiltered (gdb_stdlog, "gdbarch_frame_num_args called\n");
2647   return gdbarch->frame_num_args (frame);
2648 }
2649
2650 void
2651 set_gdbarch_frame_num_args (struct gdbarch *gdbarch,
2652                             gdbarch_frame_num_args_ftype frame_num_args)
2653 {
2654   gdbarch->frame_num_args = frame_num_args;
2655 }
2656
2657 int
2658 gdbarch_deprecated_stack_align_p (struct gdbarch *gdbarch)
2659 {
2660   gdb_assert (gdbarch != NULL);
2661   return gdbarch->deprecated_stack_align != NULL;
2662 }
2663
2664 CORE_ADDR
2665 gdbarch_deprecated_stack_align (struct gdbarch *gdbarch, CORE_ADDR sp)
2666 {
2667   gdb_assert (gdbarch != NULL);
2668   gdb_assert (gdbarch->deprecated_stack_align != NULL);
2669   if (gdbarch_debug >= 2)
2670     fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_stack_align called\n");
2671   return gdbarch->deprecated_stack_align (sp);
2672 }
2673
2674 void
2675 set_gdbarch_deprecated_stack_align (struct gdbarch *gdbarch,
2676                                     gdbarch_deprecated_stack_align_ftype deprecated_stack_align)
2677 {
2678   gdbarch->deprecated_stack_align = deprecated_stack_align;
2679 }
2680
2681 int
2682 gdbarch_frame_align_p (struct gdbarch *gdbarch)
2683 {
2684   gdb_assert (gdbarch != NULL);
2685   return gdbarch->frame_align != NULL;
2686 }
2687
2688 CORE_ADDR
2689 gdbarch_frame_align (struct gdbarch *gdbarch, CORE_ADDR address)
2690 {
2691   gdb_assert (gdbarch != NULL);
2692   gdb_assert (gdbarch->frame_align != NULL);
2693   if (gdbarch_debug >= 2)
2694     fprintf_unfiltered (gdb_stdlog, "gdbarch_frame_align called\n");
2695   return gdbarch->frame_align (gdbarch, address);
2696 }
2697
2698 void
2699 set_gdbarch_frame_align (struct gdbarch *gdbarch,
2700                          gdbarch_frame_align_ftype frame_align)
2701 {
2702   gdbarch->frame_align = frame_align;
2703 }
2704
2705 int
2706 gdbarch_deprecated_reg_struct_has_addr_p (struct gdbarch *gdbarch)
2707 {
2708   gdb_assert (gdbarch != NULL);
2709   return gdbarch->deprecated_reg_struct_has_addr != NULL;
2710 }
2711
2712 int
2713 gdbarch_deprecated_reg_struct_has_addr (struct gdbarch *gdbarch, int gcc_p, struct type *type)
2714 {
2715   gdb_assert (gdbarch != NULL);
2716   gdb_assert (gdbarch->deprecated_reg_struct_has_addr != NULL);
2717   if (gdbarch_debug >= 2)
2718     fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_reg_struct_has_addr called\n");
2719   return gdbarch->deprecated_reg_struct_has_addr (gcc_p, type);
2720 }
2721
2722 void
2723 set_gdbarch_deprecated_reg_struct_has_addr (struct gdbarch *gdbarch,
2724                                             gdbarch_deprecated_reg_struct_has_addr_ftype deprecated_reg_struct_has_addr)
2725 {
2726   gdbarch->deprecated_reg_struct_has_addr = deprecated_reg_struct_has_addr;
2727 }
2728
2729 int
2730 gdbarch_stabs_argument_has_addr (struct gdbarch *gdbarch, struct type *type)
2731 {
2732   gdb_assert (gdbarch != NULL);
2733   gdb_assert (gdbarch->stabs_argument_has_addr != NULL);
2734   if (gdbarch_debug >= 2)
2735     fprintf_unfiltered (gdb_stdlog, "gdbarch_stabs_argument_has_addr called\n");
2736   return gdbarch->stabs_argument_has_addr (gdbarch, type);
2737 }
2738
2739 void
2740 set_gdbarch_stabs_argument_has_addr (struct gdbarch *gdbarch,
2741                                      gdbarch_stabs_argument_has_addr_ftype stabs_argument_has_addr)
2742 {
2743   gdbarch->stabs_argument_has_addr = stabs_argument_has_addr;
2744 }
2745
2746 int
2747 gdbarch_frame_red_zone_size (struct gdbarch *gdbarch)
2748 {
2749   gdb_assert (gdbarch != NULL);
2750   if (gdbarch_debug >= 2)
2751     fprintf_unfiltered (gdb_stdlog, "gdbarch_frame_red_zone_size called\n");
2752   return gdbarch->frame_red_zone_size;
2753 }
2754
2755 void
2756 set_gdbarch_frame_red_zone_size (struct gdbarch *gdbarch,
2757                                  int frame_red_zone_size)
2758 {
2759   gdbarch->frame_red_zone_size = frame_red_zone_size;
2760 }
2761
2762 CORE_ADDR
2763 gdbarch_convert_from_func_ptr_addr (struct gdbarch *gdbarch, CORE_ADDR addr, struct target_ops *targ)
2764 {
2765   gdb_assert (gdbarch != NULL);
2766   gdb_assert (gdbarch->convert_from_func_ptr_addr != NULL);
2767   if (gdbarch_debug >= 2)
2768     fprintf_unfiltered (gdb_stdlog, "gdbarch_convert_from_func_ptr_addr called\n");
2769   return gdbarch->convert_from_func_ptr_addr (gdbarch, addr, targ);
2770 }
2771
2772 void
2773 set_gdbarch_convert_from_func_ptr_addr (struct gdbarch *gdbarch,
2774                                         gdbarch_convert_from_func_ptr_addr_ftype convert_from_func_ptr_addr)
2775 {
2776   gdbarch->convert_from_func_ptr_addr = convert_from_func_ptr_addr;
2777 }
2778
2779 CORE_ADDR
2780 gdbarch_addr_bits_remove (struct gdbarch *gdbarch, CORE_ADDR addr)
2781 {
2782   gdb_assert (gdbarch != NULL);
2783   gdb_assert (gdbarch->addr_bits_remove != NULL);
2784   if (gdbarch_debug >= 2)
2785     fprintf_unfiltered (gdb_stdlog, "gdbarch_addr_bits_remove called\n");
2786   return gdbarch->addr_bits_remove (addr);
2787 }
2788
2789 void
2790 set_gdbarch_addr_bits_remove (struct gdbarch *gdbarch,
2791                               gdbarch_addr_bits_remove_ftype addr_bits_remove)
2792 {
2793   gdbarch->addr_bits_remove = addr_bits_remove;
2794 }
2795
2796 CORE_ADDR
2797 gdbarch_smash_text_address (struct gdbarch *gdbarch, CORE_ADDR addr)
2798 {
2799   gdb_assert (gdbarch != NULL);
2800   gdb_assert (gdbarch->smash_text_address != NULL);
2801   if (gdbarch_debug >= 2)
2802     fprintf_unfiltered (gdb_stdlog, "gdbarch_smash_text_address called\n");
2803   return gdbarch->smash_text_address (addr);
2804 }
2805
2806 void
2807 set_gdbarch_smash_text_address (struct gdbarch *gdbarch,
2808                                 gdbarch_smash_text_address_ftype smash_text_address)
2809 {
2810   gdbarch->smash_text_address = smash_text_address;
2811 }
2812
2813 int
2814 gdbarch_software_single_step_p (struct gdbarch *gdbarch)
2815 {
2816   gdb_assert (gdbarch != NULL);
2817   return gdbarch->software_single_step != NULL;
2818 }
2819
2820 int
2821 gdbarch_software_single_step (struct gdbarch *gdbarch, struct regcache *regcache)
2822 {
2823   gdb_assert (gdbarch != NULL);
2824   gdb_assert (gdbarch->software_single_step != NULL);
2825   if (gdbarch_debug >= 2)
2826     fprintf_unfiltered (gdb_stdlog, "gdbarch_software_single_step called\n");
2827   return gdbarch->software_single_step (regcache);
2828 }
2829
2830 void
2831 set_gdbarch_software_single_step (struct gdbarch *gdbarch,
2832                                   gdbarch_software_single_step_ftype software_single_step)
2833 {
2834   gdbarch->software_single_step = software_single_step;
2835 }
2836
2837 int
2838 gdbarch_single_step_through_delay_p (struct gdbarch *gdbarch)
2839 {
2840   gdb_assert (gdbarch != NULL);
2841   return gdbarch->single_step_through_delay != NULL;
2842 }
2843
2844 int
2845 gdbarch_single_step_through_delay (struct gdbarch *gdbarch, struct frame_info *frame)
2846 {
2847   gdb_assert (gdbarch != NULL);
2848   gdb_assert (gdbarch->single_step_through_delay != NULL);
2849   if (gdbarch_debug >= 2)
2850     fprintf_unfiltered (gdb_stdlog, "gdbarch_single_step_through_delay called\n");
2851   return gdbarch->single_step_through_delay (gdbarch, frame);
2852 }
2853
2854 void
2855 set_gdbarch_single_step_through_delay (struct gdbarch *gdbarch,
2856                                        gdbarch_single_step_through_delay_ftype single_step_through_delay)
2857 {
2858   gdbarch->single_step_through_delay = single_step_through_delay;
2859 }
2860
2861 int
2862 gdbarch_print_insn (struct gdbarch *gdbarch, bfd_vma vma, struct disassemble_info *info)
2863 {
2864   gdb_assert (gdbarch != NULL);
2865   gdb_assert (gdbarch->print_insn != NULL);
2866   if (gdbarch_debug >= 2)
2867     fprintf_unfiltered (gdb_stdlog, "gdbarch_print_insn called\n");
2868   return gdbarch->print_insn (vma, info);
2869 }
2870
2871 void
2872 set_gdbarch_print_insn (struct gdbarch *gdbarch,
2873                         gdbarch_print_insn_ftype print_insn)
2874 {
2875   gdbarch->print_insn = print_insn;
2876 }
2877
2878 CORE_ADDR
2879 gdbarch_skip_trampoline_code (struct gdbarch *gdbarch, CORE_ADDR pc)
2880 {
2881   gdb_assert (gdbarch != NULL);
2882   gdb_assert (gdbarch->skip_trampoline_code != NULL);
2883   if (gdbarch_debug >= 2)
2884     fprintf_unfiltered (gdb_stdlog, "gdbarch_skip_trampoline_code called\n");
2885   return gdbarch->skip_trampoline_code (pc);
2886 }
2887
2888 void
2889 set_gdbarch_skip_trampoline_code (struct gdbarch *gdbarch,
2890                                   gdbarch_skip_trampoline_code_ftype skip_trampoline_code)
2891 {
2892   gdbarch->skip_trampoline_code = skip_trampoline_code;
2893 }
2894
2895 CORE_ADDR
2896 gdbarch_skip_solib_resolver (struct gdbarch *gdbarch, CORE_ADDR pc)
2897 {
2898   gdb_assert (gdbarch != NULL);
2899   gdb_assert (gdbarch->skip_solib_resolver != NULL);
2900   if (gdbarch_debug >= 2)
2901     fprintf_unfiltered (gdb_stdlog, "gdbarch_skip_solib_resolver called\n");
2902   return gdbarch->skip_solib_resolver (gdbarch, pc);
2903 }
2904
2905 void
2906 set_gdbarch_skip_solib_resolver (struct gdbarch *gdbarch,
2907                                  gdbarch_skip_solib_resolver_ftype skip_solib_resolver)
2908 {
2909   gdbarch->skip_solib_resolver = skip_solib_resolver;
2910 }
2911
2912 int
2913 gdbarch_in_solib_return_trampoline (struct gdbarch *gdbarch, CORE_ADDR pc, char *name)
2914 {
2915   gdb_assert (gdbarch != NULL);
2916   gdb_assert (gdbarch->in_solib_return_trampoline != NULL);
2917   if (gdbarch_debug >= 2)
2918     fprintf_unfiltered (gdb_stdlog, "gdbarch_in_solib_return_trampoline called\n");
2919   return gdbarch->in_solib_return_trampoline (pc, name);
2920 }
2921
2922 void
2923 set_gdbarch_in_solib_return_trampoline (struct gdbarch *gdbarch,
2924                                         gdbarch_in_solib_return_trampoline_ftype in_solib_return_trampoline)
2925 {
2926   gdbarch->in_solib_return_trampoline = in_solib_return_trampoline;
2927 }
2928
2929 int
2930 gdbarch_in_function_epilogue_p (struct gdbarch *gdbarch, CORE_ADDR addr)
2931 {
2932   gdb_assert (gdbarch != NULL);
2933   gdb_assert (gdbarch->in_function_epilogue_p != NULL);
2934   if (gdbarch_debug >= 2)
2935     fprintf_unfiltered (gdb_stdlog, "gdbarch_in_function_epilogue_p called\n");
2936   return gdbarch->in_function_epilogue_p (gdbarch, addr);
2937 }
2938
2939 void
2940 set_gdbarch_in_function_epilogue_p (struct gdbarch *gdbarch,
2941                                     gdbarch_in_function_epilogue_p_ftype in_function_epilogue_p)
2942 {
2943   gdbarch->in_function_epilogue_p = in_function_epilogue_p;
2944 }
2945
2946 char *
2947 gdbarch_construct_inferior_arguments (struct gdbarch *gdbarch, int argc, char **argv)
2948 {
2949   gdb_assert (gdbarch != NULL);
2950   gdb_assert (gdbarch->construct_inferior_arguments != NULL);
2951   if (gdbarch_debug >= 2)
2952     fprintf_unfiltered (gdb_stdlog, "gdbarch_construct_inferior_arguments called\n");
2953   return gdbarch->construct_inferior_arguments (gdbarch, argc, argv);
2954 }
2955
2956 void
2957 set_gdbarch_construct_inferior_arguments (struct gdbarch *gdbarch,
2958                                           gdbarch_construct_inferior_arguments_ftype construct_inferior_arguments)
2959 {
2960   gdbarch->construct_inferior_arguments = construct_inferior_arguments;
2961 }
2962
2963 void
2964 gdbarch_elf_make_msymbol_special (struct gdbarch *gdbarch, asymbol *sym, struct minimal_symbol *msym)
2965 {
2966   gdb_assert (gdbarch != NULL);
2967   gdb_assert (gdbarch->elf_make_msymbol_special != NULL);
2968   if (gdbarch_debug >= 2)
2969     fprintf_unfiltered (gdb_stdlog, "gdbarch_elf_make_msymbol_special called\n");
2970   gdbarch->elf_make_msymbol_special (sym, msym);
2971 }
2972
2973 void
2974 set_gdbarch_elf_make_msymbol_special (struct gdbarch *gdbarch,
2975                                       gdbarch_elf_make_msymbol_special_ftype elf_make_msymbol_special)
2976 {
2977   gdbarch->elf_make_msymbol_special = elf_make_msymbol_special;
2978 }
2979
2980 void
2981 gdbarch_coff_make_msymbol_special (struct gdbarch *gdbarch, int val, struct minimal_symbol *msym)
2982 {
2983   gdb_assert (gdbarch != NULL);
2984   gdb_assert (gdbarch->coff_make_msymbol_special != NULL);
2985   if (gdbarch_debug >= 2)
2986     fprintf_unfiltered (gdb_stdlog, "gdbarch_coff_make_msymbol_special called\n");
2987   gdbarch->coff_make_msymbol_special (val, msym);
2988 }
2989
2990 void
2991 set_gdbarch_coff_make_msymbol_special (struct gdbarch *gdbarch,
2992                                        gdbarch_coff_make_msymbol_special_ftype coff_make_msymbol_special)
2993 {
2994   gdbarch->coff_make_msymbol_special = coff_make_msymbol_special;
2995 }
2996
2997 const char *
2998 gdbarch_name_of_malloc (struct gdbarch *gdbarch)
2999 {
3000   gdb_assert (gdbarch != NULL);
3001   /* Skip verify of name_of_malloc, invalid_p == 0 */
3002   if (gdbarch_debug >= 2)
3003     fprintf_unfiltered (gdb_stdlog, "gdbarch_name_of_malloc called\n");
3004   return gdbarch->name_of_malloc;
3005 }
3006
3007 void
3008 set_gdbarch_name_of_malloc (struct gdbarch *gdbarch,
3009                             const char * name_of_malloc)
3010 {
3011   gdbarch->name_of_malloc = name_of_malloc;
3012 }
3013
3014 int
3015 gdbarch_cannot_step_breakpoint (struct gdbarch *gdbarch)
3016 {
3017   gdb_assert (gdbarch != NULL);
3018   /* Skip verify of cannot_step_breakpoint, invalid_p == 0 */
3019   if (gdbarch_debug >= 2)
3020     fprintf_unfiltered (gdb_stdlog, "gdbarch_cannot_step_breakpoint called\n");
3021   return gdbarch->cannot_step_breakpoint;
3022 }
3023
3024 void
3025 set_gdbarch_cannot_step_breakpoint (struct gdbarch *gdbarch,
3026                                     int cannot_step_breakpoint)
3027 {
3028   gdbarch->cannot_step_breakpoint = cannot_step_breakpoint;
3029 }
3030
3031 int
3032 gdbarch_have_nonsteppable_watchpoint (struct gdbarch *gdbarch)
3033 {
3034   gdb_assert (gdbarch != NULL);
3035   /* Skip verify of have_nonsteppable_watchpoint, invalid_p == 0 */
3036   if (gdbarch_debug >= 2)
3037     fprintf_unfiltered (gdb_stdlog, "gdbarch_have_nonsteppable_watchpoint called\n");
3038   return gdbarch->have_nonsteppable_watchpoint;
3039 }
3040
3041 void
3042 set_gdbarch_have_nonsteppable_watchpoint (struct gdbarch *gdbarch,
3043                                           int have_nonsteppable_watchpoint)
3044 {
3045   gdbarch->have_nonsteppable_watchpoint = have_nonsteppable_watchpoint;
3046 }
3047
3048 int
3049 gdbarch_address_class_type_flags_p (struct gdbarch *gdbarch)
3050 {
3051   gdb_assert (gdbarch != NULL);
3052   return gdbarch->address_class_type_flags != NULL;
3053 }
3054
3055 int
3056 gdbarch_address_class_type_flags (struct gdbarch *gdbarch, int byte_size, int dwarf2_addr_class)
3057 {
3058   gdb_assert (gdbarch != NULL);
3059   gdb_assert (gdbarch->address_class_type_flags != NULL);
3060   if (gdbarch_debug >= 2)
3061     fprintf_unfiltered (gdb_stdlog, "gdbarch_address_class_type_flags called\n");
3062   return gdbarch->address_class_type_flags (byte_size, dwarf2_addr_class);
3063 }
3064
3065 void
3066 set_gdbarch_address_class_type_flags (struct gdbarch *gdbarch,
3067                                       gdbarch_address_class_type_flags_ftype address_class_type_flags)
3068 {
3069   gdbarch->address_class_type_flags = address_class_type_flags;
3070 }
3071
3072 int
3073 gdbarch_address_class_type_flags_to_name_p (struct gdbarch *gdbarch)
3074 {
3075   gdb_assert (gdbarch != NULL);
3076   return gdbarch->address_class_type_flags_to_name != NULL;
3077 }
3078
3079 const char *
3080 gdbarch_address_class_type_flags_to_name (struct gdbarch *gdbarch, int type_flags)
3081 {
3082   gdb_assert (gdbarch != NULL);
3083   gdb_assert (gdbarch->address_class_type_flags_to_name != NULL);
3084   if (gdbarch_debug >= 2)
3085     fprintf_unfiltered (gdb_stdlog, "gdbarch_address_class_type_flags_to_name called\n");
3086   return gdbarch->address_class_type_flags_to_name (gdbarch, type_flags);
3087 }
3088
3089 void
3090 set_gdbarch_address_class_type_flags_to_name (struct gdbarch *gdbarch,
3091                                               gdbarch_address_class_type_flags_to_name_ftype address_class_type_flags_to_name)
3092 {
3093   gdbarch->address_class_type_flags_to_name = address_class_type_flags_to_name;
3094 }
3095
3096 int
3097 gdbarch_address_class_name_to_type_flags_p (struct gdbarch *gdbarch)
3098 {
3099   gdb_assert (gdbarch != NULL);
3100   return gdbarch->address_class_name_to_type_flags != NULL;
3101 }
3102
3103 int
3104 gdbarch_address_class_name_to_type_flags (struct gdbarch *gdbarch, const char *name, int *type_flags_ptr)
3105 {
3106   gdb_assert (gdbarch != NULL);
3107   gdb_assert (gdbarch->address_class_name_to_type_flags != NULL);
3108   if (gdbarch_debug >= 2)
3109     fprintf_unfiltered (gdb_stdlog, "gdbarch_address_class_name_to_type_flags called\n");
3110   return gdbarch->address_class_name_to_type_flags (gdbarch, name, type_flags_ptr);
3111 }
3112
3113 void
3114 set_gdbarch_address_class_name_to_type_flags (struct gdbarch *gdbarch,
3115                                               gdbarch_address_class_name_to_type_flags_ftype address_class_name_to_type_flags)
3116 {
3117   gdbarch->address_class_name_to_type_flags = address_class_name_to_type_flags;
3118 }
3119
3120 int
3121 gdbarch_register_reggroup_p (struct gdbarch *gdbarch, int regnum, struct reggroup *reggroup)
3122 {
3123   gdb_assert (gdbarch != NULL);
3124   gdb_assert (gdbarch->register_reggroup_p != NULL);
3125   if (gdbarch_debug >= 2)
3126     fprintf_unfiltered (gdb_stdlog, "gdbarch_register_reggroup_p called\n");
3127   return gdbarch->register_reggroup_p (gdbarch, regnum, reggroup);
3128 }
3129
3130 void
3131 set_gdbarch_register_reggroup_p (struct gdbarch *gdbarch,
3132                                  gdbarch_register_reggroup_p_ftype register_reggroup_p)
3133 {
3134   gdbarch->register_reggroup_p = register_reggroup_p;
3135 }
3136
3137 int
3138 gdbarch_fetch_pointer_argument_p (struct gdbarch *gdbarch)
3139 {
3140   gdb_assert (gdbarch != NULL);
3141   return gdbarch->fetch_pointer_argument != NULL;
3142 }
3143
3144 CORE_ADDR
3145 gdbarch_fetch_pointer_argument (struct gdbarch *gdbarch, struct frame_info *frame, int argi, struct type *type)
3146 {
3147   gdb_assert (gdbarch != NULL);
3148   gdb_assert (gdbarch->fetch_pointer_argument != NULL);
3149   if (gdbarch_debug >= 2)
3150     fprintf_unfiltered (gdb_stdlog, "gdbarch_fetch_pointer_argument called\n");
3151   return gdbarch->fetch_pointer_argument (frame, argi, type);
3152 }
3153
3154 void
3155 set_gdbarch_fetch_pointer_argument (struct gdbarch *gdbarch,
3156                                     gdbarch_fetch_pointer_argument_ftype fetch_pointer_argument)
3157 {
3158   gdbarch->fetch_pointer_argument = fetch_pointer_argument;
3159 }
3160
3161 int
3162 gdbarch_regset_from_core_section_p (struct gdbarch *gdbarch)
3163 {
3164   gdb_assert (gdbarch != NULL);
3165   return gdbarch->regset_from_core_section != NULL;
3166 }
3167
3168 const struct regset *
3169 gdbarch_regset_from_core_section (struct gdbarch *gdbarch, const char *sect_name, size_t sect_size)
3170 {
3171   gdb_assert (gdbarch != NULL);
3172   gdb_assert (gdbarch->regset_from_core_section != NULL);
3173   if (gdbarch_debug >= 2)
3174     fprintf_unfiltered (gdb_stdlog, "gdbarch_regset_from_core_section called\n");
3175   return gdbarch->regset_from_core_section (gdbarch, sect_name, sect_size);
3176 }
3177
3178 void
3179 set_gdbarch_regset_from_core_section (struct gdbarch *gdbarch,
3180                                       gdbarch_regset_from_core_section_ftype regset_from_core_section)
3181 {
3182   gdbarch->regset_from_core_section = regset_from_core_section;
3183 }
3184
3185 int
3186 gdbarch_vtable_function_descriptors (struct gdbarch *gdbarch)
3187 {
3188   gdb_assert (gdbarch != NULL);
3189   /* Skip verify of vtable_function_descriptors, invalid_p == 0 */
3190   if (gdbarch_debug >= 2)
3191     fprintf_unfiltered (gdb_stdlog, "gdbarch_vtable_function_descriptors called\n");
3192   return gdbarch->vtable_function_descriptors;
3193 }
3194
3195 void
3196 set_gdbarch_vtable_function_descriptors (struct gdbarch *gdbarch,
3197                                          int vtable_function_descriptors)
3198 {
3199   gdbarch->vtable_function_descriptors = vtable_function_descriptors;
3200 }
3201
3202 int
3203 gdbarch_vbit_in_delta (struct gdbarch *gdbarch)
3204 {
3205   gdb_assert (gdbarch != NULL);
3206   /* Skip verify of vbit_in_delta, invalid_p == 0 */
3207   if (gdbarch_debug >= 2)
3208     fprintf_unfiltered (gdb_stdlog, "gdbarch_vbit_in_delta called\n");
3209   return gdbarch->vbit_in_delta;
3210 }
3211
3212 void
3213 set_gdbarch_vbit_in_delta (struct gdbarch *gdbarch,
3214                            int vbit_in_delta)
3215 {
3216   gdbarch->vbit_in_delta = vbit_in_delta;
3217 }
3218
3219 int
3220 gdbarch_skip_permanent_breakpoint_p (struct gdbarch *gdbarch)
3221 {
3222   gdb_assert (gdbarch != NULL);
3223   return gdbarch->skip_permanent_breakpoint != NULL;
3224 }
3225
3226 void
3227 gdbarch_skip_permanent_breakpoint (struct gdbarch *gdbarch, struct regcache *regcache)
3228 {
3229   gdb_assert (gdbarch != NULL);
3230   gdb_assert (gdbarch->skip_permanent_breakpoint != NULL);
3231   if (gdbarch_debug >= 2)
3232     fprintf_unfiltered (gdb_stdlog, "gdbarch_skip_permanent_breakpoint called\n");
3233   gdbarch->skip_permanent_breakpoint (regcache);
3234 }
3235
3236 void
3237 set_gdbarch_skip_permanent_breakpoint (struct gdbarch *gdbarch,
3238                                        gdbarch_skip_permanent_breakpoint_ftype skip_permanent_breakpoint)
3239 {
3240   gdbarch->skip_permanent_breakpoint = skip_permanent_breakpoint;
3241 }
3242
3243 int
3244 gdbarch_overlay_update_p (struct gdbarch *gdbarch)
3245 {
3246   gdb_assert (gdbarch != NULL);
3247   return gdbarch->overlay_update != NULL;
3248 }
3249
3250 void
3251 gdbarch_overlay_update (struct gdbarch *gdbarch, struct obj_section *osect)
3252 {
3253   gdb_assert (gdbarch != NULL);
3254   gdb_assert (gdbarch->overlay_update != NULL);
3255   if (gdbarch_debug >= 2)
3256     fprintf_unfiltered (gdb_stdlog, "gdbarch_overlay_update called\n");
3257   gdbarch->overlay_update (osect);
3258 }
3259
3260 void
3261 set_gdbarch_overlay_update (struct gdbarch *gdbarch,
3262                             gdbarch_overlay_update_ftype overlay_update)
3263 {
3264   gdbarch->overlay_update = overlay_update;
3265 }
3266
3267
3268 /* Keep a registry of per-architecture data-pointers required by GDB
3269    modules. */
3270
3271 struct gdbarch_data
3272 {
3273   unsigned index;
3274   int init_p;
3275   gdbarch_data_pre_init_ftype *pre_init;
3276   gdbarch_data_post_init_ftype *post_init;
3277 };
3278
3279 struct gdbarch_data_registration
3280 {
3281   struct gdbarch_data *data;
3282   struct gdbarch_data_registration *next;
3283 };
3284
3285 struct gdbarch_data_registry
3286 {
3287   unsigned nr;
3288   struct gdbarch_data_registration *registrations;
3289 };
3290
3291 struct gdbarch_data_registry gdbarch_data_registry =
3292 {
3293   0, NULL,
3294 };
3295
3296 static struct gdbarch_data *
3297 gdbarch_data_register (gdbarch_data_pre_init_ftype *pre_init,
3298                        gdbarch_data_post_init_ftype *post_init)
3299 {
3300   struct gdbarch_data_registration **curr;
3301   /* Append the new registraration.  */
3302   for (curr = &gdbarch_data_registry.registrations;
3303        (*curr) != NULL;
3304        curr = &(*curr)->next);
3305   (*curr) = XMALLOC (struct gdbarch_data_registration);
3306   (*curr)->next = NULL;
3307   (*curr)->data = XMALLOC (struct gdbarch_data);
3308   (*curr)->data->index = gdbarch_data_registry.nr++;
3309   (*curr)->data->pre_init = pre_init;
3310   (*curr)->data->post_init = post_init;
3311   (*curr)->data->init_p = 1;
3312   return (*curr)->data;
3313 }
3314
3315 struct gdbarch_data *
3316 gdbarch_data_register_pre_init (gdbarch_data_pre_init_ftype *pre_init)
3317 {
3318   return gdbarch_data_register (pre_init, NULL);
3319 }
3320
3321 struct gdbarch_data *
3322 gdbarch_data_register_post_init (gdbarch_data_post_init_ftype *post_init)
3323 {
3324   return gdbarch_data_register (NULL, post_init);
3325 }
3326
3327 /* Create/delete the gdbarch data vector. */
3328
3329 static void
3330 alloc_gdbarch_data (struct gdbarch *gdbarch)
3331 {
3332   gdb_assert (gdbarch->data == NULL);
3333   gdbarch->nr_data = gdbarch_data_registry.nr;
3334   gdbarch->data = GDBARCH_OBSTACK_CALLOC (gdbarch, gdbarch->nr_data, void *);
3335 }
3336
3337 /* Initialize the current value of the specified per-architecture
3338    data-pointer. */
3339
3340 void
3341 deprecated_set_gdbarch_data (struct gdbarch *gdbarch,
3342                              struct gdbarch_data *data,
3343                              void *pointer)
3344 {
3345   gdb_assert (data->index < gdbarch->nr_data);
3346   gdb_assert (gdbarch->data[data->index] == NULL);
3347   gdb_assert (data->pre_init == NULL);
3348   gdbarch->data[data->index] = pointer;
3349 }
3350
3351 /* Return the current value of the specified per-architecture
3352    data-pointer. */
3353
3354 void *
3355 gdbarch_data (struct gdbarch *gdbarch, struct gdbarch_data *data)
3356 {
3357   gdb_assert (data->index < gdbarch->nr_data);
3358   if (gdbarch->data[data->index] == NULL)
3359     {
3360       /* The data-pointer isn't initialized, call init() to get a
3361          value.  */
3362       if (data->pre_init != NULL)
3363         /* Mid architecture creation: pass just the obstack, and not
3364            the entire architecture, as that way it isn't possible for
3365            pre-init code to refer to undefined architecture
3366            fields.  */
3367         gdbarch->data[data->index] = data->pre_init (gdbarch->obstack);
3368       else if (gdbarch->initialized_p
3369                && data->post_init != NULL)
3370         /* Post architecture creation: pass the entire architecture
3371            (as all fields are valid), but be careful to also detect
3372            recursive references.  */
3373         {
3374           gdb_assert (data->init_p);
3375           data->init_p = 0;
3376           gdbarch->data[data->index] = data->post_init (gdbarch);
3377           data->init_p = 1;
3378         }
3379       else
3380         /* The architecture initialization hasn't completed - punt -
3381          hope that the caller knows what they are doing.  Once
3382          deprecated_set_gdbarch_data has been initialized, this can be
3383          changed to an internal error.  */
3384         return NULL;
3385       gdb_assert (gdbarch->data[data->index] != NULL);
3386     }
3387   return gdbarch->data[data->index];
3388 }
3389
3390
3391
3392 /* Keep a registry of swapped data required by GDB modules. */
3393
3394 struct gdbarch_swap
3395 {
3396   void *swap;
3397   struct gdbarch_swap_registration *source;
3398   struct gdbarch_swap *next;
3399 };
3400
3401 struct gdbarch_swap_registration
3402 {
3403   void *data;
3404   unsigned long sizeof_data;
3405   gdbarch_swap_ftype *init;
3406   struct gdbarch_swap_registration *next;
3407 };
3408
3409 struct gdbarch_swap_registry
3410 {
3411   int nr;
3412   struct gdbarch_swap_registration *registrations;
3413 };
3414
3415 struct gdbarch_swap_registry gdbarch_swap_registry =
3416 {
3417   0, NULL,
3418 };
3419
3420 void
3421 deprecated_register_gdbarch_swap (void *data,
3422                                   unsigned long sizeof_data,
3423                                   gdbarch_swap_ftype *init)
3424 {
3425   struct gdbarch_swap_registration **rego;
3426   for (rego = &gdbarch_swap_registry.registrations;
3427        (*rego) != NULL;
3428        rego = &(*rego)->next);
3429   (*rego) = XMALLOC (struct gdbarch_swap_registration);
3430   (*rego)->next = NULL;
3431   (*rego)->init = init;
3432   (*rego)->data = data;
3433   (*rego)->sizeof_data = sizeof_data;
3434 }
3435
3436 static void
3437 current_gdbarch_swap_init_hack (void)
3438 {
3439   struct gdbarch_swap_registration *rego;
3440   struct gdbarch_swap **curr = &current_gdbarch->swap;
3441   for (rego = gdbarch_swap_registry.registrations;
3442        rego != NULL;
3443        rego = rego->next)
3444     {
3445       if (rego->data != NULL)
3446         {
3447           (*curr) = GDBARCH_OBSTACK_ZALLOC (current_gdbarch,
3448                                             struct gdbarch_swap);
3449           (*curr)->source = rego;
3450           (*curr)->swap = gdbarch_obstack_zalloc (current_gdbarch,
3451                                                   rego->sizeof_data);
3452           (*curr)->next = NULL;
3453           curr = &(*curr)->next;
3454         }
3455       if (rego->init != NULL)
3456         rego->init ();
3457     }
3458 }
3459
3460 static struct gdbarch *
3461 current_gdbarch_swap_out_hack (void)
3462 {
3463   struct gdbarch *old_gdbarch = current_gdbarch;
3464   struct gdbarch_swap *curr;
3465
3466   gdb_assert (old_gdbarch != NULL);
3467   for (curr = old_gdbarch->swap;
3468        curr != NULL;
3469        curr = curr->next)
3470     {
3471       memcpy (curr->swap, curr->source->data, curr->source->sizeof_data);
3472       memset (curr->source->data, 0, curr->source->sizeof_data);
3473     }
3474   current_gdbarch = NULL;
3475   return old_gdbarch;
3476 }
3477
3478 static void
3479 current_gdbarch_swap_in_hack (struct gdbarch *new_gdbarch)
3480 {
3481   struct gdbarch_swap *curr;
3482
3483   gdb_assert (current_gdbarch == NULL);
3484   for (curr = new_gdbarch->swap;
3485        curr != NULL;
3486        curr = curr->next)
3487     memcpy (curr->source->data, curr->swap, curr->source->sizeof_data);
3488   current_gdbarch = new_gdbarch;
3489 }
3490
3491
3492 /* Keep a registry of the architectures known by GDB. */
3493
3494 struct gdbarch_registration
3495 {
3496   enum bfd_architecture bfd_architecture;
3497   gdbarch_init_ftype *init;
3498   gdbarch_dump_tdep_ftype *dump_tdep;
3499   struct gdbarch_list *arches;
3500   struct gdbarch_registration *next;
3501 };
3502
3503 static struct gdbarch_registration *gdbarch_registry = NULL;
3504
3505 static void
3506 append_name (const char ***buf, int *nr, const char *name)
3507 {
3508   *buf = xrealloc (*buf, sizeof (char**) * (*nr + 1));
3509   (*buf)[*nr] = name;
3510   *nr += 1;
3511 }
3512
3513 const char **
3514 gdbarch_printable_names (void)
3515 {
3516   /* Accumulate a list of names based on the registed list of
3517      architectures. */
3518   enum bfd_architecture a;
3519   int nr_arches = 0;
3520   const char **arches = NULL;
3521   struct gdbarch_registration *rego;
3522   for (rego = gdbarch_registry;
3523        rego != NULL;
3524        rego = rego->next)
3525     {
3526       const struct bfd_arch_info *ap;
3527       ap = bfd_lookup_arch (rego->bfd_architecture, 0);
3528       if (ap == NULL)
3529         internal_error (__FILE__, __LINE__,
3530                         _("gdbarch_architecture_names: multi-arch unknown"));
3531       do
3532         {
3533           append_name (&arches, &nr_arches, ap->printable_name);
3534           ap = ap->next;
3535         }
3536       while (ap != NULL);
3537     }
3538   append_name (&arches, &nr_arches, NULL);
3539   return arches;
3540 }
3541
3542
3543 void
3544 gdbarch_register (enum bfd_architecture bfd_architecture,
3545                   gdbarch_init_ftype *init,
3546                   gdbarch_dump_tdep_ftype *dump_tdep)
3547 {
3548   struct gdbarch_registration **curr;
3549   const struct bfd_arch_info *bfd_arch_info;
3550   /* Check that BFD recognizes this architecture */
3551   bfd_arch_info = bfd_lookup_arch (bfd_architecture, 0);
3552   if (bfd_arch_info == NULL)
3553     {
3554       internal_error (__FILE__, __LINE__,
3555                       _("gdbarch: Attempt to register unknown architecture (%d)"),
3556                       bfd_architecture);
3557     }
3558   /* Check that we haven't seen this architecture before */
3559   for (curr = &gdbarch_registry;
3560        (*curr) != NULL;
3561        curr = &(*curr)->next)
3562     {
3563       if (bfd_architecture == (*curr)->bfd_architecture)
3564         internal_error (__FILE__, __LINE__,
3565                         _("gdbarch: Duplicate registraration of architecture (%s)"),
3566                         bfd_arch_info->printable_name);
3567     }
3568   /* log it */
3569   if (gdbarch_debug)
3570     fprintf_unfiltered (gdb_stdlog, "register_gdbarch_init (%s, 0x%08lx)\n",
3571                         bfd_arch_info->printable_name,
3572                         (long) init);
3573   /* Append it */
3574   (*curr) = XMALLOC (struct gdbarch_registration);
3575   (*curr)->bfd_architecture = bfd_architecture;
3576   (*curr)->init = init;
3577   (*curr)->dump_tdep = dump_tdep;
3578   (*curr)->arches = NULL;
3579   (*curr)->next = NULL;
3580 }
3581
3582 void
3583 register_gdbarch_init (enum bfd_architecture bfd_architecture,
3584                        gdbarch_init_ftype *init)
3585 {
3586   gdbarch_register (bfd_architecture, init, NULL);
3587 }
3588
3589
3590 /* Look for an architecture using gdbarch_info.  */
3591
3592 struct gdbarch_list *
3593 gdbarch_list_lookup_by_info (struct gdbarch_list *arches,
3594                              const struct gdbarch_info *info)
3595 {
3596   for (; arches != NULL; arches = arches->next)
3597     {
3598       if (info->bfd_arch_info != arches->gdbarch->bfd_arch_info)
3599         continue;
3600       if (info->byte_order != arches->gdbarch->byte_order)
3601         continue;
3602       if (info->osabi != arches->gdbarch->osabi)
3603         continue;
3604       if (info->target_desc != arches->gdbarch->target_desc)
3605         continue;
3606       return arches;
3607     }
3608   return NULL;
3609 }
3610
3611
3612 /* Find an architecture that matches the specified INFO.  Create a new
3613    architecture if needed.  Return that new architecture.  Assumes
3614    that there is no current architecture.  */
3615
3616 static struct gdbarch *
3617 find_arch_by_info (struct gdbarch_info info)
3618 {
3619   struct gdbarch *new_gdbarch;
3620   struct gdbarch_registration *rego;
3621
3622   /* The existing architecture has been swapped out - all this code
3623      works from a clean slate.  */
3624   gdb_assert (current_gdbarch == NULL);
3625
3626   /* Fill in missing parts of the INFO struct using a number of
3627      sources: "set ..."; INFOabfd supplied; and the global
3628      defaults.  */
3629   gdbarch_info_fill (&info);
3630
3631   /* Must have found some sort of architecture. */
3632   gdb_assert (info.bfd_arch_info != NULL);
3633
3634   if (gdbarch_debug)
3635     {
3636       fprintf_unfiltered (gdb_stdlog,
3637                           "find_arch_by_info: info.bfd_arch_info %s\n",
3638                           (info.bfd_arch_info != NULL
3639                            ? info.bfd_arch_info->printable_name
3640                            : "(null)"));
3641       fprintf_unfiltered (gdb_stdlog,
3642                           "find_arch_by_info: info.byte_order %d (%s)\n",
3643                           info.byte_order,
3644                           (info.byte_order == BFD_ENDIAN_BIG ? "big"
3645                            : info.byte_order == BFD_ENDIAN_LITTLE ? "little"
3646                            : "default"));
3647       fprintf_unfiltered (gdb_stdlog,
3648                           "find_arch_by_info: info.osabi %d (%s)\n",
3649                           info.osabi, gdbarch_osabi_name (info.osabi));
3650       fprintf_unfiltered (gdb_stdlog,
3651                           "find_arch_by_info: info.abfd 0x%lx\n",
3652                           (long) info.abfd);
3653       fprintf_unfiltered (gdb_stdlog,
3654                           "find_arch_by_info: info.tdep_info 0x%lx\n",
3655                           (long) info.tdep_info);
3656     }
3657
3658   /* Find the tdep code that knows about this architecture.  */
3659   for (rego = gdbarch_registry;
3660        rego != NULL;
3661        rego = rego->next)
3662     if (rego->bfd_architecture == info.bfd_arch_info->arch)
3663       break;
3664   if (rego == NULL)
3665     {
3666       if (gdbarch_debug)
3667         fprintf_unfiltered (gdb_stdlog, "find_arch_by_info: "
3668                             "No matching architecture\n");
3669       return 0;
3670     }
3671
3672   /* Ask the tdep code for an architecture that matches "info".  */
3673   new_gdbarch = rego->init (info, rego->arches);
3674
3675   /* Did the tdep code like it?  No.  Reject the change and revert to
3676      the old architecture.  */
3677   if (new_gdbarch == NULL)
3678     {
3679       if (gdbarch_debug)
3680         fprintf_unfiltered (gdb_stdlog, "find_arch_by_info: "
3681                             "Target rejected architecture\n");
3682       return NULL;
3683     }
3684
3685   /* Is this a pre-existing architecture (as determined by already
3686      being initialized)?  Move it to the front of the architecture
3687      list (keeping the list sorted Most Recently Used).  */
3688   if (new_gdbarch->initialized_p)
3689     {
3690       struct gdbarch_list **list;
3691       struct gdbarch_list *this;
3692       if (gdbarch_debug)
3693         fprintf_unfiltered (gdb_stdlog, "find_arch_by_info: "
3694                             "Previous architecture 0x%08lx (%s) selected\n",
3695                             (long) new_gdbarch,
3696                             new_gdbarch->bfd_arch_info->printable_name);
3697       /* Find the existing arch in the list.  */
3698       for (list = &rego->arches;
3699            (*list) != NULL && (*list)->gdbarch != new_gdbarch;
3700            list = &(*list)->next);
3701       /* It had better be in the list of architectures.  */
3702       gdb_assert ((*list) != NULL && (*list)->gdbarch == new_gdbarch);
3703       /* Unlink THIS.  */
3704       this = (*list);
3705       (*list) = this->next;
3706       /* Insert THIS at the front.  */
3707       this->next = rego->arches;
3708       rego->arches = this;
3709       /* Return it.  */
3710       return new_gdbarch;
3711     }
3712
3713   /* It's a new architecture.  */
3714   if (gdbarch_debug)
3715     fprintf_unfiltered (gdb_stdlog, "find_arch_by_info: "
3716                         "New architecture 0x%08lx (%s) selected\n",
3717                         (long) new_gdbarch,
3718                         new_gdbarch->bfd_arch_info->printable_name);
3719
3720   /* Insert the new architecture into the front of the architecture
3721      list (keep the list sorted Most Recently Used).  */
3722   {
3723     struct gdbarch_list *this = XMALLOC (struct gdbarch_list);
3724     this->next = rego->arches;
3725     this->gdbarch = new_gdbarch;
3726     rego->arches = this;
3727   }
3728
3729   /* Check that the newly installed architecture is valid.  Plug in
3730      any post init values.  */
3731   new_gdbarch->dump_tdep = rego->dump_tdep;
3732   verify_gdbarch (new_gdbarch);
3733   new_gdbarch->initialized_p = 1;
3734
3735   /* Initialize any per-architecture swap areas.  This phase requires
3736      a valid global CURRENT_GDBARCH.  Set it momentarially, and then
3737      swap the entire architecture out.  */
3738   current_gdbarch = new_gdbarch;
3739   current_gdbarch_swap_init_hack ();
3740   current_gdbarch_swap_out_hack ();
3741
3742   if (gdbarch_debug)
3743     gdbarch_dump (new_gdbarch, gdb_stdlog);
3744
3745   return new_gdbarch;
3746 }
3747
3748 struct gdbarch *
3749 gdbarch_find_by_info (struct gdbarch_info info)
3750 {
3751   /* Save the previously selected architecture, setting the global to
3752      NULL.  This stops things like gdbarch->init() trying to use the
3753      previous architecture's configuration.  The previous architecture
3754      may not even be of the same architecture family.  The most recent
3755      architecture of the same family is found at the head of the
3756      rego->arches list.  */
3757   struct gdbarch *old_gdbarch = current_gdbarch_swap_out_hack ();
3758
3759   /* Find the specified architecture.  */
3760   struct gdbarch *new_gdbarch = find_arch_by_info (info);
3761
3762   /* Restore the existing architecture.  */
3763   gdb_assert (current_gdbarch == NULL);
3764   current_gdbarch_swap_in_hack (old_gdbarch);
3765
3766   return new_gdbarch;
3767 }
3768
3769 /* Make the specified architecture current, swapping the existing one
3770    out.  */
3771
3772 void
3773 deprecated_current_gdbarch_select_hack (struct gdbarch *new_gdbarch)
3774 {
3775   gdb_assert (new_gdbarch != NULL);
3776   gdb_assert (current_gdbarch != NULL);
3777   gdb_assert (new_gdbarch->initialized_p);
3778   current_gdbarch_swap_out_hack ();
3779   current_gdbarch_swap_in_hack (new_gdbarch);
3780   architecture_changed_event ();
3781   reinit_frame_cache ();
3782 }
3783
3784 extern void _initialize_gdbarch (void);
3785
3786 void
3787 _initialize_gdbarch (void)
3788 {
3789   struct cmd_list_element *c;
3790
3791   add_setshow_zinteger_cmd ("arch", class_maintenance, &gdbarch_debug, _("\
3792 Set architecture debugging."), _("\
3793 Show architecture debugging."), _("\
3794 When non-zero, architecture debugging is enabled."),
3795                             NULL,
3796                             show_gdbarch_debug,
3797                             &setdebuglist, &showdebuglist);
3798 }