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