gdb/gdbarch.c

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