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