gdb/gdbarch.c

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