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