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