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