gdb/gdbarch.c

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