gdb/gdbarch.c

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