gdb/gdbarch.c

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