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