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