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