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