gdb/gdbarch.c

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