gdb/gdbarch.c

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