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