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