gdb/gdbarch.c

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