gdb/gdbarch.c

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