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