gdb/gdbarch.c

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