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