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