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,
   6    2007, 2008, 2009 Free Software Foundation, Inc.
   7
   8    This file is part of GDB.
   9
  10    This program is free software; you can redistribute it and/or modify
  11    it under the terms of the GNU General Public License as published by
  12    the Free Software Foundation; either version 3 of the License, or
  13    (at your option) any later version.
  14
  15    This program is distributed in the hope that it will be useful,
  16    but WITHOUT ANY WARRANTY; without even the implied warranty of
  17    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18    GNU General Public License for more details.
  19
  20    You should have received a copy of the GNU General Public License
  21    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  22
  23 /* This file was created with the aid of ``gdbarch.sh''.
  24
  25    The Bourne shell script ``gdbarch.sh'' creates the files
  26    ``new-gdbarch.c'' and ``new-gdbarch.h and then compares them
  27    against the existing ``gdbarch.[hc]''.  Any differences found
  28    being reported.
  29
  30    If editing this file, please also run gdbarch.sh and merge any
  31    changes into that script. Conversely, when making sweeping changes
  32    to this file, modifying gdbarch.sh and using its output may prove
  33    easier.  */
  34
  35
  36 #include "defs.h"
  37 #include "arch-utils.h"
  38
  39 #include "gdbcmd.h"
  40 #include "inferior.h"
  41 #include "symcat.h"
  42
  43 #include "floatformat.h"
  44
  45 #include "gdb_assert.h"
  46 #include "gdb_string.h"
  47 #include "reggroups.h"
  48 #include "osabi.h"
  49 #include "gdb_obstack.h"
  50 #include "observer.h"
  51 #include "regcache.h"
  52 #include "objfiles.h"
  53
  54 /* Static function declarations */
  55
  56 static void alloc_gdbarch_data (struct gdbarch *);
  57
  58 /* Non-zero if we want to trace architecture code.  */
  59
  60 #ifndef GDBARCH_DEBUG
  61 #define GDBARCH_DEBUG 0
  62 #endif
  63 int gdbarch_debug = GDBARCH_DEBUG;
  64 static void
  65 show_gdbarch_debug (struct ui_file *file, int from_tty,
  66                     struct cmd_list_element *c, const char *value)
  67 {
  68   fprintf_filtered (file, _("Architecture debugging is %s.\n"), value);
  69 }
  70
  71 static const char *
  72 pformat (const struct floatformat **format)
  73 {
  74   if (format == NULL)
  75     return "(null)";
  76   else
  77     /* Just print out one of them - this is only for diagnostics.  */
  78     return format[0]->name;
  79 }
  80
  81 static const char *
  82 pstring (const char *string)
  83 {
  84   if (string == NULL)
  85     return "(null)";
  86   return string;
  87 }
  88
  89
  90 /* Maintain the struct gdbarch object.  */
  91
  92 struct gdbarch
  93 {
  94   /* Has this architecture been fully initialized?  */
  95   int initialized_p;
  96
  97   /* An obstack bound to the lifetime of the architecture.  */
  98   struct obstack *obstack;
  99
 100   /* basic architectural information.  */
 101   const struct bfd_arch_info * bfd_arch_info;
 102   int byte_order;
 103   int byte_order_for_code;
 104   enum gdb_osabi osabi;
 105   const struct target_desc * target_desc;
 106
 107   /* target specific vector.  */
 108   struct gdbarch_tdep *tdep;
 109   gdbarch_dump_tdep_ftype *dump_tdep;
 110
 111   /* per-architecture data-pointers.  */
 112   unsigned nr_data;
 113   void **data;
 114
 115   /* per-architecture swap-regions.  */
 116   struct gdbarch_swap *swap;
 117
 118   /* Multi-arch values.
 119
 120      When extending this structure you must:
 121
 122      Add the field below.
 123
 124      Declare set/get functions and define the corresponding
 125      macro in gdbarch.h.
 126
 127      gdbarch_alloc(): If zero/NULL is not a suitable default,
 128      initialize the new field.
 129
 130      verify_gdbarch(): Confirm that the target updated the field
 131      correctly.
 132
 133      gdbarch_dump(): Add a fprintf_unfiltered call so that the new
 134      field is dumped out
 135
 136      ``startup_gdbarch()'': Append an initial value to the static
 137      variable (base values on the host's c-type system).
 138
 139      get_gdbarch(): Implement the set/get functions (probably using
 140      the macro's as shortcuts).
 141
 142      */
 143
 144   int bits_big_endian;
 145   int short_bit;
 146   int int_bit;
 147   int long_bit;
 148   int long_long_bit;
 149   int long_long_align_bit;
 150   int half_bit;
 151   const struct floatformat ** half_format;
 152   int float_bit;
 153   const struct floatformat ** float_format;
 154   int double_bit;
 155   const struct floatformat ** double_format;
 156   int long_double_bit;
 157   const struct floatformat ** long_double_format;
 158   int ptr_bit;
 159   int addr_bit;
 160   int dwarf2_addr_size;
 161   int char_signed;
 162   gdbarch_read_pc_ftype *read_pc;
 163   gdbarch_write_pc_ftype *write_pc;
 164   gdbarch_virtual_frame_pointer_ftype *virtual_frame_pointer;
 165   gdbarch_pseudo_register_read_ftype *pseudo_register_read;
 166   gdbarch_pseudo_register_read_value_ftype *pseudo_register_read_value;
 167   gdbarch_pseudo_register_write_ftype *pseudo_register_write;
 168   int num_regs;
 169   int num_pseudo_regs;
 170   gdbarch_ax_pseudo_register_collect_ftype *ax_pseudo_register_collect;
 171   gdbarch_ax_pseudo_register_push_stack_ftype *ax_pseudo_register_push_stack;
 172   int sp_regnum;
 173   int pc_regnum;
 174   int ps_regnum;
 175   int fp0_regnum;
 176   gdbarch_stab_reg_to_regnum_ftype *stab_reg_to_regnum;
 177   gdbarch_ecoff_reg_to_regnum_ftype *ecoff_reg_to_regnum;
 178   gdbarch_sdb_reg_to_regnum_ftype *sdb_reg_to_regnum;
 179   gdbarch_dwarf2_reg_to_regnum_ftype *dwarf2_reg_to_regnum;
 180   gdbarch_register_name_ftype *register_name;
 181   gdbarch_register_type_ftype *register_type;
 182   gdbarch_dummy_id_ftype *dummy_id;
 183   int deprecated_fp_regnum;
 184   gdbarch_push_dummy_call_ftype *push_dummy_call;
 185   int call_dummy_location;
 186   gdbarch_push_dummy_code_ftype *push_dummy_code;
 187   gdbarch_print_registers_info_ftype *print_registers_info;
 188   gdbarch_print_float_info_ftype *print_float_info;
 189   gdbarch_print_vector_info_ftype *print_vector_info;
 190   gdbarch_register_sim_regno_ftype *register_sim_regno;
 191   gdbarch_cannot_fetch_register_ftype *cannot_fetch_register;
 192   gdbarch_cannot_store_register_ftype *cannot_store_register;
 193   gdbarch_get_longjmp_target_ftype *get_longjmp_target;
 194   int believe_pcc_promotion;
 195   gdbarch_convert_register_p_ftype *convert_register_p;
 196   gdbarch_register_to_value_ftype *register_to_value;
 197   gdbarch_value_to_register_ftype *value_to_register;
 198   gdbarch_value_from_register_ftype *value_from_register;
 199   gdbarch_pointer_to_address_ftype *pointer_to_address;
 200   gdbarch_address_to_pointer_ftype *address_to_pointer;
 201   gdbarch_integer_to_address_ftype *integer_to_address;
 202   gdbarch_return_value_ftype *return_value;
 203   gdbarch_skip_prologue_ftype *skip_prologue;
 204   gdbarch_skip_main_prologue_ftype *skip_main_prologue;
 205   gdbarch_inner_than_ftype *inner_than;
 206   gdbarch_breakpoint_from_pc_ftype *breakpoint_from_pc;
 207   gdbarch_remote_breakpoint_from_pc_ftype *remote_breakpoint_from_pc;
 208   gdbarch_adjust_breakpoint_address_ftype *adjust_breakpoint_address;
 209   gdbarch_memory_insert_breakpoint_ftype *memory_insert_breakpoint;
 210   gdbarch_memory_remove_breakpoint_ftype *memory_remove_breakpoint;
 211   CORE_ADDR decr_pc_after_break;
 212   CORE_ADDR deprecated_function_start_offset;
 213   gdbarch_remote_register_number_ftype *remote_register_number;
 214   gdbarch_fetch_tls_load_module_address_ftype *fetch_tls_load_module_address;
 215   CORE_ADDR frame_args_skip;
 216   gdbarch_unwind_pc_ftype *unwind_pc;
 217   gdbarch_unwind_sp_ftype *unwind_sp;
 218   gdbarch_frame_num_args_ftype *frame_num_args;
 219   gdbarch_frame_align_ftype *frame_align;
 220   gdbarch_stabs_argument_has_addr_ftype *stabs_argument_has_addr;
 221   int frame_red_zone_size;
 222   gdbarch_convert_from_func_ptr_addr_ftype *convert_from_func_ptr_addr;
 223   gdbarch_addr_bits_remove_ftype *addr_bits_remove;
 224   gdbarch_smash_text_address_ftype *smash_text_address;
 225   gdbarch_software_single_step_ftype *software_single_step;
 226   gdbarch_single_step_through_delay_ftype *single_step_through_delay;
 227   gdbarch_print_insn_ftype *print_insn;
 228   gdbarch_skip_trampoline_code_ftype *skip_trampoline_code;
 229   gdbarch_skip_solib_resolver_ftype *skip_solib_resolver;
 230   gdbarch_in_solib_return_trampoline_ftype *in_solib_return_trampoline;
 231   gdbarch_in_function_epilogue_p_ftype *in_function_epilogue_p;
 232   gdbarch_elf_make_msymbol_special_ftype *elf_make_msymbol_special;
 233   gdbarch_coff_make_msymbol_special_ftype *coff_make_msymbol_special;
 234   int cannot_step_breakpoint;
 235   int have_nonsteppable_watchpoint;
 236   gdbarch_address_class_type_flags_ftype *address_class_type_flags;
 237   gdbarch_address_class_type_flags_to_name_ftype *address_class_type_flags_to_name;
 238   gdbarch_address_class_name_to_type_flags_ftype *address_class_name_to_type_flags;
 239   gdbarch_register_reggroup_p_ftype *register_reggroup_p;
 240   gdbarch_fetch_pointer_argument_ftype *fetch_pointer_argument;
 241   gdbarch_regset_from_core_section_ftype *regset_from_core_section;
 242   struct core_regset_section * core_regset_sections;
 243   gdbarch_make_corefile_notes_ftype *make_corefile_notes;
 244   gdbarch_find_memory_regions_ftype *find_memory_regions;
 245   gdbarch_core_xfer_shared_libraries_ftype *core_xfer_shared_libraries;
 246   gdbarch_core_pid_to_str_ftype *core_pid_to_str;
 247   const char * gcore_bfd_target;
 248   int vtable_function_descriptors;
 249   int vbit_in_delta;
 250   gdbarch_skip_permanent_breakpoint_ftype *skip_permanent_breakpoint;
 251   ULONGEST max_insn_length;
 252   gdbarch_displaced_step_copy_insn_ftype *displaced_step_copy_insn;
 253   gdbarch_displaced_step_hw_singlestep_ftype *displaced_step_hw_singlestep;
 254   gdbarch_displaced_step_fixup_ftype *displaced_step_fixup;
 255   gdbarch_displaced_step_free_closure_ftype *displaced_step_free_closure;
 256   gdbarch_displaced_step_location_ftype *displaced_step_location;
 257   gdbarch_relocate_instruction_ftype *relocate_instruction;
 258   gdbarch_overlay_update_ftype *overlay_update;
 259   gdbarch_core_read_description_ftype *core_read_description;
 260   gdbarch_static_transform_name_ftype *static_transform_name;
 261   int sofun_address_maybe_missing;
 262   gdbarch_process_record_ftype *process_record;
 263   gdbarch_process_record_signal_ftype *process_record_signal;
 264   gdbarch_gdb_signal_from_target_ftype *gdb_signal_from_target;
 265   gdbarch_get_siginfo_type_ftype *get_siginfo_type;
 266   gdbarch_record_special_symbol_ftype *record_special_symbol;
 267   gdbarch_get_syscall_number_ftype *get_syscall_number;
 268   const char * stap_integer_prefix;
 269   const char * stap_integer_suffix;
 270   const char * stap_register_prefix;
 271   const char * stap_register_suffix;
 272   const char * stap_register_indirection_prefix;
 273   const char * stap_register_indirection_suffix;
 274   const char * stap_gdb_register_prefix;
 275   const char * stap_gdb_register_suffix;
 276   gdbarch_stap_is_single_operand_ftype *stap_is_single_operand;
 277   gdbarch_stap_parse_special_token_ftype *stap_parse_special_token;
 278   int has_global_solist;
 279   int has_global_breakpoints;
 280   gdbarch_has_shared_address_space_ftype *has_shared_address_space;
 281   gdbarch_fast_tracepoint_valid_at_ftype *fast_tracepoint_valid_at;
 282   gdbarch_auto_charset_ftype *auto_charset;
 283   gdbarch_auto_wide_charset_ftype *auto_wide_charset;
 284   const char * solib_symbols_extension;
 285   int has_dos_based_file_system;
 286   gdbarch_gen_return_address_ftype *gen_return_address;
 287   gdbarch_info_proc_ftype *info_proc;
 288   gdbarch_iterate_over_objfiles_in_search_order_ftype *iterate_over_objfiles_in_search_order;
 289 };
 290
 291
 292 /* The default architecture uses host values (for want of a better
 293    choice).  */
 294
 295 extern const struct bfd_arch_info bfd_default_arch_struct;
 296
 297 struct gdbarch startup_gdbarch =
 298 {
 299   1, /* Always initialized.  */
 300   NULL, /* The obstack.  */
 301   /* basic architecture information.  */
 302   &bfd_default_arch_struct,  /* bfd_arch_info */
 303   BFD_ENDIAN_BIG,  /* byte_order */
 304   BFD_ENDIAN_BIG,  /* byte_order_for_code */
 305   GDB_OSABI_UNKNOWN,  /* osabi */
 306   0,  /* target_desc */
 307   /* target specific vector and its dump routine.  */
 308   NULL, NULL,
 309   /*per-architecture data-pointers and swap regions.  */
 310   0, NULL, NULL,
 311   /* Multi-arch values */
 312   1,  /* bits_big_endian */
 313   8 * sizeof (short),  /* short_bit */
 314   8 * sizeof (int),  /* int_bit */
 315   8 * sizeof (long),  /* long_bit */
 316   8 * sizeof (LONGEST),  /* long_long_bit */
 317   8 * sizeof (LONGEST),  /* long_long_align_bit */
 318   16,  /* half_bit */
 319   0,  /* half_format */
 320   8 * sizeof (float),  /* float_bit */
 321   0,  /* float_format */
 322   8 * sizeof (double),  /* double_bit */
 323   0,  /* double_format */
 324   8 * sizeof (long double),  /* long_double_bit */
 325   0,  /* long_double_format */
 326   8 * sizeof (void*),  /* ptr_bit */
 327   8 * sizeof (void*),  /* addr_bit */
 328   sizeof (void*),  /* dwarf2_addr_size */
 329   1,  /* char_signed */
 330   0,  /* read_pc */
 331   0,  /* write_pc */
 332   legacy_virtual_frame_pointer,  /* virtual_frame_pointer */
 333   0,  /* pseudo_register_read */
 334   0,  /* pseudo_register_read_value */
 335   0,  /* pseudo_register_write */
 336   0,  /* num_regs */
 337   0,  /* num_pseudo_regs */
 338   0,  /* ax_pseudo_register_collect */
 339   0,  /* ax_pseudo_register_push_stack */
 340   -1,  /* sp_regnum */
 341   -1,  /* pc_regnum */
 342   -1,  /* ps_regnum */
 343   0,  /* fp0_regnum */
 344   no_op_reg_to_regnum,  /* stab_reg_to_regnum */
 345   no_op_reg_to_regnum,  /* ecoff_reg_to_regnum */
 346   no_op_reg_to_regnum,  /* sdb_reg_to_regnum */
 347   no_op_reg_to_regnum,  /* dwarf2_reg_to_regnum */
 348   0,  /* register_name */
 349   0,  /* register_type */
 350   0,  /* dummy_id */
 351   -1,  /* deprecated_fp_regnum */
 352   0,  /* push_dummy_call */
 353   0,  /* call_dummy_location */
 354   0,  /* push_dummy_code */
 355   default_print_registers_info,  /* print_registers_info */
 356   0,  /* print_float_info */
 357   0,  /* print_vector_info */
 358   legacy_register_sim_regno,  /* register_sim_regno */
 359   cannot_register_not,  /* cannot_fetch_register */
 360   cannot_register_not,  /* cannot_store_register */
 361   0,  /* get_longjmp_target */
 362   0,  /* believe_pcc_promotion */
 363   generic_convert_register_p,  /* convert_register_p */
 364   0,  /* register_to_value */
 365   0,  /* value_to_register */
 366   0,  /* value_from_register */
 367   unsigned_pointer_to_address,  /* pointer_to_address */
 368   unsigned_address_to_pointer,  /* address_to_pointer */
 369   0,  /* integer_to_address */
 370   0,  /* return_value */
 371   0,  /* skip_prologue */
 372   0,  /* skip_main_prologue */
 373   0,  /* inner_than */
 374   0,  /* breakpoint_from_pc */
 375   default_remote_breakpoint_from_pc,  /* remote_breakpoint_from_pc */
 376   0,  /* adjust_breakpoint_address */
 377   default_memory_insert_breakpoint,  /* memory_insert_breakpoint */
 378   default_memory_remove_breakpoint,  /* memory_remove_breakpoint */
 379   0,  /* decr_pc_after_break */
 380   0,  /* deprecated_function_start_offset */
 381   default_remote_register_number,  /* remote_register_number */
 382   0,  /* fetch_tls_load_module_address */
 383   0,  /* frame_args_skip */
 384   0,  /* unwind_pc */
 385   0,  /* unwind_sp */
 386   0,  /* frame_num_args */
 387   0,  /* frame_align */
 388   default_stabs_argument_has_addr,  /* stabs_argument_has_addr */
 389   0,  /* frame_red_zone_size */
 390   convert_from_func_ptr_addr_identity,  /* convert_from_func_ptr_addr */
 391   core_addr_identity,  /* addr_bits_remove */
 392   core_addr_identity,  /* smash_text_address */
 393   0,  /* software_single_step */
 394   0,  /* single_step_through_delay */
 395   0,  /* print_insn */
 396   0,  /* skip_trampoline_code */
 397   generic_skip_solib_resolver,  /* skip_solib_resolver */
 398   generic_in_solib_return_trampoline,  /* in_solib_return_trampoline */
 399   generic_in_function_epilogue_p,  /* in_function_epilogue_p */
 400   0,  /* elf_make_msymbol_special */
 401   0,  /* coff_make_msymbol_special */
 402   0,  /* cannot_step_breakpoint */
 403   0,  /* have_nonsteppable_watchpoint */
 404   0,  /* address_class_type_flags */
 405   0,  /* address_class_type_flags_to_name */
 406   0,  /* address_class_name_to_type_flags */
 407   default_register_reggroup_p,  /* register_reggroup_p */
 408   0,  /* fetch_pointer_argument */
 409   0,  /* regset_from_core_section */
 410   0,  /* core_regset_sections */
 411   0,  /* make_corefile_notes */
 412   0,  /* find_memory_regions */
 413   0,  /* core_xfer_shared_libraries */
 414   0,  /* core_pid_to_str */
 415   0,  /* gcore_bfd_target */
 416   0,  /* vtable_function_descriptors */
 417   0,  /* vbit_in_delta */
 418   0,  /* skip_permanent_breakpoint */
 419   0,  /* max_insn_length */
 420   0,  /* displaced_step_copy_insn */
 421   default_displaced_step_hw_singlestep,  /* displaced_step_hw_singlestep */
 422   0,  /* displaced_step_fixup */
 423   NULL,  /* displaced_step_free_closure */
 424   NULL,  /* displaced_step_location */
 425   0,  /* relocate_instruction */
 426   0,  /* overlay_update */
 427   0,  /* core_read_description */
 428   0,  /* static_transform_name */
 429   0,  /* sofun_address_maybe_missing */
 430   0,  /* process_record */
 431   0,  /* process_record_signal */
 432   0,  /* gdb_signal_from_target */
 433   0,  /* get_siginfo_type */
 434   0,  /* record_special_symbol */
 435   0,  /* get_syscall_number */
 436   0,  /* stap_integer_prefix */
 437   0,  /* stap_integer_suffix */
 438   0,  /* stap_register_prefix */
 439   0,  /* stap_register_suffix */
 440   0,  /* stap_register_indirection_prefix */
 441   0,  /* stap_register_indirection_suffix */
 442   0,  /* stap_gdb_register_prefix */
 443   0,  /* stap_gdb_register_suffix */
 444   0,  /* stap_is_single_operand */
 445   0,  /* stap_parse_special_token */
 446   0,  /* has_global_solist */
 447   0,  /* has_global_breakpoints */
 448   default_has_shared_address_space,  /* has_shared_address_space */
 449   default_fast_tracepoint_valid_at,  /* fast_tracepoint_valid_at */
 450   default_auto_charset,  /* auto_charset */
 451   default_auto_wide_charset,  /* auto_wide_charset */
 452   0,  /* solib_symbols_extension */
 453   0,  /* has_dos_based_file_system */
 454   default_gen_return_address,  /* gen_return_address */
 455   0,  /* info_proc */
 456   default_iterate_over_objfiles_in_search_order,  /* iterate_over_objfiles_in_search_order */
 457   /* startup_gdbarch() */
 458 };
 459
 460 struct gdbarch *target_gdbarch = &startup_gdbarch;
 461
 462 /* Create a new ``struct gdbarch'' based on information provided by
 463    ``struct gdbarch_info''.  */
 464
 465 struct gdbarch *
 466 gdbarch_alloc (const struct gdbarch_info *info,
 467                struct gdbarch_tdep *tdep)
 468 {
 469   struct gdbarch *gdbarch;
 470
 471   /* Create an obstack for allocating all the per-architecture memory,
 472      then use that to allocate the architecture vector.  */
 473   struct obstack *obstack = XMALLOC (struct obstack);
 474   obstack_init (obstack);
 475   gdbarch = obstack_alloc (obstack, sizeof (*gdbarch));
 476   memset (gdbarch, 0, sizeof (*gdbarch));
 477   gdbarch->obstack = obstack;
 478
 479   alloc_gdbarch_data (gdbarch);
 480
 481   gdbarch->tdep = tdep;
 482
 483   gdbarch->bfd_arch_info = info->bfd_arch_info;
 484   gdbarch->byte_order = info->byte_order;
 485   gdbarch->byte_order_for_code = info->byte_order_for_code;
 486   gdbarch->osabi = info->osabi;
 487   gdbarch->target_desc = info->target_desc;
 488
 489   /* Force the explicit initialization of these.  */
 490   gdbarch->bits_big_endian = (gdbarch->byte_order == BFD_ENDIAN_BIG);
 491   gdbarch->short_bit = 2*TARGET_CHAR_BIT;
 492   gdbarch->int_bit = 4*TARGET_CHAR_BIT;
 493   gdbarch->long_bit = 4*TARGET_CHAR_BIT;
 494   gdbarch->long_long_bit = 2*gdbarch->long_bit;
 495   gdbarch->long_long_align_bit = 2*gdbarch->long_bit;
 496   gdbarch->half_bit = 2*TARGET_CHAR_BIT;
 497   gdbarch->float_bit = 4*TARGET_CHAR_BIT;
 498   gdbarch->double_bit = 8*TARGET_CHAR_BIT;
 499   gdbarch->long_double_bit = 8*TARGET_CHAR_BIT;
 500   gdbarch->ptr_bit = gdbarch->int_bit;
 501   gdbarch->char_signed = -1;
 502   gdbarch->virtual_frame_pointer = legacy_virtual_frame_pointer;
 503   gdbarch->num_regs = -1;
 504   gdbarch->sp_regnum = -1;
 505   gdbarch->pc_regnum = -1;
 506   gdbarch->ps_regnum = -1;
 507   gdbarch->fp0_regnum = -1;
 508   gdbarch->stab_reg_to_regnum = no_op_reg_to_regnum;
 509   gdbarch->ecoff_reg_to_regnum = no_op_reg_to_regnum;
 510   gdbarch->sdb_reg_to_regnum = no_op_reg_to_regnum;
 511   gdbarch->dwarf2_reg_to_regnum = no_op_reg_to_regnum;
 512   gdbarch->deprecated_fp_regnum = -1;
 513   gdbarch->call_dummy_location = AT_ENTRY_POINT;
 514   gdbarch->print_registers_info = default_print_registers_info;
 515   gdbarch->register_sim_regno = legacy_register_sim_regno;
 516   gdbarch->cannot_fetch_register = cannot_register_not;
 517   gdbarch->cannot_store_register = cannot_register_not;
 518   gdbarch->convert_register_p = generic_convert_register_p;
 519   gdbarch->value_from_register = default_value_from_register;
 520   gdbarch->pointer_to_address = unsigned_pointer_to_address;
 521   gdbarch->address_to_pointer = unsigned_address_to_pointer;
 522   gdbarch->remote_breakpoint_from_pc = default_remote_breakpoint_from_pc;
 523   gdbarch->memory_insert_breakpoint = default_memory_insert_breakpoint;
 524   gdbarch->memory_remove_breakpoint = default_memory_remove_breakpoint;
 525   gdbarch->remote_register_number = default_remote_register_number;
 526   gdbarch->stabs_argument_has_addr = default_stabs_argument_has_addr;
 527   gdbarch->convert_from_func_ptr_addr = convert_from_func_ptr_addr_identity;
 528   gdbarch->addr_bits_remove = core_addr_identity;
 529   gdbarch->smash_text_address = core_addr_identity;
 530   gdbarch->skip_trampoline_code = generic_skip_trampoline_code;
 531   gdbarch->skip_solib_resolver = generic_skip_solib_resolver;
 532   gdbarch->in_solib_return_trampoline = generic_in_solib_return_trampoline;
 533   gdbarch->in_function_epilogue_p = generic_in_function_epilogue_p;
 534   gdbarch->elf_make_msymbol_special = default_elf_make_msymbol_special;
 535   gdbarch->coff_make_msymbol_special = default_coff_make_msymbol_special;
 536   gdbarch->register_reggroup_p = default_register_reggroup_p;
 537   gdbarch->displaced_step_hw_singlestep = default_displaced_step_hw_singlestep;
 538   gdbarch->displaced_step_fixup = NULL;
 539   gdbarch->displaced_step_free_closure = NULL;
 540   gdbarch->displaced_step_location = NULL;
 541   gdbarch->relocate_instruction = NULL;
 542   gdbarch->has_shared_address_space = default_has_shared_address_space;
 543   gdbarch->fast_tracepoint_valid_at = default_fast_tracepoint_valid_at;
 544   gdbarch->auto_charset = default_auto_charset;
 545   gdbarch->auto_wide_charset = default_auto_wide_charset;
 546   gdbarch->gen_return_address = default_gen_return_address;
 547   gdbarch->iterate_over_objfiles_in_search_order = default_iterate_over_objfiles_in_search_order;
 548   /* gdbarch_alloc() */
 549
 550   return gdbarch;
 551 }
 552
 553
 554 /* Allocate extra space using the per-architecture obstack.  */
 555
 556 void *
 557 gdbarch_obstack_zalloc (struct gdbarch *arch, long size)
 558 {
 559   void *data = obstack_alloc (arch->obstack, size);
 560
 561   memset (data, 0, size);
 562   return data;
 563 }
 564
 565
 566 /* Free a gdbarch struct.  This should never happen in normal
 567    operation --- once you've created a gdbarch, you keep it around.
 568    However, if an architecture's init function encounters an error
 569    building the structure, it may need to clean up a partially
 570    constructed gdbarch.  */
 571
 572 void
 573 gdbarch_free (struct gdbarch *arch)
 574 {
 575   struct obstack *obstack;
 576
 577   gdb_assert (arch != NULL);
 578   gdb_assert (!arch->initialized_p);
 579   obstack = arch->obstack;
 580   obstack_free (obstack, 0); /* Includes the ARCH.  */
 581   xfree (obstack);
 582 }
 583
 584
 585 /* Ensure that all values in a GDBARCH are reasonable.  */
 586
 587 static void
 588 verify_gdbarch (struct gdbarch *gdbarch)
 589 {
 590   struct ui_file *log;
 591   struct cleanup *cleanups;
 592   long length;
 593   char *buf;
 594
 595   log = mem_fileopen ();
 596   cleanups = make_cleanup_ui_file_delete (log);
 597   /* fundamental */
 598   if (gdbarch->byte_order == BFD_ENDIAN_UNKNOWN)
 599     fprintf_unfiltered (log, "\n\tbyte-order");
 600   if (gdbarch->bfd_arch_info == NULL)
 601     fprintf_unfiltered (log, "\n\tbfd_arch_info");
 602   /* Check those that need to be defined for the given multi-arch level.  */
 603   /* Skip verify of bits_big_endian, invalid_p == 0 */
 604   /* Skip verify of short_bit, invalid_p == 0 */
 605   /* Skip verify of int_bit, invalid_p == 0 */
 606   /* Skip verify of long_bit, invalid_p == 0 */
 607   /* Skip verify of long_long_bit, invalid_p == 0 */
 608   /* Skip verify of long_long_align_bit, invalid_p == 0 */
 609   /* Skip verify of half_bit, invalid_p == 0 */
 610   if (gdbarch->half_format == 0)
 611     gdbarch->half_format = floatformats_ieee_half;
 612   /* Skip verify of float_bit, invalid_p == 0 */
 613   if (gdbarch->float_format == 0)
 614     gdbarch->float_format = floatformats_ieee_single;
 615   /* Skip verify of double_bit, invalid_p == 0 */
 616   if (gdbarch->double_format == 0)
 617     gdbarch->double_format = floatformats_ieee_double;
 618   /* Skip verify of long_double_bit, invalid_p == 0 */
 619   if (gdbarch->long_double_format == 0)
 620     gdbarch->long_double_format = floatformats_ieee_double;
 621   /* Skip verify of ptr_bit, invalid_p == 0 */
 622   if (gdbarch->addr_bit == 0)
 623     gdbarch->addr_bit = gdbarch_ptr_bit (gdbarch);
 624   if (gdbarch->dwarf2_addr_size == 0)
 625     gdbarch->dwarf2_addr_size = gdbarch_ptr_bit (gdbarch) / TARGET_CHAR_BIT;
 626   if (gdbarch->char_signed == -1)
 627     gdbarch->char_signed = 1;
 628   /* Skip verify of read_pc, has predicate.  */
 629   /* Skip verify of write_pc, has predicate.  */
 630   /* Skip verify of virtual_frame_pointer, invalid_p == 0 */
 631   /* Skip verify of pseudo_register_read, has predicate.  */
 632   /* Skip verify of pseudo_register_read_value, has predicate.  */
 633   /* Skip verify of pseudo_register_write, has predicate.  */
 634   if (gdbarch->num_regs == -1)
 635     fprintf_unfiltered (log, "\n\tnum_regs");
 636   /* Skip verify of num_pseudo_regs, invalid_p == 0 */
 637   /* Skip verify of ax_pseudo_register_collect, has predicate.  */
 638   /* Skip verify of ax_pseudo_register_push_stack, has predicate.  */
 639   /* Skip verify of sp_regnum, invalid_p == 0 */
 640   /* Skip verify of pc_regnum, invalid_p == 0 */
 641   /* Skip verify of ps_regnum, invalid_p == 0 */
 642   /* Skip verify of fp0_regnum, invalid_p == 0 */
 643   /* Skip verify of stab_reg_to_regnum, invalid_p == 0 */
 644   /* Skip verify of ecoff_reg_to_regnum, invalid_p == 0 */
 645   /* Skip verify of sdb_reg_to_regnum, invalid_p == 0 */
 646   /* Skip verify of dwarf2_reg_to_regnum, invalid_p == 0 */
 647   if (gdbarch->register_name == 0)
 648     fprintf_unfiltered (log, "\n\tregister_name");
 649   /* Skip verify of register_type, has predicate.  */
 650   /* Skip verify of dummy_id, has predicate.  */
 651   /* Skip verify of deprecated_fp_regnum, invalid_p == 0 */
 652   /* Skip verify of push_dummy_call, has predicate.  */
 653   /* Skip verify of call_dummy_location, invalid_p == 0 */
 654   /* Skip verify of push_dummy_code, has predicate.  */
 655   /* Skip verify of print_registers_info, invalid_p == 0 */
 656   /* Skip verify of print_float_info, has predicate.  */
 657   /* Skip verify of print_vector_info, has predicate.  */
 658   /* Skip verify of register_sim_regno, invalid_p == 0 */
 659   /* Skip verify of cannot_fetch_register, invalid_p == 0 */
 660   /* Skip verify of cannot_store_register, invalid_p == 0 */
 661   /* Skip verify of get_longjmp_target, has predicate.  */
 662   /* Skip verify of convert_register_p, invalid_p == 0 */
 663   /* Skip verify of value_from_register, invalid_p == 0 */
 664   /* Skip verify of pointer_to_address, invalid_p == 0 */
 665   /* Skip verify of address_to_pointer, invalid_p == 0 */
 666   /* Skip verify of integer_to_address, has predicate.  */
 667   /* Skip verify of return_value, has predicate.  */
 668   if (gdbarch->skip_prologue == 0)
 669     fprintf_unfiltered (log, "\n\tskip_prologue");
 670   /* Skip verify of skip_main_prologue, has predicate.  */
 671   if (gdbarch->inner_than == 0)
 672     fprintf_unfiltered (log, "\n\tinner_than");
 673   if (gdbarch->breakpoint_from_pc == 0)
 674     fprintf_unfiltered (log, "\n\tbreakpoint_from_pc");
 675   /* Skip verify of remote_breakpoint_from_pc, invalid_p == 0 */
 676   /* Skip verify of adjust_breakpoint_address, has predicate.  */
 677   /* Skip verify of memory_insert_breakpoint, invalid_p == 0 */
 678   /* Skip verify of memory_remove_breakpoint, invalid_p == 0 */
 679   /* Skip verify of decr_pc_after_break, invalid_p == 0 */
 680   /* Skip verify of deprecated_function_start_offset, invalid_p == 0 */
 681   /* Skip verify of remote_register_number, invalid_p == 0 */
 682   /* Skip verify of fetch_tls_load_module_address, has predicate.  */
 683   /* Skip verify of frame_args_skip, invalid_p == 0 */
 684   /* Skip verify of unwind_pc, has predicate.  */
 685   /* Skip verify of unwind_sp, has predicate.  */
 686   /* Skip verify of frame_num_args, has predicate.  */
 687   /* Skip verify of frame_align, has predicate.  */
 688   /* Skip verify of stabs_argument_has_addr, invalid_p == 0 */
 689   /* Skip verify of convert_from_func_ptr_addr, invalid_p == 0 */
 690   /* Skip verify of addr_bits_remove, invalid_p == 0 */
 691   /* Skip verify of smash_text_address, invalid_p == 0 */
 692   /* Skip verify of software_single_step, has predicate.  */
 693   /* Skip verify of single_step_through_delay, has predicate.  */
 694   if (gdbarch->print_insn == 0)
 695     fprintf_unfiltered (log, "\n\tprint_insn");
 696   /* Skip verify of skip_trampoline_code, invalid_p == 0 */
 697   /* Skip verify of skip_solib_resolver, invalid_p == 0 */
 698   /* Skip verify of in_solib_return_trampoline, invalid_p == 0 */
 699   /* Skip verify of in_function_epilogue_p, invalid_p == 0 */
 700   /* Skip verify of elf_make_msymbol_special, invalid_p == 0 */
 701   /* Skip verify of coff_make_msymbol_special, invalid_p == 0 */
 702   /* Skip verify of cannot_step_breakpoint, invalid_p == 0 */
 703   /* Skip verify of have_nonsteppable_watchpoint, invalid_p == 0 */
 704   /* Skip verify of address_class_type_flags, has predicate.  */
 705   /* Skip verify of address_class_type_flags_to_name, has predicate.  */
 706   /* Skip verify of address_class_name_to_type_flags, has predicate.  */
 707   /* Skip verify of register_reggroup_p, invalid_p == 0 */
 708   /* Skip verify of fetch_pointer_argument, has predicate.  */
 709   /* Skip verify of regset_from_core_section, has predicate.  */
 710   /* Skip verify of make_corefile_notes, has predicate.  */
 711   /* Skip verify of find_memory_regions, has predicate.  */
 712   /* Skip verify of core_xfer_shared_libraries, has predicate.  */
 713   /* Skip verify of core_pid_to_str, has predicate.  */
 714   /* Skip verify of gcore_bfd_target, has predicate.  */
 715   /* Skip verify of vtable_function_descriptors, invalid_p == 0 */
 716   /* Skip verify of vbit_in_delta, invalid_p == 0 */
 717   /* Skip verify of skip_permanent_breakpoint, has predicate.  */
 718   /* Skip verify of max_insn_length, has predicate.  */
 719   /* Skip verify of displaced_step_copy_insn, has predicate.  */
 720   /* Skip verify of displaced_step_hw_singlestep, invalid_p == 0 */
 721   /* Skip verify of displaced_step_fixup, has predicate.  */
 722   if ((! gdbarch->displaced_step_free_closure) != (! gdbarch->displaced_step_copy_insn))
 723     fprintf_unfiltered (log, "\n\tdisplaced_step_free_closure");
 724   if ((! gdbarch->displaced_step_location) != (! gdbarch->displaced_step_copy_insn))
 725     fprintf_unfiltered (log, "\n\tdisplaced_step_location");
 726   /* Skip verify of relocate_instruction, has predicate.  */
 727   /* Skip verify of overlay_update, has predicate.  */
 728   /* Skip verify of core_read_description, has predicate.  */
 729   /* Skip verify of static_transform_name, has predicate.  */
 730   /* Skip verify of sofun_address_maybe_missing, invalid_p == 0 */
 731   /* Skip verify of process_record, has predicate.  */
 732   /* Skip verify of process_record_signal, has predicate.  */
 733   /* Skip verify of gdb_signal_from_target, has predicate.  */
 734   /* Skip verify of get_siginfo_type, has predicate.  */
 735   /* Skip verify of record_special_symbol, has predicate.  */
 736   /* Skip verify of get_syscall_number, has predicate.  */
 737   /* Skip verify of stap_integer_prefix, invalid_p == 0 */
 738   /* Skip verify of stap_integer_suffix, invalid_p == 0 */
 739   /* Skip verify of stap_register_prefix, invalid_p == 0 */
 740   /* Skip verify of stap_register_suffix, invalid_p == 0 */
 741   /* Skip verify of stap_register_indirection_prefix, invalid_p == 0 */
 742   /* Skip verify of stap_register_indirection_suffix, invalid_p == 0 */
 743   /* Skip verify of stap_gdb_register_prefix, invalid_p == 0 */
 744   /* Skip verify of stap_gdb_register_suffix, invalid_p == 0 */
 745   /* Skip verify of stap_is_single_operand, has predicate.  */
 746   /* Skip verify of stap_parse_special_token, has predicate.  */
 747   /* Skip verify of has_global_solist, invalid_p == 0 */
 748   /* Skip verify of has_global_breakpoints, invalid_p == 0 */
 749   /* Skip verify of has_shared_address_space, invalid_p == 0 */
 750   /* Skip verify of fast_tracepoint_valid_at, invalid_p == 0 */
 751   /* Skip verify of auto_charset, invalid_p == 0 */
 752   /* Skip verify of auto_wide_charset, invalid_p == 0 */
 753   /* Skip verify of has_dos_based_file_system, invalid_p == 0 */
 754   /* Skip verify of gen_return_address, invalid_p == 0 */
 755   /* Skip verify of info_proc, has predicate.  */
 756   /* Skip verify of iterate_over_objfiles_in_search_order, invalid_p == 0 */
 757   buf = ui_file_xstrdup (log, &length);
 758   make_cleanup (xfree, buf);
 759   if (length > 0)
 760     internal_error (__FILE__, __LINE__,
 761                     _("verify_gdbarch: the following are invalid ...%s"),
 762                     buf);
 763   do_cleanups (cleanups);
 764 }
 765
 766
 767 /* Print out the details of the current architecture.  */
 768
 769 void
 770 gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file)
 771 {
 772   const char *gdb_nm_file = "<not-defined>";
 773
 774 #if defined (GDB_NM_FILE)
 775   gdb_nm_file = GDB_NM_FILE;
 776 #endif
 777   fprintf_unfiltered (file,
 778                       "gdbarch_dump: GDB_NM_FILE = %s\n",
 779                       gdb_nm_file);
 780   fprintf_unfiltered (file,
 781                       "gdbarch_dump: addr_bit = %s\n",
 782                       plongest (gdbarch->addr_bit));
 783   fprintf_unfiltered (file,
 784                       "gdbarch_dump: addr_bits_remove = <%s>\n",
 785                       host_address_to_string (gdbarch->addr_bits_remove));
 786   fprintf_unfiltered (file,
 787                       "gdbarch_dump: gdbarch_address_class_name_to_type_flags_p() = %d\n",
 788                       gdbarch_address_class_name_to_type_flags_p (gdbarch));
 789   fprintf_unfiltered (file,
 790                       "gdbarch_dump: address_class_name_to_type_flags = <%s>\n",
 791                       host_address_to_string (gdbarch->address_class_name_to_type_flags));
 792   fprintf_unfiltered (file,
 793                       "gdbarch_dump: gdbarch_address_class_type_flags_p() = %d\n",
 794                       gdbarch_address_class_type_flags_p (gdbarch));
 795   fprintf_unfiltered (file,
 796                       "gdbarch_dump: address_class_type_flags = <%s>\n",
 797                       host_address_to_string (gdbarch->address_class_type_flags));
 798   fprintf_unfiltered (file,
 799                       "gdbarch_dump: gdbarch_address_class_type_flags_to_name_p() = %d\n",
 800                       gdbarch_address_class_type_flags_to_name_p (gdbarch));
 801   fprintf_unfiltered (file,
 802                       "gdbarch_dump: address_class_type_flags_to_name = <%s>\n",
 803                       host_address_to_string (gdbarch->address_class_type_flags_to_name));
 804   fprintf_unfiltered (file,
 805                       "gdbarch_dump: address_to_pointer = <%s>\n",
 806                       host_address_to_string (gdbarch->address_to_pointer));
 807   fprintf_unfiltered (file,
 808                       "gdbarch_dump: gdbarch_adjust_breakpoint_address_p() = %d\n",
 809                       gdbarch_adjust_breakpoint_address_p (gdbarch));
 810   fprintf_unfiltered (file,
 811                       "gdbarch_dump: adjust_breakpoint_address = <%s>\n",
 812                       host_address_to_string (gdbarch->adjust_breakpoint_address));
 813   fprintf_unfiltered (file,
 814                       "gdbarch_dump: auto_charset = <%s>\n",
 815                       host_address_to_string (gdbarch->auto_charset));
 816   fprintf_unfiltered (file,
 817                       "gdbarch_dump: auto_wide_charset = <%s>\n",
 818                       host_address_to_string (gdbarch->auto_wide_charset));
 819   fprintf_unfiltered (file,
 820                       "gdbarch_dump: gdbarch_ax_pseudo_register_collect_p() = %d\n",
 821                       gdbarch_ax_pseudo_register_collect_p (gdbarch));
 822   fprintf_unfiltered (file,
 823                       "gdbarch_dump: ax_pseudo_register_collect = <%s>\n",
 824                       host_address_to_string (gdbarch->ax_pseudo_register_collect));
 825   fprintf_unfiltered (file,
 826                       "gdbarch_dump: gdbarch_ax_pseudo_register_push_stack_p() = %d\n",
 827                       gdbarch_ax_pseudo_register_push_stack_p (gdbarch));
 828   fprintf_unfiltered (file,
 829                       "gdbarch_dump: ax_pseudo_register_push_stack = <%s>\n",
 830                       host_address_to_string (gdbarch->ax_pseudo_register_push_stack));
 831   fprintf_unfiltered (file,
 832                       "gdbarch_dump: believe_pcc_promotion = %s\n",
 833                       plongest (gdbarch->believe_pcc_promotion));
 834   fprintf_unfiltered (file,
 835                       "gdbarch_dump: bfd_arch_info = %s\n",
 836                       gdbarch_bfd_arch_info (gdbarch)->printable_name);
 837   fprintf_unfiltered (file,
 838                       "gdbarch_dump: bits_big_endian = %s\n",
 839                       plongest (gdbarch->bits_big_endian));
 840   fprintf_unfiltered (file,
 841                       "gdbarch_dump: breakpoint_from_pc = <%s>\n",
 842                       host_address_to_string (gdbarch->breakpoint_from_pc));
 843   fprintf_unfiltered (file,
 844                       "gdbarch_dump: byte_order = %s\n",
 845                       plongest (gdbarch->byte_order));
 846   fprintf_unfiltered (file,
 847                       "gdbarch_dump: byte_order_for_code = %s\n",
 848                       plongest (gdbarch->byte_order_for_code));
 849   fprintf_unfiltered (file,
 850                       "gdbarch_dump: call_dummy_location = %s\n",
 851                       plongest (gdbarch->call_dummy_location));
 852   fprintf_unfiltered (file,
 853                       "gdbarch_dump: cannot_fetch_register = <%s>\n",
 854                       host_address_to_string (gdbarch->cannot_fetch_register));
 855   fprintf_unfiltered (file,
 856                       "gdbarch_dump: cannot_step_breakpoint = %s\n",
 857                       plongest (gdbarch->cannot_step_breakpoint));
 858   fprintf_unfiltered (file,
 859                       "gdbarch_dump: cannot_store_register = <%s>\n",
 860                       host_address_to_string (gdbarch->cannot_store_register));
 861   fprintf_unfiltered (file,
 862                       "gdbarch_dump: char_signed = %s\n",
 863                       plongest (gdbarch->char_signed));
 864   fprintf_unfiltered (file,
 865                       "gdbarch_dump: coff_make_msymbol_special = <%s>\n",
 866                       host_address_to_string (gdbarch->coff_make_msymbol_special));
 867   fprintf_unfiltered (file,
 868                       "gdbarch_dump: convert_from_func_ptr_addr = <%s>\n",
 869                       host_address_to_string (gdbarch->convert_from_func_ptr_addr));
 870   fprintf_unfiltered (file,
 871                       "gdbarch_dump: convert_register_p = <%s>\n",
 872                       host_address_to_string (gdbarch->convert_register_p));
 873   fprintf_unfiltered (file,
 874                       "gdbarch_dump: gdbarch_core_pid_to_str_p() = %d\n",
 875                       gdbarch_core_pid_to_str_p (gdbarch));
 876   fprintf_unfiltered (file,
 877                       "gdbarch_dump: core_pid_to_str = <%s>\n",
 878                       host_address_to_string (gdbarch->core_pid_to_str));
 879   fprintf_unfiltered (file,
 880                       "gdbarch_dump: gdbarch_core_read_description_p() = %d\n",
 881                       gdbarch_core_read_description_p (gdbarch));
 882   fprintf_unfiltered (file,
 883                       "gdbarch_dump: core_read_description = <%s>\n",
 884                       host_address_to_string (gdbarch->core_read_description));
 885   fprintf_unfiltered (file,
 886                       "gdbarch_dump: core_regset_sections = %s\n",
 887                       host_address_to_string (gdbarch->core_regset_sections));
 888   fprintf_unfiltered (file,
 889                       "gdbarch_dump: gdbarch_core_xfer_shared_libraries_p() = %d\n",
 890                       gdbarch_core_xfer_shared_libraries_p (gdbarch));
 891   fprintf_unfiltered (file,
 892                       "gdbarch_dump: core_xfer_shared_libraries = <%s>\n",
 893                       host_address_to_string (gdbarch->core_xfer_shared_libraries));
 894   fprintf_unfiltered (file,
 895                       "gdbarch_dump: decr_pc_after_break = %s\n",
 896                       core_addr_to_string_nz (gdbarch->decr_pc_after_break));
 897   fprintf_unfiltered (file,
 898                       "gdbarch_dump: deprecated_fp_regnum = %s\n",
 899                       plongest (gdbarch->deprecated_fp_regnum));
 900   fprintf_unfiltered (file,
 901                       "gdbarch_dump: deprecated_function_start_offset = %s\n",
 902                       core_addr_to_string_nz (gdbarch->deprecated_function_start_offset));
 903   fprintf_unfiltered (file,
 904                       "gdbarch_dump: gdbarch_displaced_step_copy_insn_p() = %d\n",
 905                       gdbarch_displaced_step_copy_insn_p (gdbarch));
 906   fprintf_unfiltered (file,
 907                       "gdbarch_dump: displaced_step_copy_insn = <%s>\n",
 908                       host_address_to_string (gdbarch->displaced_step_copy_insn));
 909   fprintf_unfiltered (file,
 910                       "gdbarch_dump: gdbarch_displaced_step_fixup_p() = %d\n",
 911                       gdbarch_displaced_step_fixup_p (gdbarch));
 912   fprintf_unfiltered (file,
 913                       "gdbarch_dump: displaced_step_fixup = <%s>\n",
 914                       host_address_to_string (gdbarch->displaced_step_fixup));
 915   fprintf_unfiltered (file,
 916                       "gdbarch_dump: displaced_step_free_closure = <%s>\n",
 917                       host_address_to_string (gdbarch->displaced_step_free_closure));
 918   fprintf_unfiltered (file,
 919                       "gdbarch_dump: displaced_step_hw_singlestep = <%s>\n",
 920                       host_address_to_string (gdbarch->displaced_step_hw_singlestep));
 921   fprintf_unfiltered (file,
 922                       "gdbarch_dump: displaced_step_location = <%s>\n",
 923                       host_address_to_string (gdbarch->displaced_step_location));
 924   fprintf_unfiltered (file,
 925                       "gdbarch_dump: double_bit = %s\n",
 926                       plongest (gdbarch->double_bit));
 927   fprintf_unfiltered (file,
 928                       "gdbarch_dump: double_format = %s\n",
 929                       pformat (gdbarch->double_format));
 930   fprintf_unfiltered (file,
 931                       "gdbarch_dump: gdbarch_dummy_id_p() = %d\n",
 932                       gdbarch_dummy_id_p (gdbarch));
 933   fprintf_unfiltered (file,
 934                       "gdbarch_dump: dummy_id = <%s>\n",
 935                       host_address_to_string (gdbarch->dummy_id));
 936   fprintf_unfiltered (file,
 937                       "gdbarch_dump: dwarf2_addr_size = %s\n",
 938                       plongest (gdbarch->dwarf2_addr_size));
 939   fprintf_unfiltered (file,
 940                       "gdbarch_dump: dwarf2_reg_to_regnum = <%s>\n",
 941                       host_address_to_string (gdbarch->dwarf2_reg_to_regnum));
 942   fprintf_unfiltered (file,
 943                       "gdbarch_dump: ecoff_reg_to_regnum = <%s>\n",
 944                       host_address_to_string (gdbarch->ecoff_reg_to_regnum));
 945   fprintf_unfiltered (file,
 946                       "gdbarch_dump: elf_make_msymbol_special = <%s>\n",
 947                       host_address_to_string (gdbarch->elf_make_msymbol_special));
 948   fprintf_unfiltered (file,
 949                       "gdbarch_dump: fast_tracepoint_valid_at = <%s>\n",
 950                       host_address_to_string (gdbarch->fast_tracepoint_valid_at));
 951   fprintf_unfiltered (file,
 952                       "gdbarch_dump: gdbarch_fetch_pointer_argument_p() = %d\n",
 953                       gdbarch_fetch_pointer_argument_p (gdbarch));
 954   fprintf_unfiltered (file,
 955                       "gdbarch_dump: fetch_pointer_argument = <%s>\n",
 956                       host_address_to_string (gdbarch->fetch_pointer_argument));
 957   fprintf_unfiltered (file,
 958                       "gdbarch_dump: gdbarch_fetch_tls_load_module_address_p() = %d\n",
 959                       gdbarch_fetch_tls_load_module_address_p (gdbarch));
 960   fprintf_unfiltered (file,
 961                       "gdbarch_dump: fetch_tls_load_module_address = <%s>\n",
 962                       host_address_to_string (gdbarch->fetch_tls_load_module_address));
 963   fprintf_unfiltered (file,
 964                       "gdbarch_dump: gdbarch_find_memory_regions_p() = %d\n",
 965                       gdbarch_find_memory_regions_p (gdbarch));
 966   fprintf_unfiltered (file,
 967                       "gdbarch_dump: find_memory_regions = <%s>\n",
 968                       host_address_to_string (gdbarch->find_memory_regions));
 969   fprintf_unfiltered (file,
 970                       "gdbarch_dump: float_bit = %s\n",
 971                       plongest (gdbarch->float_bit));
 972   fprintf_unfiltered (file,
 973                       "gdbarch_dump: float_format = %s\n",
 974                       pformat (gdbarch->float_format));
 975   fprintf_unfiltered (file,
 976                       "gdbarch_dump: fp0_regnum = %s\n",
 977                       plongest (gdbarch->fp0_regnum));
 978   fprintf_unfiltered (file,
 979                       "gdbarch_dump: gdbarch_frame_align_p() = %d\n",
 980                       gdbarch_frame_align_p (gdbarch));
 981   fprintf_unfiltered (file,
 982                       "gdbarch_dump: frame_align = <%s>\n",
 983                       host_address_to_string (gdbarch->frame_align));
 984   fprintf_unfiltered (file,
 985                       "gdbarch_dump: frame_args_skip = %s\n",
 986                       core_addr_to_string_nz (gdbarch->frame_args_skip));
 987   fprintf_unfiltered (file,
 988                       "gdbarch_dump: gdbarch_frame_num_args_p() = %d\n",
 989                       gdbarch_frame_num_args_p (gdbarch));
 990   fprintf_unfiltered (file,
 991                       "gdbarch_dump: frame_num_args = <%s>\n",
 992                       host_address_to_string (gdbarch->frame_num_args));
 993   fprintf_unfiltered (file,
 994                       "gdbarch_dump: frame_red_zone_size = %s\n",
 995                       plongest (gdbarch->frame_red_zone_size));
 996   fprintf_unfiltered (file,
 997                       "gdbarch_dump: gdbarch_gcore_bfd_target_p() = %d\n",
 998                       gdbarch_gcore_bfd_target_p (gdbarch));
 999   fprintf_unfiltered (file,
1000                       "gdbarch_dump: gcore_bfd_target = %s\n",
1001                       pstring (gdbarch->gcore_bfd_target));
1002   fprintf_unfiltered (file,
1003                       "gdbarch_dump: gdbarch_gdb_signal_from_target_p() = %d\n",
1004                       gdbarch_gdb_signal_from_target_p (gdbarch));
1005   fprintf_unfiltered (file,
1006                       "gdbarch_dump: gdb_signal_from_target = <%s>\n",
1007                       host_address_to_string (gdbarch->gdb_signal_from_target));
1008   fprintf_unfiltered (file,
1009                       "gdbarch_dump: gen_return_address = <%s>\n",
1010                       host_address_to_string (gdbarch->gen_return_address));
1011   fprintf_unfiltered (file,
1012                       "gdbarch_dump: gdbarch_get_longjmp_target_p() = %d\n",
1013                       gdbarch_get_longjmp_target_p (gdbarch));
1014   fprintf_unfiltered (file,
1015                       "gdbarch_dump: get_longjmp_target = <%s>\n",
1016                       host_address_to_string (gdbarch->get_longjmp_target));
1017   fprintf_unfiltered (file,
1018                       "gdbarch_dump: gdbarch_get_siginfo_type_p() = %d\n",
1019                       gdbarch_get_siginfo_type_p (gdbarch));
1020   fprintf_unfiltered (file,
1021                       "gdbarch_dump: get_siginfo_type = <%s>\n",
1022                       host_address_to_string (gdbarch->get_siginfo_type));
1023   fprintf_unfiltered (file,
1024                       "gdbarch_dump: gdbarch_get_syscall_number_p() = %d\n",
1025                       gdbarch_get_syscall_number_p (gdbarch));
1026   fprintf_unfiltered (file,
1027                       "gdbarch_dump: get_syscall_number = <%s>\n",
1028                       host_address_to_string (gdbarch->get_syscall_number));
1029   fprintf_unfiltered (file,
1030                       "gdbarch_dump: half_bit = %s\n",
1031                       plongest (gdbarch->half_bit));
1032   fprintf_unfiltered (file,
1033                       "gdbarch_dump: half_format = %s\n",
1034                       pformat (gdbarch->half_format));
1035   fprintf_unfiltered (file,
1036                       "gdbarch_dump: has_dos_based_file_system = %s\n",
1037                       plongest (gdbarch->has_dos_based_file_system));
1038   fprintf_unfiltered (file,
1039                       "gdbarch_dump: has_global_breakpoints = %s\n",
1040                       plongest (gdbarch->has_global_breakpoints));
1041   fprintf_unfiltered (file,
1042                       "gdbarch_dump: has_global_solist = %s\n",
1043                       plongest (gdbarch->has_global_solist));
1044   fprintf_unfiltered (file,
1045                       "gdbarch_dump: has_shared_address_space = <%s>\n",
1046                       host_address_to_string (gdbarch->has_shared_address_space));
1047   fprintf_unfiltered (file,
1048                       "gdbarch_dump: have_nonsteppable_watchpoint = %s\n",
1049                       plongest (gdbarch->have_nonsteppable_watchpoint));
1050   fprintf_unfiltered (file,
1051                       "gdbarch_dump: in_function_epilogue_p = <%s>\n",
1052                       host_address_to_string (gdbarch->in_function_epilogue_p));
1053   fprintf_unfiltered (file,
1054                       "gdbarch_dump: in_solib_return_trampoline = <%s>\n",
1055                       host_address_to_string (gdbarch->in_solib_return_trampoline));
1056   fprintf_unfiltered (file,
1057                       "gdbarch_dump: gdbarch_info_proc_p() = %d\n",
1058                       gdbarch_info_proc_p (gdbarch));
1059   fprintf_unfiltered (file,
1060                       "gdbarch_dump: info_proc = <%s>\n",
1061                       host_address_to_string (gdbarch->info_proc));
1062   fprintf_unfiltered (file,
1063                       "gdbarch_dump: inner_than = <%s>\n",
1064                       host_address_to_string (gdbarch->inner_than));
1065   fprintf_unfiltered (file,
1066                       "gdbarch_dump: int_bit = %s\n",
1067                       plongest (gdbarch->int_bit));
1068   fprintf_unfiltered (file,
1069                       "gdbarch_dump: gdbarch_integer_to_address_p() = %d\n",
1070                       gdbarch_integer_to_address_p (gdbarch));
1071   fprintf_unfiltered (file,
1072                       "gdbarch_dump: integer_to_address = <%s>\n",
1073                       host_address_to_string (gdbarch->integer_to_address));
1074   fprintf_unfiltered (file,
1075                       "gdbarch_dump: iterate_over_objfiles_in_search_order = <%s>\n",
1076                       host_address_to_string (gdbarch->iterate_over_objfiles_in_search_order));
1077   fprintf_unfiltered (file,
1078                       "gdbarch_dump: long_bit = %s\n",
1079                       plongest (gdbarch->long_bit));
1080   fprintf_unfiltered (file,
1081                       "gdbarch_dump: long_double_bit = %s\n",
1082                       plongest (gdbarch->long_double_bit));
1083   fprintf_unfiltered (file,
1084                       "gdbarch_dump: long_double_format = %s\n",
1085                       pformat (gdbarch->long_double_format));
1086   fprintf_unfiltered (file,
1087                       "gdbarch_dump: long_long_align_bit = %s\n",
1088                       plongest (gdbarch->long_long_align_bit));
1089   fprintf_unfiltered (file,
1090                       "gdbarch_dump: long_long_bit = %s\n",
1091                       plongest (gdbarch->long_long_bit));
1092   fprintf_unfiltered (file,
1093                       "gdbarch_dump: gdbarch_make_corefile_notes_p() = %d\n",
1094                       gdbarch_make_corefile_notes_p (gdbarch));
1095   fprintf_unfiltered (file,
1096                       "gdbarch_dump: make_corefile_notes = <%s>\n",
1097                       host_address_to_string (gdbarch->make_corefile_notes));
1098   fprintf_unfiltered (file,
1099                       "gdbarch_dump: gdbarch_max_insn_length_p() = %d\n",
1100                       gdbarch_max_insn_length_p (gdbarch));
1101   fprintf_unfiltered (file,
1102                       "gdbarch_dump: max_insn_length = %s\n",
1103                       plongest (gdbarch->max_insn_length));
1104   fprintf_unfiltered (file,
1105                       "gdbarch_dump: memory_insert_breakpoint = <%s>\n",
1106                       host_address_to_string (gdbarch->memory_insert_breakpoint));
1107   fprintf_unfiltered (file,
1108                       "gdbarch_dump: memory_remove_breakpoint = <%s>\n",
1109                       host_address_to_string (gdbarch->memory_remove_breakpoint));
1110   fprintf_unfiltered (file,
1111                       "gdbarch_dump: num_pseudo_regs = %s\n",
1112                       plongest (gdbarch->num_pseudo_regs));
1113   fprintf_unfiltered (file,
1114                       "gdbarch_dump: num_regs = %s\n",
1115                       plongest (gdbarch->num_regs));
1116   fprintf_unfiltered (file,
1117                       "gdbarch_dump: osabi = %s\n",
1118                       plongest (gdbarch->osabi));
1119   fprintf_unfiltered (file,
1120                       "gdbarch_dump: gdbarch_overlay_update_p() = %d\n",
1121                       gdbarch_overlay_update_p (gdbarch));
1122   fprintf_unfiltered (file,
1123                       "gdbarch_dump: overlay_update = <%s>\n",
1124                       host_address_to_string (gdbarch->overlay_update));
1125   fprintf_unfiltered (file,
1126                       "gdbarch_dump: pc_regnum = %s\n",
1127                       plongest (gdbarch->pc_regnum));
1128   fprintf_unfiltered (file,
1129                       "gdbarch_dump: pointer_to_address = <%s>\n",
1130                       host_address_to_string (gdbarch->pointer_to_address));
1131   fprintf_unfiltered (file,
1132                       "gdbarch_dump: gdbarch_print_float_info_p() = %d\n",
1133                       gdbarch_print_float_info_p (gdbarch));
1134   fprintf_unfiltered (file,
1135                       "gdbarch_dump: print_float_info = <%s>\n",
1136                       host_address_to_string (gdbarch->print_float_info));
1137   fprintf_unfiltered (file,
1138                       "gdbarch_dump: print_insn = <%s>\n",
1139                       host_address_to_string (gdbarch->print_insn));
1140   fprintf_unfiltered (file,
1141                       "gdbarch_dump: print_registers_info = <%s>\n",
1142                       host_address_to_string (gdbarch->print_registers_info));
1143   fprintf_unfiltered (file,
1144                       "gdbarch_dump: gdbarch_print_vector_info_p() = %d\n",
1145                       gdbarch_print_vector_info_p (gdbarch));
1146   fprintf_unfiltered (file,
1147                       "gdbarch_dump: print_vector_info = <%s>\n",
1148                       host_address_to_string (gdbarch->print_vector_info));
1149   fprintf_unfiltered (file,
1150                       "gdbarch_dump: gdbarch_process_record_p() = %d\n",
1151                       gdbarch_process_record_p (gdbarch));
1152   fprintf_unfiltered (file,
1153                       "gdbarch_dump: process_record = <%s>\n",
1154                       host_address_to_string (gdbarch->process_record));
1155   fprintf_unfiltered (file,
1156                       "gdbarch_dump: gdbarch_process_record_signal_p() = %d\n",
1157                       gdbarch_process_record_signal_p (gdbarch));
1158   fprintf_unfiltered (file,
1159                       "gdbarch_dump: process_record_signal = <%s>\n",
1160                       host_address_to_string (gdbarch->process_record_signal));
1161   fprintf_unfiltered (file,
1162                       "gdbarch_dump: ps_regnum = %s\n",
1163                       plongest (gdbarch->ps_regnum));
1164   fprintf_unfiltered (file,
1165                       "gdbarch_dump: gdbarch_pseudo_register_read_p() = %d\n",
1166                       gdbarch_pseudo_register_read_p (gdbarch));
1167   fprintf_unfiltered (file,
1168                       "gdbarch_dump: pseudo_register_read = <%s>\n",
1169                       host_address_to_string (gdbarch->pseudo_register_read));
1170   fprintf_unfiltered (file,
1171                       "gdbarch_dump: gdbarch_pseudo_register_read_value_p() = %d\n",
1172                       gdbarch_pseudo_register_read_value_p (gdbarch));
1173   fprintf_unfiltered (file,
1174                       "gdbarch_dump: pseudo_register_read_value = <%s>\n",
1175                       host_address_to_string (gdbarch->pseudo_register_read_value));
1176   fprintf_unfiltered (file,
1177                       "gdbarch_dump: gdbarch_pseudo_register_write_p() = %d\n",
1178                       gdbarch_pseudo_register_write_p (gdbarch));
1179   fprintf_unfiltered (file,
1180                       "gdbarch_dump: pseudo_register_write = <%s>\n",
1181                       host_address_to_string (gdbarch->pseudo_register_write));
1182   fprintf_unfiltered (file,
1183                       "gdbarch_dump: ptr_bit = %s\n",
1184                       plongest (gdbarch->ptr_bit));
1185   fprintf_unfiltered (file,
1186                       "gdbarch_dump: gdbarch_push_dummy_call_p() = %d\n",
1187                       gdbarch_push_dummy_call_p (gdbarch));
1188   fprintf_unfiltered (file,
1189                       "gdbarch_dump: push_dummy_call = <%s>\n",
1190                       host_address_to_string (gdbarch->push_dummy_call));
1191   fprintf_unfiltered (file,
1192                       "gdbarch_dump: gdbarch_push_dummy_code_p() = %d\n",
1193                       gdbarch_push_dummy_code_p (gdbarch));
1194   fprintf_unfiltered (file,
1195                       "gdbarch_dump: push_dummy_code = <%s>\n",
1196                       host_address_to_string (gdbarch->push_dummy_code));
1197   fprintf_unfiltered (file,
1198                       "gdbarch_dump: gdbarch_read_pc_p() = %d\n",
1199                       gdbarch_read_pc_p (gdbarch));
1200   fprintf_unfiltered (file,
1201                       "gdbarch_dump: read_pc = <%s>\n",
1202                       host_address_to_string (gdbarch->read_pc));
1203   fprintf_unfiltered (file,
1204                       "gdbarch_dump: gdbarch_record_special_symbol_p() = %d\n",
1205                       gdbarch_record_special_symbol_p (gdbarch));
1206   fprintf_unfiltered (file,
1207                       "gdbarch_dump: record_special_symbol = <%s>\n",
1208                       host_address_to_string (gdbarch->record_special_symbol));
1209   fprintf_unfiltered (file,
1210                       "gdbarch_dump: register_name = <%s>\n",
1211                       host_address_to_string (gdbarch->register_name));
1212   fprintf_unfiltered (file,
1213                       "gdbarch_dump: register_reggroup_p = <%s>\n",
1214                       host_address_to_string (gdbarch->register_reggroup_p));
1215   fprintf_unfiltered (file,
1216                       "gdbarch_dump: register_sim_regno = <%s>\n",
1217                       host_address_to_string (gdbarch->register_sim_regno));
1218   fprintf_unfiltered (file,
1219                       "gdbarch_dump: register_to_value = <%s>\n",
1220                       host_address_to_string (gdbarch->register_to_value));
1221   fprintf_unfiltered (file,
1222                       "gdbarch_dump: gdbarch_register_type_p() = %d\n",
1223                       gdbarch_register_type_p (gdbarch));
1224   fprintf_unfiltered (file,
1225                       "gdbarch_dump: register_type = <%s>\n",
1226                       host_address_to_string (gdbarch->register_type));
1227   fprintf_unfiltered (file,
1228                       "gdbarch_dump: gdbarch_regset_from_core_section_p() = %d\n",
1229                       gdbarch_regset_from_core_section_p (gdbarch));
1230   fprintf_unfiltered (file,
1231                       "gdbarch_dump: regset_from_core_section = <%s>\n",
1232                       host_address_to_string (gdbarch->regset_from_core_section));
1233   fprintf_unfiltered (file,
1234                       "gdbarch_dump: gdbarch_relocate_instruction_p() = %d\n",
1235                       gdbarch_relocate_instruction_p (gdbarch));
1236   fprintf_unfiltered (file,
1237                       "gdbarch_dump: relocate_instruction = <%s>\n",
1238                       host_address_to_string (gdbarch->relocate_instruction));
1239   fprintf_unfiltered (file,
1240                       "gdbarch_dump: remote_breakpoint_from_pc = <%s>\n",
1241                       host_address_to_string (gdbarch->remote_breakpoint_from_pc));
1242   fprintf_unfiltered (file,
1243                       "gdbarch_dump: remote_register_number = <%s>\n",
1244                       host_address_to_string (gdbarch->remote_register_number));
1245   fprintf_unfiltered (file,
1246                       "gdbarch_dump: gdbarch_return_value_p() = %d\n",
1247                       gdbarch_return_value_p (gdbarch));
1248   fprintf_unfiltered (file,
1249                       "gdbarch_dump: return_value = <%s>\n",
1250                       host_address_to_string (gdbarch->return_value));
1251   fprintf_unfiltered (file,
1252                       "gdbarch_dump: sdb_reg_to_regnum = <%s>\n",
1253                       host_address_to_string (gdbarch->sdb_reg_to_regnum));
1254   fprintf_unfiltered (file,
1255                       "gdbarch_dump: short_bit = %s\n",
1256                       plongest (gdbarch->short_bit));
1257   fprintf_unfiltered (file,
1258                       "gdbarch_dump: gdbarch_single_step_through_delay_p() = %d\n",
1259                       gdbarch_single_step_through_delay_p (gdbarch));
1260   fprintf_unfiltered (file,
1261                       "gdbarch_dump: single_step_through_delay = <%s>\n",
1262                       host_address_to_string (gdbarch->single_step_through_delay));
1263   fprintf_unfiltered (file,
1264                       "gdbarch_dump: gdbarch_skip_main_prologue_p() = %d\n",
1265                       gdbarch_skip_main_prologue_p (gdbarch));
1266   fprintf_unfiltered (file,
1267                       "gdbarch_dump: skip_main_prologue = <%s>\n",
1268                       host_address_to_string (gdbarch->skip_main_prologue));
1269   fprintf_unfiltered (file,
1270                       "gdbarch_dump: gdbarch_skip_permanent_breakpoint_p() = %d\n",
1271                       gdbarch_skip_permanent_breakpoint_p (gdbarch));
1272   fprintf_unfiltered (file,
1273                       "gdbarch_dump: skip_permanent_breakpoint = <%s>\n",
1274                       host_address_to_string (gdbarch->skip_permanent_breakpoint));
1275   fprintf_unfiltered (file,
1276                       "gdbarch_dump: skip_prologue = <%s>\n",
1277                       host_address_to_string (gdbarch->skip_prologue));
1278   fprintf_unfiltered (file,
1279                       "gdbarch_dump: skip_solib_resolver = <%s>\n",
1280                       host_address_to_string (gdbarch->skip_solib_resolver));
1281   fprintf_unfiltered (file,
1282                       "gdbarch_dump: skip_trampoline_code = <%s>\n",
1283                       host_address_to_string (gdbarch->skip_trampoline_code));
1284   fprintf_unfiltered (file,
1285                       "gdbarch_dump: smash_text_address = <%s>\n",
1286                       host_address_to_string (gdbarch->smash_text_address));
1287   fprintf_unfiltered (file,
1288                       "gdbarch_dump: gdbarch_software_single_step_p() = %d\n",
1289                       gdbarch_software_single_step_p (gdbarch));
1290   fprintf_unfiltered (file,
1291                       "gdbarch_dump: software_single_step = <%s>\n",
1292                       host_address_to_string (gdbarch->software_single_step));
1293   fprintf_unfiltered (file,
1294                       "gdbarch_dump: sofun_address_maybe_missing = %s\n",
1295                       plongest (gdbarch->sofun_address_maybe_missing));
1296   fprintf_unfiltered (file,
1297                       "gdbarch_dump: solib_symbols_extension = %s\n",
1298                       pstring (gdbarch->solib_symbols_extension));
1299   fprintf_unfiltered (file,
1300                       "gdbarch_dump: sp_regnum = %s\n",
1301                       plongest (gdbarch->sp_regnum));
1302   fprintf_unfiltered (file,
1303                       "gdbarch_dump: stab_reg_to_regnum = <%s>\n",
1304                       host_address_to_string (gdbarch->stab_reg_to_regnum));
1305   fprintf_unfiltered (file,
1306                       "gdbarch_dump: stabs_argument_has_addr = <%s>\n",
1307                       host_address_to_string (gdbarch->stabs_argument_has_addr));
1308   fprintf_unfiltered (file,
1309                       "gdbarch_dump: stap_gdb_register_prefix = %s\n",
1310                       gdbarch->stap_gdb_register_prefix);
1311   fprintf_unfiltered (file,
1312                       "gdbarch_dump: stap_gdb_register_suffix = %s\n",
1313                       gdbarch->stap_gdb_register_suffix);
1314   fprintf_unfiltered (file,
1315                       "gdbarch_dump: stap_integer_prefix = %s\n",
1316                       gdbarch->stap_integer_prefix);
1317   fprintf_unfiltered (file,
1318                       "gdbarch_dump: stap_integer_suffix = %s\n",
1319                       gdbarch->stap_integer_suffix);
1320   fprintf_unfiltered (file,
1321                       "gdbarch_dump: gdbarch_stap_is_single_operand_p() = %d\n",
1322                       gdbarch_stap_is_single_operand_p (gdbarch));
1323   fprintf_unfiltered (file,
1324                       "gdbarch_dump: stap_is_single_operand = <%s>\n",
1325                       host_address_to_string (gdbarch->stap_is_single_operand));
1326   fprintf_unfiltered (file,
1327                       "gdbarch_dump: gdbarch_stap_parse_special_token_p() = %d\n",
1328                       gdbarch_stap_parse_special_token_p (gdbarch));
1329   fprintf_unfiltered (file,
1330                       "gdbarch_dump: stap_parse_special_token = <%s>\n",
1331                       host_address_to_string (gdbarch->stap_parse_special_token));
1332   fprintf_unfiltered (file,
1333                       "gdbarch_dump: stap_register_indirection_prefix = %s\n",
1334                       gdbarch->stap_register_indirection_prefix);
1335   fprintf_unfiltered (file,
1336                       "gdbarch_dump: stap_register_indirection_suffix = %s\n",
1337                       gdbarch->stap_register_indirection_suffix);
1338   fprintf_unfiltered (file,
1339                       "gdbarch_dump: stap_register_prefix = %s\n",
1340                       gdbarch->stap_register_prefix);
1341   fprintf_unfiltered (file,
1342                       "gdbarch_dump: stap_register_suffix = %s\n",
1343                       gdbarch->stap_register_suffix);
1344   fprintf_unfiltered (file,
1345                       "gdbarch_dump: gdbarch_static_transform_name_p() = %d\n",
1346                       gdbarch_static_transform_name_p (gdbarch));
1347   fprintf_unfiltered (file,
1348                       "gdbarch_dump: static_transform_name = <%s>\n",
1349                       host_address_to_string (gdbarch->static_transform_name));
1350   fprintf_unfiltered (file,
1351                       "gdbarch_dump: target_desc = %s\n",
1352                       host_address_to_string (gdbarch->target_desc));
1353   fprintf_unfiltered (file,
1354                       "gdbarch_dump: gdbarch_unwind_pc_p() = %d\n",
1355                       gdbarch_unwind_pc_p (gdbarch));
1356   fprintf_unfiltered (file,
1357                       "gdbarch_dump: unwind_pc = <%s>\n",
1358                       host_address_to_string (gdbarch->unwind_pc));
1359   fprintf_unfiltered (file,
1360                       "gdbarch_dump: gdbarch_unwind_sp_p() = %d\n",
1361                       gdbarch_unwind_sp_p (gdbarch));
1362   fprintf_unfiltered (file,
1363                       "gdbarch_dump: unwind_sp = <%s>\n",
1364                       host_address_to_string (gdbarch->unwind_sp));
1365   fprintf_unfiltered (file,
1366                       "gdbarch_dump: value_from_register = <%s>\n",
1367                       host_address_to_string (gdbarch->value_from_register));
1368   fprintf_unfiltered (file,
1369                       "gdbarch_dump: value_to_register = <%s>\n",
1370                       host_address_to_string (gdbarch->value_to_register));
1371   fprintf_unfiltered (file,
1372                       "gdbarch_dump: vbit_in_delta = %s\n",
1373                       plongest (gdbarch->vbit_in_delta));
1374   fprintf_unfiltered (file,
1375                       "gdbarch_dump: virtual_frame_pointer = <%s>\n",
1376                       host_address_to_string (gdbarch->virtual_frame_pointer));
1377   fprintf_unfiltered (file,
1378                       "gdbarch_dump: vtable_function_descriptors = %s\n",
1379                       plongest (gdbarch->vtable_function_descriptors));
1380   fprintf_unfiltered (file,
1381                       "gdbarch_dump: gdbarch_write_pc_p() = %d\n",
1382                       gdbarch_write_pc_p (gdbarch));
1383   fprintf_unfiltered (file,
1384                       "gdbarch_dump: write_pc = <%s>\n",
1385                       host_address_to_string (gdbarch->write_pc));
1386   if (gdbarch->dump_tdep != NULL)
1387     gdbarch->dump_tdep (gdbarch, file);
1388 }
1389
1390 struct gdbarch_tdep *
1391 gdbarch_tdep (struct gdbarch *gdbarch)
1392 {
1393   if (gdbarch_debug >= 2)
1394     fprintf_unfiltered (gdb_stdlog, "gdbarch_tdep called\n");
1395   return gdbarch->tdep;
1396 }
1397
1398
1399 const struct bfd_arch_info *
1400 gdbarch_bfd_arch_info (struct gdbarch *gdbarch)
1401 {
1402   gdb_assert (gdbarch != NULL);
1403   if (gdbarch_debug >= 2)
1404     fprintf_unfiltered (gdb_stdlog, "gdbarch_bfd_arch_info called\n");
1405   return gdbarch->bfd_arch_info;
1406 }
1407
1408 int
1409 gdbarch_byte_order (struct gdbarch *gdbarch)
1410 {
1411   gdb_assert (gdbarch != NULL);
1412   if (gdbarch_debug >= 2)
1413     fprintf_unfiltered (gdb_stdlog, "gdbarch_byte_order called\n");
1414   return gdbarch->byte_order;
1415 }
1416
1417 int
1418 gdbarch_byte_order_for_code (struct gdbarch *gdbarch)
1419 {
1420   gdb_assert (gdbarch != NULL);
1421   if (gdbarch_debug >= 2)
1422     fprintf_unfiltered (gdb_stdlog, "gdbarch_byte_order_for_code called\n");
1423   return gdbarch->byte_order_for_code;
1424 }
1425
1426 enum gdb_osabi
1427 gdbarch_osabi (struct gdbarch *gdbarch)
1428 {
1429   gdb_assert (gdbarch != NULL);
1430   if (gdbarch_debug >= 2)
1431     fprintf_unfiltered (gdb_stdlog, "gdbarch_osabi called\n");
1432   return gdbarch->osabi;
1433 }
1434
1435 const struct target_desc *
1436 gdbarch_target_desc (struct gdbarch *gdbarch)
1437 {
1438   gdb_assert (gdbarch != NULL);
1439   if (gdbarch_debug >= 2)
1440     fprintf_unfiltered (gdb_stdlog, "gdbarch_target_desc called\n");
1441   return gdbarch->target_desc;
1442 }
1443
1444 int
1445 gdbarch_bits_big_endian (struct gdbarch *gdbarch)
1446 {
1447   gdb_assert (gdbarch != NULL);
1448   /* Skip verify of bits_big_endian, invalid_p == 0 */
1449   if (gdbarch_debug >= 2)
1450     fprintf_unfiltered (gdb_stdlog, "gdbarch_bits_big_endian called\n");
1451   return gdbarch->bits_big_endian;
1452 }
1453
1454 void
1455 set_gdbarch_bits_big_endian (struct gdbarch *gdbarch,
1456                              int bits_big_endian)
1457 {
1458   gdbarch->bits_big_endian = bits_big_endian;
1459 }
1460
1461 int
1462 gdbarch_short_bit (struct gdbarch *gdbarch)
1463 {
1464   gdb_assert (gdbarch != NULL);
1465   /* Skip verify of short_bit, invalid_p == 0 */
1466   if (gdbarch_debug >= 2)
1467     fprintf_unfiltered (gdb_stdlog, "gdbarch_short_bit called\n");
1468   return gdbarch->short_bit;
1469 }
1470
1471 void
1472 set_gdbarch_short_bit (struct gdbarch *gdbarch,
1473                        int short_bit)
1474 {
1475   gdbarch->short_bit = short_bit;
1476 }
1477
1478 int
1479 gdbarch_int_bit (struct gdbarch *gdbarch)
1480 {
1481   gdb_assert (gdbarch != NULL);
1482   /* Skip verify of int_bit, invalid_p == 0 */
1483   if (gdbarch_debug >= 2)
1484     fprintf_unfiltered (gdb_stdlog, "gdbarch_int_bit called\n");
1485   return gdbarch->int_bit;
1486 }
1487
1488 void
1489 set_gdbarch_int_bit (struct gdbarch *gdbarch,
1490                      int int_bit)
1491 {
1492   gdbarch->int_bit = int_bit;
1493 }
1494
1495 int
1496 gdbarch_long_bit (struct gdbarch *gdbarch)
1497 {
1498   gdb_assert (gdbarch != NULL);
1499   /* Skip verify of long_bit, invalid_p == 0 */
1500   if (gdbarch_debug >= 2)
1501     fprintf_unfiltered (gdb_stdlog, "gdbarch_long_bit called\n");
1502   return gdbarch->long_bit;
1503 }
1504
1505 void
1506 set_gdbarch_long_bit (struct gdbarch *gdbarch,
1507                       int long_bit)
1508 {
1509   gdbarch->long_bit = long_bit;
1510 }
1511
1512 int
1513 gdbarch_long_long_bit (struct gdbarch *gdbarch)
1514 {
1515   gdb_assert (gdbarch != NULL);
1516   /* Skip verify of long_long_bit, invalid_p == 0 */
1517   if (gdbarch_debug >= 2)
1518     fprintf_unfiltered (gdb_stdlog, "gdbarch_long_long_bit called\n");
1519   return gdbarch->long_long_bit;
1520 }
1521
1522 void
1523 set_gdbarch_long_long_bit (struct gdbarch *gdbarch,
1524                            int long_long_bit)
1525 {
1526   gdbarch->long_long_bit = long_long_bit;
1527 }
1528
1529 int
1530 gdbarch_long_long_align_bit (struct gdbarch *gdbarch)
1531 {
1532   gdb_assert (gdbarch != NULL);
1533   /* Skip verify of long_long_align_bit, invalid_p == 0 */
1534   if (gdbarch_debug >= 2)
1535     fprintf_unfiltered (gdb_stdlog, "gdbarch_long_long_align_bit called\n");
1536   return gdbarch->long_long_align_bit;
1537 }
1538
1539 void
1540 set_gdbarch_long_long_align_bit (struct gdbarch *gdbarch,
1541                                  int long_long_align_bit)
1542 {
1543   gdbarch->long_long_align_bit = long_long_align_bit;
1544 }
1545
1546 int
1547 gdbarch_half_bit (struct gdbarch *gdbarch)
1548 {
1549   gdb_assert (gdbarch != NULL);
1550   /* Skip verify of half_bit, invalid_p == 0 */
1551   if (gdbarch_debug >= 2)
1552     fprintf_unfiltered (gdb_stdlog, "gdbarch_half_bit called\n");
1553   return gdbarch->half_bit;
1554 }
1555
1556 void
1557 set_gdbarch_half_bit (struct gdbarch *gdbarch,
1558                       int half_bit)
1559 {
1560   gdbarch->half_bit = half_bit;
1561 }
1562
1563 const struct floatformat **
1564 gdbarch_half_format (struct gdbarch *gdbarch)
1565 {
1566   gdb_assert (gdbarch != NULL);
1567   if (gdbarch_debug >= 2)
1568     fprintf_unfiltered (gdb_stdlog, "gdbarch_half_format called\n");
1569   return gdbarch->half_format;
1570 }
1571
1572 void
1573 set_gdbarch_half_format (struct gdbarch *gdbarch,
1574                          const struct floatformat ** half_format)
1575 {
1576   gdbarch->half_format = half_format;
1577 }
1578
1579 int
1580 gdbarch_float_bit (struct gdbarch *gdbarch)
1581 {
1582   gdb_assert (gdbarch != NULL);
1583   /* Skip verify of float_bit, invalid_p == 0 */
1584   if (gdbarch_debug >= 2)
1585     fprintf_unfiltered (gdb_stdlog, "gdbarch_float_bit called\n");
1586   return gdbarch->float_bit;
1587 }
1588
1589 void
1590 set_gdbarch_float_bit (struct gdbarch *gdbarch,
1591                        int float_bit)
1592 {
1593   gdbarch->float_bit = float_bit;
1594 }
1595
1596 const struct floatformat **
1597 gdbarch_float_format (struct gdbarch *gdbarch)
1598 {
1599   gdb_assert (gdbarch != NULL);
1600   if (gdbarch_debug >= 2)
1601     fprintf_unfiltered (gdb_stdlog, "gdbarch_float_format called\n");
1602   return gdbarch->float_format;
1603 }
1604
1605 void
1606 set_gdbarch_float_format (struct gdbarch *gdbarch,
1607                           const struct floatformat ** float_format)
1608 {
1609   gdbarch->float_format = float_format;
1610 }
1611
1612 int
1613 gdbarch_double_bit (struct gdbarch *gdbarch)
1614 {
1615   gdb_assert (gdbarch != NULL);
1616   /* Skip verify of double_bit, invalid_p == 0 */
1617   if (gdbarch_debug >= 2)
1618     fprintf_unfiltered (gdb_stdlog, "gdbarch_double_bit called\n");
1619   return gdbarch->double_bit;
1620 }
1621
1622 void
1623 set_gdbarch_double_bit (struct gdbarch *gdbarch,
1624                         int double_bit)
1625 {
1626   gdbarch->double_bit = double_bit;
1627 }
1628
1629 const struct floatformat **
1630 gdbarch_double_format (struct gdbarch *gdbarch)
1631 {
1632   gdb_assert (gdbarch != NULL);
1633   if (gdbarch_debug >= 2)
1634     fprintf_unfiltered (gdb_stdlog, "gdbarch_double_format called\n");
1635   return gdbarch->double_format;
1636 }
1637
1638 void
1639 set_gdbarch_double_format (struct gdbarch *gdbarch,
1640                            const struct floatformat ** double_format)
1641 {
1642   gdbarch->double_format = double_format;
1643 }
1644
1645 int
1646 gdbarch_long_double_bit (struct gdbarch *gdbarch)
1647 {
1648   gdb_assert (gdbarch != NULL);
1649   /* Skip verify of long_double_bit, invalid_p == 0 */
1650   if (gdbarch_debug >= 2)
1651     fprintf_unfiltered (gdb_stdlog, "gdbarch_long_double_bit called\n");
1652   return gdbarch->long_double_bit;
1653 }
1654
1655 void
1656 set_gdbarch_long_double_bit (struct gdbarch *gdbarch,
1657                              int long_double_bit)
1658 {
1659   gdbarch->long_double_bit = long_double_bit;
1660 }
1661
1662 const struct floatformat **
1663 gdbarch_long_double_format (struct gdbarch *gdbarch)
1664 {
1665   gdb_assert (gdbarch != NULL);
1666   if (gdbarch_debug >= 2)
1667     fprintf_unfiltered (gdb_stdlog, "gdbarch_long_double_format called\n");
1668   return gdbarch->long_double_format;
1669 }
1670
1671 void
1672 set_gdbarch_long_double_format (struct gdbarch *gdbarch,
1673                                 const struct floatformat ** long_double_format)
1674 {
1675   gdbarch->long_double_format = long_double_format;
1676 }
1677
1678 int
1679 gdbarch_ptr_bit (struct gdbarch *gdbarch)
1680 {
1681   gdb_assert (gdbarch != NULL);
1682   /* Skip verify of ptr_bit, invalid_p == 0 */
1683   if (gdbarch_debug >= 2)
1684     fprintf_unfiltered (gdb_stdlog, "gdbarch_ptr_bit called\n");
1685   return gdbarch->ptr_bit;
1686 }
1687
1688 void
1689 set_gdbarch_ptr_bit (struct gdbarch *gdbarch,
1690                      int ptr_bit)
1691 {
1692   gdbarch->ptr_bit = ptr_bit;
1693 }
1694
1695 int
1696 gdbarch_addr_bit (struct gdbarch *gdbarch)
1697 {
1698   gdb_assert (gdbarch != NULL);
1699   /* Check variable changed from pre-default.  */
1700   gdb_assert (gdbarch->addr_bit != 0);
1701   if (gdbarch_debug >= 2)
1702     fprintf_unfiltered (gdb_stdlog, "gdbarch_addr_bit called\n");
1703   return gdbarch->addr_bit;
1704 }
1705
1706 void
1707 set_gdbarch_addr_bit (struct gdbarch *gdbarch,
1708                       int addr_bit)
1709 {
1710   gdbarch->addr_bit = addr_bit;
1711 }
1712
1713 int
1714 gdbarch_dwarf2_addr_size (struct gdbarch *gdbarch)
1715 {
1716   gdb_assert (gdbarch != NULL);
1717   /* Check variable changed from pre-default.  */
1718   gdb_assert (gdbarch->dwarf2_addr_size != 0);
1719   if (gdbarch_debug >= 2)
1720     fprintf_unfiltered (gdb_stdlog, "gdbarch_dwarf2_addr_size called\n");
1721   return gdbarch->dwarf2_addr_size;
1722 }
1723
1724 void
1725 set_gdbarch_dwarf2_addr_size (struct gdbarch *gdbarch,
1726                               int dwarf2_addr_size)
1727 {
1728   gdbarch->dwarf2_addr_size = dwarf2_addr_size;
1729 }
1730
1731 int
1732 gdbarch_char_signed (struct gdbarch *gdbarch)
1733 {
1734   gdb_assert (gdbarch != NULL);
1735   /* Check variable changed from pre-default.  */
1736   gdb_assert (gdbarch->char_signed != -1);
1737   if (gdbarch_debug >= 2)
1738     fprintf_unfiltered (gdb_stdlog, "gdbarch_char_signed called\n");
1739   return gdbarch->char_signed;
1740 }
1741
1742 void
1743 set_gdbarch_char_signed (struct gdbarch *gdbarch,
1744                          int char_signed)
1745 {
1746   gdbarch->char_signed = char_signed;
1747 }
1748
1749 int
1750 gdbarch_read_pc_p (struct gdbarch *gdbarch)
1751 {
1752   gdb_assert (gdbarch != NULL);
1753   return gdbarch->read_pc != NULL;
1754 }
1755
1756 CORE_ADDR
1757 gdbarch_read_pc (struct gdbarch *gdbarch, struct regcache *regcache)
1758 {
1759   gdb_assert (gdbarch != NULL);
1760   gdb_assert (gdbarch->read_pc != NULL);
1761   if (gdbarch_debug >= 2)
1762     fprintf_unfiltered (gdb_stdlog, "gdbarch_read_pc called\n");
1763   return gdbarch->read_pc (regcache);
1764 }
1765
1766 void
1767 set_gdbarch_read_pc (struct gdbarch *gdbarch,
1768                      gdbarch_read_pc_ftype read_pc)
1769 {
1770   gdbarch->read_pc = read_pc;
1771 }
1772
1773 int
1774 gdbarch_write_pc_p (struct gdbarch *gdbarch)
1775 {
1776   gdb_assert (gdbarch != NULL);
1777   return gdbarch->write_pc != NULL;
1778 }
1779
1780 void
1781 gdbarch_write_pc (struct gdbarch *gdbarch, struct regcache *regcache, CORE_ADDR val)
1782 {
1783   gdb_assert (gdbarch != NULL);
1784   gdb_assert (gdbarch->write_pc != NULL);
1785   if (gdbarch_debug >= 2)
1786     fprintf_unfiltered (gdb_stdlog, "gdbarch_write_pc called\n");
1787   gdbarch->write_pc (regcache, val);
1788 }
1789
1790 void
1791 set_gdbarch_write_pc (struct gdbarch *gdbarch,
1792                       gdbarch_write_pc_ftype write_pc)
1793 {
1794   gdbarch->write_pc = write_pc;
1795 }
1796
1797 void
1798 gdbarch_virtual_frame_pointer (struct gdbarch *gdbarch, CORE_ADDR pc, int *frame_regnum, LONGEST *frame_offset)
1799 {
1800   gdb_assert (gdbarch != NULL);
1801   gdb_assert (gdbarch->virtual_frame_pointer != NULL);
1802   if (gdbarch_debug >= 2)
1803     fprintf_unfiltered (gdb_stdlog, "gdbarch_virtual_frame_pointer called\n");
1804   gdbarch->virtual_frame_pointer (gdbarch, pc, frame_regnum, frame_offset);
1805 }
1806
1807 void
1808 set_gdbarch_virtual_frame_pointer (struct gdbarch *gdbarch,
1809                                    gdbarch_virtual_frame_pointer_ftype virtual_frame_pointer)
1810 {
1811   gdbarch->virtual_frame_pointer = virtual_frame_pointer;
1812 }
1813
1814 int
1815 gdbarch_pseudo_register_read_p (struct gdbarch *gdbarch)
1816 {
1817   gdb_assert (gdbarch != NULL);
1818   return gdbarch->pseudo_register_read != NULL;
1819 }
1820
1821 enum register_status
1822 gdbarch_pseudo_register_read (struct gdbarch *gdbarch, struct regcache *regcache, int cookednum, gdb_byte *buf)
1823 {
1824   gdb_assert (gdbarch != NULL);
1825   gdb_assert (gdbarch->pseudo_register_read != NULL);
1826   if (gdbarch_debug >= 2)
1827     fprintf_unfiltered (gdb_stdlog, "gdbarch_pseudo_register_read called\n");
1828   return gdbarch->pseudo_register_read (gdbarch, regcache, cookednum, buf);
1829 }
1830
1831 void
1832 set_gdbarch_pseudo_register_read (struct gdbarch *gdbarch,
1833                                   gdbarch_pseudo_register_read_ftype pseudo_register_read)
1834 {
1835   gdbarch->pseudo_register_read = pseudo_register_read;
1836 }
1837
1838 int
1839 gdbarch_pseudo_register_read_value_p (struct gdbarch *gdbarch)
1840 {
1841   gdb_assert (gdbarch != NULL);
1842   return gdbarch->pseudo_register_read_value != NULL;
1843 }
1844
1845 struct value *
1846 gdbarch_pseudo_register_read_value (struct gdbarch *gdbarch, struct regcache *regcache, int cookednum)
1847 {
1848   gdb_assert (gdbarch != NULL);
1849   gdb_assert (gdbarch->pseudo_register_read_value != NULL);
1850   if (gdbarch_debug >= 2)
1851     fprintf_unfiltered (gdb_stdlog, "gdbarch_pseudo_register_read_value called\n");
1852   return gdbarch->pseudo_register_read_value (gdbarch, regcache, cookednum);
1853 }
1854
1855 void
1856 set_gdbarch_pseudo_register_read_value (struct gdbarch *gdbarch,
1857                                         gdbarch_pseudo_register_read_value_ftype pseudo_register_read_value)
1858 {
1859   gdbarch->pseudo_register_read_value = pseudo_register_read_value;
1860 }
1861
1862 int
1863 gdbarch_pseudo_register_write_p (struct gdbarch *gdbarch)
1864 {
1865   gdb_assert (gdbarch != NULL);
1866   return gdbarch->pseudo_register_write != NULL;
1867 }
1868
1869 void
1870 gdbarch_pseudo_register_write (struct gdbarch *gdbarch, struct regcache *regcache, int cookednum, const gdb_byte *buf)
1871 {
1872   gdb_assert (gdbarch != NULL);
1873   gdb_assert (gdbarch->pseudo_register_write != NULL);
1874   if (gdbarch_debug >= 2)
1875     fprintf_unfiltered (gdb_stdlog, "gdbarch_pseudo_register_write called\n");
1876   gdbarch->pseudo_register_write (gdbarch, regcache, cookednum, buf);
1877 }
1878
1879 void
1880 set_gdbarch_pseudo_register_write (struct gdbarch *gdbarch,
1881                                    gdbarch_pseudo_register_write_ftype pseudo_register_write)
1882 {
1883   gdbarch->pseudo_register_write = pseudo_register_write;
1884 }
1885
1886 int
1887 gdbarch_num_regs (struct gdbarch *gdbarch)
1888 {
1889   gdb_assert (gdbarch != NULL);
1890   /* Check variable changed from pre-default.  */
1891   gdb_assert (gdbarch->num_regs != -1);
1892   if (gdbarch_debug >= 2)
1893     fprintf_unfiltered (gdb_stdlog, "gdbarch_num_regs called\n");
1894   return gdbarch->num_regs;
1895 }
1896
1897 void
1898 set_gdbarch_num_regs (struct gdbarch *gdbarch,
1899                       int num_regs)
1900 {
1901   gdbarch->num_regs = num_regs;
1902 }
1903
1904 int
1905 gdbarch_num_pseudo_regs (struct gdbarch *gdbarch)
1906 {
1907   gdb_assert (gdbarch != NULL);
1908   /* Skip verify of num_pseudo_regs, invalid_p == 0 */
1909   if (gdbarch_debug >= 2)
1910     fprintf_unfiltered (gdb_stdlog, "gdbarch_num_pseudo_regs called\n");
1911   return gdbarch->num_pseudo_regs;
1912 }
1913
1914 void
1915 set_gdbarch_num_pseudo_regs (struct gdbarch *gdbarch,
1916                              int num_pseudo_regs)
1917 {
1918   gdbarch->num_pseudo_regs = num_pseudo_regs;
1919 }
1920
1921 int
1922 gdbarch_ax_pseudo_register_collect_p (struct gdbarch *gdbarch)
1923 {
1924   gdb_assert (gdbarch != NULL);
1925   return gdbarch->ax_pseudo_register_collect != NULL;
1926 }
1927
1928 int
1929 gdbarch_ax_pseudo_register_collect (struct gdbarch *gdbarch, struct agent_expr *ax, int reg)
1930 {
1931   gdb_assert (gdbarch != NULL);
1932   gdb_assert (gdbarch->ax_pseudo_register_collect != NULL);
1933   if (gdbarch_debug >= 2)
1934     fprintf_unfiltered (gdb_stdlog, "gdbarch_ax_pseudo_register_collect called\n");
1935   return gdbarch->ax_pseudo_register_collect (gdbarch, ax, reg);
1936 }
1937
1938 void
1939 set_gdbarch_ax_pseudo_register_collect (struct gdbarch *gdbarch,
1940                                         gdbarch_ax_pseudo_register_collect_ftype ax_pseudo_register_collect)
1941 {
1942   gdbarch->ax_pseudo_register_collect = ax_pseudo_register_collect;
1943 }
1944
1945 int
1946 gdbarch_ax_pseudo_register_push_stack_p (struct gdbarch *gdbarch)
1947 {
1948   gdb_assert (gdbarch != NULL);
1949   return gdbarch->ax_pseudo_register_push_stack != NULL;
1950 }
1951
1952 int
1953 gdbarch_ax_pseudo_register_push_stack (struct gdbarch *gdbarch, struct agent_expr *ax, int reg)
1954 {
1955   gdb_assert (gdbarch != NULL);
1956   gdb_assert (gdbarch->ax_pseudo_register_push_stack != NULL);
1957   if (gdbarch_debug >= 2)
1958     fprintf_unfiltered (gdb_stdlog, "gdbarch_ax_pseudo_register_push_stack called\n");
1959   return gdbarch->ax_pseudo_register_push_stack (gdbarch, ax, reg);
1960 }
1961
1962 void
1963 set_gdbarch_ax_pseudo_register_push_stack (struct gdbarch *gdbarch,
1964                                            gdbarch_ax_pseudo_register_push_stack_ftype ax_pseudo_register_push_stack)
1965 {
1966   gdbarch->ax_pseudo_register_push_stack = ax_pseudo_register_push_stack;
1967 }
1968
1969 int
1970 gdbarch_sp_regnum (struct gdbarch *gdbarch)
1971 {
1972   gdb_assert (gdbarch != NULL);
1973   /* Skip verify of sp_regnum, invalid_p == 0 */
1974   if (gdbarch_debug >= 2)
1975     fprintf_unfiltered (gdb_stdlog, "gdbarch_sp_regnum called\n");
1976   return gdbarch->sp_regnum;
1977 }
1978
1979 void
1980 set_gdbarch_sp_regnum (struct gdbarch *gdbarch,
1981                        int sp_regnum)
1982 {
1983   gdbarch->sp_regnum = sp_regnum;
1984 }
1985
1986 int
1987 gdbarch_pc_regnum (struct gdbarch *gdbarch)
1988 {
1989   gdb_assert (gdbarch != NULL);
1990   /* Skip verify of pc_regnum, invalid_p == 0 */
1991   if (gdbarch_debug >= 2)
1992     fprintf_unfiltered (gdb_stdlog, "gdbarch_pc_regnum called\n");
1993   return gdbarch->pc_regnum;
1994 }
1995
1996 void
1997 set_gdbarch_pc_regnum (struct gdbarch *gdbarch,
1998                        int pc_regnum)
1999 {
2000   gdbarch->pc_regnum = pc_regnum;
2001 }
2002
2003 int
2004 gdbarch_ps_regnum (struct gdbarch *gdbarch)
2005 {
2006   gdb_assert (gdbarch != NULL);
2007   /* Skip verify of ps_regnum, invalid_p == 0 */
2008   if (gdbarch_debug >= 2)
2009     fprintf_unfiltered (gdb_stdlog, "gdbarch_ps_regnum called\n");
2010   return gdbarch->ps_regnum;
2011 }
2012
2013 void
2014 set_gdbarch_ps_regnum (struct gdbarch *gdbarch,
2015                        int ps_regnum)
2016 {
2017   gdbarch->ps_regnum = ps_regnum;
2018 }
2019
2020 int
2021 gdbarch_fp0_regnum (struct gdbarch *gdbarch)
2022 {
2023   gdb_assert (gdbarch != NULL);
2024   /* Skip verify of fp0_regnum, invalid_p == 0 */
2025   if (gdbarch_debug >= 2)
2026     fprintf_unfiltered (gdb_stdlog, "gdbarch_fp0_regnum called\n");
2027   return gdbarch->fp0_regnum;
2028 }
2029
2030 void
2031 set_gdbarch_fp0_regnum (struct gdbarch *gdbarch,
2032                         int fp0_regnum)
2033 {
2034   gdbarch->fp0_regnum = fp0_regnum;
2035 }
2036
2037 int
2038 gdbarch_stab_reg_to_regnum (struct gdbarch *gdbarch, int stab_regnr)
2039 {
2040   gdb_assert (gdbarch != NULL);
2041   gdb_assert (gdbarch->stab_reg_to_regnum != NULL);
2042   if (gdbarch_debug >= 2)
2043     fprintf_unfiltered (gdb_stdlog, "gdbarch_stab_reg_to_regnum called\n");
2044   return gdbarch->stab_reg_to_regnum (gdbarch, stab_regnr);
2045 }
2046
2047 void
2048 set_gdbarch_stab_reg_to_regnum (struct gdbarch *gdbarch,
2049                                 gdbarch_stab_reg_to_regnum_ftype stab_reg_to_regnum)
2050 {
2051   gdbarch->stab_reg_to_regnum = stab_reg_to_regnum;
2052 }
2053
2054 int
2055 gdbarch_ecoff_reg_to_regnum (struct gdbarch *gdbarch, int ecoff_regnr)
2056 {
2057   gdb_assert (gdbarch != NULL);
2058   gdb_assert (gdbarch->ecoff_reg_to_regnum != NULL);
2059   if (gdbarch_debug >= 2)
2060     fprintf_unfiltered (gdb_stdlog, "gdbarch_ecoff_reg_to_regnum called\n");
2061   return gdbarch->ecoff_reg_to_regnum (gdbarch, ecoff_regnr);
2062 }
2063
2064 void
2065 set_gdbarch_ecoff_reg_to_regnum (struct gdbarch *gdbarch,
2066                                  gdbarch_ecoff_reg_to_regnum_ftype ecoff_reg_to_regnum)
2067 {
2068   gdbarch->ecoff_reg_to_regnum = ecoff_reg_to_regnum;
2069 }
2070
2071 int
2072 gdbarch_sdb_reg_to_regnum (struct gdbarch *gdbarch, int sdb_regnr)
2073 {
2074   gdb_assert (gdbarch != NULL);
2075   gdb_assert (gdbarch->sdb_reg_to_regnum != NULL);
2076   if (gdbarch_debug >= 2)
2077     fprintf_unfiltered (gdb_stdlog, "gdbarch_sdb_reg_to_regnum called\n");
2078   return gdbarch->sdb_reg_to_regnum (gdbarch, sdb_regnr);
2079 }
2080
2081 void
2082 set_gdbarch_sdb_reg_to_regnum (struct gdbarch *gdbarch,
2083                                gdbarch_sdb_reg_to_regnum_ftype sdb_reg_to_regnum)
2084 {
2085   gdbarch->sdb_reg_to_regnum = sdb_reg_to_regnum;
2086 }
2087
2088 int
2089 gdbarch_dwarf2_reg_to_regnum (struct gdbarch *gdbarch, int dwarf2_regnr)
2090 {
2091   gdb_assert (gdbarch != NULL);
2092   gdb_assert (gdbarch->dwarf2_reg_to_regnum != NULL);
2093   if (gdbarch_debug >= 2)
2094     fprintf_unfiltered (gdb_stdlog, "gdbarch_dwarf2_reg_to_regnum called\n");
2095   return gdbarch->dwarf2_reg_to_regnum (gdbarch, dwarf2_regnr);
2096 }
2097
2098 void
2099 set_gdbarch_dwarf2_reg_to_regnum (struct gdbarch *gdbarch,
2100                                   gdbarch_dwarf2_reg_to_regnum_ftype dwarf2_reg_to_regnum)
2101 {
2102   gdbarch->dwarf2_reg_to_regnum = dwarf2_reg_to_regnum;
2103 }
2104
2105 const char *
2106 gdbarch_register_name (struct gdbarch *gdbarch, int regnr)
2107 {
2108   gdb_assert (gdbarch != NULL);
2109   gdb_assert (gdbarch->register_name != NULL);
2110   if (gdbarch_debug >= 2)
2111     fprintf_unfiltered (gdb_stdlog, "gdbarch_register_name called\n");
2112   return gdbarch->register_name (gdbarch, regnr);
2113 }
2114
2115 void
2116 set_gdbarch_register_name (struct gdbarch *gdbarch,
2117                            gdbarch_register_name_ftype register_name)
2118 {
2119   gdbarch->register_name = register_name;
2120 }
2121
2122 int
2123 gdbarch_register_type_p (struct gdbarch *gdbarch)
2124 {
2125   gdb_assert (gdbarch != NULL);
2126   return gdbarch->register_type != NULL;
2127 }
2128
2129 struct type *
2130 gdbarch_register_type (struct gdbarch *gdbarch, int reg_nr)
2131 {
2132   gdb_assert (gdbarch != NULL);
2133   gdb_assert (gdbarch->register_type != NULL);
2134   if (gdbarch_debug >= 2)
2135     fprintf_unfiltered (gdb_stdlog, "gdbarch_register_type called\n");
2136   return gdbarch->register_type (gdbarch, reg_nr);
2137 }
2138
2139 void
2140 set_gdbarch_register_type (struct gdbarch *gdbarch,
2141                            gdbarch_register_type_ftype register_type)
2142 {
2143   gdbarch->register_type = register_type;
2144 }
2145
2146 int
2147 gdbarch_dummy_id_p (struct gdbarch *gdbarch)
2148 {
2149   gdb_assert (gdbarch != NULL);
2150   return gdbarch->dummy_id != NULL;
2151 }
2152
2153 struct frame_id
2154 gdbarch_dummy_id (struct gdbarch *gdbarch, struct frame_info *this_frame)
2155 {
2156   gdb_assert (gdbarch != NULL);
2157   gdb_assert (gdbarch->dummy_id != NULL);
2158   if (gdbarch_debug >= 2)
2159     fprintf_unfiltered (gdb_stdlog, "gdbarch_dummy_id called\n");
2160   return gdbarch->dummy_id (gdbarch, this_frame);
2161 }
2162
2163 void
2164 set_gdbarch_dummy_id (struct gdbarch *gdbarch,
2165                       gdbarch_dummy_id_ftype dummy_id)
2166 {
2167   gdbarch->dummy_id = dummy_id;
2168 }
2169
2170 int
2171 gdbarch_deprecated_fp_regnum (struct gdbarch *gdbarch)
2172 {
2173   gdb_assert (gdbarch != NULL);
2174   /* Skip verify of deprecated_fp_regnum, invalid_p == 0 */
2175   if (gdbarch_debug >= 2)
2176     fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_fp_regnum called\n");
2177   return gdbarch->deprecated_fp_regnum;
2178 }
2179
2180 void
2181 set_gdbarch_deprecated_fp_regnum (struct gdbarch *gdbarch,
2182                                   int deprecated_fp_regnum)
2183 {
2184   gdbarch->deprecated_fp_regnum = deprecated_fp_regnum;
2185 }
2186
2187 int
2188 gdbarch_push_dummy_call_p (struct gdbarch *gdbarch)
2189 {
2190   gdb_assert (gdbarch != NULL);
2191   return gdbarch->push_dummy_call != NULL;
2192 }
2193
2194 CORE_ADDR
2195 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)
2196 {
2197   gdb_assert (gdbarch != NULL);
2198   gdb_assert (gdbarch->push_dummy_call != NULL);
2199   if (gdbarch_debug >= 2)
2200     fprintf_unfiltered (gdb_stdlog, "gdbarch_push_dummy_call called\n");
2201   return gdbarch->push_dummy_call (gdbarch, function, regcache, bp_addr, nargs, args, sp, struct_return, struct_addr);
2202 }
2203
2204 void
2205 set_gdbarch_push_dummy_call (struct gdbarch *gdbarch,
2206                              gdbarch_push_dummy_call_ftype push_dummy_call)
2207 {
2208   gdbarch->push_dummy_call = push_dummy_call;
2209 }
2210
2211 int
2212 gdbarch_call_dummy_location (struct gdbarch *gdbarch)
2213 {
2214   gdb_assert (gdbarch != NULL);
2215   /* Skip verify of call_dummy_location, invalid_p == 0 */
2216   if (gdbarch_debug >= 2)
2217     fprintf_unfiltered (gdb_stdlog, "gdbarch_call_dummy_location called\n");
2218   return gdbarch->call_dummy_location;
2219 }
2220
2221 void
2222 set_gdbarch_call_dummy_location (struct gdbarch *gdbarch,
2223                                  int call_dummy_location)
2224 {
2225   gdbarch->call_dummy_location = call_dummy_location;
2226 }
2227
2228 int
2229 gdbarch_push_dummy_code_p (struct gdbarch *gdbarch)
2230 {
2231   gdb_assert (gdbarch != NULL);
2232   return gdbarch->push_dummy_code != NULL;
2233 }
2234
2235 CORE_ADDR
2236 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)
2237 {
2238   gdb_assert (gdbarch != NULL);
2239   gdb_assert (gdbarch->push_dummy_code != NULL);
2240   if (gdbarch_debug >= 2)
2241     fprintf_unfiltered (gdb_stdlog, "gdbarch_push_dummy_code called\n");
2242   return gdbarch->push_dummy_code (gdbarch, sp, funaddr, args, nargs, value_type, real_pc, bp_addr, regcache);
2243 }
2244
2245 void
2246 set_gdbarch_push_dummy_code (struct gdbarch *gdbarch,
2247                              gdbarch_push_dummy_code_ftype push_dummy_code)
2248 {
2249   gdbarch->push_dummy_code = push_dummy_code;
2250 }
2251
2252 void
2253 gdbarch_print_registers_info (struct gdbarch *gdbarch, struct ui_file *file, struct frame_info *frame, int regnum, int all)
2254 {
2255   gdb_assert (gdbarch != NULL);
2256   gdb_assert (gdbarch->print_registers_info != NULL);
2257   if (gdbarch_debug >= 2)
2258     fprintf_unfiltered (gdb_stdlog, "gdbarch_print_registers_info called\n");
2259   gdbarch->print_registers_info (gdbarch, file, frame, regnum, all);
2260 }
2261
2262 void
2263 set_gdbarch_print_registers_info (struct gdbarch *gdbarch,
2264                                   gdbarch_print_registers_info_ftype print_registers_info)
2265 {
2266   gdbarch->print_registers_info = print_registers_info;
2267 }
2268
2269 int
2270 gdbarch_print_float_info_p (struct gdbarch *gdbarch)
2271 {
2272   gdb_assert (gdbarch != NULL);
2273   return gdbarch->print_float_info != NULL;
2274 }
2275
2276 void
2277 gdbarch_print_float_info (struct gdbarch *gdbarch, struct ui_file *file, struct frame_info *frame, const char *args)
2278 {
2279   gdb_assert (gdbarch != NULL);
2280   gdb_assert (gdbarch->print_float_info != NULL);
2281   if (gdbarch_debug >= 2)
2282     fprintf_unfiltered (gdb_stdlog, "gdbarch_print_float_info called\n");
2283   gdbarch->print_float_info (gdbarch, file, frame, args);
2284 }
2285
2286 void
2287 set_gdbarch_print_float_info (struct gdbarch *gdbarch,
2288                               gdbarch_print_float_info_ftype print_float_info)
2289 {
2290   gdbarch->print_float_info = print_float_info;
2291 }
2292
2293 int
2294 gdbarch_print_vector_info_p (struct gdbarch *gdbarch)
2295 {
2296   gdb_assert (gdbarch != NULL);
2297   return gdbarch->print_vector_info != NULL;
2298 }
2299
2300 void
2301 gdbarch_print_vector_info (struct gdbarch *gdbarch, struct ui_file *file, struct frame_info *frame, const char *args)
2302 {
2303   gdb_assert (gdbarch != NULL);
2304   gdb_assert (gdbarch->print_vector_info != NULL);
2305   if (gdbarch_debug >= 2)
2306     fprintf_unfiltered (gdb_stdlog, "gdbarch_print_vector_info called\n");
2307   gdbarch->print_vector_info (gdbarch, file, frame, args);
2308 }
2309
2310 void
2311 set_gdbarch_print_vector_info (struct gdbarch *gdbarch,
2312                                gdbarch_print_vector_info_ftype print_vector_info)
2313 {
2314   gdbarch->print_vector_info = print_vector_info;
2315 }
2316
2317 int
2318 gdbarch_register_sim_regno (struct gdbarch *gdbarch, int reg_nr)
2319 {
2320   gdb_assert (gdbarch != NULL);
2321   gdb_assert (gdbarch->register_sim_regno != NULL);
2322   if (gdbarch_debug >= 2)
2323     fprintf_unfiltered (gdb_stdlog, "gdbarch_register_sim_regno called\n");
2324   return gdbarch->register_sim_regno (gdbarch, reg_nr);
2325 }
2326
2327 void
2328 set_gdbarch_register_sim_regno (struct gdbarch *gdbarch,
2329                                 gdbarch_register_sim_regno_ftype register_sim_regno)
2330 {
2331   gdbarch->register_sim_regno = register_sim_regno;
2332 }
2333
2334 int
2335 gdbarch_cannot_fetch_register (struct gdbarch *gdbarch, int regnum)
2336 {
2337   gdb_assert (gdbarch != NULL);
2338   gdb_assert (gdbarch->cannot_fetch_register != NULL);
2339   if (gdbarch_debug >= 2)
2340     fprintf_unfiltered (gdb_stdlog, "gdbarch_cannot_fetch_register called\n");
2341   return gdbarch->cannot_fetch_register (gdbarch, regnum);
2342 }
2343
2344 void
2345 set_gdbarch_cannot_fetch_register (struct gdbarch *gdbarch,
2346                                    gdbarch_cannot_fetch_register_ftype cannot_fetch_register)
2347 {
2348   gdbarch->cannot_fetch_register = cannot_fetch_register;
2349 }
2350
2351 int
2352 gdbarch_cannot_store_register (struct gdbarch *gdbarch, int regnum)
2353 {
2354   gdb_assert (gdbarch != NULL);
2355   gdb_assert (gdbarch->cannot_store_register != NULL);
2356   if (gdbarch_debug >= 2)
2357     fprintf_unfiltered (gdb_stdlog, "gdbarch_cannot_store_register called\n");
2358   return gdbarch->cannot_store_register (gdbarch, regnum);
2359 }
2360
2361 void
2362 set_gdbarch_cannot_store_register (struct gdbarch *gdbarch,
2363                                    gdbarch_cannot_store_register_ftype cannot_store_register)
2364 {
2365   gdbarch->cannot_store_register = cannot_store_register;
2366 }
2367
2368 int
2369 gdbarch_get_longjmp_target_p (struct gdbarch *gdbarch)
2370 {
2371   gdb_assert (gdbarch != NULL);
2372   return gdbarch->get_longjmp_target != NULL;
2373 }
2374
2375 int
2376 gdbarch_get_longjmp_target (struct gdbarch *gdbarch, struct frame_info *frame, CORE_ADDR *pc)
2377 {
2378   gdb_assert (gdbarch != NULL);
2379   gdb_assert (gdbarch->get_longjmp_target != NULL);
2380   if (gdbarch_debug >= 2)
2381     fprintf_unfiltered (gdb_stdlog, "gdbarch_get_longjmp_target called\n");
2382   return gdbarch->get_longjmp_target (frame, pc);
2383 }
2384
2385 void
2386 set_gdbarch_get_longjmp_target (struct gdbarch *gdbarch,
2387                                 gdbarch_get_longjmp_target_ftype get_longjmp_target)
2388 {
2389   gdbarch->get_longjmp_target = get_longjmp_target;
2390 }
2391
2392 int
2393 gdbarch_believe_pcc_promotion (struct gdbarch *gdbarch)
2394 {
2395   gdb_assert (gdbarch != NULL);
2396   if (gdbarch_debug >= 2)
2397     fprintf_unfiltered (gdb_stdlog, "gdbarch_believe_pcc_promotion called\n");
2398   return gdbarch->believe_pcc_promotion;
2399 }
2400
2401 void
2402 set_gdbarch_believe_pcc_promotion (struct gdbarch *gdbarch,
2403                                    int believe_pcc_promotion)
2404 {
2405   gdbarch->believe_pcc_promotion = believe_pcc_promotion;
2406 }
2407
2408 int
2409 gdbarch_convert_register_p (struct gdbarch *gdbarch, int regnum, struct type *type)
2410 {
2411   gdb_assert (gdbarch != NULL);
2412   gdb_assert (gdbarch->convert_register_p != NULL);
2413   if (gdbarch_debug >= 2)
2414     fprintf_unfiltered (gdb_stdlog, "gdbarch_convert_register_p called\n");
2415   return gdbarch->convert_register_p (gdbarch, regnum, type);
2416 }
2417
2418 void
2419 set_gdbarch_convert_register_p (struct gdbarch *gdbarch,
2420                                 gdbarch_convert_register_p_ftype convert_register_p)
2421 {
2422   gdbarch->convert_register_p = convert_register_p;
2423 }
2424
2425 int
2426 gdbarch_register_to_value (struct gdbarch *gdbarch, struct frame_info *frame, int regnum, struct type *type, gdb_byte *buf, int *optimizedp, int *unavailablep)
2427 {
2428   gdb_assert (gdbarch != NULL);
2429   gdb_assert (gdbarch->register_to_value != NULL);
2430   if (gdbarch_debug >= 2)
2431     fprintf_unfiltered (gdb_stdlog, "gdbarch_register_to_value called\n");
2432   return gdbarch->register_to_value (frame, regnum, type, buf, optimizedp, unavailablep);
2433 }
2434
2435 void
2436 set_gdbarch_register_to_value (struct gdbarch *gdbarch,
2437                                gdbarch_register_to_value_ftype register_to_value)
2438 {
2439   gdbarch->register_to_value = register_to_value;
2440 }
2441
2442 void
2443 gdbarch_value_to_register (struct gdbarch *gdbarch, struct frame_info *frame, int regnum, struct type *type, const gdb_byte *buf)
2444 {
2445   gdb_assert (gdbarch != NULL);
2446   gdb_assert (gdbarch->value_to_register != NULL);
2447   if (gdbarch_debug >= 2)
2448     fprintf_unfiltered (gdb_stdlog, "gdbarch_value_to_register called\n");
2449   gdbarch->value_to_register (frame, regnum, type, buf);
2450 }
2451
2452 void
2453 set_gdbarch_value_to_register (struct gdbarch *gdbarch,
2454                                gdbarch_value_to_register_ftype value_to_register)
2455 {
2456   gdbarch->value_to_register = value_to_register;
2457 }
2458
2459 struct value *
2460 gdbarch_value_from_register (struct gdbarch *gdbarch, struct type *type, int regnum, struct frame_info *frame)
2461 {
2462   gdb_assert (gdbarch != NULL);
2463   gdb_assert (gdbarch->value_from_register != NULL);
2464   if (gdbarch_debug >= 2)
2465     fprintf_unfiltered (gdb_stdlog, "gdbarch_value_from_register called\n");
2466   return gdbarch->value_from_register (type, regnum, frame);
2467 }
2468
2469 void
2470 set_gdbarch_value_from_register (struct gdbarch *gdbarch,
2471                                  gdbarch_value_from_register_ftype value_from_register)
2472 {
2473   gdbarch->value_from_register = value_from_register;
2474 }
2475
2476 CORE_ADDR
2477 gdbarch_pointer_to_address (struct gdbarch *gdbarch, struct type *type, const gdb_byte *buf)
2478 {
2479   gdb_assert (gdbarch != NULL);
2480   gdb_assert (gdbarch->pointer_to_address != NULL);
2481   if (gdbarch_debug >= 2)
2482     fprintf_unfiltered (gdb_stdlog, "gdbarch_pointer_to_address called\n");
2483   return gdbarch->pointer_to_address (gdbarch, type, buf);
2484 }
2485
2486 void
2487 set_gdbarch_pointer_to_address (struct gdbarch *gdbarch,
2488                                 gdbarch_pointer_to_address_ftype pointer_to_address)
2489 {
2490   gdbarch->pointer_to_address = pointer_to_address;
2491 }
2492
2493 void
2494 gdbarch_address_to_pointer (struct gdbarch *gdbarch, struct type *type, gdb_byte *buf, CORE_ADDR addr)
2495 {
2496   gdb_assert (gdbarch != NULL);
2497   gdb_assert (gdbarch->address_to_pointer != NULL);
2498   if (gdbarch_debug >= 2)
2499     fprintf_unfiltered (gdb_stdlog, "gdbarch_address_to_pointer called\n");
2500   gdbarch->address_to_pointer (gdbarch, type, buf, addr);
2501 }
2502
2503 void
2504 set_gdbarch_address_to_pointer (struct gdbarch *gdbarch,
2505                                 gdbarch_address_to_pointer_ftype address_to_pointer)
2506 {
2507   gdbarch->address_to_pointer = address_to_pointer;
2508 }
2509
2510 int
2511 gdbarch_integer_to_address_p (struct gdbarch *gdbarch)
2512 {
2513   gdb_assert (gdbarch != NULL);
2514   return gdbarch->integer_to_address != NULL;
2515 }
2516
2517 CORE_ADDR
2518 gdbarch_integer_to_address (struct gdbarch *gdbarch, struct type *type, const gdb_byte *buf)
2519 {
2520   gdb_assert (gdbarch != NULL);
2521   gdb_assert (gdbarch->integer_to_address != NULL);
2522   if (gdbarch_debug >= 2)
2523     fprintf_unfiltered (gdb_stdlog, "gdbarch_integer_to_address called\n");
2524   return gdbarch->integer_to_address (gdbarch, type, buf);
2525 }
2526
2527 void
2528 set_gdbarch_integer_to_address (struct gdbarch *gdbarch,
2529                                 gdbarch_integer_to_address_ftype integer_to_address)
2530 {
2531   gdbarch->integer_to_address = integer_to_address;
2532 }
2533
2534 int
2535 gdbarch_return_value_p (struct gdbarch *gdbarch)
2536 {
2537   gdb_assert (gdbarch != NULL);
2538   return gdbarch->return_value != NULL;
2539 }
2540
2541 enum return_value_convention
2542 gdbarch_return_value (struct gdbarch *gdbarch, struct value *function, struct type *valtype, struct regcache *regcache, gdb_byte *readbuf, const gdb_byte *writebuf)
2543 {
2544   gdb_assert (gdbarch != NULL);
2545   gdb_assert (gdbarch->return_value != NULL);
2546   if (gdbarch_debug >= 2)
2547     fprintf_unfiltered (gdb_stdlog, "gdbarch_return_value called\n");
2548   return gdbarch->return_value (gdbarch, function, valtype, regcache, readbuf, writebuf);
2549 }
2550
2551 void
2552 set_gdbarch_return_value (struct gdbarch *gdbarch,
2553                           gdbarch_return_value_ftype return_value)
2554 {
2555   gdbarch->return_value = return_value;
2556 }
2557
2558 CORE_ADDR
2559 gdbarch_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR ip)
2560 {
2561   gdb_assert (gdbarch != NULL);
2562   gdb_assert (gdbarch->skip_prologue != NULL);
2563   if (gdbarch_debug >= 2)
2564     fprintf_unfiltered (gdb_stdlog, "gdbarch_skip_prologue called\n");
2565   return gdbarch->skip_prologue (gdbarch, ip);
2566 }
2567
2568 void
2569 set_gdbarch_skip_prologue (struct gdbarch *gdbarch,
2570                            gdbarch_skip_prologue_ftype skip_prologue)
2571 {
2572   gdbarch->skip_prologue = skip_prologue;
2573 }
2574
2575 int
2576 gdbarch_skip_main_prologue_p (struct gdbarch *gdbarch)
2577 {
2578   gdb_assert (gdbarch != NULL);
2579   return gdbarch->skip_main_prologue != NULL;
2580 }
2581
2582 CORE_ADDR
2583 gdbarch_skip_main_prologue (struct gdbarch *gdbarch, CORE_ADDR ip)
2584 {
2585   gdb_assert (gdbarch != NULL);
2586   gdb_assert (gdbarch->skip_main_prologue != NULL);
2587   if (gdbarch_debug >= 2)
2588     fprintf_unfiltered (gdb_stdlog, "gdbarch_skip_main_prologue called\n");
2589   return gdbarch->skip_main_prologue (gdbarch, ip);
2590 }
2591
2592 void
2593 set_gdbarch_skip_main_prologue (struct gdbarch *gdbarch,
2594                                 gdbarch_skip_main_prologue_ftype skip_main_prologue)
2595 {
2596   gdbarch->skip_main_prologue = skip_main_prologue;
2597 }
2598
2599 int
2600 gdbarch_inner_than (struct gdbarch *gdbarch, CORE_ADDR lhs, CORE_ADDR rhs)
2601 {
2602   gdb_assert (gdbarch != NULL);
2603   gdb_assert (gdbarch->inner_than != NULL);
2604   if (gdbarch_debug >= 2)
2605     fprintf_unfiltered (gdb_stdlog, "gdbarch_inner_than called\n");
2606   return gdbarch->inner_than (lhs, rhs);
2607 }
2608
2609 void
2610 set_gdbarch_inner_than (struct gdbarch *gdbarch,
2611                         gdbarch_inner_than_ftype inner_than)
2612 {
2613   gdbarch->inner_than = inner_than;
2614 }
2615
2616 const gdb_byte *
2617 gdbarch_breakpoint_from_pc (struct gdbarch *gdbarch, CORE_ADDR *pcptr, int *lenptr)
2618 {
2619   gdb_assert (gdbarch != NULL);
2620   gdb_assert (gdbarch->breakpoint_from_pc != NULL);
2621   if (gdbarch_debug >= 2)
2622     fprintf_unfiltered (gdb_stdlog, "gdbarch_breakpoint_from_pc called\n");
2623   return gdbarch->breakpoint_from_pc (gdbarch, pcptr, lenptr);
2624 }
2625
2626 void
2627 set_gdbarch_breakpoint_from_pc (struct gdbarch *gdbarch,
2628                                 gdbarch_breakpoint_from_pc_ftype breakpoint_from_pc)
2629 {
2630   gdbarch->breakpoint_from_pc = breakpoint_from_pc;
2631 }
2632
2633 void
2634 gdbarch_remote_breakpoint_from_pc (struct gdbarch *gdbarch, CORE_ADDR *pcptr, int *kindptr)
2635 {
2636   gdb_assert (gdbarch != NULL);
2637   gdb_assert (gdbarch->remote_breakpoint_from_pc != NULL);
2638   if (gdbarch_debug >= 2)
2639     fprintf_unfiltered (gdb_stdlog, "gdbarch_remote_breakpoint_from_pc called\n");
2640   gdbarch->remote_breakpoint_from_pc (gdbarch, pcptr, kindptr);
2641 }
2642
2643 void
2644 set_gdbarch_remote_breakpoint_from_pc (struct gdbarch *gdbarch,
2645                                        gdbarch_remote_breakpoint_from_pc_ftype remote_breakpoint_from_pc)
2646 {
2647   gdbarch->remote_breakpoint_from_pc = remote_breakpoint_from_pc;
2648 }
2649
2650 int
2651 gdbarch_adjust_breakpoint_address_p (struct gdbarch *gdbarch)
2652 {
2653   gdb_assert (gdbarch != NULL);
2654   return gdbarch->adjust_breakpoint_address != NULL;
2655 }
2656
2657 CORE_ADDR
2658 gdbarch_adjust_breakpoint_address (struct gdbarch *gdbarch, CORE_ADDR bpaddr)
2659 {
2660   gdb_assert (gdbarch != NULL);
2661   gdb_assert (gdbarch->adjust_breakpoint_address != NULL);
2662   if (gdbarch_debug >= 2)
2663     fprintf_unfiltered (gdb_stdlog, "gdbarch_adjust_breakpoint_address called\n");
2664   return gdbarch->adjust_breakpoint_address (gdbarch, bpaddr);
2665 }
2666
2667 void
2668 set_gdbarch_adjust_breakpoint_address (struct gdbarch *gdbarch,
2669                                        gdbarch_adjust_breakpoint_address_ftype adjust_breakpoint_address)
2670 {
2671   gdbarch->adjust_breakpoint_address = adjust_breakpoint_address;
2672 }
2673
2674 int
2675 gdbarch_memory_insert_breakpoint (struct gdbarch *gdbarch, struct bp_target_info *bp_tgt)
2676 {
2677   gdb_assert (gdbarch != NULL);
2678   gdb_assert (gdbarch->memory_insert_breakpoint != NULL);
2679   if (gdbarch_debug >= 2)
2680     fprintf_unfiltered (gdb_stdlog, "gdbarch_memory_insert_breakpoint called\n");
2681   return gdbarch->memory_insert_breakpoint (gdbarch, bp_tgt);
2682 }
2683
2684 void
2685 set_gdbarch_memory_insert_breakpoint (struct gdbarch *gdbarch,
2686                                       gdbarch_memory_insert_breakpoint_ftype memory_insert_breakpoint)
2687 {
2688   gdbarch->memory_insert_breakpoint = memory_insert_breakpoint;
2689 }
2690
2691 int
2692 gdbarch_memory_remove_breakpoint (struct gdbarch *gdbarch, struct bp_target_info *bp_tgt)
2693 {
2694   gdb_assert (gdbarch != NULL);
2695   gdb_assert (gdbarch->memory_remove_breakpoint != NULL);
2696   if (gdbarch_debug >= 2)
2697     fprintf_unfiltered (gdb_stdlog, "gdbarch_memory_remove_breakpoint called\n");
2698   return gdbarch->memory_remove_breakpoint (gdbarch, bp_tgt);
2699 }
2700
2701 void
2702 set_gdbarch_memory_remove_breakpoint (struct gdbarch *gdbarch,
2703                                       gdbarch_memory_remove_breakpoint_ftype memory_remove_breakpoint)
2704 {
2705   gdbarch->memory_remove_breakpoint = memory_remove_breakpoint;
2706 }
2707
2708 CORE_ADDR
2709 gdbarch_decr_pc_after_break (struct gdbarch *gdbarch)
2710 {
2711   gdb_assert (gdbarch != NULL);
2712   /* Skip verify of decr_pc_after_break, invalid_p == 0 */
2713   if (gdbarch_debug >= 2)
2714     fprintf_unfiltered (gdb_stdlog, "gdbarch_decr_pc_after_break called\n");
2715   return gdbarch->decr_pc_after_break;
2716 }
2717
2718 void
2719 set_gdbarch_decr_pc_after_break (struct gdbarch *gdbarch,
2720                                  CORE_ADDR decr_pc_after_break)
2721 {
2722   gdbarch->decr_pc_after_break = decr_pc_after_break;
2723 }
2724
2725 CORE_ADDR
2726 gdbarch_deprecated_function_start_offset (struct gdbarch *gdbarch)
2727 {
2728   gdb_assert (gdbarch != NULL);
2729   /* Skip verify of deprecated_function_start_offset, invalid_p == 0 */
2730   if (gdbarch_debug >= 2)
2731     fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_function_start_offset called\n");
2732   return gdbarch->deprecated_function_start_offset;
2733 }
2734
2735 void
2736 set_gdbarch_deprecated_function_start_offset (struct gdbarch *gdbarch,
2737                                               CORE_ADDR deprecated_function_start_offset)
2738 {
2739   gdbarch->deprecated_function_start_offset = deprecated_function_start_offset;
2740 }
2741
2742 int
2743 gdbarch_remote_register_number (struct gdbarch *gdbarch, int regno)
2744 {
2745   gdb_assert (gdbarch != NULL);
2746   gdb_assert (gdbarch->remote_register_number != NULL);
2747   if (gdbarch_debug >= 2)
2748     fprintf_unfiltered (gdb_stdlog, "gdbarch_remote_register_number called\n");
2749   return gdbarch->remote_register_number (gdbarch, regno);
2750 }
2751
2752 void
2753 set_gdbarch_remote_register_number (struct gdbarch *gdbarch,
2754                                     gdbarch_remote_register_number_ftype remote_register_number)
2755 {
2756   gdbarch->remote_register_number = remote_register_number;
2757 }
2758
2759 int
2760 gdbarch_fetch_tls_load_module_address_p (struct gdbarch *gdbarch)
2761 {
2762   gdb_assert (gdbarch != NULL);
2763   return gdbarch->fetch_tls_load_module_address != NULL;
2764 }
2765
2766 CORE_ADDR
2767 gdbarch_fetch_tls_load_module_address (struct gdbarch *gdbarch, struct objfile *objfile)
2768 {
2769   gdb_assert (gdbarch != NULL);
2770   gdb_assert (gdbarch->fetch_tls_load_module_address != NULL);
2771   if (gdbarch_debug >= 2)
2772     fprintf_unfiltered (gdb_stdlog, "gdbarch_fetch_tls_load_module_address called\n");
2773   return gdbarch->fetch_tls_load_module_address (objfile);
2774 }
2775
2776 void
2777 set_gdbarch_fetch_tls_load_module_address (struct gdbarch *gdbarch,
2778                                            gdbarch_fetch_tls_load_module_address_ftype fetch_tls_load_module_address)
2779 {
2780   gdbarch->fetch_tls_load_module_address = fetch_tls_load_module_address;
2781 }
2782
2783 CORE_ADDR
2784 gdbarch_frame_args_skip (struct gdbarch *gdbarch)
2785 {
2786   gdb_assert (gdbarch != NULL);
2787   /* Skip verify of frame_args_skip, invalid_p == 0 */
2788   if (gdbarch_debug >= 2)
2789     fprintf_unfiltered (gdb_stdlog, "gdbarch_frame_args_skip called\n");
2790   return gdbarch->frame_args_skip;
2791 }
2792
2793 void
2794 set_gdbarch_frame_args_skip (struct gdbarch *gdbarch,
2795                              CORE_ADDR frame_args_skip)
2796 {
2797   gdbarch->frame_args_skip = frame_args_skip;
2798 }
2799
2800 int
2801 gdbarch_unwind_pc_p (struct gdbarch *gdbarch)
2802 {
2803   gdb_assert (gdbarch != NULL);
2804   return gdbarch->unwind_pc != NULL;
2805 }
2806
2807 CORE_ADDR
2808 gdbarch_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame)
2809 {
2810   gdb_assert (gdbarch != NULL);
2811   gdb_assert (gdbarch->unwind_pc != NULL);
2812   if (gdbarch_debug >= 2)
2813     fprintf_unfiltered (gdb_stdlog, "gdbarch_unwind_pc called\n");
2814   return gdbarch->unwind_pc (gdbarch, next_frame);
2815 }
2816
2817 void
2818 set_gdbarch_unwind_pc (struct gdbarch *gdbarch,
2819                        gdbarch_unwind_pc_ftype unwind_pc)
2820 {
2821   gdbarch->unwind_pc = unwind_pc;
2822 }
2823
2824 int
2825 gdbarch_unwind_sp_p (struct gdbarch *gdbarch)
2826 {
2827   gdb_assert (gdbarch != NULL);
2828   return gdbarch->unwind_sp != NULL;
2829 }
2830
2831 CORE_ADDR
2832 gdbarch_unwind_sp (struct gdbarch *gdbarch, struct frame_info *next_frame)
2833 {
2834   gdb_assert (gdbarch != NULL);
2835   gdb_assert (gdbarch->unwind_sp != NULL);
2836   if (gdbarch_debug >= 2)
2837     fprintf_unfiltered (gdb_stdlog, "gdbarch_unwind_sp called\n");
2838   return gdbarch->unwind_sp (gdbarch, next_frame);
2839 }
2840
2841 void
2842 set_gdbarch_unwind_sp (struct gdbarch *gdbarch,
2843                        gdbarch_unwind_sp_ftype unwind_sp)
2844 {
2845   gdbarch->unwind_sp = unwind_sp;
2846 }
2847
2848 int
2849 gdbarch_frame_num_args_p (struct gdbarch *gdbarch)
2850 {
2851   gdb_assert (gdbarch != NULL);
2852   return gdbarch->frame_num_args != NULL;
2853 }
2854
2855 int
2856 gdbarch_frame_num_args (struct gdbarch *gdbarch, struct frame_info *frame)
2857 {
2858   gdb_assert (gdbarch != NULL);
2859   gdb_assert (gdbarch->frame_num_args != NULL);
2860   if (gdbarch_debug >= 2)
2861     fprintf_unfiltered (gdb_stdlog, "gdbarch_frame_num_args called\n");
2862   return gdbarch->frame_num_args (frame);
2863 }
2864
2865 void
2866 set_gdbarch_frame_num_args (struct gdbarch *gdbarch,
2867                             gdbarch_frame_num_args_ftype frame_num_args)
2868 {
2869   gdbarch->frame_num_args = frame_num_args;
2870 }
2871
2872 int
2873 gdbarch_frame_align_p (struct gdbarch *gdbarch)
2874 {
2875   gdb_assert (gdbarch != NULL);
2876   return gdbarch->frame_align != NULL;
2877 }
2878
2879 CORE_ADDR
2880 gdbarch_frame_align (struct gdbarch *gdbarch, CORE_ADDR address)
2881 {
2882   gdb_assert (gdbarch != NULL);
2883   gdb_assert (gdbarch->frame_align != NULL);
2884   if (gdbarch_debug >= 2)
2885     fprintf_unfiltered (gdb_stdlog, "gdbarch_frame_align called\n");
2886   return gdbarch->frame_align (gdbarch, address);
2887 }
2888
2889 void
2890 set_gdbarch_frame_align (struct gdbarch *gdbarch,
2891                          gdbarch_frame_align_ftype frame_align)
2892 {
2893   gdbarch->frame_align = frame_align;
2894 }
2895
2896 int
2897 gdbarch_stabs_argument_has_addr (struct gdbarch *gdbarch, struct type *type)
2898 {
2899   gdb_assert (gdbarch != NULL);
2900   gdb_assert (gdbarch->stabs_argument_has_addr != NULL);
2901   if (gdbarch_debug >= 2)
2902     fprintf_unfiltered (gdb_stdlog, "gdbarch_stabs_argument_has_addr called\n");
2903   return gdbarch->stabs_argument_has_addr (gdbarch, type);
2904 }
2905
2906 void
2907 set_gdbarch_stabs_argument_has_addr (struct gdbarch *gdbarch,
2908                                      gdbarch_stabs_argument_has_addr_ftype stabs_argument_has_addr)
2909 {
2910   gdbarch->stabs_argument_has_addr = stabs_argument_has_addr;
2911 }
2912
2913 int
2914 gdbarch_frame_red_zone_size (struct gdbarch *gdbarch)
2915 {
2916   gdb_assert (gdbarch != NULL);
2917   if (gdbarch_debug >= 2)
2918     fprintf_unfiltered (gdb_stdlog, "gdbarch_frame_red_zone_size called\n");
2919   return gdbarch->frame_red_zone_size;
2920 }
2921
2922 void
2923 set_gdbarch_frame_red_zone_size (struct gdbarch *gdbarch,
2924                                  int frame_red_zone_size)
2925 {
2926   gdbarch->frame_red_zone_size = frame_red_zone_size;
2927 }
2928
2929 CORE_ADDR
2930 gdbarch_convert_from_func_ptr_addr (struct gdbarch *gdbarch, CORE_ADDR addr, struct target_ops *targ)
2931 {
2932   gdb_assert (gdbarch != NULL);
2933   gdb_assert (gdbarch->convert_from_func_ptr_addr != NULL);
2934   if (gdbarch_debug >= 2)
2935     fprintf_unfiltered (gdb_stdlog, "gdbarch_convert_from_func_ptr_addr called\n");
2936   return gdbarch->convert_from_func_ptr_addr (gdbarch, addr, targ);
2937 }
2938
2939 void
2940 set_gdbarch_convert_from_func_ptr_addr (struct gdbarch *gdbarch,
2941                                         gdbarch_convert_from_func_ptr_addr_ftype convert_from_func_ptr_addr)
2942 {
2943   gdbarch->convert_from_func_ptr_addr = convert_from_func_ptr_addr;
2944 }
2945
2946 CORE_ADDR
2947 gdbarch_addr_bits_remove (struct gdbarch *gdbarch, CORE_ADDR addr)
2948 {
2949   gdb_assert (gdbarch != NULL);
2950   gdb_assert (gdbarch->addr_bits_remove != NULL);
2951   if (gdbarch_debug >= 2)
2952     fprintf_unfiltered (gdb_stdlog, "gdbarch_addr_bits_remove called\n");
2953   return gdbarch->addr_bits_remove (gdbarch, addr);
2954 }
2955
2956 void
2957 set_gdbarch_addr_bits_remove (struct gdbarch *gdbarch,
2958                               gdbarch_addr_bits_remove_ftype addr_bits_remove)
2959 {
2960   gdbarch->addr_bits_remove = addr_bits_remove;
2961 }
2962
2963 CORE_ADDR
2964 gdbarch_smash_text_address (struct gdbarch *gdbarch, CORE_ADDR addr)
2965 {
2966   gdb_assert (gdbarch != NULL);
2967   gdb_assert (gdbarch->smash_text_address != NULL);
2968   if (gdbarch_debug >= 2)
2969     fprintf_unfiltered (gdb_stdlog, "gdbarch_smash_text_address called\n");
2970   return gdbarch->smash_text_address (gdbarch, addr);
2971 }
2972
2973 void
2974 set_gdbarch_smash_text_address (struct gdbarch *gdbarch,
2975                                 gdbarch_smash_text_address_ftype smash_text_address)
2976 {
2977   gdbarch->smash_text_address = smash_text_address;
2978 }
2979
2980 int
2981 gdbarch_software_single_step_p (struct gdbarch *gdbarch)
2982 {
2983   gdb_assert (gdbarch != NULL);
2984   return gdbarch->software_single_step != NULL;
2985 }
2986
2987 int
2988 gdbarch_software_single_step (struct gdbarch *gdbarch, struct frame_info *frame)
2989 {
2990   gdb_assert (gdbarch != NULL);
2991   gdb_assert (gdbarch->software_single_step != NULL);
2992   if (gdbarch_debug >= 2)
2993     fprintf_unfiltered (gdb_stdlog, "gdbarch_software_single_step called\n");
2994   return gdbarch->software_single_step (frame);
2995 }
2996
2997 void
2998 set_gdbarch_software_single_step (struct gdbarch *gdbarch,
2999                                   gdbarch_software_single_step_ftype software_single_step)
3000 {
3001   gdbarch->software_single_step = software_single_step;
3002 }
3003
3004 int
3005 gdbarch_single_step_through_delay_p (struct gdbarch *gdbarch)
3006 {
3007   gdb_assert (gdbarch != NULL);
3008   return gdbarch->single_step_through_delay != NULL;
3009 }
3010
3011 int
3012 gdbarch_single_step_through_delay (struct gdbarch *gdbarch, struct frame_info *frame)
3013 {
3014   gdb_assert (gdbarch != NULL);
3015   gdb_assert (gdbarch->single_step_through_delay != NULL);
3016   if (gdbarch_debug >= 2)
3017     fprintf_unfiltered (gdb_stdlog, "gdbarch_single_step_through_delay called\n");
3018   return gdbarch->single_step_through_delay (gdbarch, frame);
3019 }
3020
3021 void
3022 set_gdbarch_single_step_through_delay (struct gdbarch *gdbarch,
3023                                        gdbarch_single_step_through_delay_ftype single_step_through_delay)
3024 {
3025   gdbarch->single_step_through_delay = single_step_through_delay;
3026 }
3027
3028 int
3029 gdbarch_print_insn (struct gdbarch *gdbarch, bfd_vma vma, struct disassemble_info *info)
3030 {
3031   gdb_assert (gdbarch != NULL);
3032   gdb_assert (gdbarch->print_insn != NULL);
3033   if (gdbarch_debug >= 2)
3034     fprintf_unfiltered (gdb_stdlog, "gdbarch_print_insn called\n");
3035   return gdbarch->print_insn (vma, info);
3036 }
3037
3038 void
3039 set_gdbarch_print_insn (struct gdbarch *gdbarch,
3040                         gdbarch_print_insn_ftype print_insn)
3041 {
3042   gdbarch->print_insn = print_insn;
3043 }
3044
3045 CORE_ADDR
3046 gdbarch_skip_trampoline_code (struct gdbarch *gdbarch, struct frame_info *frame, CORE_ADDR pc)
3047 {
3048   gdb_assert (gdbarch != NULL);
3049   gdb_assert (gdbarch->skip_trampoline_code != NULL);
3050   if (gdbarch_debug >= 2)
3051     fprintf_unfiltered (gdb_stdlog, "gdbarch_skip_trampoline_code called\n");
3052   return gdbarch->skip_trampoline_code (frame, pc);
3053 }
3054
3055 void
3056 set_gdbarch_skip_trampoline_code (struct gdbarch *gdbarch,
3057                                   gdbarch_skip_trampoline_code_ftype skip_trampoline_code)
3058 {
3059   gdbarch->skip_trampoline_code = skip_trampoline_code;
3060 }
3061
3062 CORE_ADDR
3063 gdbarch_skip_solib_resolver (struct gdbarch *gdbarch, CORE_ADDR pc)
3064 {
3065   gdb_assert (gdbarch != NULL);
3066   gdb_assert (gdbarch->skip_solib_resolver != NULL);
3067   if (gdbarch_debug >= 2)
3068     fprintf_unfiltered (gdb_stdlog, "gdbarch_skip_solib_resolver called\n");
3069   return gdbarch->skip_solib_resolver (gdbarch, pc);
3070 }
3071
3072 void
3073 set_gdbarch_skip_solib_resolver (struct gdbarch *gdbarch,
3074                                  gdbarch_skip_solib_resolver_ftype skip_solib_resolver)
3075 {
3076   gdbarch->skip_solib_resolver = skip_solib_resolver;
3077 }
3078
3079 int
3080 gdbarch_in_solib_return_trampoline (struct gdbarch *gdbarch, CORE_ADDR pc, const char *name)
3081 {
3082   gdb_assert (gdbarch != NULL);
3083   gdb_assert (gdbarch->in_solib_return_trampoline != NULL);
3084   if (gdbarch_debug >= 2)
3085     fprintf_unfiltered (gdb_stdlog, "gdbarch_in_solib_return_trampoline called\n");
3086   return gdbarch->in_solib_return_trampoline (gdbarch, pc, name);
3087 }
3088
3089 void
3090 set_gdbarch_in_solib_return_trampoline (struct gdbarch *gdbarch,
3091                                         gdbarch_in_solib_return_trampoline_ftype in_solib_return_trampoline)
3092 {
3093   gdbarch->in_solib_return_trampoline = in_solib_return_trampoline;
3094 }
3095
3096 int
3097 gdbarch_in_function_epilogue_p (struct gdbarch *gdbarch, CORE_ADDR addr)
3098 {
3099   gdb_assert (gdbarch != NULL);
3100   gdb_assert (gdbarch->in_function_epilogue_p != NULL);
3101   if (gdbarch_debug >= 2)
3102     fprintf_unfiltered (gdb_stdlog, "gdbarch_in_function_epilogue_p called\n");
3103   return gdbarch->in_function_epilogue_p (gdbarch, addr);
3104 }
3105
3106 void
3107 set_gdbarch_in_function_epilogue_p (struct gdbarch *gdbarch,
3108                                     gdbarch_in_function_epilogue_p_ftype in_function_epilogue_p)
3109 {
3110   gdbarch->in_function_epilogue_p = in_function_epilogue_p;
3111 }
3112
3113 void
3114 gdbarch_elf_make_msymbol_special (struct gdbarch *gdbarch, asymbol *sym, struct minimal_symbol *msym)
3115 {
3116   gdb_assert (gdbarch != NULL);
3117   gdb_assert (gdbarch->elf_make_msymbol_special != NULL);
3118   if (gdbarch_debug >= 2)
3119     fprintf_unfiltered (gdb_stdlog, "gdbarch_elf_make_msymbol_special called\n");
3120   gdbarch->elf_make_msymbol_special (sym, msym);
3121 }
3122
3123 void
3124 set_gdbarch_elf_make_msymbol_special (struct gdbarch *gdbarch,
3125                                       gdbarch_elf_make_msymbol_special_ftype elf_make_msymbol_special)
3126 {
3127   gdbarch->elf_make_msymbol_special = elf_make_msymbol_special;
3128 }
3129
3130 void
3131 gdbarch_coff_make_msymbol_special (struct gdbarch *gdbarch, int val, struct minimal_symbol *msym)
3132 {
3133   gdb_assert (gdbarch != NULL);
3134   gdb_assert (gdbarch->coff_make_msymbol_special != NULL);
3135   if (gdbarch_debug >= 2)
3136     fprintf_unfiltered (gdb_stdlog, "gdbarch_coff_make_msymbol_special called\n");
3137   gdbarch->coff_make_msymbol_special (val, msym);
3138 }
3139
3140 void
3141 set_gdbarch_coff_make_msymbol_special (struct gdbarch *gdbarch,
3142                                        gdbarch_coff_make_msymbol_special_ftype coff_make_msymbol_special)
3143 {
3144   gdbarch->coff_make_msymbol_special = coff_make_msymbol_special;
3145 }
3146
3147 int
3148 gdbarch_cannot_step_breakpoint (struct gdbarch *gdbarch)
3149 {
3150   gdb_assert (gdbarch != NULL);
3151   /* Skip verify of cannot_step_breakpoint, invalid_p == 0 */
3152   if (gdbarch_debug >= 2)
3153     fprintf_unfiltered (gdb_stdlog, "gdbarch_cannot_step_breakpoint called\n");
3154   return gdbarch->cannot_step_breakpoint;
3155 }
3156
3157 void
3158 set_gdbarch_cannot_step_breakpoint (struct gdbarch *gdbarch,
3159                                     int cannot_step_breakpoint)
3160 {
3161   gdbarch->cannot_step_breakpoint = cannot_step_breakpoint;
3162 }
3163
3164 int
3165 gdbarch_have_nonsteppable_watchpoint (struct gdbarch *gdbarch)
3166 {
3167   gdb_assert (gdbarch != NULL);
3168   /* Skip verify of have_nonsteppable_watchpoint, invalid_p == 0 */
3169   if (gdbarch_debug >= 2)
3170     fprintf_unfiltered (gdb_stdlog, "gdbarch_have_nonsteppable_watchpoint called\n");
3171   return gdbarch->have_nonsteppable_watchpoint;
3172 }
3173
3174 void
3175 set_gdbarch_have_nonsteppable_watchpoint (struct gdbarch *gdbarch,
3176                                           int have_nonsteppable_watchpoint)
3177 {
3178   gdbarch->have_nonsteppable_watchpoint = have_nonsteppable_watchpoint;
3179 }
3180
3181 int
3182 gdbarch_address_class_type_flags_p (struct gdbarch *gdbarch)
3183 {
3184   gdb_assert (gdbarch != NULL);
3185   return gdbarch->address_class_type_flags != NULL;
3186 }
3187
3188 int
3189 gdbarch_address_class_type_flags (struct gdbarch *gdbarch, int byte_size, int dwarf2_addr_class)
3190 {
3191   gdb_assert (gdbarch != NULL);
3192   gdb_assert (gdbarch->address_class_type_flags != NULL);
3193   if (gdbarch_debug >= 2)
3194     fprintf_unfiltered (gdb_stdlog, "gdbarch_address_class_type_flags called\n");
3195   return gdbarch->address_class_type_flags (byte_size, dwarf2_addr_class);
3196 }
3197
3198 void
3199 set_gdbarch_address_class_type_flags (struct gdbarch *gdbarch,
3200                                       gdbarch_address_class_type_flags_ftype address_class_type_flags)
3201 {
3202   gdbarch->address_class_type_flags = address_class_type_flags;
3203 }
3204
3205 int
3206 gdbarch_address_class_type_flags_to_name_p (struct gdbarch *gdbarch)
3207 {
3208   gdb_assert (gdbarch != NULL);
3209   return gdbarch->address_class_type_flags_to_name != NULL;
3210 }
3211
3212 const char *
3213 gdbarch_address_class_type_flags_to_name (struct gdbarch *gdbarch, int type_flags)
3214 {
3215   gdb_assert (gdbarch != NULL);
3216   gdb_assert (gdbarch->address_class_type_flags_to_name != NULL);
3217   if (gdbarch_debug >= 2)
3218     fprintf_unfiltered (gdb_stdlog, "gdbarch_address_class_type_flags_to_name called\n");
3219   return gdbarch->address_class_type_flags_to_name (gdbarch, type_flags);
3220 }
3221
3222 void
3223 set_gdbarch_address_class_type_flags_to_name (struct gdbarch *gdbarch,
3224                                               gdbarch_address_class_type_flags_to_name_ftype address_class_type_flags_to_name)
3225 {
3226   gdbarch->address_class_type_flags_to_name = address_class_type_flags_to_name;
3227 }
3228
3229 int
3230 gdbarch_address_class_name_to_type_flags_p (struct gdbarch *gdbarch)
3231 {
3232   gdb_assert (gdbarch != NULL);
3233   return gdbarch->address_class_name_to_type_flags != NULL;
3234 }
3235
3236 int
3237 gdbarch_address_class_name_to_type_flags (struct gdbarch *gdbarch, const char *name, int *type_flags_ptr)
3238 {
3239   gdb_assert (gdbarch != NULL);
3240   gdb_assert (gdbarch->address_class_name_to_type_flags != NULL);
3241   if (gdbarch_debug >= 2)
3242     fprintf_unfiltered (gdb_stdlog, "gdbarch_address_class_name_to_type_flags called\n");
3243   return gdbarch->address_class_name_to_type_flags (gdbarch, name, type_flags_ptr);
3244 }
3245
3246 void
3247 set_gdbarch_address_class_name_to_type_flags (struct gdbarch *gdbarch,
3248                                               gdbarch_address_class_name_to_type_flags_ftype address_class_name_to_type_flags)
3249 {
3250   gdbarch->address_class_name_to_type_flags = address_class_name_to_type_flags;
3251 }
3252
3253 int
3254 gdbarch_register_reggroup_p (struct gdbarch *gdbarch, int regnum, struct reggroup *reggroup)
3255 {
3256   gdb_assert (gdbarch != NULL);
3257   gdb_assert (gdbarch->register_reggroup_p != NULL);
3258   if (gdbarch_debug >= 2)
3259     fprintf_unfiltered (gdb_stdlog, "gdbarch_register_reggroup_p called\n");
3260   return gdbarch->register_reggroup_p (gdbarch, regnum, reggroup);
3261 }
3262
3263 void
3264 set_gdbarch_register_reggroup_p (struct gdbarch *gdbarch,
3265                                  gdbarch_register_reggroup_p_ftype register_reggroup_p)
3266 {
3267   gdbarch->register_reggroup_p = register_reggroup_p;
3268 }
3269
3270 int
3271 gdbarch_fetch_pointer_argument_p (struct gdbarch *gdbarch)
3272 {
3273   gdb_assert (gdbarch != NULL);
3274   return gdbarch->fetch_pointer_argument != NULL;
3275 }
3276
3277 CORE_ADDR
3278 gdbarch_fetch_pointer_argument (struct gdbarch *gdbarch, struct frame_info *frame, int argi, struct type *type)
3279 {
3280   gdb_assert (gdbarch != NULL);
3281   gdb_assert (gdbarch->fetch_pointer_argument != NULL);
3282   if (gdbarch_debug >= 2)
3283     fprintf_unfiltered (gdb_stdlog, "gdbarch_fetch_pointer_argument called\n");
3284   return gdbarch->fetch_pointer_argument (frame, argi, type);
3285 }
3286
3287 void
3288 set_gdbarch_fetch_pointer_argument (struct gdbarch *gdbarch,
3289                                     gdbarch_fetch_pointer_argument_ftype fetch_pointer_argument)
3290 {
3291   gdbarch->fetch_pointer_argument = fetch_pointer_argument;
3292 }
3293
3294 int
3295 gdbarch_regset_from_core_section_p (struct gdbarch *gdbarch)
3296 {
3297   gdb_assert (gdbarch != NULL);
3298   return gdbarch->regset_from_core_section != NULL;
3299 }
3300
3301 const struct regset *
3302 gdbarch_regset_from_core_section (struct gdbarch *gdbarch, const char *sect_name, size_t sect_size)
3303 {
3304   gdb_assert (gdbarch != NULL);
3305   gdb_assert (gdbarch->regset_from_core_section != NULL);
3306   if (gdbarch_debug >= 2)
3307     fprintf_unfiltered (gdb_stdlog, "gdbarch_regset_from_core_section called\n");
3308   return gdbarch->regset_from_core_section (gdbarch, sect_name, sect_size);
3309 }
3310
3311 void
3312 set_gdbarch_regset_from_core_section (struct gdbarch *gdbarch,
3313                                       gdbarch_regset_from_core_section_ftype regset_from_core_section)
3314 {
3315   gdbarch->regset_from_core_section = regset_from_core_section;
3316 }
3317
3318 struct core_regset_section *
3319 gdbarch_core_regset_sections (struct gdbarch *gdbarch)
3320 {
3321   gdb_assert (gdbarch != NULL);
3322   if (gdbarch_debug >= 2)
3323     fprintf_unfiltered (gdb_stdlog, "gdbarch_core_regset_sections called\n");
3324   return gdbarch->core_regset_sections;
3325 }
3326
3327 void
3328 set_gdbarch_core_regset_sections (struct gdbarch *gdbarch,
3329                                   struct core_regset_section * core_regset_sections)
3330 {
3331   gdbarch->core_regset_sections = core_regset_sections;
3332 }
3333
3334 int
3335 gdbarch_make_corefile_notes_p (struct gdbarch *gdbarch)
3336 {
3337   gdb_assert (gdbarch != NULL);
3338   return gdbarch->make_corefile_notes != NULL;
3339 }
3340
3341 char *
3342 gdbarch_make_corefile_notes (struct gdbarch *gdbarch, bfd *obfd, int *note_size)
3343 {
3344   gdb_assert (gdbarch != NULL);
3345   gdb_assert (gdbarch->make_corefile_notes != NULL);
3346   if (gdbarch_debug >= 2)
3347     fprintf_unfiltered (gdb_stdlog, "gdbarch_make_corefile_notes called\n");
3348   return gdbarch->make_corefile_notes (gdbarch, obfd, note_size);
3349 }
3350
3351 void
3352 set_gdbarch_make_corefile_notes (struct gdbarch *gdbarch,
3353                                  gdbarch_make_corefile_notes_ftype make_corefile_notes)
3354 {
3355   gdbarch->make_corefile_notes = make_corefile_notes;
3356 }
3357
3358 int
3359 gdbarch_find_memory_regions_p (struct gdbarch *gdbarch)
3360 {
3361   gdb_assert (gdbarch != NULL);
3362   return gdbarch->find_memory_regions != NULL;
3363 }
3364
3365 int
3366 gdbarch_find_memory_regions (struct gdbarch *gdbarch, find_memory_region_ftype func, void *data)
3367 {
3368   gdb_assert (gdbarch != NULL);
3369   gdb_assert (gdbarch->find_memory_regions != NULL);
3370   if (gdbarch_debug >= 2)
3371     fprintf_unfiltered (gdb_stdlog, "gdbarch_find_memory_regions called\n");
3372   return gdbarch->find_memory_regions (gdbarch, func, data);
3373 }
3374
3375 void
3376 set_gdbarch_find_memory_regions (struct gdbarch *gdbarch,
3377                                  gdbarch_find_memory_regions_ftype find_memory_regions)
3378 {
3379   gdbarch->find_memory_regions = find_memory_regions;
3380 }
3381
3382 int
3383 gdbarch_core_xfer_shared_libraries_p (struct gdbarch *gdbarch)
3384 {
3385   gdb_assert (gdbarch != NULL);
3386   return gdbarch->core_xfer_shared_libraries != NULL;
3387 }
3388
3389 LONGEST
3390 gdbarch_core_xfer_shared_libraries (struct gdbarch *gdbarch, gdb_byte *readbuf, ULONGEST offset, LONGEST len)
3391 {
3392   gdb_assert (gdbarch != NULL);
3393   gdb_assert (gdbarch->core_xfer_shared_libraries != NULL);
3394   if (gdbarch_debug >= 2)
3395     fprintf_unfiltered (gdb_stdlog, "gdbarch_core_xfer_shared_libraries called\n");
3396   return gdbarch->core_xfer_shared_libraries (gdbarch, readbuf, offset, len);
3397 }
3398
3399 void
3400 set_gdbarch_core_xfer_shared_libraries (struct gdbarch *gdbarch,
3401                                         gdbarch_core_xfer_shared_libraries_ftype core_xfer_shared_libraries)
3402 {
3403   gdbarch->core_xfer_shared_libraries = core_xfer_shared_libraries;
3404 }
3405
3406 int
3407 gdbarch_core_pid_to_str_p (struct gdbarch *gdbarch)
3408 {
3409   gdb_assert (gdbarch != NULL);
3410   return gdbarch->core_pid_to_str != NULL;
3411 }
3412
3413 char *
3414 gdbarch_core_pid_to_str (struct gdbarch *gdbarch, ptid_t ptid)
3415 {
3416   gdb_assert (gdbarch != NULL);
3417   gdb_assert (gdbarch->core_pid_to_str != NULL);
3418   if (gdbarch_debug >= 2)
3419     fprintf_unfiltered (gdb_stdlog, "gdbarch_core_pid_to_str called\n");
3420   return gdbarch->core_pid_to_str (gdbarch, ptid);
3421 }
3422
3423 void
3424 set_gdbarch_core_pid_to_str (struct gdbarch *gdbarch,
3425                              gdbarch_core_pid_to_str_ftype core_pid_to_str)
3426 {
3427   gdbarch->core_pid_to_str = core_pid_to_str;
3428 }
3429
3430 int
3431 gdbarch_gcore_bfd_target_p (struct gdbarch *gdbarch)
3432 {
3433   gdb_assert (gdbarch != NULL);
3434   return gdbarch->gcore_bfd_target != 0;
3435 }
3436
3437 const char *
3438 gdbarch_gcore_bfd_target (struct gdbarch *gdbarch)
3439 {
3440   gdb_assert (gdbarch != NULL);
3441   /* Check variable changed from pre-default.  */
3442   gdb_assert (gdbarch->gcore_bfd_target != 0);
3443   if (gdbarch_debug >= 2)
3444     fprintf_unfiltered (gdb_stdlog, "gdbarch_gcore_bfd_target called\n");
3445   return gdbarch->gcore_bfd_target;
3446 }
3447
3448 void
3449 set_gdbarch_gcore_bfd_target (struct gdbarch *gdbarch,
3450                               const char * gcore_bfd_target)
3451 {
3452   gdbarch->gcore_bfd_target = gcore_bfd_target;
3453 }
3454
3455 int
3456 gdbarch_vtable_function_descriptors (struct gdbarch *gdbarch)
3457 {
3458   gdb_assert (gdbarch != NULL);
3459   /* Skip verify of vtable_function_descriptors, invalid_p == 0 */
3460   if (gdbarch_debug >= 2)
3461     fprintf_unfiltered (gdb_stdlog, "gdbarch_vtable_function_descriptors called\n");
3462   return gdbarch->vtable_function_descriptors;
3463 }
3464
3465 void
3466 set_gdbarch_vtable_function_descriptors (struct gdbarch *gdbarch,
3467                                          int vtable_function_descriptors)
3468 {
3469   gdbarch->vtable_function_descriptors = vtable_function_descriptors;
3470 }
3471
3472 int
3473 gdbarch_vbit_in_delta (struct gdbarch *gdbarch)
3474 {
3475   gdb_assert (gdbarch != NULL);
3476   /* Skip verify of vbit_in_delta, invalid_p == 0 */
3477   if (gdbarch_debug >= 2)
3478     fprintf_unfiltered (gdb_stdlog, "gdbarch_vbit_in_delta called\n");
3479   return gdbarch->vbit_in_delta;
3480 }
3481
3482 void
3483 set_gdbarch_vbit_in_delta (struct gdbarch *gdbarch,
3484                            int vbit_in_delta)
3485 {
3486   gdbarch->vbit_in_delta = vbit_in_delta;
3487 }
3488
3489 int
3490 gdbarch_skip_permanent_breakpoint_p (struct gdbarch *gdbarch)
3491 {
3492   gdb_assert (gdbarch != NULL);
3493   return gdbarch->skip_permanent_breakpoint != NULL;
3494 }
3495
3496 void
3497 gdbarch_skip_permanent_breakpoint (struct gdbarch *gdbarch, struct regcache *regcache)
3498 {
3499   gdb_assert (gdbarch != NULL);
3500   gdb_assert (gdbarch->skip_permanent_breakpoint != NULL);
3501   if (gdbarch_debug >= 2)
3502     fprintf_unfiltered (gdb_stdlog, "gdbarch_skip_permanent_breakpoint called\n");
3503   gdbarch->skip_permanent_breakpoint (regcache);
3504 }
3505
3506 void
3507 set_gdbarch_skip_permanent_breakpoint (struct gdbarch *gdbarch,
3508                                        gdbarch_skip_permanent_breakpoint_ftype skip_permanent_breakpoint)
3509 {
3510   gdbarch->skip_permanent_breakpoint = skip_permanent_breakpoint;
3511 }
3512
3513 int
3514 gdbarch_max_insn_length_p (struct gdbarch *gdbarch)
3515 {
3516   gdb_assert (gdbarch != NULL);
3517   return gdbarch->max_insn_length != 0;
3518 }
3519
3520 ULONGEST
3521 gdbarch_max_insn_length (struct gdbarch *gdbarch)
3522 {
3523   gdb_assert (gdbarch != NULL);
3524   /* Check variable changed from pre-default.  */
3525   gdb_assert (gdbarch->max_insn_length != 0);
3526   if (gdbarch_debug >= 2)
3527     fprintf_unfiltered (gdb_stdlog, "gdbarch_max_insn_length called\n");
3528   return gdbarch->max_insn_length;
3529 }
3530
3531 void
3532 set_gdbarch_max_insn_length (struct gdbarch *gdbarch,
3533                              ULONGEST max_insn_length)
3534 {
3535   gdbarch->max_insn_length = max_insn_length;
3536 }
3537
3538 int
3539 gdbarch_displaced_step_copy_insn_p (struct gdbarch *gdbarch)
3540 {
3541   gdb_assert (gdbarch != NULL);
3542   return gdbarch->displaced_step_copy_insn != NULL;
3543 }
3544
3545 struct displaced_step_closure *
3546 gdbarch_displaced_step_copy_insn (struct gdbarch *gdbarch, CORE_ADDR from, CORE_ADDR to, struct regcache *regs)
3547 {
3548   gdb_assert (gdbarch != NULL);
3549   gdb_assert (gdbarch->displaced_step_copy_insn != NULL);
3550   if (gdbarch_debug >= 2)
3551     fprintf_unfiltered (gdb_stdlog, "gdbarch_displaced_step_copy_insn called\n");
3552   return gdbarch->displaced_step_copy_insn (gdbarch, from, to, regs);
3553 }
3554
3555 void
3556 set_gdbarch_displaced_step_copy_insn (struct gdbarch *gdbarch,
3557                                       gdbarch_displaced_step_copy_insn_ftype displaced_step_copy_insn)
3558 {
3559   gdbarch->displaced_step_copy_insn = displaced_step_copy_insn;
3560 }
3561
3562 int
3563 gdbarch_displaced_step_hw_singlestep (struct gdbarch *gdbarch, struct displaced_step_closure *closure)
3564 {
3565   gdb_assert (gdbarch != NULL);
3566   gdb_assert (gdbarch->displaced_step_hw_singlestep != NULL);
3567   if (gdbarch_debug >= 2)
3568     fprintf_unfiltered (gdb_stdlog, "gdbarch_displaced_step_hw_singlestep called\n");
3569   return gdbarch->displaced_step_hw_singlestep (gdbarch, closure);
3570 }
3571
3572 void
3573 set_gdbarch_displaced_step_hw_singlestep (struct gdbarch *gdbarch,
3574                                           gdbarch_displaced_step_hw_singlestep_ftype displaced_step_hw_singlestep)
3575 {
3576   gdbarch->displaced_step_hw_singlestep = displaced_step_hw_singlestep;
3577 }
3578
3579 int
3580 gdbarch_displaced_step_fixup_p (struct gdbarch *gdbarch)
3581 {
3582   gdb_assert (gdbarch != NULL);
3583   return gdbarch->displaced_step_fixup != NULL;
3584 }
3585
3586 void
3587 gdbarch_displaced_step_fixup (struct gdbarch *gdbarch, struct displaced_step_closure *closure, CORE_ADDR from, CORE_ADDR to, struct regcache *regs)
3588 {
3589   gdb_assert (gdbarch != NULL);
3590   gdb_assert (gdbarch->displaced_step_fixup != NULL);
3591   /* Do not check predicate: gdbarch->displaced_step_fixup != NULL, allow call.  */
3592   if (gdbarch_debug >= 2)
3593     fprintf_unfiltered (gdb_stdlog, "gdbarch_displaced_step_fixup called\n");
3594   gdbarch->displaced_step_fixup (gdbarch, closure, from, to, regs);
3595 }
3596
3597 void
3598 set_gdbarch_displaced_step_fixup (struct gdbarch *gdbarch,
3599                                   gdbarch_displaced_step_fixup_ftype displaced_step_fixup)
3600 {
3601   gdbarch->displaced_step_fixup = displaced_step_fixup;
3602 }
3603
3604 void
3605 gdbarch_displaced_step_free_closure (struct gdbarch *gdbarch, struct displaced_step_closure *closure)
3606 {
3607   gdb_assert (gdbarch != NULL);
3608   gdb_assert (gdbarch->displaced_step_free_closure != NULL);
3609   if (gdbarch_debug >= 2)
3610     fprintf_unfiltered (gdb_stdlog, "gdbarch_displaced_step_free_closure called\n");
3611   gdbarch->displaced_step_free_closure (gdbarch, closure);
3612 }
3613
3614 void
3615 set_gdbarch_displaced_step_free_closure (struct gdbarch *gdbarch,
3616                                          gdbarch_displaced_step_free_closure_ftype displaced_step_free_closure)
3617 {
3618   gdbarch->displaced_step_free_closure = displaced_step_free_closure;
3619 }
3620
3621 CORE_ADDR
3622 gdbarch_displaced_step_location (struct gdbarch *gdbarch)
3623 {
3624   gdb_assert (gdbarch != NULL);
3625   gdb_assert (gdbarch->displaced_step_location != NULL);
3626   if (gdbarch_debug >= 2)
3627     fprintf_unfiltered (gdb_stdlog, "gdbarch_displaced_step_location called\n");
3628   return gdbarch->displaced_step_location (gdbarch);
3629 }
3630
3631 void
3632 set_gdbarch_displaced_step_location (struct gdbarch *gdbarch,
3633                                      gdbarch_displaced_step_location_ftype displaced_step_location)
3634 {
3635   gdbarch->displaced_step_location = displaced_step_location;
3636 }
3637
3638 int
3639 gdbarch_relocate_instruction_p (struct gdbarch *gdbarch)
3640 {
3641   gdb_assert (gdbarch != NULL);
3642   return gdbarch->relocate_instruction != NULL;
3643 }
3644
3645 void
3646 gdbarch_relocate_instruction (struct gdbarch *gdbarch, CORE_ADDR *to, CORE_ADDR from)
3647 {
3648   gdb_assert (gdbarch != NULL);
3649   gdb_assert (gdbarch->relocate_instruction != NULL);
3650   /* Do not check predicate: gdbarch->relocate_instruction != NULL, allow call.  */
3651   if (gdbarch_debug >= 2)
3652     fprintf_unfiltered (gdb_stdlog, "gdbarch_relocate_instruction called\n");
3653   gdbarch->relocate_instruction (gdbarch, to, from);
3654 }
3655
3656 void
3657 set_gdbarch_relocate_instruction (struct gdbarch *gdbarch,
3658                                   gdbarch_relocate_instruction_ftype relocate_instruction)
3659 {
3660   gdbarch->relocate_instruction = relocate_instruction;
3661 }
3662
3663 int
3664 gdbarch_overlay_update_p (struct gdbarch *gdbarch)
3665 {
3666   gdb_assert (gdbarch != NULL);
3667   return gdbarch->overlay_update != NULL;
3668 }
3669
3670 void
3671 gdbarch_overlay_update (struct gdbarch *gdbarch, struct obj_section *osect)
3672 {
3673   gdb_assert (gdbarch != NULL);
3674   gdb_assert (gdbarch->overlay_update != NULL);
3675   if (gdbarch_debug >= 2)
3676     fprintf_unfiltered (gdb_stdlog, "gdbarch_overlay_update called\n");
3677   gdbarch->overlay_update (osect);
3678 }
3679
3680 void
3681 set_gdbarch_overlay_update (struct gdbarch *gdbarch,
3682                             gdbarch_overlay_update_ftype overlay_update)
3683 {
3684   gdbarch->overlay_update = overlay_update;
3685 }
3686
3687 int
3688 gdbarch_core_read_description_p (struct gdbarch *gdbarch)
3689 {
3690   gdb_assert (gdbarch != NULL);
3691   return gdbarch->core_read_description != NULL;
3692 }
3693
3694 const struct target_desc *
3695 gdbarch_core_read_description (struct gdbarch *gdbarch, struct target_ops *target, bfd *abfd)
3696 {
3697   gdb_assert (gdbarch != NULL);
3698   gdb_assert (gdbarch->core_read_description != NULL);
3699   if (gdbarch_debug >= 2)
3700     fprintf_unfiltered (gdb_stdlog, "gdbarch_core_read_description called\n");
3701   return gdbarch->core_read_description (gdbarch, target, abfd);
3702 }
3703
3704 void
3705 set_gdbarch_core_read_description (struct gdbarch *gdbarch,
3706                                    gdbarch_core_read_description_ftype core_read_description)
3707 {
3708   gdbarch->core_read_description = core_read_description;
3709 }
3710
3711 int
3712 gdbarch_static_transform_name_p (struct gdbarch *gdbarch)
3713 {
3714   gdb_assert (gdbarch != NULL);
3715   return gdbarch->static_transform_name != NULL;
3716 }
3717
3718 const char *
3719 gdbarch_static_transform_name (struct gdbarch *gdbarch, const char *name)
3720 {
3721   gdb_assert (gdbarch != NULL);
3722   gdb_assert (gdbarch->static_transform_name != NULL);
3723   if (gdbarch_debug >= 2)
3724     fprintf_unfiltered (gdb_stdlog, "gdbarch_static_transform_name called\n");
3725   return gdbarch->static_transform_name (name);
3726 }
3727
3728 void
3729 set_gdbarch_static_transform_name (struct gdbarch *gdbarch,
3730                                    gdbarch_static_transform_name_ftype static_transform_name)
3731 {
3732   gdbarch->static_transform_name = static_transform_name;
3733 }
3734
3735 int
3736 gdbarch_sofun_address_maybe_missing (struct gdbarch *gdbarch)
3737 {
3738   gdb_assert (gdbarch != NULL);
3739   /* Skip verify of sofun_address_maybe_missing, invalid_p == 0 */
3740   if (gdbarch_debug >= 2)
3741     fprintf_unfiltered (gdb_stdlog, "gdbarch_sofun_address_maybe_missing called\n");
3742   return gdbarch->sofun_address_maybe_missing;
3743 }
3744
3745 void
3746 set_gdbarch_sofun_address_maybe_missing (struct gdbarch *gdbarch,
3747                                          int sofun_address_maybe_missing)
3748 {
3749   gdbarch->sofun_address_maybe_missing = sofun_address_maybe_missing;
3750 }
3751
3752 int
3753 gdbarch_process_record_p (struct gdbarch *gdbarch)
3754 {
3755   gdb_assert (gdbarch != NULL);
3756   return gdbarch->process_record != NULL;
3757 }
3758
3759 int
3760 gdbarch_process_record (struct gdbarch *gdbarch, struct regcache *regcache, CORE_ADDR addr)
3761 {
3762   gdb_assert (gdbarch != NULL);
3763   gdb_assert (gdbarch->process_record != NULL);
3764   if (gdbarch_debug >= 2)
3765     fprintf_unfiltered (gdb_stdlog, "gdbarch_process_record called\n");
3766   return gdbarch->process_record (gdbarch, regcache, addr);
3767 }
3768
3769 void
3770 set_gdbarch_process_record (struct gdbarch *gdbarch,
3771                             gdbarch_process_record_ftype process_record)
3772 {
3773   gdbarch->process_record = process_record;
3774 }
3775
3776 int
3777 gdbarch_process_record_signal_p (struct gdbarch *gdbarch)
3778 {
3779   gdb_assert (gdbarch != NULL);
3780   return gdbarch->process_record_signal != NULL;
3781 }
3782
3783 int
3784 gdbarch_process_record_signal (struct gdbarch *gdbarch, struct regcache *regcache, enum gdb_signal signal)
3785 {
3786   gdb_assert (gdbarch != NULL);
3787   gdb_assert (gdbarch->process_record_signal != NULL);
3788   if (gdbarch_debug >= 2)
3789     fprintf_unfiltered (gdb_stdlog, "gdbarch_process_record_signal called\n");
3790   return gdbarch->process_record_signal (gdbarch, regcache, signal);
3791 }
3792
3793 void
3794 set_gdbarch_process_record_signal (struct gdbarch *gdbarch,
3795                                    gdbarch_process_record_signal_ftype process_record_signal)
3796 {
3797   gdbarch->process_record_signal = process_record_signal;
3798 }
3799
3800 int
3801 gdbarch_gdb_signal_from_target_p (struct gdbarch *gdbarch)
3802 {
3803   gdb_assert (gdbarch != NULL);
3804   return gdbarch->gdb_signal_from_target != NULL;
3805 }
3806
3807 enum gdb_signal
3808 gdbarch_gdb_signal_from_target (struct gdbarch *gdbarch, int signo)
3809 {
3810   gdb_assert (gdbarch != NULL);
3811   gdb_assert (gdbarch->gdb_signal_from_target != NULL);
3812   if (gdbarch_debug >= 2)
3813     fprintf_unfiltered (gdb_stdlog, "gdbarch_gdb_signal_from_target called\n");
3814   return gdbarch->gdb_signal_from_target (gdbarch, signo);
3815 }
3816
3817 void
3818 set_gdbarch_gdb_signal_from_target (struct gdbarch *gdbarch,
3819                                     gdbarch_gdb_signal_from_target_ftype gdb_signal_from_target)
3820 {
3821   gdbarch->gdb_signal_from_target = gdb_signal_from_target;
3822 }
3823
3824 int
3825 gdbarch_get_siginfo_type_p (struct gdbarch *gdbarch)
3826 {
3827   gdb_assert (gdbarch != NULL);
3828   return gdbarch->get_siginfo_type != NULL;
3829 }
3830
3831 struct type *
3832 gdbarch_get_siginfo_type (struct gdbarch *gdbarch)
3833 {
3834   gdb_assert (gdbarch != NULL);
3835   gdb_assert (gdbarch->get_siginfo_type != NULL);
3836   if (gdbarch_debug >= 2)
3837     fprintf_unfiltered (gdb_stdlog, "gdbarch_get_siginfo_type called\n");
3838   return gdbarch->get_siginfo_type (gdbarch);
3839 }
3840
3841 void
3842 set_gdbarch_get_siginfo_type (struct gdbarch *gdbarch,
3843                               gdbarch_get_siginfo_type_ftype get_siginfo_type)
3844 {
3845   gdbarch->get_siginfo_type = get_siginfo_type;
3846 }
3847
3848 int
3849 gdbarch_record_special_symbol_p (struct gdbarch *gdbarch)
3850 {
3851   gdb_assert (gdbarch != NULL);
3852   return gdbarch->record_special_symbol != NULL;
3853 }
3854
3855 void
3856 gdbarch_record_special_symbol (struct gdbarch *gdbarch, struct objfile *objfile, asymbol *sym)
3857 {
3858   gdb_assert (gdbarch != NULL);
3859   gdb_assert (gdbarch->record_special_symbol != NULL);
3860   if (gdbarch_debug >= 2)
3861     fprintf_unfiltered (gdb_stdlog, "gdbarch_record_special_symbol called\n");
3862   gdbarch->record_special_symbol (gdbarch, objfile, sym);
3863 }
3864
3865 void
3866 set_gdbarch_record_special_symbol (struct gdbarch *gdbarch,
3867                                    gdbarch_record_special_symbol_ftype record_special_symbol)
3868 {
3869   gdbarch->record_special_symbol = record_special_symbol;
3870 }
3871
3872 int
3873 gdbarch_get_syscall_number_p (struct gdbarch *gdbarch)
3874 {
3875   gdb_assert (gdbarch != NULL);
3876   return gdbarch->get_syscall_number != NULL;
3877 }
3878
3879 LONGEST
3880 gdbarch_get_syscall_number (struct gdbarch *gdbarch, ptid_t ptid)
3881 {
3882   gdb_assert (gdbarch != NULL);
3883   gdb_assert (gdbarch->get_syscall_number != NULL);
3884   if (gdbarch_debug >= 2)
3885     fprintf_unfiltered (gdb_stdlog, "gdbarch_get_syscall_number called\n");
3886   return gdbarch->get_syscall_number (gdbarch, ptid);
3887 }
3888
3889 void
3890 set_gdbarch_get_syscall_number (struct gdbarch *gdbarch,
3891                                 gdbarch_get_syscall_number_ftype get_syscall_number)
3892 {
3893   gdbarch->get_syscall_number = get_syscall_number;
3894 }
3895
3896 const char *
3897 gdbarch_stap_integer_prefix (struct gdbarch *gdbarch)
3898 {
3899   gdb_assert (gdbarch != NULL);
3900   /* Skip verify of stap_integer_prefix, invalid_p == 0 */
3901   if (gdbarch_debug >= 2)
3902     fprintf_unfiltered (gdb_stdlog, "gdbarch_stap_integer_prefix called\n");
3903   return gdbarch->stap_integer_prefix;
3904 }
3905
3906 void
3907 set_gdbarch_stap_integer_prefix (struct gdbarch *gdbarch,
3908                                  const char * stap_integer_prefix)
3909 {
3910   gdbarch->stap_integer_prefix = stap_integer_prefix;
3911 }
3912
3913 const char *
3914 gdbarch_stap_integer_suffix (struct gdbarch *gdbarch)
3915 {
3916   gdb_assert (gdbarch != NULL);
3917   /* Skip verify of stap_integer_suffix, invalid_p == 0 */
3918   if (gdbarch_debug >= 2)
3919     fprintf_unfiltered (gdb_stdlog, "gdbarch_stap_integer_suffix called\n");
3920   return gdbarch->stap_integer_suffix;
3921 }
3922
3923 void
3924 set_gdbarch_stap_integer_suffix (struct gdbarch *gdbarch,
3925                                  const char * stap_integer_suffix)
3926 {
3927   gdbarch->stap_integer_suffix = stap_integer_suffix;
3928 }
3929
3930 const char *
3931 gdbarch_stap_register_prefix (struct gdbarch *gdbarch)
3932 {
3933   gdb_assert (gdbarch != NULL);
3934   /* Skip verify of stap_register_prefix, invalid_p == 0 */
3935   if (gdbarch_debug >= 2)
3936     fprintf_unfiltered (gdb_stdlog, "gdbarch_stap_register_prefix called\n");
3937   return gdbarch->stap_register_prefix;
3938 }
3939
3940 void
3941 set_gdbarch_stap_register_prefix (struct gdbarch *gdbarch,
3942                                   const char * stap_register_prefix)
3943 {
3944   gdbarch->stap_register_prefix = stap_register_prefix;
3945 }
3946
3947 const char *
3948 gdbarch_stap_register_suffix (struct gdbarch *gdbarch)
3949 {
3950   gdb_assert (gdbarch != NULL);
3951   /* Skip verify of stap_register_suffix, invalid_p == 0 */
3952   if (gdbarch_debug >= 2)
3953     fprintf_unfiltered (gdb_stdlog, "gdbarch_stap_register_suffix called\n");
3954   return gdbarch->stap_register_suffix;
3955 }
3956
3957 void
3958 set_gdbarch_stap_register_suffix (struct gdbarch *gdbarch,
3959                                   const char * stap_register_suffix)
3960 {
3961   gdbarch->stap_register_suffix = stap_register_suffix;
3962 }
3963
3964 const char *
3965 gdbarch_stap_register_indirection_prefix (struct gdbarch *gdbarch)
3966 {
3967   gdb_assert (gdbarch != NULL);
3968   /* Skip verify of stap_register_indirection_prefix, invalid_p == 0 */
3969   if (gdbarch_debug >= 2)
3970     fprintf_unfiltered (gdb_stdlog, "gdbarch_stap_register_indirection_prefix called\n");
3971   return gdbarch->stap_register_indirection_prefix;
3972 }
3973
3974 void
3975 set_gdbarch_stap_register_indirection_prefix (struct gdbarch *gdbarch,
3976                                               const char * stap_register_indirection_prefix)
3977 {
3978   gdbarch->stap_register_indirection_prefix = stap_register_indirection_prefix;
3979 }
3980
3981 const char *
3982 gdbarch_stap_register_indirection_suffix (struct gdbarch *gdbarch)
3983 {
3984   gdb_assert (gdbarch != NULL);
3985   /* Skip verify of stap_register_indirection_suffix, invalid_p == 0 */
3986   if (gdbarch_debug >= 2)
3987     fprintf_unfiltered (gdb_stdlog, "gdbarch_stap_register_indirection_suffix called\n");
3988   return gdbarch->stap_register_indirection_suffix;
3989 }
3990
3991 void
3992 set_gdbarch_stap_register_indirection_suffix (struct gdbarch *gdbarch,
3993                                               const char * stap_register_indirection_suffix)
3994 {
3995   gdbarch->stap_register_indirection_suffix = stap_register_indirection_suffix;
3996 }
3997
3998 const char *
3999 gdbarch_stap_gdb_register_prefix (struct gdbarch *gdbarch)
4000 {
4001   gdb_assert (gdbarch != NULL);
4002   /* Skip verify of stap_gdb_register_prefix, invalid_p == 0 */
4003   if (gdbarch_debug >= 2)
4004     fprintf_unfiltered (gdb_stdlog, "gdbarch_stap_gdb_register_prefix called\n");
4005   return gdbarch->stap_gdb_register_prefix;
4006 }
4007
4008 void
4009 set_gdbarch_stap_gdb_register_prefix (struct gdbarch *gdbarch,
4010                                       const char * stap_gdb_register_prefix)
4011 {
4012   gdbarch->stap_gdb_register_prefix = stap_gdb_register_prefix;
4013 }
4014
4015 const char *
4016 gdbarch_stap_gdb_register_suffix (struct gdbarch *gdbarch)
4017 {
4018   gdb_assert (gdbarch != NULL);
4019   /* Skip verify of stap_gdb_register_suffix, invalid_p == 0 */
4020   if (gdbarch_debug >= 2)
4021     fprintf_unfiltered (gdb_stdlog, "gdbarch_stap_gdb_register_suffix called\n");
4022   return gdbarch->stap_gdb_register_suffix;
4023 }
4024
4025 void
4026 set_gdbarch_stap_gdb_register_suffix (struct gdbarch *gdbarch,
4027                                       const char * stap_gdb_register_suffix)
4028 {
4029   gdbarch->stap_gdb_register_suffix = stap_gdb_register_suffix;
4030 }
4031
4032 int
4033 gdbarch_stap_is_single_operand_p (struct gdbarch *gdbarch)
4034 {
4035   gdb_assert (gdbarch != NULL);
4036   return gdbarch->stap_is_single_operand != NULL;
4037 }
4038
4039 int
4040 gdbarch_stap_is_single_operand (struct gdbarch *gdbarch, const char *s)
4041 {
4042   gdb_assert (gdbarch != NULL);
4043   gdb_assert (gdbarch->stap_is_single_operand != NULL);
4044   if (gdbarch_debug >= 2)
4045     fprintf_unfiltered (gdb_stdlog, "gdbarch_stap_is_single_operand called\n");
4046   return gdbarch->stap_is_single_operand (gdbarch, s);
4047 }
4048
4049 void
4050 set_gdbarch_stap_is_single_operand (struct gdbarch *gdbarch,
4051                                     gdbarch_stap_is_single_operand_ftype stap_is_single_operand)
4052 {
4053   gdbarch->stap_is_single_operand = stap_is_single_operand;
4054 }
4055
4056 int
4057 gdbarch_stap_parse_special_token_p (struct gdbarch *gdbarch)
4058 {
4059   gdb_assert (gdbarch != NULL);
4060   return gdbarch->stap_parse_special_token != NULL;
4061 }
4062
4063 int
4064 gdbarch_stap_parse_special_token (struct gdbarch *gdbarch, struct stap_parse_info *p)
4065 {
4066   gdb_assert (gdbarch != NULL);
4067   gdb_assert (gdbarch->stap_parse_special_token != NULL);
4068   if (gdbarch_debug >= 2)
4069     fprintf_unfiltered (gdb_stdlog, "gdbarch_stap_parse_special_token called\n");
4070   return gdbarch->stap_parse_special_token (gdbarch, p);
4071 }
4072
4073 void
4074 set_gdbarch_stap_parse_special_token (struct gdbarch *gdbarch,
4075                                       gdbarch_stap_parse_special_token_ftype stap_parse_special_token)
4076 {
4077   gdbarch->stap_parse_special_token = stap_parse_special_token;
4078 }
4079
4080 int
4081 gdbarch_has_global_solist (struct gdbarch *gdbarch)
4082 {
4083   gdb_assert (gdbarch != NULL);
4084   /* Skip verify of has_global_solist, invalid_p == 0 */
4085   if (gdbarch_debug >= 2)
4086     fprintf_unfiltered (gdb_stdlog, "gdbarch_has_global_solist called\n");
4087   return gdbarch->has_global_solist;
4088 }
4089
4090 void
4091 set_gdbarch_has_global_solist (struct gdbarch *gdbarch,
4092                                int has_global_solist)
4093 {
4094   gdbarch->has_global_solist = has_global_solist;
4095 }
4096
4097 int
4098 gdbarch_has_global_breakpoints (struct gdbarch *gdbarch)
4099 {
4100   gdb_assert (gdbarch != NULL);
4101   /* Skip verify of has_global_breakpoints, invalid_p == 0 */
4102   if (gdbarch_debug >= 2)
4103     fprintf_unfiltered (gdb_stdlog, "gdbarch_has_global_breakpoints called\n");
4104   return gdbarch->has_global_breakpoints;
4105 }
4106
4107 void
4108 set_gdbarch_has_global_breakpoints (struct gdbarch *gdbarch,
4109                                     int has_global_breakpoints)
4110 {
4111   gdbarch->has_global_breakpoints = has_global_breakpoints;
4112 }
4113
4114 int
4115 gdbarch_has_shared_address_space (struct gdbarch *gdbarch)
4116 {
4117   gdb_assert (gdbarch != NULL);
4118   gdb_assert (gdbarch->has_shared_address_space != NULL);
4119   if (gdbarch_debug >= 2)
4120     fprintf_unfiltered (gdb_stdlog, "gdbarch_has_shared_address_space called\n");
4121   return gdbarch->has_shared_address_space (gdbarch);
4122 }
4123
4124 void
4125 set_gdbarch_has_shared_address_space (struct gdbarch *gdbarch,
4126                                       gdbarch_has_shared_address_space_ftype has_shared_address_space)
4127 {
4128   gdbarch->has_shared_address_space = has_shared_address_space;
4129 }
4130
4131 int
4132 gdbarch_fast_tracepoint_valid_at (struct gdbarch *gdbarch, CORE_ADDR addr, int *isize, char **msg)
4133 {
4134   gdb_assert (gdbarch != NULL);
4135   gdb_assert (gdbarch->fast_tracepoint_valid_at != NULL);
4136   if (gdbarch_debug >= 2)
4137     fprintf_unfiltered (gdb_stdlog, "gdbarch_fast_tracepoint_valid_at called\n");
4138   return gdbarch->fast_tracepoint_valid_at (gdbarch, addr, isize, msg);
4139 }
4140
4141 void
4142 set_gdbarch_fast_tracepoint_valid_at (struct gdbarch *gdbarch,
4143                                       gdbarch_fast_tracepoint_valid_at_ftype fast_tracepoint_valid_at)
4144 {
4145   gdbarch->fast_tracepoint_valid_at = fast_tracepoint_valid_at;
4146 }
4147
4148 const char *
4149 gdbarch_auto_charset (struct gdbarch *gdbarch)
4150 {
4151   gdb_assert (gdbarch != NULL);
4152   gdb_assert (gdbarch->auto_charset != NULL);
4153   if (gdbarch_debug >= 2)
4154     fprintf_unfiltered (gdb_stdlog, "gdbarch_auto_charset called\n");
4155   return gdbarch->auto_charset ();
4156 }
4157
4158 void
4159 set_gdbarch_auto_charset (struct gdbarch *gdbarch,
4160                           gdbarch_auto_charset_ftype auto_charset)
4161 {
4162   gdbarch->auto_charset = auto_charset;
4163 }
4164
4165 const char *
4166 gdbarch_auto_wide_charset (struct gdbarch *gdbarch)
4167 {
4168   gdb_assert (gdbarch != NULL);
4169   gdb_assert (gdbarch->auto_wide_charset != NULL);
4170   if (gdbarch_debug >= 2)
4171     fprintf_unfiltered (gdb_stdlog, "gdbarch_auto_wide_charset called\n");
4172   return gdbarch->auto_wide_charset ();
4173 }
4174
4175 void
4176 set_gdbarch_auto_wide_charset (struct gdbarch *gdbarch,
4177                                gdbarch_auto_wide_charset_ftype auto_wide_charset)
4178 {
4179   gdbarch->auto_wide_charset = auto_wide_charset;
4180 }
4181
4182 const char *
4183 gdbarch_solib_symbols_extension (struct gdbarch *gdbarch)
4184 {
4185   gdb_assert (gdbarch != NULL);
4186   if (gdbarch_debug >= 2)
4187     fprintf_unfiltered (gdb_stdlog, "gdbarch_solib_symbols_extension called\n");
4188   return gdbarch->solib_symbols_extension;
4189 }
4190
4191 void
4192 set_gdbarch_solib_symbols_extension (struct gdbarch *gdbarch,
4193                                      const char * solib_symbols_extension)
4194 {
4195   gdbarch->solib_symbols_extension = solib_symbols_extension;
4196 }
4197
4198 int
4199 gdbarch_has_dos_based_file_system (struct gdbarch *gdbarch)
4200 {
4201   gdb_assert (gdbarch != NULL);
4202   /* Skip verify of has_dos_based_file_system, invalid_p == 0 */
4203   if (gdbarch_debug >= 2)
4204     fprintf_unfiltered (gdb_stdlog, "gdbarch_has_dos_based_file_system called\n");
4205   return gdbarch->has_dos_based_file_system;
4206 }
4207
4208 void
4209 set_gdbarch_has_dos_based_file_system (struct gdbarch *gdbarch,
4210                                        int has_dos_based_file_system)
4211 {
4212   gdbarch->has_dos_based_file_system = has_dos_based_file_system;
4213 }
4214
4215 void
4216 gdbarch_gen_return_address (struct gdbarch *gdbarch, struct agent_expr *ax, struct axs_value *value, CORE_ADDR scope)
4217 {
4218   gdb_assert (gdbarch != NULL);
4219   gdb_assert (gdbarch->gen_return_address != NULL);
4220   if (gdbarch_debug >= 2)
4221     fprintf_unfiltered (gdb_stdlog, "gdbarch_gen_return_address called\n");
4222   gdbarch->gen_return_address (gdbarch, ax, value, scope);
4223 }
4224
4225 void
4226 set_gdbarch_gen_return_address (struct gdbarch *gdbarch,
4227                                 gdbarch_gen_return_address_ftype gen_return_address)
4228 {
4229   gdbarch->gen_return_address = gen_return_address;
4230 }
4231
4232 int
4233 gdbarch_info_proc_p (struct gdbarch *gdbarch)
4234 {
4235   gdb_assert (gdbarch != NULL);
4236   return gdbarch->info_proc != NULL;
4237 }
4238
4239 void
4240 gdbarch_info_proc (struct gdbarch *gdbarch, char *args, enum info_proc_what what)
4241 {
4242   gdb_assert (gdbarch != NULL);
4243   gdb_assert (gdbarch->info_proc != NULL);
4244   if (gdbarch_debug >= 2)
4245     fprintf_unfiltered (gdb_stdlog, "gdbarch_info_proc called\n");
4246   gdbarch->info_proc (gdbarch, args, what);
4247 }
4248
4249 void
4250 set_gdbarch_info_proc (struct gdbarch *gdbarch,
4251                        gdbarch_info_proc_ftype info_proc)
4252 {
4253   gdbarch->info_proc = info_proc;
4254 }
4255
4256 void
4257 gdbarch_iterate_over_objfiles_in_search_order (struct gdbarch *gdbarch, iterate_over_objfiles_in_search_order_cb_ftype *cb, void *cb_data, struct objfile *current_objfile)
4258 {
4259   gdb_assert (gdbarch != NULL);
4260   gdb_assert (gdbarch->iterate_over_objfiles_in_search_order != NULL);
4261   if (gdbarch_debug >= 2)
4262     fprintf_unfiltered (gdb_stdlog, "gdbarch_iterate_over_objfiles_in_search_order called\n");
4263   gdbarch->iterate_over_objfiles_in_search_order (gdbarch, cb, cb_data, current_objfile);
4264 }
4265
4266 void
4267 set_gdbarch_iterate_over_objfiles_in_search_order (struct gdbarch *gdbarch,
4268                                                    gdbarch_iterate_over_objfiles_in_search_order_ftype iterate_over_objfiles_in_search_order)
4269 {
4270   gdbarch->iterate_over_objfiles_in_search_order = iterate_over_objfiles_in_search_order;
4271 }
4272
4273
4274 /* Keep a registry of per-architecture data-pointers required by GDB
4275    modules.  */
4276
4277 struct gdbarch_data
4278 {
4279   unsigned index;
4280   int init_p;
4281   gdbarch_data_pre_init_ftype *pre_init;
4282   gdbarch_data_post_init_ftype *post_init;
4283 };
4284
4285 struct gdbarch_data_registration
4286 {
4287   struct gdbarch_data *data;
4288   struct gdbarch_data_registration *next;
4289 };
4290
4291 struct gdbarch_data_registry
4292 {
4293   unsigned nr;
4294   struct gdbarch_data_registration *registrations;
4295 };
4296
4297 struct gdbarch_data_registry gdbarch_data_registry =
4298 {
4299   0, NULL,
4300 };
4301
4302 static struct gdbarch_data *
4303 gdbarch_data_register (gdbarch_data_pre_init_ftype *pre_init,
4304                        gdbarch_data_post_init_ftype *post_init)
4305 {
4306   struct gdbarch_data_registration **curr;
4307
4308   /* Append the new registration.  */
4309   for (curr = &gdbarch_data_registry.registrations;
4310        (*curr) != NULL;
4311        curr = &(*curr)->next);
4312   (*curr) = XMALLOC (struct gdbarch_data_registration);
4313   (*curr)->next = NULL;
4314   (*curr)->data = XMALLOC (struct gdbarch_data);
4315   (*curr)->data->index = gdbarch_data_registry.nr++;
4316   (*curr)->data->pre_init = pre_init;
4317   (*curr)->data->post_init = post_init;
4318   (*curr)->data->init_p = 1;
4319   return (*curr)->data;
4320 }
4321
4322 struct gdbarch_data *
4323 gdbarch_data_register_pre_init (gdbarch_data_pre_init_ftype *pre_init)
4324 {
4325   return gdbarch_data_register (pre_init, NULL);
4326 }
4327
4328 struct gdbarch_data *
4329 gdbarch_data_register_post_init (gdbarch_data_post_init_ftype *post_init)
4330 {
4331   return gdbarch_data_register (NULL, post_init);
4332 }
4333
4334 /* Create/delete the gdbarch data vector.  */
4335
4336 static void
4337 alloc_gdbarch_data (struct gdbarch *gdbarch)
4338 {
4339   gdb_assert (gdbarch->data == NULL);
4340   gdbarch->nr_data = gdbarch_data_registry.nr;
4341   gdbarch->data = GDBARCH_OBSTACK_CALLOC (gdbarch, gdbarch->nr_data, void *);
4342 }
4343
4344 /* Initialize the current value of the specified per-architecture
4345    data-pointer.  */
4346
4347 void
4348 deprecated_set_gdbarch_data (struct gdbarch *gdbarch,
4349                              struct gdbarch_data *data,
4350                              void *pointer)
4351 {
4352   gdb_assert (data->index < gdbarch->nr_data);
4353   gdb_assert (gdbarch->data[data->index] == NULL);
4354   gdb_assert (data->pre_init == NULL);
4355   gdbarch->data[data->index] = pointer;
4356 }
4357
4358 /* Return the current value of the specified per-architecture
4359    data-pointer.  */
4360
4361 void *
4362 gdbarch_data (struct gdbarch *gdbarch, struct gdbarch_data *data)
4363 {
4364   gdb_assert (data->index < gdbarch->nr_data);
4365   if (gdbarch->data[data->index] == NULL)
4366     {
4367       /* The data-pointer isn't initialized, call init() to get a
4368          value.  */
4369       if (data->pre_init != NULL)
4370         /* Mid architecture creation: pass just the obstack, and not
4371            the entire architecture, as that way it isn't possible for
4372            pre-init code to refer to undefined architecture
4373            fields.  */
4374         gdbarch->data[data->index] = data->pre_init (gdbarch->obstack);
4375       else if (gdbarch->initialized_p
4376                && data->post_init != NULL)
4377         /* Post architecture creation: pass the entire architecture
4378            (as all fields are valid), but be careful to also detect
4379            recursive references.  */
4380         {
4381           gdb_assert (data->init_p);
4382           data->init_p = 0;
4383           gdbarch->data[data->index] = data->post_init (gdbarch);
4384           data->init_p = 1;
4385         }
4386       else
4387         /* The architecture initialization hasn't completed - punt -
4388          hope that the caller knows what they are doing.  Once
4389          deprecated_set_gdbarch_data has been initialized, this can be
4390          changed to an internal error.  */
4391         return NULL;
4392       gdb_assert (gdbarch->data[data->index] != NULL);
4393     }
4394   return gdbarch->data[data->index];
4395 }
4396
4397
4398 /* Keep a registry of the architectures known by GDB.  */
4399
4400 struct gdbarch_registration
4401 {
4402   enum bfd_architecture bfd_architecture;
4403   gdbarch_init_ftype *init;
4404   gdbarch_dump_tdep_ftype *dump_tdep;
4405   struct gdbarch_list *arches;
4406   struct gdbarch_registration *next;
4407 };
4408
4409 static struct gdbarch_registration *gdbarch_registry = NULL;
4410
4411 static void
4412 append_name (const char ***buf, int *nr, const char *name)
4413 {
4414   *buf = xrealloc (*buf, sizeof (char**) * (*nr + 1));
4415   (*buf)[*nr] = name;
4416   *nr += 1;
4417 }
4418
4419 const char **
4420 gdbarch_printable_names (void)
4421 {
4422   /* Accumulate a list of names based on the registed list of
4423      architectures.  */
4424   int nr_arches = 0;
4425   const char **arches = NULL;
4426   struct gdbarch_registration *rego;
4427
4428   for (rego = gdbarch_registry;
4429        rego != NULL;
4430        rego = rego->next)
4431     {
4432       const struct bfd_arch_info *ap;
4433       ap = bfd_lookup_arch (rego->bfd_architecture, 0);
4434       if (ap == NULL)
4435         internal_error (__FILE__, __LINE__,
4436                         _("gdbarch_architecture_names: multi-arch unknown"));
4437       do
4438         {
4439           append_name (&arches, &nr_arches, ap->printable_name);
4440           ap = ap->next;
4441         }
4442       while (ap != NULL);
4443     }
4444   append_name (&arches, &nr_arches, NULL);
4445   return arches;
4446 }
4447
4448
4449 void
4450 gdbarch_register (enum bfd_architecture bfd_architecture,
4451                   gdbarch_init_ftype *init,
4452                   gdbarch_dump_tdep_ftype *dump_tdep)
4453 {
4454   struct gdbarch_registration **curr;
4455   const struct bfd_arch_info *bfd_arch_info;
4456
4457   /* Check that BFD recognizes this architecture */
4458   bfd_arch_info = bfd_lookup_arch (bfd_architecture, 0);
4459   if (bfd_arch_info == NULL)
4460     {
4461       internal_error (__FILE__, __LINE__,
4462                       _("gdbarch: Attempt to register "
4463                         "unknown architecture (%d)"),
4464                       bfd_architecture);
4465     }
4466   /* Check that we haven't seen this architecture before.  */
4467   for (curr = &gdbarch_registry;
4468        (*curr) != NULL;
4469        curr = &(*curr)->next)
4470     {
4471       if (bfd_architecture == (*curr)->bfd_architecture)
4472         internal_error (__FILE__, __LINE__,
4473                         _("gdbarch: Duplicate registration "
4474                           "of architecture (%s)"),
4475                         bfd_arch_info->printable_name);
4476     }
4477   /* log it */
4478   if (gdbarch_debug)
4479     fprintf_unfiltered (gdb_stdlog, "register_gdbarch_init (%s, %s)\n",
4480                         bfd_arch_info->printable_name,
4481                         host_address_to_string (init));
4482   /* Append it */
4483   (*curr) = XMALLOC (struct gdbarch_registration);
4484   (*curr)->bfd_architecture = bfd_architecture;
4485   (*curr)->init = init;
4486   (*curr)->dump_tdep = dump_tdep;
4487   (*curr)->arches = NULL;
4488   (*curr)->next = NULL;
4489 }
4490
4491 void
4492 register_gdbarch_init (enum bfd_architecture bfd_architecture,
4493                        gdbarch_init_ftype *init)
4494 {
4495   gdbarch_register (bfd_architecture, init, NULL);
4496 }
4497
4498
4499 /* Look for an architecture using gdbarch_info.  */
4500
4501 struct gdbarch_list *
4502 gdbarch_list_lookup_by_info (struct gdbarch_list *arches,
4503                              const struct gdbarch_info *info)
4504 {
4505   for (; arches != NULL; arches = arches->next)
4506     {
4507       if (info->bfd_arch_info != arches->gdbarch->bfd_arch_info)
4508         continue;
4509       if (info->byte_order != arches->gdbarch->byte_order)
4510         continue;
4511       if (info->osabi != arches->gdbarch->osabi)
4512         continue;
4513       if (info->target_desc != arches->gdbarch->target_desc)
4514         continue;
4515       return arches;
4516     }
4517   return NULL;
4518 }
4519
4520
4521 /* Find an architecture that matches the specified INFO.  Create a new
4522    architecture if needed.  Return that new architecture.  */
4523
4524 struct gdbarch *
4525 gdbarch_find_by_info (struct gdbarch_info info)
4526 {
4527   struct gdbarch *new_gdbarch;
4528   struct gdbarch_registration *rego;
4529
4530   /* Fill in missing parts of the INFO struct using a number of
4531      sources: "set ..."; INFOabfd supplied; and the global
4532      defaults.  */
4533   gdbarch_info_fill (&info);
4534
4535   /* Must have found some sort of architecture.  */
4536   gdb_assert (info.bfd_arch_info != NULL);
4537
4538   if (gdbarch_debug)
4539     {
4540       fprintf_unfiltered (gdb_stdlog,
4541                           "gdbarch_find_by_info: info.bfd_arch_info %s\n",
4542                           (info.bfd_arch_info != NULL
4543                            ? info.bfd_arch_info->printable_name
4544                            : "(null)"));
4545       fprintf_unfiltered (gdb_stdlog,
4546                           "gdbarch_find_by_info: info.byte_order %d (%s)\n",
4547                           info.byte_order,
4548                           (info.byte_order == BFD_ENDIAN_BIG ? "big"
4549                            : info.byte_order == BFD_ENDIAN_LITTLE ? "little"
4550                            : "default"));
4551       fprintf_unfiltered (gdb_stdlog,
4552                           "gdbarch_find_by_info: info.osabi %d (%s)\n",
4553                           info.osabi, gdbarch_osabi_name (info.osabi));
4554       fprintf_unfiltered (gdb_stdlog,
4555                           "gdbarch_find_by_info: info.abfd %s\n",
4556                           host_address_to_string (info.abfd));
4557       fprintf_unfiltered (gdb_stdlog,
4558                           "gdbarch_find_by_info: info.tdep_info %s\n",
4559                           host_address_to_string (info.tdep_info));
4560     }
4561
4562   /* Find the tdep code that knows about this architecture.  */
4563   for (rego = gdbarch_registry;
4564        rego != NULL;
4565        rego = rego->next)
4566     if (rego->bfd_architecture == info.bfd_arch_info->arch)
4567       break;
4568   if (rego == NULL)
4569     {
4570       if (gdbarch_debug)
4571         fprintf_unfiltered (gdb_stdlog, "gdbarch_find_by_info: "
4572                             "No matching architecture\n");
4573       return 0;
4574     }
4575
4576   /* Ask the tdep code for an architecture that matches "info".  */
4577   new_gdbarch = rego->init (info, rego->arches);
4578
4579   /* Did the tdep code like it?  No.  Reject the change and revert to
4580      the old architecture.  */
4581   if (new_gdbarch == NULL)
4582     {
4583       if (gdbarch_debug)
4584         fprintf_unfiltered (gdb_stdlog, "gdbarch_find_by_info: "
4585                             "Target rejected architecture\n");
4586       return NULL;
4587     }
4588
4589   /* Is this a pre-existing architecture (as determined by already
4590      being initialized)?  Move it to the front of the architecture
4591      list (keeping the list sorted Most Recently Used).  */
4592   if (new_gdbarch->initialized_p)
4593     {
4594       struct gdbarch_list **list;
4595       struct gdbarch_list *this;
4596       if (gdbarch_debug)
4597         fprintf_unfiltered (gdb_stdlog, "gdbarch_find_by_info: "
4598                             "Previous architecture %s (%s) selected\n",
4599                             host_address_to_string (new_gdbarch),
4600                             new_gdbarch->bfd_arch_info->printable_name);
4601       /* Find the existing arch in the list.  */
4602       for (list = &rego->arches;
4603            (*list) != NULL && (*list)->gdbarch != new_gdbarch;
4604            list = &(*list)->next);
4605       /* It had better be in the list of architectures.  */
4606       gdb_assert ((*list) != NULL && (*list)->gdbarch == new_gdbarch);
4607       /* Unlink THIS.  */
4608       this = (*list);
4609       (*list) = this->next;
4610       /* Insert THIS at the front.  */
4611       this->next = rego->arches;
4612       rego->arches = this;
4613       /* Return it.  */
4614       return new_gdbarch;
4615     }
4616
4617   /* It's a new architecture.  */
4618   if (gdbarch_debug)
4619     fprintf_unfiltered (gdb_stdlog, "gdbarch_find_by_info: "
4620                         "New architecture %s (%s) selected\n",
4621                         host_address_to_string (new_gdbarch),
4622                         new_gdbarch->bfd_arch_info->printable_name);
4623
4624   /* Insert the new architecture into the front of the architecture
4625      list (keep the list sorted Most Recently Used).  */
4626   {
4627     struct gdbarch_list *this = XMALLOC (struct gdbarch_list);
4628     this->next = rego->arches;
4629     this->gdbarch = new_gdbarch;
4630     rego->arches = this;
4631   }
4632
4633   /* Check that the newly installed architecture is valid.  Plug in
4634      any post init values.  */
4635   new_gdbarch->dump_tdep = rego->dump_tdep;
4636   verify_gdbarch (new_gdbarch);
4637   new_gdbarch->initialized_p = 1;
4638
4639   if (gdbarch_debug)
4640     gdbarch_dump (new_gdbarch, gdb_stdlog);
4641
4642   return new_gdbarch;
4643 }
4644
4645 /* Make the specified architecture current.  */
4646
4647 void
4648 deprecated_target_gdbarch_select_hack (struct gdbarch *new_gdbarch)
4649 {
4650   gdb_assert (new_gdbarch != NULL);
4651   gdb_assert (new_gdbarch->initialized_p);
4652   target_gdbarch = new_gdbarch;
4653   observer_notify_architecture_changed (new_gdbarch);
4654   registers_changed ();
4655 }
4656
4657 extern void _initialize_gdbarch (void);
4658
4659 void
4660 _initialize_gdbarch (void)
4661 {
4662   add_setshow_zinteger_cmd ("arch", class_maintenance, &gdbarch_debug, _("\
4663 Set architecture debugging."), _("\
4664 Show architecture debugging."), _("\
4665 When non-zero, architecture debugging is enabled."),
4666                             NULL,
4667                             show_gdbarch_debug,
4668                             &setdebuglist, &showdebuglist);
4669 }