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