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