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