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