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