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