gdb/gdbarch.c

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