gdb/gdbarch.c

   1 /* *INDENT-OFF* */ /* THIS FILE IS GENERATED */
   2
   3 /* Dynamic architecture support for GDB, the GNU debugger.
   4
   5    Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006
   6    Free 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., 51 Franklin Street, Fifth Floor,
  23    Boston, MA 02110-1301, 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"
  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 static void
  65 show_gdbarch_debug (struct ui_file *file, int from_tty,
  66                     struct cmd_list_element *c, const char *value)
  67 {
  68   fprintf_filtered (file, _("Architecture debugging is %s.\n"), value);
  69 }
  70
  71 static const char *
  72 pformat (const struct floatformat **format)
  73 {
  74   if (format == NULL)
  75     return "(null)";
  76   else
  77     /* Just print out one of them - this is only for diagnostics.  */
  78     return format[0]->name;
  79 }
  80
  81
  82 /* Maintain the struct gdbarch object */
  83
  84 struct gdbarch
  85 {
  86   /* Has this architecture been fully initialized?  */
  87   int initialized_p;
  88
  89   /* An obstack bound to the lifetime of the architecture.  */
  90   struct obstack *obstack;
  91
  92   /* basic architectural information */
  93   const struct bfd_arch_info * bfd_arch_info;
  94   int byte_order;
  95   enum gdb_osabi osabi;
  96   const struct target_desc * target_desc;
  97
  98   /* target specific vector. */
  99   struct gdbarch_tdep *tdep;
 100   gdbarch_dump_tdep_ftype *dump_tdep;
 101
 102   /* per-architecture data-pointers */
 103   unsigned nr_data;
 104   void **data;
 105
 106   /* per-architecture swap-regions */
 107   struct gdbarch_swap *swap;
 108
 109   /* Multi-arch values.
 110
 111      When extending this structure you must:
 112
 113      Add the field below.
 114
 115      Declare set/get functions and define the corresponding
 116      macro in gdbarch.h.
 117
 118      gdbarch_alloc(): If zero/NULL is not a suitable default,
 119      initialize the new field.
 120
 121      verify_gdbarch(): Confirm that the target updated the field
 122      correctly.
 123
 124      gdbarch_dump(): Add a fprintf_unfiltered call so that the new
 125      field is dumped out
 126
 127      ``startup_gdbarch()'': Append an initial value to the static
 128      variable (base values on the host's c-type system).
 129
 130      get_gdbarch(): Implement the set/get functions (probably using
 131      the macro's as shortcuts).
 132
 133      */
 134
 135   int short_bit;
 136   int int_bit;
 137   int long_bit;
 138   int long_long_bit;
 139   int float_bit;
 140   const struct floatformat ** float_format;
 141   int double_bit;
 142   const struct floatformat ** double_format;
 143   int long_double_bit;
 144   const struct floatformat ** long_double_format;
 145   int ptr_bit;
 146   int addr_bit;
 147   int bfd_vma_bit;
 148   int char_signed;
 149   gdbarch_read_pc_ftype *read_pc;
 150   gdbarch_write_pc_ftype *write_pc;
 151   gdbarch_virtual_frame_pointer_ftype *virtual_frame_pointer;
 152   gdbarch_pseudo_register_read_ftype *pseudo_register_read;
 153   gdbarch_pseudo_register_write_ftype *pseudo_register_write;
 154   int num_regs;
 155   int num_pseudo_regs;
 156   int sp_regnum;
 157   int pc_regnum;
 158   int ps_regnum;
 159   int fp0_regnum;
 160   gdbarch_stab_reg_to_regnum_ftype *stab_reg_to_regnum;
 161   gdbarch_ecoff_reg_to_regnum_ftype *ecoff_reg_to_regnum;
 162   gdbarch_dwarf_reg_to_regnum_ftype *dwarf_reg_to_regnum;
 163   gdbarch_sdb_reg_to_regnum_ftype *sdb_reg_to_regnum;
 164   gdbarch_dwarf2_reg_to_regnum_ftype *dwarf2_reg_to_regnum;
 165   gdbarch_register_name_ftype *register_name;
 166   gdbarch_register_type_ftype *register_type;
 167   gdbarch_unwind_dummy_id_ftype *unwind_dummy_id;
 168   int deprecated_fp_regnum;
 169   gdbarch_push_dummy_call_ftype *push_dummy_call;
 170   int deprecated_register_size;
 171   int call_dummy_location;
 172   gdbarch_push_dummy_code_ftype *push_dummy_code;
 173   gdbarch_print_registers_info_ftype *print_registers_info;
 174   gdbarch_print_float_info_ftype *print_float_info;
 175   gdbarch_print_vector_info_ftype *print_vector_info;
 176   gdbarch_register_sim_regno_ftype *register_sim_regno;
 177   gdbarch_register_bytes_ok_ftype *register_bytes_ok;
 178   gdbarch_cannot_fetch_register_ftype *cannot_fetch_register;
 179   gdbarch_cannot_store_register_ftype *cannot_store_register;
 180   gdbarch_get_longjmp_target_ftype *get_longjmp_target;
 181   int believe_pcc_promotion;
 182   gdbarch_convert_register_p_ftype *convert_register_p;
 183   gdbarch_register_to_value_ftype *register_to_value;
 184   gdbarch_value_to_register_ftype *value_to_register;
 185   gdbarch_value_from_register_ftype *value_from_register;
 186   gdbarch_pointer_to_address_ftype *pointer_to_address;
 187   gdbarch_address_to_pointer_ftype *address_to_pointer;
 188   gdbarch_integer_to_address_ftype *integer_to_address;
 189   gdbarch_return_value_ftype *return_value;
 190   gdbarch_extract_return_value_ftype *extract_return_value;
 191   gdbarch_store_return_value_ftype *store_return_value;
 192   gdbarch_deprecated_use_struct_convention_ftype *deprecated_use_struct_convention;
 193   gdbarch_deprecated_extract_struct_value_address_ftype *deprecated_extract_struct_value_address;
 194   gdbarch_skip_prologue_ftype *skip_prologue;
 195   gdbarch_inner_than_ftype *inner_than;
 196   gdbarch_breakpoint_from_pc_ftype *breakpoint_from_pc;
 197   gdbarch_adjust_breakpoint_address_ftype *adjust_breakpoint_address;
 198   gdbarch_memory_insert_breakpoint_ftype *memory_insert_breakpoint;
 199   gdbarch_memory_remove_breakpoint_ftype *memory_remove_breakpoint;
 200   CORE_ADDR decr_pc_after_break;
 201   CORE_ADDR deprecated_function_start_offset;
 202   gdbarch_remote_register_number_ftype *remote_register_number;
 203   gdbarch_fetch_tls_load_module_address_ftype *fetch_tls_load_module_address;
 204   CORE_ADDR frame_args_skip;
 205   gdbarch_unwind_pc_ftype *unwind_pc;
 206   gdbarch_unwind_sp_ftype *unwind_sp;
 207   gdbarch_frame_num_args_ftype *frame_num_args;
 208   gdbarch_deprecated_stack_align_ftype *deprecated_stack_align;
 209   gdbarch_frame_align_ftype *frame_align;
 210   gdbarch_deprecated_reg_struct_has_addr_ftype *deprecated_reg_struct_has_addr;
 211   gdbarch_stabs_argument_has_addr_ftype *stabs_argument_has_addr;
 212   int frame_red_zone_size;
 213   gdbarch_convert_from_func_ptr_addr_ftype *convert_from_func_ptr_addr;
 214   gdbarch_addr_bits_remove_ftype *addr_bits_remove;
 215   gdbarch_smash_text_address_ftype *smash_text_address;
 216   gdbarch_software_single_step_ftype *software_single_step;
 217   gdbarch_single_step_through_delay_ftype *single_step_through_delay;
 218   gdbarch_print_insn_ftype *print_insn;
 219   gdbarch_skip_trampoline_code_ftype *skip_trampoline_code;
 220   gdbarch_skip_solib_resolver_ftype *skip_solib_resolver;
 221   gdbarch_in_solib_return_trampoline_ftype *in_solib_return_trampoline;
 222   gdbarch_in_function_epilogue_p_ftype *in_function_epilogue_p;
 223   gdbarch_construct_inferior_arguments_ftype *construct_inferior_arguments;
 224   gdbarch_elf_make_msymbol_special_ftype *elf_make_msymbol_special;
 225   gdbarch_coff_make_msymbol_special_ftype *coff_make_msymbol_special;
 226   const char * name_of_malloc;
 227   int cannot_step_breakpoint;
 228   int have_nonsteppable_watchpoint;
 229   gdbarch_address_class_type_flags_ftype *address_class_type_flags;
 230   gdbarch_address_class_type_flags_to_name_ftype *address_class_type_flags_to_name;
 231   gdbarch_address_class_name_to_type_flags_ftype *address_class_name_to_type_flags;
 232   gdbarch_register_reggroup_p_ftype *register_reggroup_p;
 233   gdbarch_fetch_pointer_argument_ftype *fetch_pointer_argument;
 234   gdbarch_regset_from_core_section_ftype *regset_from_core_section;
 235   int vtable_function_descriptors;
 236   int vbit_in_delta;
 237   gdbarch_skip_permanent_breakpoint_ftype *skip_permanent_breakpoint;
 238   gdbarch_overlay_update_ftype *overlay_update;
 239 };
 240
 241
 242 /* The default architecture uses host values (for want of a better
 243    choice). */
 244
 245 extern const struct bfd_arch_info bfd_default_arch_struct;
 246
 247 struct gdbarch startup_gdbarch =
 248 {
 249   1, /* Always initialized.  */
 250   NULL, /* The obstack.  */
 251   /* basic architecture information */
 252   &bfd_default_arch_struct,  /* bfd_arch_info */
 253   BFD_ENDIAN_BIG,  /* byte_order */
 254   GDB_OSABI_UNKNOWN,  /* osabi */
 255   0,  /* target_desc */
 256   /* target specific vector and its dump routine */
 257   NULL, NULL,
 258   /*per-architecture data-pointers and swap regions */
 259   0, NULL, NULL,
 260   /* Multi-arch values */
 261   8 * sizeof (short),  /* short_bit */
 262   8 * sizeof (int),  /* int_bit */
 263   8 * sizeof (long),  /* long_bit */
 264   8 * sizeof (LONGEST),  /* long_long_bit */
 265   8 * sizeof (float),  /* float_bit */
 266   0,  /* float_format */
 267   8 * sizeof (double),  /* double_bit */
 268   0,  /* double_format */
 269   8 * sizeof (long double),  /* long_double_bit */
 270   0,  /* long_double_format */
 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,  /* virtual_frame_pointer */
 278   0,  /* pseudo_register_read */
 279   0,  /* pseudo_register_write */
 280   0,  /* num_regs */
 281   0,  /* num_pseudo_regs */
 282   -1,  /* sp_regnum */
 283   -1,  /* pc_regnum */
 284   -1,  /* ps_regnum */
 285   0,  /* fp0_regnum */
 286   0,  /* stab_reg_to_regnum */
 287   0,  /* ecoff_reg_to_regnum */
 288   0,  /* dwarf_reg_to_regnum */
 289   0,  /* sdb_reg_to_regnum */
 290   0,  /* dwarf2_reg_to_regnum */
 291   0,  /* register_name */
 292   0,  /* register_type */
 293   0,  /* unwind_dummy_id */
 294   -1,  /* deprecated_fp_regnum */
 295   0,  /* push_dummy_call */
 296   0,  /* deprecated_register_size */
 297   0,  /* call_dummy_location */
 298   0,  /* push_dummy_code */
 299   default_print_registers_info,  /* print_registers_info */
 300   0,  /* print_float_info */
 301   0,  /* print_vector_info */
 302   0,  /* register_sim_regno */
 303   0,  /* register_bytes_ok */
 304   0,  /* cannot_fetch_register */
 305   0,  /* cannot_store_register */
 306   0,  /* get_longjmp_target */
 307   0,  /* believe_pcc_promotion */
 308   0,  /* convert_register_p */
 309   0,  /* register_to_value */
 310   0,  /* value_to_register */
 311   0,  /* value_from_register */
 312   0,  /* pointer_to_address */
 313   0,  /* address_to_pointer */
 314   0,  /* integer_to_address */
 315   0,  /* return_value */
 316   0,  /* extract_return_value */
 317   0,  /* store_return_value */
 318   0,  /* deprecated_use_struct_convention */
 319   0,  /* deprecated_extract_struct_value_address */
 320   0,  /* skip_prologue */
 321   0,  /* inner_than */
 322   0,  /* breakpoint_from_pc */
 323   0,  /* adjust_breakpoint_address */
 324   0,  /* memory_insert_breakpoint */
 325   0,  /* memory_remove_breakpoint */
 326   0,  /* decr_pc_after_break */
 327   0,  /* deprecated_function_start_offset */
 328   default_remote_register_number,  /* remote_register_number */
 329   0,  /* fetch_tls_load_module_address */
 330   0,  /* frame_args_skip */
 331   0,  /* unwind_pc */
 332   0,  /* unwind_sp */
 333   0,  /* frame_num_args */
 334   0,  /* deprecated_stack_align */
 335   0,  /* frame_align */
 336   0,  /* deprecated_reg_struct_has_addr */
 337   default_stabs_argument_has_addr,  /* stabs_argument_has_addr */
 338   0,  /* frame_red_zone_size */
 339   convert_from_func_ptr_addr_identity,  /* convert_from_func_ptr_addr */
 340   0,  /* addr_bits_remove */
 341   0,  /* smash_text_address */
 342   0,  /* software_single_step */
 343   0,  /* single_step_through_delay */
 344   0,  /* print_insn */
 345   0,  /* skip_trampoline_code */
 346   generic_skip_solib_resolver,  /* skip_solib_resolver */
 347   0,  /* in_solib_return_trampoline */
 348   generic_in_function_epilogue_p,  /* in_function_epilogue_p */
 349   construct_inferior_arguments,  /* construct_inferior_arguments */
 350   0,  /* elf_make_msymbol_special */
 351   0,  /* coff_make_msymbol_special */
 352   "malloc",  /* name_of_malloc */
 353   0,  /* cannot_step_breakpoint */
 354   0,  /* have_nonsteppable_watchpoint */
 355   0,  /* address_class_type_flags */
 356   0,  /* address_class_type_flags_to_name */
 357   0,  /* address_class_name_to_type_flags */
 358   default_register_reggroup_p,  /* register_reggroup_p */
 359   0,  /* fetch_pointer_argument */
 360   0,  /* regset_from_core_section */
 361   0,  /* vtable_function_descriptors */
 362   0,  /* vbit_in_delta */
 363   0,  /* skip_permanent_breakpoint */
 364   0,  /* overlay_update */
 365   /* startup_gdbarch() */
 366 };
 367
 368 struct gdbarch *current_gdbarch = &startup_gdbarch;
 369
 370 /* Create a new ``struct gdbarch'' based on information provided by
 371    ``struct gdbarch_info''. */
 372
 373 struct gdbarch *
 374 gdbarch_alloc (const struct gdbarch_info *info,
 375                struct gdbarch_tdep *tdep)
 376 {
 377   /* NOTE: The new architecture variable is named ``current_gdbarch''
 378      so that macros such as TARGET_DOUBLE_BIT, when expanded, refer to
 379      the current local architecture and not the previous global
 380      architecture.  This ensures that the new architectures initial
 381      values are not influenced by the previous architecture.  Once
 382      everything is parameterised with gdbarch, this will go away.  */
 383   struct gdbarch *current_gdbarch;
 384
 385   /* Create an obstack for allocating all the per-architecture memory,
 386      then use that to allocate the architecture vector.  */
 387   struct obstack *obstack = XMALLOC (struct obstack);
 388   obstack_init (obstack);
 389   current_gdbarch = obstack_alloc (obstack, sizeof (*current_gdbarch));
 390   memset (current_gdbarch, 0, sizeof (*current_gdbarch));
 391   current_gdbarch->obstack = obstack;
 392
 393   alloc_gdbarch_data (current_gdbarch);
 394
 395   current_gdbarch->tdep = tdep;
 396
 397   current_gdbarch->bfd_arch_info = info->bfd_arch_info;
 398   current_gdbarch->byte_order = info->byte_order;
 399   current_gdbarch->osabi = info->osabi;
 400   current_gdbarch->target_desc = info->target_desc;
 401
 402   /* Force the explicit initialization of these. */
 403   current_gdbarch->short_bit = 2*TARGET_CHAR_BIT;
 404   current_gdbarch->int_bit = 4*TARGET_CHAR_BIT;
 405   current_gdbarch->long_bit = 4*TARGET_CHAR_BIT;
 406   current_gdbarch->long_long_bit = 2*TARGET_LONG_BIT;
 407   current_gdbarch->float_bit = 4*TARGET_CHAR_BIT;
 408   current_gdbarch->double_bit = 8*TARGET_CHAR_BIT;
 409   current_gdbarch->long_double_bit = 8*TARGET_CHAR_BIT;
 410   current_gdbarch->ptr_bit = TARGET_INT_BIT;
 411   current_gdbarch->bfd_vma_bit = TARGET_ARCHITECTURE->bits_per_address;
 412   current_gdbarch->char_signed = -1;
 413   current_gdbarch->write_pc = generic_target_write_pc;
 414   current_gdbarch->virtual_frame_pointer = legacy_virtual_frame_pointer;
 415   current_gdbarch->num_regs = -1;
 416   current_gdbarch->sp_regnum = -1;
 417   current_gdbarch->pc_regnum = -1;
 418   current_gdbarch->ps_regnum = -1;
 419   current_gdbarch->fp0_regnum = -1;
 420   current_gdbarch->stab_reg_to_regnum = no_op_reg_to_regnum;
 421   current_gdbarch->ecoff_reg_to_regnum = no_op_reg_to_regnum;
 422   current_gdbarch->dwarf_reg_to_regnum = no_op_reg_to_regnum;
 423   current_gdbarch->sdb_reg_to_regnum = no_op_reg_to_regnum;
 424   current_gdbarch->dwarf2_reg_to_regnum = no_op_reg_to_regnum;
 425   current_gdbarch->deprecated_fp_regnum = -1;
 426   current_gdbarch->call_dummy_location = AT_ENTRY_POINT;
 427   current_gdbarch->print_registers_info = default_print_registers_info;
 428   current_gdbarch->register_sim_regno = legacy_register_sim_regno;
 429   current_gdbarch->cannot_fetch_register = cannot_register_not;
 430   current_gdbarch->cannot_store_register = cannot_register_not;
 431   current_gdbarch->convert_register_p = generic_convert_register_p;
 432   current_gdbarch->value_from_register = default_value_from_register;
 433   current_gdbarch->pointer_to_address = unsigned_pointer_to_address;
 434   current_gdbarch->address_to_pointer = unsigned_address_to_pointer;
 435   current_gdbarch->return_value = legacy_return_value;
 436   current_gdbarch->deprecated_use_struct_convention = generic_use_struct_convention;
 437   current_gdbarch->memory_insert_breakpoint = default_memory_insert_breakpoint;
 438   current_gdbarch->memory_remove_breakpoint = default_memory_remove_breakpoint;
 439   current_gdbarch->remote_register_number = default_remote_register_number;
 440   current_gdbarch->stabs_argument_has_addr = default_stabs_argument_has_addr;
 441   current_gdbarch->convert_from_func_ptr_addr = convert_from_func_ptr_addr_identity;
 442   current_gdbarch->addr_bits_remove = core_addr_identity;
 443   current_gdbarch->smash_text_address = core_addr_identity;
 444   current_gdbarch->skip_trampoline_code = generic_skip_trampoline_code;
 445   current_gdbarch->skip_solib_resolver = generic_skip_solib_resolver;
 446   current_gdbarch->in_solib_return_trampoline = generic_in_solib_return_trampoline;
 447   current_gdbarch->in_function_epilogue_p = generic_in_function_epilogue_p;
 448   current_gdbarch->construct_inferior_arguments = construct_inferior_arguments;
 449   current_gdbarch->elf_make_msymbol_special = default_elf_make_msymbol_special;
 450   current_gdbarch->coff_make_msymbol_special = default_coff_make_msymbol_special;
 451   current_gdbarch->name_of_malloc = "malloc";
 452   current_gdbarch->register_reggroup_p = default_register_reggroup_p;
 453   /* gdbarch_alloc() */
 454
 455   return current_gdbarch;
 456 }
 457
 458
 459 /* Allocate extra space using the per-architecture obstack.  */
 460
 461 void *
 462 gdbarch_obstack_zalloc (struct gdbarch *arch, long size)
 463 {
 464   void *data = obstack_alloc (arch->obstack, size);
 465   memset (data, 0, size);
 466   return data;
 467 }
 468
 469
 470 /* Free a gdbarch struct.  This should never happen in normal
 471    operation --- once you've created a gdbarch, you keep it around.
 472    However, if an architecture's init function encounters an error
 473    building the structure, it may need to clean up a partially
 474    constructed gdbarch.  */
 475
 476 void
 477 gdbarch_free (struct gdbarch *arch)
 478 {
 479   struct obstack *obstack;
 480   gdb_assert (arch != NULL);
 481   gdb_assert (!arch->initialized_p);
 482   obstack = arch->obstack;
 483   obstack_free (obstack, 0); /* Includes the ARCH.  */
 484   xfree (obstack);
 485 }
 486
 487
 488 /* Ensure that all values in a GDBARCH are reasonable.  */
 489
 490 /* NOTE/WARNING: The parameter is called ``current_gdbarch'' so that it
 491    just happens to match the global variable ``current_gdbarch''.  That
 492    way macros refering to that variable get the local and not the global
 493    version - ulgh.  Once everything is parameterised with gdbarch, this
 494    will go away. */
 495
 496 static void
 497 verify_gdbarch (struct gdbarch *current_gdbarch)
 498 {
 499   struct ui_file *log;
 500   struct cleanup *cleanups;
 501   long dummy;
 502   char *buf;
 503   log = mem_fileopen ();
 504   cleanups = make_cleanup_ui_file_delete (log);
 505   /* fundamental */
 506   if (current_gdbarch->byte_order == BFD_ENDIAN_UNKNOWN)
 507     fprintf_unfiltered (log, "\n\tbyte-order");
 508   if (current_gdbarch->bfd_arch_info == NULL)
 509     fprintf_unfiltered (log, "\n\tbfd_arch_info");
 510   /* Check those that need to be defined for the given multi-arch level. */
 511   /* Skip verify of short_bit, invalid_p == 0 */
 512   /* Skip verify of int_bit, invalid_p == 0 */
 513   /* Skip verify of long_bit, invalid_p == 0 */
 514   /* Skip verify of long_long_bit, invalid_p == 0 */
 515   /* Skip verify of float_bit, invalid_p == 0 */
 516   if (current_gdbarch->float_format == 0)
 517     current_gdbarch->float_format = floatformats_ieee_single;
 518   /* Skip verify of double_bit, invalid_p == 0 */
 519   if (current_gdbarch->double_format == 0)
 520     current_gdbarch->double_format = floatformats_ieee_double;
 521   /* Skip verify of long_double_bit, invalid_p == 0 */
 522   if (current_gdbarch->long_double_format == 0)
 523     current_gdbarch->long_double_format = floatformats_ieee_double;
 524   /* Skip verify of ptr_bit, invalid_p == 0 */
 525   if (current_gdbarch->addr_bit == 0)
 526     current_gdbarch->addr_bit = TARGET_PTR_BIT;
 527   /* Skip verify of bfd_vma_bit, invalid_p == 0 */
 528   if (current_gdbarch->char_signed == -1)
 529     current_gdbarch->char_signed = 1;
 530   /* Skip verify of read_pc, has predicate */
 531   /* Skip verify of write_pc, invalid_p == 0 */
 532   /* Skip verify of virtual_frame_pointer, invalid_p == 0 */
 533   /* Skip verify of pseudo_register_read, has predicate */
 534   /* Skip verify of pseudo_register_write, has predicate */
 535   if (current_gdbarch->num_regs == -1)
 536     fprintf_unfiltered (log, "\n\tnum_regs");
 537   /* Skip verify of num_pseudo_regs, invalid_p == 0 */
 538   /* Skip verify of sp_regnum, invalid_p == 0 */
 539   /* Skip verify of pc_regnum, invalid_p == 0 */
 540   /* Skip verify of ps_regnum, invalid_p == 0 */
 541   /* Skip verify of fp0_regnum, invalid_p == 0 */
 542   /* Skip verify of stab_reg_to_regnum, invalid_p == 0 */
 543   /* Skip verify of ecoff_reg_to_regnum, invalid_p == 0 */
 544   /* Skip verify of dwarf_reg_to_regnum, invalid_p == 0 */
 545   /* Skip verify of sdb_reg_to_regnum, invalid_p == 0 */
 546   /* Skip verify of dwarf2_reg_to_regnum, invalid_p == 0 */
 547   /* Skip verify of register_type, has predicate */
 548   /* Skip verify of unwind_dummy_id, has predicate */
 549   /* Skip verify of deprecated_fp_regnum, invalid_p == 0 */
 550   /* Skip verify of push_dummy_call, has predicate */
 551   /* Skip verify of call_dummy_location, invalid_p == 0 */
 552   /* Skip verify of push_dummy_code, has predicate */
 553   /* Skip verify of print_registers_info, invalid_p == 0 */
 554   /* Skip verify of print_float_info, has predicate */
 555   /* Skip verify of print_vector_info, has predicate */
 556   /* Skip verify of register_sim_regno, invalid_p == 0 */
 557   /* Skip verify of register_bytes_ok, has predicate */
 558   /* Skip verify of cannot_fetch_register, invalid_p == 0 */
 559   /* Skip verify of cannot_store_register, invalid_p == 0 */
 560   /* Skip verify of get_longjmp_target, has predicate */
 561   /* Skip verify of convert_register_p, invalid_p == 0 */
 562   /* Skip verify of value_from_register, invalid_p == 0 */
 563   /* Skip verify of pointer_to_address, invalid_p == 0 */
 564   /* Skip verify of address_to_pointer, invalid_p == 0 */
 565   /* Skip verify of integer_to_address, has predicate */
 566   /* Skip verify of return_value, has predicate */
 567   /* Skip verify of deprecated_use_struct_convention, invalid_p == 0 */
 568   /* Skip verify of deprecated_extract_struct_value_address, has predicate */
 569   if (current_gdbarch->skip_prologue == 0)
 570     fprintf_unfiltered (log, "\n\tskip_prologue");
 571   if (current_gdbarch->inner_than == 0)
 572     fprintf_unfiltered (log, "\n\tinner_than");
 573   if (current_gdbarch->breakpoint_from_pc == 0)
 574     fprintf_unfiltered (log, "\n\tbreakpoint_from_pc");
 575   /* Skip verify of adjust_breakpoint_address, has predicate */
 576   /* Skip verify of memory_insert_breakpoint, invalid_p == 0 */
 577   /* Skip verify of memory_remove_breakpoint, invalid_p == 0 */
 578   /* Skip verify of decr_pc_after_break, invalid_p == 0 */
 579   /* Skip verify of deprecated_function_start_offset, invalid_p == 0 */
 580   /* Skip verify of remote_register_number, invalid_p == 0 */
 581   /* Skip verify of fetch_tls_load_module_address, has predicate */
 582   /* Skip verify of frame_args_skip, invalid_p == 0 */
 583   /* Skip verify of unwind_pc, has predicate */
 584   /* Skip verify of unwind_sp, has predicate */
 585   /* Skip verify of frame_num_args, has predicate */
 586   /* Skip verify of deprecated_stack_align, has predicate */
 587   /* Skip verify of frame_align, has predicate */
 588   /* Skip verify of deprecated_reg_struct_has_addr, has predicate */
 589   /* Skip verify of stabs_argument_has_addr, invalid_p == 0 */
 590   /* Skip verify of convert_from_func_ptr_addr, invalid_p == 0 */
 591   /* Skip verify of addr_bits_remove, invalid_p == 0 */
 592   /* Skip verify of smash_text_address, invalid_p == 0 */
 593   /* Skip verify of software_single_step, has predicate */
 594   /* Skip verify of single_step_through_delay, has predicate */
 595   if (current_gdbarch->print_insn == 0)
 596     fprintf_unfiltered (log, "\n\tprint_insn");
 597   /* Skip verify of skip_trampoline_code, invalid_p == 0 */
 598   /* Skip verify of skip_solib_resolver, invalid_p == 0 */
 599   /* Skip verify of in_solib_return_trampoline, invalid_p == 0 */
 600   /* Skip verify of in_function_epilogue_p, invalid_p == 0 */
 601   /* Skip verify of construct_inferior_arguments, invalid_p == 0 */
 602   /* Skip verify of elf_make_msymbol_special, invalid_p == 0 */
 603   /* Skip verify of coff_make_msymbol_special, invalid_p == 0 */
 604   /* Skip verify of name_of_malloc, invalid_p == 0 */
 605   /* Skip verify of cannot_step_breakpoint, invalid_p == 0 */
 606   /* Skip verify of have_nonsteppable_watchpoint, invalid_p == 0 */
 607   /* Skip verify of address_class_type_flags, has predicate */
 608   /* Skip verify of address_class_type_flags_to_name, has predicate */
 609   /* Skip verify of address_class_name_to_type_flags, has predicate */
 610   /* Skip verify of register_reggroup_p, invalid_p == 0 */
 611   /* Skip verify of fetch_pointer_argument, has predicate */
 612   /* Skip verify of regset_from_core_section, has predicate */
 613   /* Skip verify of vtable_function_descriptors, invalid_p == 0 */
 614   /* Skip verify of vbit_in_delta, invalid_p == 0 */
 615   /* Skip verify of skip_permanent_breakpoint, has predicate */
 616   /* Skip verify of overlay_update, has predicate */
 617   buf = ui_file_xstrdup (log, &dummy);
 618   make_cleanup (xfree, buf);
 619   if (strlen (buf) > 0)
 620     internal_error (__FILE__, __LINE__,
 621                     _("verify_gdbarch: the following are invalid ...%s"),
 622                     buf);
 623   do_cleanups (cleanups);
 624 }
 625
 626
 627 /* Print out the details of the current architecture. */
 628
 629 /* NOTE/WARNING: The parameter is called ``current_gdbarch'' so that it
 630    just happens to match the global variable ``current_gdbarch''.  That
 631    way macros refering to that variable get the local and not the global
 632    version - ulgh.  Once everything is parameterised with gdbarch, this
 633    will go away. */
 634
 635 void
 636 gdbarch_dump (struct gdbarch *current_gdbarch, struct ui_file *file)
 637 {
 638   const char *gdb_xm_file = "<not-defined>";
 639   const char *gdb_nm_file = "<not-defined>";
 640   const char *gdb_tm_file = "<not-defined>";
 641 #if defined (GDB_XM_FILE)
 642   gdb_xm_file = GDB_XM_FILE;
 643 #endif
 644   fprintf_unfiltered (file,
 645                       "gdbarch_dump: GDB_XM_FILE = %s\n",
 646                       gdb_xm_file);
 647 #if defined (GDB_NM_FILE)
 648   gdb_nm_file = GDB_NM_FILE;
 649 #endif
 650   fprintf_unfiltered (file,
 651                       "gdbarch_dump: GDB_NM_FILE = %s\n",
 652                       gdb_nm_file);
 653 #if defined (GDB_TM_FILE)
 654   gdb_tm_file = GDB_TM_FILE;
 655 #endif
 656   fprintf_unfiltered (file,
 657                       "gdbarch_dump: GDB_TM_FILE = %s\n",
 658                       gdb_tm_file);
 659 #ifdef TARGET_ADDR_BIT
 660   fprintf_unfiltered (file,
 661                       "gdbarch_dump: TARGET_ADDR_BIT # %s\n",
 662                       XSTRING (TARGET_ADDR_BIT));
 663 #endif
 664   fprintf_unfiltered (file,
 665                       "gdbarch_dump: addr_bit = %s\n",
 666                       paddr_d (current_gdbarch->addr_bit));
 667 #ifdef ADDR_BITS_REMOVE
 668   fprintf_unfiltered (file,
 669                       "gdbarch_dump: %s # %s\n",
 670                       "ADDR_BITS_REMOVE(addr)",
 671                       XSTRING (ADDR_BITS_REMOVE (addr)));
 672 #endif
 673   fprintf_unfiltered (file,
 674                       "gdbarch_dump: addr_bits_remove = <0x%lx>\n",
 675                       (long) current_gdbarch->addr_bits_remove);
 676   fprintf_unfiltered (file,
 677                       "gdbarch_dump: gdbarch_address_class_name_to_type_flags_p() = %d\n",
 678                       gdbarch_address_class_name_to_type_flags_p (current_gdbarch));
 679   fprintf_unfiltered (file,
 680                       "gdbarch_dump: address_class_name_to_type_flags = <0x%lx>\n",
 681                       (long) current_gdbarch->address_class_name_to_type_flags);
 682 #ifdef ADDRESS_CLASS_TYPE_FLAGS_P
 683   fprintf_unfiltered (file,
 684                       "gdbarch_dump: %s # %s\n",
 685                       "ADDRESS_CLASS_TYPE_FLAGS_P()",
 686                       XSTRING (ADDRESS_CLASS_TYPE_FLAGS_P ()));
 687 #endif
 688   fprintf_unfiltered (file,
 689                       "gdbarch_dump: gdbarch_address_class_type_flags_p() = %d\n",
 690                       gdbarch_address_class_type_flags_p (current_gdbarch));
 691 #ifdef ADDRESS_CLASS_TYPE_FLAGS
 692   fprintf_unfiltered (file,
 693                       "gdbarch_dump: %s # %s\n",
 694                       "ADDRESS_CLASS_TYPE_FLAGS(byte_size, dwarf2_addr_class)",
 695                       XSTRING (ADDRESS_CLASS_TYPE_FLAGS (byte_size, dwarf2_addr_class)));
 696 #endif
 697   fprintf_unfiltered (file,
 698                       "gdbarch_dump: address_class_type_flags = <0x%lx>\n",
 699                       (long) current_gdbarch->address_class_type_flags);
 700   fprintf_unfiltered (file,
 701                       "gdbarch_dump: gdbarch_address_class_type_flags_to_name_p() = %d\n",
 702                       gdbarch_address_class_type_flags_to_name_p (current_gdbarch));
 703   fprintf_unfiltered (file,
 704                       "gdbarch_dump: address_class_type_flags_to_name = <0x%lx>\n",
 705                       (long) current_gdbarch->address_class_type_flags_to_name);
 706   fprintf_unfiltered (file,
 707                       "gdbarch_dump: address_to_pointer = <0x%lx>\n",
 708                       (long) current_gdbarch->address_to_pointer);
 709   fprintf_unfiltered (file,
 710                       "gdbarch_dump: gdbarch_adjust_breakpoint_address_p() = %d\n",
 711                       gdbarch_adjust_breakpoint_address_p (current_gdbarch));
 712   fprintf_unfiltered (file,
 713                       "gdbarch_dump: adjust_breakpoint_address = <0x%lx>\n",
 714                       (long) current_gdbarch->adjust_breakpoint_address);
 715 #ifdef BELIEVE_PCC_PROMOTION
 716   fprintf_unfiltered (file,
 717                       "gdbarch_dump: BELIEVE_PCC_PROMOTION # %s\n",
 718                       XSTRING (BELIEVE_PCC_PROMOTION));
 719 #endif
 720   fprintf_unfiltered (file,
 721                       "gdbarch_dump: believe_pcc_promotion = %s\n",
 722                       paddr_d (current_gdbarch->believe_pcc_promotion));
 723 #ifdef TARGET_ARCHITECTURE
 724   fprintf_unfiltered (file,
 725                       "gdbarch_dump: TARGET_ARCHITECTURE # %s\n",
 726                       XSTRING (TARGET_ARCHITECTURE));
 727 #endif
 728   fprintf_unfiltered (file,
 729                       "gdbarch_dump: bfd_arch_info = %s\n",
 730                       TARGET_ARCHITECTURE->printable_name);
 731 #ifdef TARGET_BFD_VMA_BIT
 732   fprintf_unfiltered (file,
 733                       "gdbarch_dump: TARGET_BFD_VMA_BIT # %s\n",
 734                       XSTRING (TARGET_BFD_VMA_BIT));
 735 #endif
 736   fprintf_unfiltered (file,
 737                       "gdbarch_dump: bfd_vma_bit = %s\n",
 738                       paddr_d (current_gdbarch->bfd_vma_bit));
 739 #ifdef BREAKPOINT_FROM_PC
 740   fprintf_unfiltered (file,
 741                       "gdbarch_dump: %s # %s\n",
 742                       "BREAKPOINT_FROM_PC(pcptr, lenptr)",
 743                       XSTRING (BREAKPOINT_FROM_PC (pcptr, lenptr)));
 744 #endif
 745   fprintf_unfiltered (file,
 746                       "gdbarch_dump: breakpoint_from_pc = <0x%lx>\n",
 747                       (long) current_gdbarch->breakpoint_from_pc);
 748   fprintf_unfiltered (file,
 749                       "gdbarch_dump: byte_order = %s\n",
 750                       paddr_d (current_gdbarch->byte_order));
 751   fprintf_unfiltered (file,
 752                       "gdbarch_dump: call_dummy_location = %s\n",
 753                       paddr_d (current_gdbarch->call_dummy_location));
 754   fprintf_unfiltered (file,
 755                       "gdbarch_dump: cannot_fetch_register = <0x%lx>\n",
 756                       (long) current_gdbarch->cannot_fetch_register);
 757 #ifdef CANNOT_STEP_BREAKPOINT
 758   fprintf_unfiltered (file,
 759                       "gdbarch_dump: CANNOT_STEP_BREAKPOINT # %s\n",
 760                       XSTRING (CANNOT_STEP_BREAKPOINT));
 761 #endif
 762   fprintf_unfiltered (file,
 763                       "gdbarch_dump: cannot_step_breakpoint = %s\n",
 764                       paddr_d (current_gdbarch->cannot_step_breakpoint));
 765   fprintf_unfiltered (file,
 766                       "gdbarch_dump: cannot_store_register = <0x%lx>\n",
 767                       (long) current_gdbarch->cannot_store_register);
 768   fprintf_unfiltered (file,
 769                       "gdbarch_dump: char_signed = %s\n",
 770                       paddr_d (current_gdbarch->char_signed));
 771 #ifdef COFF_MAKE_MSYMBOL_SPECIAL
 772   fprintf_unfiltered (file,
 773                       "gdbarch_dump: %s # %s\n",
 774                       "COFF_MAKE_MSYMBOL_SPECIAL(val, msym)",
 775                       XSTRING (COFF_MAKE_MSYMBOL_SPECIAL (val, msym)));
 776 #endif
 777   fprintf_unfiltered (file,
 778                       "gdbarch_dump: coff_make_msymbol_special = <0x%lx>\n",
 779                       (long) current_gdbarch->coff_make_msymbol_special);
 780   fprintf_unfiltered (file,
 781                       "gdbarch_dump: construct_inferior_arguments = <0x%lx>\n",
 782                       (long) current_gdbarch->construct_inferior_arguments);
 783   fprintf_unfiltered (file,
 784                       "gdbarch_dump: convert_from_func_ptr_addr = <0x%lx>\n",
 785                       (long) current_gdbarch->convert_from_func_ptr_addr);
 786 #ifdef CONVERT_REGISTER_P
 787   fprintf_unfiltered (file,
 788                       "gdbarch_dump: %s # %s\n",
 789                       "CONVERT_REGISTER_P(regnum, type)",
 790                       XSTRING (CONVERT_REGISTER_P (regnum, type)));
 791 #endif
 792   fprintf_unfiltered (file,
 793                       "gdbarch_dump: convert_register_p = <0x%lx>\n",
 794                       (long) current_gdbarch->convert_register_p);
 795 #ifdef DECR_PC_AFTER_BREAK
 796   fprintf_unfiltered (file,
 797                       "gdbarch_dump: DECR_PC_AFTER_BREAK # %s\n",
 798                       XSTRING (DECR_PC_AFTER_BREAK));
 799 #endif
 800   fprintf_unfiltered (file,
 801                       "gdbarch_dump: decr_pc_after_break = 0x%s\n",
 802                       paddr_nz (current_gdbarch->decr_pc_after_break));
 803 #ifdef DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS_P
 804   fprintf_unfiltered (file,
 805                       "gdbarch_dump: %s # %s\n",
 806                       "DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS_P()",
 807                       XSTRING (DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS_P ()));
 808 #endif
 809   fprintf_unfiltered (file,
 810                       "gdbarch_dump: gdbarch_deprecated_extract_struct_value_address_p() = %d\n",
 811                       gdbarch_deprecated_extract_struct_value_address_p (current_gdbarch));
 812 #ifdef DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS
 813   fprintf_unfiltered (file,
 814                       "gdbarch_dump: %s # %s\n",
 815                       "DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS(regcache)",
 816                       XSTRING (DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS (regcache)));
 817 #endif
 818   fprintf_unfiltered (file,
 819                       "gdbarch_dump: deprecated_extract_struct_value_address = <0x%lx>\n",
 820                       (long) current_gdbarch->deprecated_extract_struct_value_address);
 821 #ifdef DEPRECATED_FP_REGNUM
 822   fprintf_unfiltered (file,
 823                       "gdbarch_dump: DEPRECATED_FP_REGNUM # %s\n",
 824                       XSTRING (DEPRECATED_FP_REGNUM));
 825 #endif
 826   fprintf_unfiltered (file,
 827                       "gdbarch_dump: deprecated_fp_regnum = %s\n",
 828                       paddr_d (current_gdbarch->deprecated_fp_regnum));
 829 #ifdef DEPRECATED_FUNCTION_START_OFFSET
 830   fprintf_unfiltered (file,
 831                       "gdbarch_dump: DEPRECATED_FUNCTION_START_OFFSET # %s\n",
 832                       XSTRING (DEPRECATED_FUNCTION_START_OFFSET));
 833 #endif
 834   fprintf_unfiltered (file,
 835                       "gdbarch_dump: deprecated_function_start_offset = 0x%s\n",
 836                       paddr_nz (current_gdbarch->deprecated_function_start_offset));
 837 #ifdef DEPRECATED_REG_STRUCT_HAS_ADDR_P
 838   fprintf_unfiltered (file,
 839                       "gdbarch_dump: %s # %s\n",
 840                       "DEPRECATED_REG_STRUCT_HAS_ADDR_P()",
 841                       XSTRING (DEPRECATED_REG_STRUCT_HAS_ADDR_P ()));
 842 #endif
 843   fprintf_unfiltered (file,
 844                       "gdbarch_dump: gdbarch_deprecated_reg_struct_has_addr_p() = %d\n",
 845                       gdbarch_deprecated_reg_struct_has_addr_p (current_gdbarch));
 846 #ifdef DEPRECATED_REG_STRUCT_HAS_ADDR
 847   fprintf_unfiltered (file,
 848                       "gdbarch_dump: %s # %s\n",
 849                       "DEPRECATED_REG_STRUCT_HAS_ADDR(gcc_p, type)",
 850                       XSTRING (DEPRECATED_REG_STRUCT_HAS_ADDR (gcc_p, type)));
 851 #endif
 852   fprintf_unfiltered (file,
 853                       "gdbarch_dump: deprecated_reg_struct_has_addr = <0x%lx>\n",
 854                       (long) current_gdbarch->deprecated_reg_struct_has_addr);
 855 #ifdef DEPRECATED_REGISTER_SIZE
 856   fprintf_unfiltered (file,
 857                       "gdbarch_dump: DEPRECATED_REGISTER_SIZE # %s\n",
 858                       XSTRING (DEPRECATED_REGISTER_SIZE));
 859 #endif
 860   fprintf_unfiltered (file,
 861                       "gdbarch_dump: deprecated_register_size = %s\n",
 862                       paddr_d (current_gdbarch->deprecated_register_size));
 863 #ifdef DEPRECATED_STACK_ALIGN_P
 864   fprintf_unfiltered (file,
 865                       "gdbarch_dump: %s # %s\n",
 866                       "DEPRECATED_STACK_ALIGN_P()",
 867                       XSTRING (DEPRECATED_STACK_ALIGN_P ()));
 868 #endif
 869   fprintf_unfiltered (file,
 870                       "gdbarch_dump: gdbarch_deprecated_stack_align_p() = %d\n",
 871                       gdbarch_deprecated_stack_align_p (current_gdbarch));
 872 #ifdef DEPRECATED_STACK_ALIGN
 873   fprintf_unfiltered (file,
 874                       "gdbarch_dump: %s # %s\n",
 875                       "DEPRECATED_STACK_ALIGN(sp)",
 876                       XSTRING (DEPRECATED_STACK_ALIGN (sp)));
 877 #endif
 878   fprintf_unfiltered (file,
 879                       "gdbarch_dump: deprecated_stack_align = <0x%lx>\n",
 880                       (long) current_gdbarch->deprecated_stack_align);
 881 #ifdef DEPRECATED_USE_STRUCT_CONVENTION
 882   fprintf_unfiltered (file,
 883                       "gdbarch_dump: %s # %s\n",
 884                       "DEPRECATED_USE_STRUCT_CONVENTION(gcc_p, value_type)",
 885                       XSTRING (DEPRECATED_USE_STRUCT_CONVENTION (gcc_p, value_type)));
 886 #endif
 887   fprintf_unfiltered (file,
 888                       "gdbarch_dump: deprecated_use_struct_convention = <0x%lx>\n",
 889                       (long) current_gdbarch->deprecated_use_struct_convention);
 890 #ifdef TARGET_DOUBLE_BIT
 891   fprintf_unfiltered (file,
 892                       "gdbarch_dump: TARGET_DOUBLE_BIT # %s\n",
 893                       XSTRING (TARGET_DOUBLE_BIT));
 894 #endif
 895   fprintf_unfiltered (file,
 896                       "gdbarch_dump: double_bit = %s\n",
 897                       paddr_d (current_gdbarch->double_bit));
 898 #ifdef TARGET_DOUBLE_FORMAT
 899   fprintf_unfiltered (file,
 900                       "gdbarch_dump: TARGET_DOUBLE_FORMAT # %s\n",
 901                       XSTRING (TARGET_DOUBLE_FORMAT));
 902 #endif
 903   fprintf_unfiltered (file,
 904                       "gdbarch_dump: double_format = %s\n",
 905                       pformat (current_gdbarch->double_format));
 906 #ifdef DWARF2_REG_TO_REGNUM
 907   fprintf_unfiltered (file,
 908                       "gdbarch_dump: %s # %s\n",
 909                       "DWARF2_REG_TO_REGNUM(dwarf2_regnr)",
 910                       XSTRING (DWARF2_REG_TO_REGNUM (dwarf2_regnr)));
 911 #endif
 912   fprintf_unfiltered (file,
 913                       "gdbarch_dump: dwarf2_reg_to_regnum = <0x%lx>\n",
 914                       (long) current_gdbarch->dwarf2_reg_to_regnum);
 915 #ifdef DWARF_REG_TO_REGNUM
 916   fprintf_unfiltered (file,
 917                       "gdbarch_dump: %s # %s\n",
 918                       "DWARF_REG_TO_REGNUM(dwarf_regnr)",
 919                       XSTRING (DWARF_REG_TO_REGNUM (dwarf_regnr)));
 920 #endif
 921   fprintf_unfiltered (file,
 922                       "gdbarch_dump: dwarf_reg_to_regnum = <0x%lx>\n",
 923                       (long) current_gdbarch->dwarf_reg_to_regnum);
 924 #ifdef ECOFF_REG_TO_REGNUM
 925   fprintf_unfiltered (file,
 926                       "gdbarch_dump: %s # %s\n",
 927                       "ECOFF_REG_TO_REGNUM(ecoff_regnr)",
 928                       XSTRING (ECOFF_REG_TO_REGNUM (ecoff_regnr)));
 929 #endif
 930   fprintf_unfiltered (file,
 931                       "gdbarch_dump: ecoff_reg_to_regnum = <0x%lx>\n",
 932                       (long) current_gdbarch->ecoff_reg_to_regnum);
 933 #ifdef ELF_MAKE_MSYMBOL_SPECIAL
 934   fprintf_unfiltered (file,
 935                       "gdbarch_dump: %s # %s\n",
 936                       "ELF_MAKE_MSYMBOL_SPECIAL(sym, msym)",
 937                       XSTRING (ELF_MAKE_MSYMBOL_SPECIAL (sym, msym)));
 938 #endif
 939   fprintf_unfiltered (file,
 940                       "gdbarch_dump: elf_make_msymbol_special = <0x%lx>\n",
 941                       (long) current_gdbarch->elf_make_msymbol_special);
 942 #ifdef EXTRACT_RETURN_VALUE
 943   fprintf_unfiltered (file,
 944                       "gdbarch_dump: %s # %s\n",
 945                       "EXTRACT_RETURN_VALUE(type, regcache, valbuf)",
 946                       XSTRING (EXTRACT_RETURN_VALUE (type, regcache, valbuf)));
 947 #endif
 948   fprintf_unfiltered (file,
 949                       "gdbarch_dump: extract_return_value = <0x%lx>\n",
 950                       (long) current_gdbarch->extract_return_value);
 951 #ifdef FETCH_POINTER_ARGUMENT_P
 952   fprintf_unfiltered (file,
 953                       "gdbarch_dump: %s # %s\n",
 954                       "FETCH_POINTER_ARGUMENT_P()",
 955                       XSTRING (FETCH_POINTER_ARGUMENT_P ()));
 956 #endif
 957   fprintf_unfiltered (file,
 958                       "gdbarch_dump: gdbarch_fetch_pointer_argument_p() = %d\n",
 959                       gdbarch_fetch_pointer_argument_p (current_gdbarch));
 960 #ifdef FETCH_POINTER_ARGUMENT
 961   fprintf_unfiltered (file,
 962                       "gdbarch_dump: %s # %s\n",
 963                       "FETCH_POINTER_ARGUMENT(frame, argi, type)",
 964                       XSTRING (FETCH_POINTER_ARGUMENT (frame, argi, type)));
 965 #endif
 966   fprintf_unfiltered (file,
 967                       "gdbarch_dump: fetch_pointer_argument = <0x%lx>\n",
 968                       (long) current_gdbarch->fetch_pointer_argument);
 969 #ifdef FETCH_TLS_LOAD_MODULE_ADDRESS_P
 970   fprintf_unfiltered (file,
 971                       "gdbarch_dump: %s # %s\n",
 972                       "FETCH_TLS_LOAD_MODULE_ADDRESS_P()",
 973                       XSTRING (FETCH_TLS_LOAD_MODULE_ADDRESS_P ()));
 974 #endif
 975   fprintf_unfiltered (file,
 976                       "gdbarch_dump: gdbarch_fetch_tls_load_module_address_p() = %d\n",
 977                       gdbarch_fetch_tls_load_module_address_p (current_gdbarch));
 978 #ifdef FETCH_TLS_LOAD_MODULE_ADDRESS
 979   fprintf_unfiltered (file,
 980                       "gdbarch_dump: %s # %s\n",
 981                       "FETCH_TLS_LOAD_MODULE_ADDRESS(objfile)",
 982                       XSTRING (FETCH_TLS_LOAD_MODULE_ADDRESS (objfile)));
 983 #endif
 984   fprintf_unfiltered (file,
 985                       "gdbarch_dump: fetch_tls_load_module_address = <0x%lx>\n",
 986                       (long) current_gdbarch->fetch_tls_load_module_address);
 987 #ifdef TARGET_FLOAT_BIT
 988   fprintf_unfiltered (file,
 989                       "gdbarch_dump: TARGET_FLOAT_BIT # %s\n",
 990                       XSTRING (TARGET_FLOAT_BIT));
 991 #endif
 992   fprintf_unfiltered (file,
 993                       "gdbarch_dump: float_bit = %s\n",
 994                       paddr_d (current_gdbarch->float_bit));
 995 #ifdef TARGET_FLOAT_FORMAT
 996   fprintf_unfiltered (file,
 997                       "gdbarch_dump: TARGET_FLOAT_FORMAT # %s\n",
 998                       XSTRING (TARGET_FLOAT_FORMAT));
 999 #endif
1000   fprintf_unfiltered (file,
1001                       "gdbarch_dump: float_format = %s\n",
1002                       pformat (current_gdbarch->float_format));
1003 #ifdef FP0_REGNUM
1004   fprintf_unfiltered (file,
1005                       "gdbarch_dump: FP0_REGNUM # %s\n",
1006                       XSTRING (FP0_REGNUM));
1007 #endif
1008   fprintf_unfiltered (file,
1009                       "gdbarch_dump: fp0_regnum = %s\n",
1010                       paddr_d (current_gdbarch->fp0_regnum));
1011   fprintf_unfiltered (file,
1012                       "gdbarch_dump: gdbarch_frame_align_p() = %d\n",
1013                       gdbarch_frame_align_p (current_gdbarch));
1014   fprintf_unfiltered (file,
1015                       "gdbarch_dump: frame_align = <0x%lx>\n",
1016                       (long) current_gdbarch->frame_align);
1017 #ifdef FRAME_ARGS_SKIP
1018   fprintf_unfiltered (file,
1019                       "gdbarch_dump: FRAME_ARGS_SKIP # %s\n",
1020                       XSTRING (FRAME_ARGS_SKIP));
1021 #endif
1022   fprintf_unfiltered (file,
1023                       "gdbarch_dump: frame_args_skip = 0x%s\n",
1024                       paddr_nz (current_gdbarch->frame_args_skip));
1025 #ifdef FRAME_NUM_ARGS_P
1026   fprintf_unfiltered (file,
1027                       "gdbarch_dump: %s # %s\n",
1028                       "FRAME_NUM_ARGS_P()",
1029                       XSTRING (FRAME_NUM_ARGS_P ()));
1030 #endif
1031   fprintf_unfiltered (file,
1032                       "gdbarch_dump: gdbarch_frame_num_args_p() = %d\n",
1033                       gdbarch_frame_num_args_p (current_gdbarch));
1034 #ifdef FRAME_NUM_ARGS
1035   fprintf_unfiltered (file,
1036                       "gdbarch_dump: %s # %s\n",
1037                       "FRAME_NUM_ARGS(frame)",
1038                       XSTRING (FRAME_NUM_ARGS (frame)));
1039 #endif
1040   fprintf_unfiltered (file,
1041                       "gdbarch_dump: frame_num_args = <0x%lx>\n",
1042                       (long) current_gdbarch->frame_num_args);
1043 #ifdef FRAME_RED_ZONE_SIZE
1044   fprintf_unfiltered (file,
1045                       "gdbarch_dump: FRAME_RED_ZONE_SIZE # %s\n",
1046                       XSTRING (FRAME_RED_ZONE_SIZE));
1047 #endif
1048   fprintf_unfiltered (file,
1049                       "gdbarch_dump: frame_red_zone_size = %s\n",
1050                       paddr_d (current_gdbarch->frame_red_zone_size));
1051   fprintf_unfiltered (file,
1052                       "gdbarch_dump: gdbarch_get_longjmp_target_p() = %d\n",
1053                       gdbarch_get_longjmp_target_p (current_gdbarch));
1054   fprintf_unfiltered (file,
1055                       "gdbarch_dump: get_longjmp_target = <0x%lx>\n",
1056                       (long) current_gdbarch->get_longjmp_target);
1057 #ifdef HAVE_NONSTEPPABLE_WATCHPOINT
1058   fprintf_unfiltered (file,
1059                       "gdbarch_dump: HAVE_NONSTEPPABLE_WATCHPOINT # %s\n",
1060                       XSTRING (HAVE_NONSTEPPABLE_WATCHPOINT));
1061 #endif
1062   fprintf_unfiltered (file,
1063                       "gdbarch_dump: have_nonsteppable_watchpoint = %s\n",
1064                       paddr_d (current_gdbarch->have_nonsteppable_watchpoint));
1065   fprintf_unfiltered (file,
1066                       "gdbarch_dump: in_function_epilogue_p = <0x%lx>\n",
1067                       (long) current_gdbarch->in_function_epilogue_p);
1068 #ifdef IN_SOLIB_RETURN_TRAMPOLINE
1069   fprintf_unfiltered (file,
1070                       "gdbarch_dump: %s # %s\n",
1071                       "IN_SOLIB_RETURN_TRAMPOLINE(pc, name)",
1072                       XSTRING (IN_SOLIB_RETURN_TRAMPOLINE (pc, name)));
1073 #endif
1074   fprintf_unfiltered (file,
1075                       "gdbarch_dump: in_solib_return_trampoline = <0x%lx>\n",
1076                       (long) current_gdbarch->in_solib_return_trampoline);
1077 #ifdef INNER_THAN
1078   fprintf_unfiltered (file,
1079                       "gdbarch_dump: %s # %s\n",
1080                       "INNER_THAN(lhs, rhs)",
1081                       XSTRING (INNER_THAN (lhs, rhs)));
1082 #endif
1083   fprintf_unfiltered (file,
1084                       "gdbarch_dump: inner_than = <0x%lx>\n",
1085                       (long) current_gdbarch->inner_than);
1086 #ifdef TARGET_INT_BIT
1087   fprintf_unfiltered (file,
1088                       "gdbarch_dump: TARGET_INT_BIT # %s\n",
1089                       XSTRING (TARGET_INT_BIT));
1090 #endif
1091   fprintf_unfiltered (file,
1092                       "gdbarch_dump: int_bit = %s\n",
1093                       paddr_d (current_gdbarch->int_bit));
1094   fprintf_unfiltered (file,
1095                       "gdbarch_dump: gdbarch_integer_to_address_p() = %d\n",
1096                       gdbarch_integer_to_address_p (current_gdbarch));
1097   fprintf_unfiltered (file,
1098                       "gdbarch_dump: integer_to_address = <0x%lx>\n",
1099                       (long) current_gdbarch->integer_to_address);
1100 #ifdef TARGET_LONG_BIT
1101   fprintf_unfiltered (file,
1102                       "gdbarch_dump: TARGET_LONG_BIT # %s\n",
1103                       XSTRING (TARGET_LONG_BIT));
1104 #endif
1105   fprintf_unfiltered (file,
1106                       "gdbarch_dump: long_bit = %s\n",
1107                       paddr_d (current_gdbarch->long_bit));
1108 #ifdef TARGET_LONG_DOUBLE_BIT
1109   fprintf_unfiltered (file,
1110                       "gdbarch_dump: TARGET_LONG_DOUBLE_BIT # %s\n",
1111                       XSTRING (TARGET_LONG_DOUBLE_BIT));
1112 #endif
1113   fprintf_unfiltered (file,
1114                       "gdbarch_dump: long_double_bit = %s\n",
1115                       paddr_d (current_gdbarch->long_double_bit));
1116 #ifdef TARGET_LONG_DOUBLE_FORMAT
1117   fprintf_unfiltered (file,
1118                       "gdbarch_dump: TARGET_LONG_DOUBLE_FORMAT # %s\n",
1119                       XSTRING (TARGET_LONG_DOUBLE_FORMAT));
1120 #endif
1121   fprintf_unfiltered (file,
1122                       "gdbarch_dump: long_double_format = %s\n",
1123                       pformat (current_gdbarch->long_double_format));
1124 #ifdef TARGET_LONG_LONG_BIT
1125   fprintf_unfiltered (file,
1126                       "gdbarch_dump: TARGET_LONG_LONG_BIT # %s\n",
1127                       XSTRING (TARGET_LONG_LONG_BIT));
1128 #endif
1129   fprintf_unfiltered (file,
1130                       "gdbarch_dump: long_long_bit = %s\n",
1131                       paddr_d (current_gdbarch->long_long_bit));
1132 #ifdef MEMORY_INSERT_BREAKPOINT
1133   fprintf_unfiltered (file,
1134                       "gdbarch_dump: %s # %s\n",
1135                       "MEMORY_INSERT_BREAKPOINT(bp_tgt)",
1136                       XSTRING (MEMORY_INSERT_BREAKPOINT (bp_tgt)));
1137 #endif
1138   fprintf_unfiltered (file,
1139                       "gdbarch_dump: memory_insert_breakpoint = <0x%lx>\n",
1140                       (long) current_gdbarch->memory_insert_breakpoint);
1141 #ifdef MEMORY_REMOVE_BREAKPOINT
1142   fprintf_unfiltered (file,
1143                       "gdbarch_dump: %s # %s\n",
1144                       "MEMORY_REMOVE_BREAKPOINT(bp_tgt)",
1145                       XSTRING (MEMORY_REMOVE_BREAKPOINT (bp_tgt)));
1146 #endif
1147   fprintf_unfiltered (file,
1148                       "gdbarch_dump: memory_remove_breakpoint = <0x%lx>\n",
1149                       (long) current_gdbarch->memory_remove_breakpoint);
1150 #ifdef NAME_OF_MALLOC
1151   fprintf_unfiltered (file,
1152                       "gdbarch_dump: NAME_OF_MALLOC # %s\n",
1153                       XSTRING (NAME_OF_MALLOC));
1154 #endif
1155   fprintf_unfiltered (file,
1156                       "gdbarch_dump: name_of_malloc = %s\n",
1157                       NAME_OF_MALLOC);
1158   fprintf_unfiltered (file,
1159                       "gdbarch_dump: num_pseudo_regs = %s\n",
1160                       paddr_d (current_gdbarch->num_pseudo_regs));
1161   fprintf_unfiltered (file,
1162                       "gdbarch_dump: num_regs = %s\n",
1163                       paddr_d (current_gdbarch->num_regs));
1164   fprintf_unfiltered (file,
1165                       "gdbarch_dump: osabi = %s\n",
1166                       paddr_d (current_gdbarch->osabi));
1167   fprintf_unfiltered (file,
1168                       "gdbarch_dump: gdbarch_overlay_update_p() = %d\n",
1169                       gdbarch_overlay_update_p (current_gdbarch));
1170   fprintf_unfiltered (file,
1171                       "gdbarch_dump: overlay_update = <0x%lx>\n",
1172                       (long) current_gdbarch->overlay_update);
1173 #ifdef PC_REGNUM
1174   fprintf_unfiltered (file,
1175                       "gdbarch_dump: PC_REGNUM # %s\n",
1176                       XSTRING (PC_REGNUM));
1177 #endif
1178   fprintf_unfiltered (file,
1179                       "gdbarch_dump: pc_regnum = %s\n",
1180                       paddr_d (current_gdbarch->pc_regnum));
1181   fprintf_unfiltered (file,
1182                       "gdbarch_dump: pointer_to_address = <0x%lx>\n",
1183                       (long) current_gdbarch->pointer_to_address);
1184   fprintf_unfiltered (file,
1185                       "gdbarch_dump: gdbarch_print_float_info_p() = %d\n",
1186                       gdbarch_print_float_info_p (current_gdbarch));
1187   fprintf_unfiltered (file,
1188                       "gdbarch_dump: print_float_info = <0x%lx>\n",
1189                       (long) current_gdbarch->print_float_info);
1190 #ifdef TARGET_PRINT_INSN
1191   fprintf_unfiltered (file,
1192                       "gdbarch_dump: %s # %s\n",
1193                       "TARGET_PRINT_INSN(vma, info)",
1194                       XSTRING (TARGET_PRINT_INSN (vma, info)));
1195 #endif
1196   fprintf_unfiltered (file,
1197                       "gdbarch_dump: print_insn = <0x%lx>\n",
1198                       (long) current_gdbarch->print_insn);
1199   fprintf_unfiltered (file,
1200                       "gdbarch_dump: print_registers_info = <0x%lx>\n",
1201                       (long) current_gdbarch->print_registers_info);
1202   fprintf_unfiltered (file,
1203                       "gdbarch_dump: gdbarch_print_vector_info_p() = %d\n",
1204                       gdbarch_print_vector_info_p (current_gdbarch));
1205   fprintf_unfiltered (file,
1206                       "gdbarch_dump: print_vector_info = <0x%lx>\n",
1207                       (long) current_gdbarch->print_vector_info);
1208 #ifdef PS_REGNUM
1209   fprintf_unfiltered (file,
1210                       "gdbarch_dump: PS_REGNUM # %s\n",
1211                       XSTRING (PS_REGNUM));
1212 #endif
1213   fprintf_unfiltered (file,
1214                       "gdbarch_dump: ps_regnum = %s\n",
1215                       paddr_d (current_gdbarch->ps_regnum));
1216   fprintf_unfiltered (file,
1217                       "gdbarch_dump: gdbarch_pseudo_register_read_p() = %d\n",
1218                       gdbarch_pseudo_register_read_p (current_gdbarch));
1219   fprintf_unfiltered (file,
1220                       "gdbarch_dump: pseudo_register_read = <0x%lx>\n",
1221                       (long) current_gdbarch->pseudo_register_read);
1222   fprintf_unfiltered (file,
1223                       "gdbarch_dump: gdbarch_pseudo_register_write_p() = %d\n",
1224                       gdbarch_pseudo_register_write_p (current_gdbarch));
1225   fprintf_unfiltered (file,
1226                       "gdbarch_dump: pseudo_register_write = <0x%lx>\n",
1227                       (long) current_gdbarch->pseudo_register_write);
1228 #ifdef TARGET_PTR_BIT
1229   fprintf_unfiltered (file,
1230                       "gdbarch_dump: TARGET_PTR_BIT # %s\n",
1231                       XSTRING (TARGET_PTR_BIT));
1232 #endif
1233   fprintf_unfiltered (file,
1234                       "gdbarch_dump: ptr_bit = %s\n",
1235                       paddr_d (current_gdbarch->ptr_bit));
1236   fprintf_unfiltered (file,
1237                       "gdbarch_dump: gdbarch_push_dummy_call_p() = %d\n",
1238                       gdbarch_push_dummy_call_p (current_gdbarch));
1239   fprintf_unfiltered (file,
1240                       "gdbarch_dump: push_dummy_call = <0x%lx>\n",
1241                       (long) current_gdbarch->push_dummy_call);
1242   fprintf_unfiltered (file,
1243                       "gdbarch_dump: gdbarch_push_dummy_code_p() = %d\n",
1244                       gdbarch_push_dummy_code_p (current_gdbarch));
1245   fprintf_unfiltered (file,
1246                       "gdbarch_dump: push_dummy_code = <0x%lx>\n",
1247                       (long) current_gdbarch->push_dummy_code);
1248 #ifdef TARGET_READ_PC_P
1249   fprintf_unfiltered (file,
1250                       "gdbarch_dump: %s # %s\n",
1251                       "TARGET_READ_PC_P()",
1252                       XSTRING (TARGET_READ_PC_P ()));
1253 #endif
1254   fprintf_unfiltered (file,
1255                       "gdbarch_dump: gdbarch_read_pc_p() = %d\n",
1256                       gdbarch_read_pc_p (current_gdbarch));
1257 #ifdef TARGET_READ_PC
1258   fprintf_unfiltered (file,
1259                       "gdbarch_dump: %s # %s\n",
1260                       "TARGET_READ_PC(ptid)",
1261                       XSTRING (TARGET_READ_PC (ptid)));
1262 #endif
1263   fprintf_unfiltered (file,
1264                       "gdbarch_dump: read_pc = <0x%lx>\n",
1265                       (long) current_gdbarch->read_pc);
1266 #ifdef REGISTER_BYTES_OK_P
1267   fprintf_unfiltered (file,
1268                       "gdbarch_dump: %s # %s\n",
1269                       "REGISTER_BYTES_OK_P()",
1270                       XSTRING (REGISTER_BYTES_OK_P ()));
1271 #endif
1272   fprintf_unfiltered (file,
1273                       "gdbarch_dump: gdbarch_register_bytes_ok_p() = %d\n",
1274                       gdbarch_register_bytes_ok_p (current_gdbarch));
1275 #ifdef REGISTER_BYTES_OK
1276   fprintf_unfiltered (file,
1277                       "gdbarch_dump: %s # %s\n",
1278                       "REGISTER_BYTES_OK(nr_bytes)",
1279                       XSTRING (REGISTER_BYTES_OK (nr_bytes)));
1280 #endif
1281   fprintf_unfiltered (file,
1282                       "gdbarch_dump: register_bytes_ok = <0x%lx>\n",
1283                       (long) current_gdbarch->register_bytes_ok);
1284 #ifdef REGISTER_NAME
1285   fprintf_unfiltered (file,
1286                       "gdbarch_dump: %s # %s\n",
1287                       "REGISTER_NAME(regnr)",
1288                       XSTRING (REGISTER_NAME (regnr)));
1289 #endif
1290   fprintf_unfiltered (file,
1291                       "gdbarch_dump: register_name = <0x%lx>\n",
1292                       (long) current_gdbarch->register_name);
1293   fprintf_unfiltered (file,
1294                       "gdbarch_dump: register_reggroup_p = <0x%lx>\n",
1295                       (long) current_gdbarch->register_reggroup_p);
1296 #ifdef REGISTER_SIM_REGNO
1297   fprintf_unfiltered (file,
1298                       "gdbarch_dump: %s # %s\n",
1299                       "REGISTER_SIM_REGNO(reg_nr)",
1300                       XSTRING (REGISTER_SIM_REGNO (reg_nr)));
1301 #endif
1302   fprintf_unfiltered (file,
1303                       "gdbarch_dump: register_sim_regno = <0x%lx>\n",
1304                       (long) current_gdbarch->register_sim_regno);
1305 #ifdef REGISTER_TO_VALUE
1306   fprintf_unfiltered (file,
1307                       "gdbarch_dump: %s # %s\n",
1308                       "REGISTER_TO_VALUE(frame, regnum, type, buf)",
1309                       XSTRING (REGISTER_TO_VALUE (frame, regnum, type, buf)));
1310 #endif
1311   fprintf_unfiltered (file,
1312                       "gdbarch_dump: register_to_value = <0x%lx>\n",
1313                       (long) current_gdbarch->register_to_value);
1314   fprintf_unfiltered (file,
1315                       "gdbarch_dump: gdbarch_register_type_p() = %d\n",
1316                       gdbarch_register_type_p (current_gdbarch));
1317   fprintf_unfiltered (file,
1318                       "gdbarch_dump: register_type = <0x%lx>\n",
1319                       (long) current_gdbarch->register_type);
1320   fprintf_unfiltered (file,
1321                       "gdbarch_dump: gdbarch_regset_from_core_section_p() = %d\n",
1322                       gdbarch_regset_from_core_section_p (current_gdbarch));
1323   fprintf_unfiltered (file,
1324                       "gdbarch_dump: regset_from_core_section = <0x%lx>\n",
1325                       (long) current_gdbarch->regset_from_core_section);
1326   fprintf_unfiltered (file,
1327                       "gdbarch_dump: remote_register_number = <0x%lx>\n",
1328                       (long) current_gdbarch->remote_register_number);
1329   fprintf_unfiltered (file,
1330                       "gdbarch_dump: gdbarch_return_value_p() = %d\n",
1331                       gdbarch_return_value_p (current_gdbarch));
1332   fprintf_unfiltered (file,
1333                       "gdbarch_dump: return_value = <0x%lx>\n",
1334                       (long) current_gdbarch->return_value);
1335 #ifdef SDB_REG_TO_REGNUM
1336   fprintf_unfiltered (file,
1337                       "gdbarch_dump: %s # %s\n",
1338                       "SDB_REG_TO_REGNUM(sdb_regnr)",
1339                       XSTRING (SDB_REG_TO_REGNUM (sdb_regnr)));
1340 #endif
1341   fprintf_unfiltered (file,
1342                       "gdbarch_dump: sdb_reg_to_regnum = <0x%lx>\n",
1343                       (long) current_gdbarch->sdb_reg_to_regnum);
1344 #ifdef TARGET_SHORT_BIT
1345   fprintf_unfiltered (file,
1346                       "gdbarch_dump: TARGET_SHORT_BIT # %s\n",
1347                       XSTRING (TARGET_SHORT_BIT));
1348 #endif
1349   fprintf_unfiltered (file,
1350                       "gdbarch_dump: short_bit = %s\n",
1351                       paddr_d (current_gdbarch->short_bit));
1352   fprintf_unfiltered (file,
1353                       "gdbarch_dump: gdbarch_single_step_through_delay_p() = %d\n",
1354                       gdbarch_single_step_through_delay_p (current_gdbarch));
1355   fprintf_unfiltered (file,
1356                       "gdbarch_dump: single_step_through_delay = <0x%lx>\n",
1357                       (long) current_gdbarch->single_step_through_delay);
1358   fprintf_unfiltered (file,
1359                       "gdbarch_dump: gdbarch_skip_permanent_breakpoint_p() = %d\n",
1360                       gdbarch_skip_permanent_breakpoint_p (current_gdbarch));
1361   fprintf_unfiltered (file,
1362                       "gdbarch_dump: skip_permanent_breakpoint = <0x%lx>\n",
1363                       (long) current_gdbarch->skip_permanent_breakpoint);
1364 #ifdef SKIP_PROLOGUE
1365   fprintf_unfiltered (file,
1366                       "gdbarch_dump: %s # %s\n",
1367                       "SKIP_PROLOGUE(ip)",
1368                       XSTRING (SKIP_PROLOGUE (ip)));
1369 #endif
1370   fprintf_unfiltered (file,
1371                       "gdbarch_dump: skip_prologue = <0x%lx>\n",
1372                       (long) current_gdbarch->skip_prologue);
1373   fprintf_unfiltered (file,
1374                       "gdbarch_dump: skip_solib_resolver = <0x%lx>\n",
1375                       (long) current_gdbarch->skip_solib_resolver);
1376 #ifdef SKIP_TRAMPOLINE_CODE
1377   fprintf_unfiltered (file,
1378                       "gdbarch_dump: %s # %s\n",
1379                       "SKIP_TRAMPOLINE_CODE(pc)",
1380                       XSTRING (SKIP_TRAMPOLINE_CODE (pc)));
1381 #endif
1382   fprintf_unfiltered (file,
1383                       "gdbarch_dump: skip_trampoline_code = <0x%lx>\n",
1384                       (long) current_gdbarch->skip_trampoline_code);
1385 #ifdef SMASH_TEXT_ADDRESS
1386   fprintf_unfiltered (file,
1387                       "gdbarch_dump: %s # %s\n",
1388                       "SMASH_TEXT_ADDRESS(addr)",
1389                       XSTRING (SMASH_TEXT_ADDRESS (addr)));
1390 #endif
1391   fprintf_unfiltered (file,
1392                       "gdbarch_dump: smash_text_address = <0x%lx>\n",
1393                       (long) current_gdbarch->smash_text_address);
1394 #ifdef SOFTWARE_SINGLE_STEP_P
1395   fprintf_unfiltered (file,
1396                       "gdbarch_dump: %s # %s\n",
1397                       "SOFTWARE_SINGLE_STEP_P()",
1398                       XSTRING (SOFTWARE_SINGLE_STEP_P ()));
1399 #endif
1400   fprintf_unfiltered (file,
1401                       "gdbarch_dump: gdbarch_software_single_step_p() = %d\n",
1402                       gdbarch_software_single_step_p (current_gdbarch));
1403 #ifdef SOFTWARE_SINGLE_STEP
1404   fprintf_unfiltered (file,
1405                       "gdbarch_dump: %s # %s\n",
1406                       "SOFTWARE_SINGLE_STEP(regcache)",
1407                       XSTRING (SOFTWARE_SINGLE_STEP (regcache)));
1408 #endif
1409   fprintf_unfiltered (file,
1410                       "gdbarch_dump: software_single_step = <0x%lx>\n",
1411                       (long) current_gdbarch->software_single_step);
1412 #ifdef SP_REGNUM
1413   fprintf_unfiltered (file,
1414                       "gdbarch_dump: SP_REGNUM # %s\n",
1415                       XSTRING (SP_REGNUM));
1416 #endif
1417   fprintf_unfiltered (file,
1418                       "gdbarch_dump: sp_regnum = %s\n",
1419                       paddr_d (current_gdbarch->sp_regnum));
1420 #ifdef STAB_REG_TO_REGNUM
1421   fprintf_unfiltered (file,
1422                       "gdbarch_dump: %s # %s\n",
1423                       "STAB_REG_TO_REGNUM(stab_regnr)",
1424                       XSTRING (STAB_REG_TO_REGNUM (stab_regnr)));
1425 #endif
1426   fprintf_unfiltered (file,
1427                       "gdbarch_dump: stab_reg_to_regnum = <0x%lx>\n",
1428                       (long) current_gdbarch->stab_reg_to_regnum);
1429   fprintf_unfiltered (file,
1430                       "gdbarch_dump: stabs_argument_has_addr = <0x%lx>\n",
1431                       (long) current_gdbarch->stabs_argument_has_addr);
1432 #ifdef STORE_RETURN_VALUE
1433   fprintf_unfiltered (file,
1434                       "gdbarch_dump: %s # %s\n",
1435                       "STORE_RETURN_VALUE(type, regcache, valbuf)",
1436                       XSTRING (STORE_RETURN_VALUE (type, regcache, valbuf)));
1437 #endif
1438   fprintf_unfiltered (file,
1439                       "gdbarch_dump: store_return_value = <0x%lx>\n",
1440                       (long) current_gdbarch->store_return_value);
1441   fprintf_unfiltered (file,
1442                       "gdbarch_dump: target_desc = %s\n",
1443                       paddr_d ((long) current_gdbarch->target_desc));
1444   fprintf_unfiltered (file,
1445                       "gdbarch_dump: gdbarch_unwind_dummy_id_p() = %d\n",
1446                       gdbarch_unwind_dummy_id_p (current_gdbarch));
1447   fprintf_unfiltered (file,
1448                       "gdbarch_dump: unwind_dummy_id = <0x%lx>\n",
1449                       (long) current_gdbarch->unwind_dummy_id);
1450   fprintf_unfiltered (file,
1451                       "gdbarch_dump: gdbarch_unwind_pc_p() = %d\n",
1452                       gdbarch_unwind_pc_p (current_gdbarch));
1453   fprintf_unfiltered (file,
1454                       "gdbarch_dump: unwind_pc = <0x%lx>\n",
1455                       (long) current_gdbarch->unwind_pc);
1456   fprintf_unfiltered (file,
1457                       "gdbarch_dump: gdbarch_unwind_sp_p() = %d\n",
1458                       gdbarch_unwind_sp_p (current_gdbarch));
1459   fprintf_unfiltered (file,
1460                       "gdbarch_dump: unwind_sp = <0x%lx>\n",
1461                       (long) current_gdbarch->unwind_sp);
1462   fprintf_unfiltered (file,
1463                       "gdbarch_dump: value_from_register = <0x%lx>\n",
1464                       (long) current_gdbarch->value_from_register);
1465 #ifdef VALUE_TO_REGISTER
1466   fprintf_unfiltered (file,
1467                       "gdbarch_dump: %s # %s\n",
1468                       "VALUE_TO_REGISTER(frame, regnum, type, buf)",
1469                       XSTRING (VALUE_TO_REGISTER (frame, regnum, type, buf)));
1470 #endif
1471   fprintf_unfiltered (file,
1472                       "gdbarch_dump: value_to_register = <0x%lx>\n",
1473                       (long) current_gdbarch->value_to_register);
1474   fprintf_unfiltered (file,
1475                       "gdbarch_dump: vbit_in_delta = %s\n",
1476                       paddr_d (current_gdbarch->vbit_in_delta));
1477 #ifdef TARGET_VIRTUAL_FRAME_POINTER
1478   fprintf_unfiltered (file,
1479                       "gdbarch_dump: %s # %s\n",
1480                       "TARGET_VIRTUAL_FRAME_POINTER(pc, frame_regnum, frame_offset)",
1481                       XSTRING (TARGET_VIRTUAL_FRAME_POINTER (pc, frame_regnum, frame_offset)));
1482 #endif
1483   fprintf_unfiltered (file,
1484                       "gdbarch_dump: virtual_frame_pointer = <0x%lx>\n",
1485                       (long) current_gdbarch->virtual_frame_pointer);
1486   fprintf_unfiltered (file,
1487                       "gdbarch_dump: vtable_function_descriptors = %s\n",
1488                       paddr_d (current_gdbarch->vtable_function_descriptors));
1489 #ifdef TARGET_WRITE_PC
1490   fprintf_unfiltered (file,
1491                       "gdbarch_dump: %s # %s\n",
1492                       "TARGET_WRITE_PC(val, ptid)",
1493                       XSTRING (TARGET_WRITE_PC (val, ptid)));
1494 #endif
1495   fprintf_unfiltered (file,
1496                       "gdbarch_dump: write_pc = <0x%lx>\n",
1497                       (long) current_gdbarch->write_pc);
1498   if (current_gdbarch->dump_tdep != NULL)
1499     current_gdbarch->dump_tdep (current_gdbarch, file);
1500 }
1501
1502 struct gdbarch_tdep *
1503 gdbarch_tdep (struct gdbarch *gdbarch)
1504 {
1505   if (gdbarch_debug >= 2)
1506     fprintf_unfiltered (gdb_stdlog, "gdbarch_tdep called\n");
1507   return gdbarch->tdep;
1508 }
1509
1510
1511 const struct bfd_arch_info *
1512 gdbarch_bfd_arch_info (struct gdbarch *gdbarch)
1513 {
1514   gdb_assert (gdbarch != NULL);
1515   if (gdbarch_debug >= 2)
1516     fprintf_unfiltered (gdb_stdlog, "gdbarch_bfd_arch_info called\n");
1517   return gdbarch->bfd_arch_info;
1518 }
1519
1520 int
1521 gdbarch_byte_order (struct gdbarch *gdbarch)
1522 {
1523   gdb_assert (gdbarch != NULL);
1524   if (gdbarch_debug >= 2)
1525     fprintf_unfiltered (gdb_stdlog, "gdbarch_byte_order called\n");
1526   return gdbarch->byte_order;
1527 }
1528
1529 enum gdb_osabi
1530 gdbarch_osabi (struct gdbarch *gdbarch)
1531 {
1532   gdb_assert (gdbarch != NULL);
1533   if (gdbarch_debug >= 2)
1534     fprintf_unfiltered (gdb_stdlog, "gdbarch_osabi called\n");
1535   return gdbarch->osabi;
1536 }
1537
1538 const struct target_desc *
1539 gdbarch_target_desc (struct gdbarch *gdbarch)
1540 {
1541   gdb_assert (gdbarch != NULL);
1542   if (gdbarch_debug >= 2)
1543     fprintf_unfiltered (gdb_stdlog, "gdbarch_target_desc called\n");
1544   return gdbarch->target_desc;
1545 }
1546
1547 int
1548 gdbarch_short_bit (struct gdbarch *gdbarch)
1549 {
1550   gdb_assert (gdbarch != NULL);
1551   /* Skip verify of short_bit, invalid_p == 0 */
1552   if (gdbarch_debug >= 2)
1553     fprintf_unfiltered (gdb_stdlog, "gdbarch_short_bit called\n");
1554   return gdbarch->short_bit;
1555 }
1556
1557 void
1558 set_gdbarch_short_bit (struct gdbarch *gdbarch,
1559                        int short_bit)
1560 {
1561   gdbarch->short_bit = short_bit;
1562 }
1563
1564 int
1565 gdbarch_int_bit (struct gdbarch *gdbarch)
1566 {
1567   gdb_assert (gdbarch != NULL);
1568   /* Skip verify of int_bit, invalid_p == 0 */
1569   if (gdbarch_debug >= 2)
1570     fprintf_unfiltered (gdb_stdlog, "gdbarch_int_bit called\n");
1571   return gdbarch->int_bit;
1572 }
1573
1574 void
1575 set_gdbarch_int_bit (struct gdbarch *gdbarch,
1576                      int int_bit)
1577 {
1578   gdbarch->int_bit = int_bit;
1579 }
1580
1581 int
1582 gdbarch_long_bit (struct gdbarch *gdbarch)
1583 {
1584   gdb_assert (gdbarch != NULL);
1585   /* Skip verify of long_bit, invalid_p == 0 */
1586   if (gdbarch_debug >= 2)
1587     fprintf_unfiltered (gdb_stdlog, "gdbarch_long_bit called\n");
1588   return gdbarch->long_bit;
1589 }
1590
1591 void
1592 set_gdbarch_long_bit (struct gdbarch *gdbarch,
1593                       int long_bit)
1594 {
1595   gdbarch->long_bit = long_bit;
1596 }
1597
1598 int
1599 gdbarch_long_long_bit (struct gdbarch *gdbarch)
1600 {
1601   gdb_assert (gdbarch != NULL);
1602   /* Skip verify of long_long_bit, invalid_p == 0 */
1603   if (gdbarch_debug >= 2)
1604     fprintf_unfiltered (gdb_stdlog, "gdbarch_long_long_bit called\n");
1605   return gdbarch->long_long_bit;
1606 }
1607
1608 void
1609 set_gdbarch_long_long_bit (struct gdbarch *gdbarch,
1610                            int long_long_bit)
1611 {
1612   gdbarch->long_long_bit = long_long_bit;
1613 }
1614
1615 int
1616 gdbarch_float_bit (struct gdbarch *gdbarch)
1617 {
1618   gdb_assert (gdbarch != NULL);
1619   /* Skip verify of float_bit, invalid_p == 0 */
1620   if (gdbarch_debug >= 2)
1621     fprintf_unfiltered (gdb_stdlog, "gdbarch_float_bit called\n");
1622   return gdbarch->float_bit;
1623 }
1624
1625 void
1626 set_gdbarch_float_bit (struct gdbarch *gdbarch,
1627                        int float_bit)
1628 {
1629   gdbarch->float_bit = float_bit;
1630 }
1631
1632 const struct floatformat **
1633 gdbarch_float_format (struct gdbarch *gdbarch)
1634 {
1635   gdb_assert (gdbarch != NULL);
1636   if (gdbarch_debug >= 2)
1637     fprintf_unfiltered (gdb_stdlog, "gdbarch_float_format called\n");
1638   return gdbarch->float_format;
1639 }
1640
1641 void
1642 set_gdbarch_float_format (struct gdbarch *gdbarch,
1643                           const struct floatformat ** float_format)
1644 {
1645   gdbarch->float_format = float_format;
1646 }
1647
1648 int
1649 gdbarch_double_bit (struct gdbarch *gdbarch)
1650 {
1651   gdb_assert (gdbarch != NULL);
1652   /* Skip verify of double_bit, invalid_p == 0 */
1653   if (gdbarch_debug >= 2)
1654     fprintf_unfiltered (gdb_stdlog, "gdbarch_double_bit called\n");
1655   return gdbarch->double_bit;
1656 }
1657
1658 void
1659 set_gdbarch_double_bit (struct gdbarch *gdbarch,
1660                         int double_bit)
1661 {
1662   gdbarch->double_bit = double_bit;
1663 }
1664
1665 const struct floatformat **
1666 gdbarch_double_format (struct gdbarch *gdbarch)
1667 {
1668   gdb_assert (gdbarch != NULL);
1669   if (gdbarch_debug >= 2)
1670     fprintf_unfiltered (gdb_stdlog, "gdbarch_double_format called\n");
1671   return gdbarch->double_format;
1672 }
1673
1674 void
1675 set_gdbarch_double_format (struct gdbarch *gdbarch,
1676                            const struct floatformat ** double_format)
1677 {
1678   gdbarch->double_format = double_format;
1679 }
1680
1681 int
1682 gdbarch_long_double_bit (struct gdbarch *gdbarch)
1683 {
1684   gdb_assert (gdbarch != NULL);
1685   /* Skip verify of long_double_bit, invalid_p == 0 */
1686   if (gdbarch_debug >= 2)
1687     fprintf_unfiltered (gdb_stdlog, "gdbarch_long_double_bit called\n");
1688   return gdbarch->long_double_bit;
1689 }
1690
1691 void
1692 set_gdbarch_long_double_bit (struct gdbarch *gdbarch,
1693                              int long_double_bit)
1694 {
1695   gdbarch->long_double_bit = long_double_bit;
1696 }
1697
1698 const struct floatformat **
1699 gdbarch_long_double_format (struct gdbarch *gdbarch)
1700 {
1701   gdb_assert (gdbarch != NULL);
1702   if (gdbarch_debug >= 2)
1703     fprintf_unfiltered (gdb_stdlog, "gdbarch_long_double_format called\n");
1704   return gdbarch->long_double_format;
1705 }
1706
1707 void
1708 set_gdbarch_long_double_format (struct gdbarch *gdbarch,
1709                                 const struct floatformat ** long_double_format)
1710 {
1711   gdbarch->long_double_format = long_double_format;
1712 }
1713
1714 int
1715 gdbarch_ptr_bit (struct gdbarch *gdbarch)
1716 {
1717   gdb_assert (gdbarch != NULL);
1718   /* Skip verify of ptr_bit, invalid_p == 0 */
1719   if (gdbarch_debug >= 2)
1720     fprintf_unfiltered (gdb_stdlog, "gdbarch_ptr_bit called\n");
1721   return gdbarch->ptr_bit;
1722 }
1723
1724 void
1725 set_gdbarch_ptr_bit (struct gdbarch *gdbarch,
1726                      int ptr_bit)
1727 {
1728   gdbarch->ptr_bit = ptr_bit;
1729 }
1730
1731 int
1732 gdbarch_addr_bit (struct gdbarch *gdbarch)
1733 {
1734   gdb_assert (gdbarch != NULL);
1735   /* Check variable changed from pre-default.  */
1736   gdb_assert (gdbarch->addr_bit != 0);
1737   if (gdbarch_debug >= 2)
1738     fprintf_unfiltered (gdb_stdlog, "gdbarch_addr_bit called\n");
1739   return gdbarch->addr_bit;
1740 }
1741
1742 void
1743 set_gdbarch_addr_bit (struct gdbarch *gdbarch,
1744                       int addr_bit)
1745 {
1746   gdbarch->addr_bit = addr_bit;
1747 }
1748
1749 int
1750 gdbarch_bfd_vma_bit (struct gdbarch *gdbarch)
1751 {
1752   gdb_assert (gdbarch != NULL);
1753   /* Skip verify of bfd_vma_bit, invalid_p == 0 */
1754   if (gdbarch_debug >= 2)
1755     fprintf_unfiltered (gdb_stdlog, "gdbarch_bfd_vma_bit called\n");
1756   return gdbarch->bfd_vma_bit;
1757 }
1758
1759 void
1760 set_gdbarch_bfd_vma_bit (struct gdbarch *gdbarch,
1761                          int bfd_vma_bit)
1762 {
1763   gdbarch->bfd_vma_bit = bfd_vma_bit;
1764 }
1765
1766 int
1767 gdbarch_char_signed (struct gdbarch *gdbarch)
1768 {
1769   gdb_assert (gdbarch != NULL);
1770   /* Check variable changed from pre-default.  */
1771   gdb_assert (gdbarch->char_signed != -1);
1772   if (gdbarch_debug >= 2)
1773     fprintf_unfiltered (gdb_stdlog, "gdbarch_char_signed called\n");
1774   return gdbarch->char_signed;
1775 }
1776
1777 void
1778 set_gdbarch_char_signed (struct gdbarch *gdbarch,
1779                          int char_signed)
1780 {
1781   gdbarch->char_signed = char_signed;
1782 }
1783
1784 int
1785 gdbarch_read_pc_p (struct gdbarch *gdbarch)
1786 {
1787   gdb_assert (gdbarch != NULL);
1788   return gdbarch->read_pc != NULL;
1789 }
1790
1791 CORE_ADDR
1792 gdbarch_read_pc (struct gdbarch *gdbarch, ptid_t ptid)
1793 {
1794   gdb_assert (gdbarch != NULL);
1795   gdb_assert (gdbarch->read_pc != NULL);
1796   if (gdbarch_debug >= 2)
1797     fprintf_unfiltered (gdb_stdlog, "gdbarch_read_pc called\n");
1798   return gdbarch->read_pc (ptid);
1799 }
1800
1801 void
1802 set_gdbarch_read_pc (struct gdbarch *gdbarch,
1803                      gdbarch_read_pc_ftype read_pc)
1804 {
1805   gdbarch->read_pc = read_pc;
1806 }
1807
1808 void
1809 gdbarch_write_pc (struct gdbarch *gdbarch, CORE_ADDR val, ptid_t ptid)
1810 {
1811   gdb_assert (gdbarch != NULL);
1812   gdb_assert (gdbarch->write_pc != NULL);
1813   if (gdbarch_debug >= 2)
1814     fprintf_unfiltered (gdb_stdlog, "gdbarch_write_pc called\n");
1815   gdbarch->write_pc (val, ptid);
1816 }
1817
1818 void
1819 set_gdbarch_write_pc (struct gdbarch *gdbarch,
1820                       gdbarch_write_pc_ftype write_pc)
1821 {
1822   gdbarch->write_pc = write_pc;
1823 }
1824
1825 void
1826 gdbarch_virtual_frame_pointer (struct gdbarch *gdbarch, CORE_ADDR pc, int *frame_regnum, LONGEST *frame_offset)
1827 {
1828   gdb_assert (gdbarch != NULL);
1829   gdb_assert (gdbarch->virtual_frame_pointer != NULL);
1830   if (gdbarch_debug >= 2)
1831     fprintf_unfiltered (gdb_stdlog, "gdbarch_virtual_frame_pointer called\n");
1832   gdbarch->virtual_frame_pointer (pc, frame_regnum, frame_offset);
1833 }
1834
1835 void
1836 set_gdbarch_virtual_frame_pointer (struct gdbarch *gdbarch,
1837                                    gdbarch_virtual_frame_pointer_ftype virtual_frame_pointer)
1838 {
1839   gdbarch->virtual_frame_pointer = virtual_frame_pointer;
1840 }
1841
1842 int
1843 gdbarch_pseudo_register_read_p (struct gdbarch *gdbarch)
1844 {
1845   gdb_assert (gdbarch != NULL);
1846   return gdbarch->pseudo_register_read != NULL;
1847 }
1848
1849 void
1850 gdbarch_pseudo_register_read (struct gdbarch *gdbarch, struct regcache *regcache, int cookednum, gdb_byte *buf)
1851 {
1852   gdb_assert (gdbarch != NULL);
1853   gdb_assert (gdbarch->pseudo_register_read != NULL);
1854   if (gdbarch_debug >= 2)
1855     fprintf_unfiltered (gdb_stdlog, "gdbarch_pseudo_register_read called\n");
1856   gdbarch->pseudo_register_read (gdbarch, regcache, cookednum, buf);
1857 }
1858
1859 void
1860 set_gdbarch_pseudo_register_read (struct gdbarch *gdbarch,
1861                                   gdbarch_pseudo_register_read_ftype pseudo_register_read)
1862 {
1863   gdbarch->pseudo_register_read = pseudo_register_read;
1864 }
1865
1866 int
1867 gdbarch_pseudo_register_write_p (struct gdbarch *gdbarch)
1868 {
1869   gdb_assert (gdbarch != NULL);
1870   return gdbarch->pseudo_register_write != NULL;
1871 }
1872
1873 void
1874 gdbarch_pseudo_register_write (struct gdbarch *gdbarch, struct regcache *regcache, int cookednum, const gdb_byte *buf)
1875 {
1876   gdb_assert (gdbarch != NULL);
1877   gdb_assert (gdbarch->pseudo_register_write != NULL);
1878   if (gdbarch_debug >= 2)
1879     fprintf_unfiltered (gdb_stdlog, "gdbarch_pseudo_register_write called\n");
1880   gdbarch->pseudo_register_write (gdbarch, regcache, cookednum, buf);
1881 }
1882
1883 void
1884 set_gdbarch_pseudo_register_write (struct gdbarch *gdbarch,
1885                                    gdbarch_pseudo_register_write_ftype pseudo_register_write)
1886 {
1887   gdbarch->pseudo_register_write = pseudo_register_write;
1888 }
1889
1890 int
1891 gdbarch_num_regs (struct gdbarch *gdbarch)
1892 {
1893   gdb_assert (gdbarch != NULL);
1894   /* Check variable changed from pre-default.  */
1895   gdb_assert (gdbarch->num_regs != -1);
1896   if (gdbarch_debug >= 2)
1897     fprintf_unfiltered (gdb_stdlog, "gdbarch_num_regs called\n");
1898   return gdbarch->num_regs;
1899 }
1900
1901 void
1902 set_gdbarch_num_regs (struct gdbarch *gdbarch,
1903                       int num_regs)
1904 {
1905   gdbarch->num_regs = num_regs;
1906 }
1907
1908 int
1909 gdbarch_num_pseudo_regs (struct gdbarch *gdbarch)
1910 {
1911   gdb_assert (gdbarch != NULL);
1912   /* Skip verify of num_pseudo_regs, invalid_p == 0 */
1913   if (gdbarch_debug >= 2)
1914     fprintf_unfiltered (gdb_stdlog, "gdbarch_num_pseudo_regs called\n");
1915   return gdbarch->num_pseudo_regs;
1916 }
1917
1918 void
1919 set_gdbarch_num_pseudo_regs (struct gdbarch *gdbarch,
1920                              int num_pseudo_regs)
1921 {
1922   gdbarch->num_pseudo_regs = num_pseudo_regs;
1923 }
1924
1925 int
1926 gdbarch_sp_regnum (struct gdbarch *gdbarch)
1927 {
1928   gdb_assert (gdbarch != NULL);
1929   /* Skip verify of sp_regnum, invalid_p == 0 */
1930   if (gdbarch_debug >= 2)
1931     fprintf_unfiltered (gdb_stdlog, "gdbarch_sp_regnum called\n");
1932   return gdbarch->sp_regnum;
1933 }
1934
1935 void
1936 set_gdbarch_sp_regnum (struct gdbarch *gdbarch,
1937                        int sp_regnum)
1938 {
1939   gdbarch->sp_regnum = sp_regnum;
1940 }
1941
1942 int
1943 gdbarch_pc_regnum (struct gdbarch *gdbarch)
1944 {
1945   gdb_assert (gdbarch != NULL);
1946   /* Skip verify of pc_regnum, invalid_p == 0 */
1947   if (gdbarch_debug >= 2)
1948     fprintf_unfiltered (gdb_stdlog, "gdbarch_pc_regnum called\n");
1949   return gdbarch->pc_regnum;
1950 }
1951
1952 void
1953 set_gdbarch_pc_regnum (struct gdbarch *gdbarch,
1954                        int pc_regnum)
1955 {
1956   gdbarch->pc_regnum = pc_regnum;
1957 }
1958
1959 int
1960 gdbarch_ps_regnum (struct gdbarch *gdbarch)
1961 {
1962   gdb_assert (gdbarch != NULL);
1963   /* Skip verify of ps_regnum, invalid_p == 0 */
1964   if (gdbarch_debug >= 2)
1965     fprintf_unfiltered (gdb_stdlog, "gdbarch_ps_regnum called\n");
1966   return gdbarch->ps_regnum;
1967 }
1968
1969 void
1970 set_gdbarch_ps_regnum (struct gdbarch *gdbarch,
1971                        int ps_regnum)
1972 {
1973   gdbarch->ps_regnum = ps_regnum;
1974 }
1975
1976 int
1977 gdbarch_fp0_regnum (struct gdbarch *gdbarch)
1978 {
1979   gdb_assert (gdbarch != NULL);
1980   /* Skip verify of fp0_regnum, invalid_p == 0 */
1981   if (gdbarch_debug >= 2)
1982     fprintf_unfiltered (gdb_stdlog, "gdbarch_fp0_regnum called\n");
1983   return gdbarch->fp0_regnum;
1984 }
1985
1986 void
1987 set_gdbarch_fp0_regnum (struct gdbarch *gdbarch,
1988                         int fp0_regnum)
1989 {
1990   gdbarch->fp0_regnum = fp0_regnum;
1991 }
1992
1993 int
1994 gdbarch_stab_reg_to_regnum (struct gdbarch *gdbarch, int stab_regnr)
1995 {
1996   gdb_assert (gdbarch != NULL);
1997   gdb_assert (gdbarch->stab_reg_to_regnum != NULL);
1998   if (gdbarch_debug >= 2)
1999     fprintf_unfiltered (gdb_stdlog, "gdbarch_stab_reg_to_regnum called\n");
2000   return gdbarch->stab_reg_to_regnum (stab_regnr);
2001 }
2002
2003 void
2004 set_gdbarch_stab_reg_to_regnum (struct gdbarch *gdbarch,
2005                                 gdbarch_stab_reg_to_regnum_ftype stab_reg_to_regnum)
2006 {
2007   gdbarch->stab_reg_to_regnum = stab_reg_to_regnum;
2008 }
2009
2010 int
2011 gdbarch_ecoff_reg_to_regnum (struct gdbarch *gdbarch, int ecoff_regnr)
2012 {
2013   gdb_assert (gdbarch != NULL);
2014   gdb_assert (gdbarch->ecoff_reg_to_regnum != NULL);
2015   if (gdbarch_debug >= 2)
2016     fprintf_unfiltered (gdb_stdlog, "gdbarch_ecoff_reg_to_regnum called\n");
2017   return gdbarch->ecoff_reg_to_regnum (ecoff_regnr);
2018 }
2019
2020 void
2021 set_gdbarch_ecoff_reg_to_regnum (struct gdbarch *gdbarch,
2022                                  gdbarch_ecoff_reg_to_regnum_ftype ecoff_reg_to_regnum)
2023 {
2024   gdbarch->ecoff_reg_to_regnum = ecoff_reg_to_regnum;
2025 }
2026
2027 int
2028 gdbarch_dwarf_reg_to_regnum (struct gdbarch *gdbarch, int dwarf_regnr)
2029 {
2030   gdb_assert (gdbarch != NULL);
2031   gdb_assert (gdbarch->dwarf_reg_to_regnum != NULL);
2032   if (gdbarch_debug >= 2)
2033     fprintf_unfiltered (gdb_stdlog, "gdbarch_dwarf_reg_to_regnum called\n");
2034   return gdbarch->dwarf_reg_to_regnum (dwarf_regnr);
2035 }
2036
2037 void
2038 set_gdbarch_dwarf_reg_to_regnum (struct gdbarch *gdbarch,
2039                                  gdbarch_dwarf_reg_to_regnum_ftype dwarf_reg_to_regnum)
2040 {
2041   gdbarch->dwarf_reg_to_regnum = dwarf_reg_to_regnum;
2042 }
2043
2044 int
2045 gdbarch_sdb_reg_to_regnum (struct gdbarch *gdbarch, int sdb_regnr)
2046 {
2047   gdb_assert (gdbarch != NULL);
2048   gdb_assert (gdbarch->sdb_reg_to_regnum != NULL);
2049   if (gdbarch_debug >= 2)
2050     fprintf_unfiltered (gdb_stdlog, "gdbarch_sdb_reg_to_regnum called\n");
2051   return gdbarch->sdb_reg_to_regnum (sdb_regnr);
2052 }
2053
2054 void
2055 set_gdbarch_sdb_reg_to_regnum (struct gdbarch *gdbarch,
2056                                gdbarch_sdb_reg_to_regnum_ftype sdb_reg_to_regnum)
2057 {
2058   gdbarch->sdb_reg_to_regnum = sdb_reg_to_regnum;
2059 }
2060
2061 int
2062 gdbarch_dwarf2_reg_to_regnum (struct gdbarch *gdbarch, int dwarf2_regnr)
2063 {
2064   gdb_assert (gdbarch != NULL);
2065   gdb_assert (gdbarch->dwarf2_reg_to_regnum != NULL);
2066   if (gdbarch_debug >= 2)
2067     fprintf_unfiltered (gdb_stdlog, "gdbarch_dwarf2_reg_to_regnum called\n");
2068   return gdbarch->dwarf2_reg_to_regnum (dwarf2_regnr);
2069 }
2070
2071 void
2072 set_gdbarch_dwarf2_reg_to_regnum (struct gdbarch *gdbarch,
2073                                   gdbarch_dwarf2_reg_to_regnum_ftype dwarf2_reg_to_regnum)
2074 {
2075   gdbarch->dwarf2_reg_to_regnum = dwarf2_reg_to_regnum;
2076 }
2077
2078 const char *
2079 gdbarch_register_name (struct gdbarch *gdbarch, int regnr)
2080 {
2081   gdb_assert (gdbarch != NULL);
2082   gdb_assert (gdbarch->register_name != NULL);
2083   if (gdbarch_debug >= 2)
2084     fprintf_unfiltered (gdb_stdlog, "gdbarch_register_name called\n");
2085   return gdbarch->register_name (regnr);
2086 }
2087
2088 void
2089 set_gdbarch_register_name (struct gdbarch *gdbarch,
2090                            gdbarch_register_name_ftype register_name)
2091 {
2092   gdbarch->register_name = register_name;
2093 }
2094
2095 int
2096 gdbarch_register_type_p (struct gdbarch *gdbarch)
2097 {
2098   gdb_assert (gdbarch != NULL);
2099   return gdbarch->register_type != NULL;
2100 }
2101
2102 struct type *
2103 gdbarch_register_type (struct gdbarch *gdbarch, int reg_nr)
2104 {
2105   gdb_assert (gdbarch != NULL);
2106   gdb_assert (gdbarch->register_type != NULL);
2107   if (gdbarch_debug >= 2)
2108     fprintf_unfiltered (gdb_stdlog, "gdbarch_register_type called\n");
2109   return gdbarch->register_type (gdbarch, reg_nr);
2110 }
2111
2112 void
2113 set_gdbarch_register_type (struct gdbarch *gdbarch,
2114                            gdbarch_register_type_ftype register_type)
2115 {
2116   gdbarch->register_type = register_type;
2117 }
2118
2119 int
2120 gdbarch_unwind_dummy_id_p (struct gdbarch *gdbarch)
2121 {
2122   gdb_assert (gdbarch != NULL);
2123   return gdbarch->unwind_dummy_id != NULL;
2124 }
2125
2126 struct frame_id
2127 gdbarch_unwind_dummy_id (struct gdbarch *gdbarch, struct frame_info *info)
2128 {
2129   gdb_assert (gdbarch != NULL);
2130   gdb_assert (gdbarch->unwind_dummy_id != NULL);
2131   if (gdbarch_debug >= 2)
2132     fprintf_unfiltered (gdb_stdlog, "gdbarch_unwind_dummy_id called\n");
2133   return gdbarch->unwind_dummy_id (gdbarch, info);
2134 }
2135
2136 void
2137 set_gdbarch_unwind_dummy_id (struct gdbarch *gdbarch,
2138                              gdbarch_unwind_dummy_id_ftype unwind_dummy_id)
2139 {
2140   gdbarch->unwind_dummy_id = unwind_dummy_id;
2141 }
2142
2143 int
2144 gdbarch_deprecated_fp_regnum (struct gdbarch *gdbarch)
2145 {
2146   gdb_assert (gdbarch != NULL);
2147   /* Skip verify of deprecated_fp_regnum, invalid_p == 0 */
2148   if (gdbarch_debug >= 2)
2149     fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_fp_regnum called\n");
2150   return gdbarch->deprecated_fp_regnum;
2151 }
2152
2153 void
2154 set_gdbarch_deprecated_fp_regnum (struct gdbarch *gdbarch,
2155                                   int deprecated_fp_regnum)
2156 {
2157   gdbarch->deprecated_fp_regnum = deprecated_fp_regnum;
2158 }
2159
2160 int
2161 gdbarch_push_dummy_call_p (struct gdbarch *gdbarch)
2162 {
2163   gdb_assert (gdbarch != NULL);
2164   return gdbarch->push_dummy_call != NULL;
2165 }
2166
2167 CORE_ADDR
2168 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)
2169 {
2170   gdb_assert (gdbarch != NULL);
2171   gdb_assert (gdbarch->push_dummy_call != NULL);
2172   if (gdbarch_debug >= 2)
2173     fprintf_unfiltered (gdb_stdlog, "gdbarch_push_dummy_call called\n");
2174   return gdbarch->push_dummy_call (gdbarch, function, regcache, bp_addr, nargs, args, sp, struct_return, struct_addr);
2175 }
2176
2177 void
2178 set_gdbarch_push_dummy_call (struct gdbarch *gdbarch,
2179                              gdbarch_push_dummy_call_ftype push_dummy_call)
2180 {
2181   gdbarch->push_dummy_call = push_dummy_call;
2182 }
2183
2184 int
2185 gdbarch_deprecated_register_size (struct gdbarch *gdbarch)
2186 {
2187   gdb_assert (gdbarch != NULL);
2188   if (gdbarch_debug >= 2)
2189     fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_register_size called\n");
2190   return gdbarch->deprecated_register_size;
2191 }
2192
2193 void
2194 set_gdbarch_deprecated_register_size (struct gdbarch *gdbarch,
2195                                       int deprecated_register_size)
2196 {
2197   gdbarch->deprecated_register_size = deprecated_register_size;
2198 }
2199
2200 int
2201 gdbarch_call_dummy_location (struct gdbarch *gdbarch)
2202 {
2203   gdb_assert (gdbarch != NULL);
2204   /* Skip verify of call_dummy_location, invalid_p == 0 */
2205   if (gdbarch_debug >= 2)
2206     fprintf_unfiltered (gdb_stdlog, "gdbarch_call_dummy_location called\n");
2207   return gdbarch->call_dummy_location;
2208 }
2209
2210 void
2211 set_gdbarch_call_dummy_location (struct gdbarch *gdbarch,
2212                                  int call_dummy_location)
2213 {
2214   gdbarch->call_dummy_location = call_dummy_location;
2215 }
2216
2217 int
2218 gdbarch_push_dummy_code_p (struct gdbarch *gdbarch)
2219 {
2220   gdb_assert (gdbarch != NULL);
2221   return gdbarch->push_dummy_code != NULL;
2222 }
2223
2224 CORE_ADDR
2225 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)
2226 {
2227   gdb_assert (gdbarch != NULL);
2228   gdb_assert (gdbarch->push_dummy_code != NULL);
2229   if (gdbarch_debug >= 2)
2230     fprintf_unfiltered (gdb_stdlog, "gdbarch_push_dummy_code called\n");
2231   return gdbarch->push_dummy_code (gdbarch, sp, funaddr, using_gcc, args, nargs, value_type, real_pc, bp_addr);
2232 }
2233
2234 void
2235 set_gdbarch_push_dummy_code (struct gdbarch *gdbarch,
2236                              gdbarch_push_dummy_code_ftype push_dummy_code)
2237 {
2238   gdbarch->push_dummy_code = push_dummy_code;
2239 }
2240
2241 void
2242 gdbarch_print_registers_info (struct gdbarch *gdbarch, struct ui_file *file, struct frame_info *frame, int regnum, int all)
2243 {
2244   gdb_assert (gdbarch != NULL);
2245   gdb_assert (gdbarch->print_registers_info != NULL);
2246   if (gdbarch_debug >= 2)
2247     fprintf_unfiltered (gdb_stdlog, "gdbarch_print_registers_info called\n");
2248   gdbarch->print_registers_info (gdbarch, file, frame, regnum, all);
2249 }
2250
2251 void
2252 set_gdbarch_print_registers_info (struct gdbarch *gdbarch,
2253                                   gdbarch_print_registers_info_ftype print_registers_info)
2254 {
2255   gdbarch->print_registers_info = print_registers_info;
2256 }
2257
2258 int
2259 gdbarch_print_float_info_p (struct gdbarch *gdbarch)
2260 {
2261   gdb_assert (gdbarch != NULL);
2262   return gdbarch->print_float_info != NULL;
2263 }
2264
2265 void
2266 gdbarch_print_float_info (struct gdbarch *gdbarch, struct ui_file *file, struct frame_info *frame, const char *args)
2267 {
2268   gdb_assert (gdbarch != NULL);
2269   gdb_assert (gdbarch->print_float_info != NULL);
2270   if (gdbarch_debug >= 2)
2271     fprintf_unfiltered (gdb_stdlog, "gdbarch_print_float_info called\n");
2272   gdbarch->print_float_info (gdbarch, file, frame, args);
2273 }
2274
2275 void
2276 set_gdbarch_print_float_info (struct gdbarch *gdbarch,
2277                               gdbarch_print_float_info_ftype print_float_info)
2278 {
2279   gdbarch->print_float_info = print_float_info;
2280 }
2281
2282 int
2283 gdbarch_print_vector_info_p (struct gdbarch *gdbarch)
2284 {
2285   gdb_assert (gdbarch != NULL);
2286   return gdbarch->print_vector_info != NULL;
2287 }
2288
2289 void
2290 gdbarch_print_vector_info (struct gdbarch *gdbarch, struct ui_file *file, struct frame_info *frame, const char *args)
2291 {
2292   gdb_assert (gdbarch != NULL);
2293   gdb_assert (gdbarch->print_vector_info != NULL);
2294   if (gdbarch_debug >= 2)
2295     fprintf_unfiltered (gdb_stdlog, "gdbarch_print_vector_info called\n");
2296   gdbarch->print_vector_info (gdbarch, file, frame, args);
2297 }
2298
2299 void
2300 set_gdbarch_print_vector_info (struct gdbarch *gdbarch,
2301                                gdbarch_print_vector_info_ftype print_vector_info)
2302 {
2303   gdbarch->print_vector_info = print_vector_info;
2304 }
2305
2306 int
2307 gdbarch_register_sim_regno (struct gdbarch *gdbarch, int reg_nr)
2308 {
2309   gdb_assert (gdbarch != NULL);
2310   gdb_assert (gdbarch->register_sim_regno != NULL);
2311   if (gdbarch_debug >= 2)
2312     fprintf_unfiltered (gdb_stdlog, "gdbarch_register_sim_regno called\n");
2313   return gdbarch->register_sim_regno (reg_nr);
2314 }
2315
2316 void
2317 set_gdbarch_register_sim_regno (struct gdbarch *gdbarch,
2318                                 gdbarch_register_sim_regno_ftype register_sim_regno)
2319 {
2320   gdbarch->register_sim_regno = register_sim_regno;
2321 }
2322
2323 int
2324 gdbarch_register_bytes_ok_p (struct gdbarch *gdbarch)
2325 {
2326   gdb_assert (gdbarch != NULL);
2327   return gdbarch->register_bytes_ok != NULL;
2328 }
2329
2330 int
2331 gdbarch_register_bytes_ok (struct gdbarch *gdbarch, long nr_bytes)
2332 {
2333   gdb_assert (gdbarch != NULL);
2334   gdb_assert (gdbarch->register_bytes_ok != NULL);
2335   if (gdbarch_debug >= 2)
2336     fprintf_unfiltered (gdb_stdlog, "gdbarch_register_bytes_ok called\n");
2337   return gdbarch->register_bytes_ok (nr_bytes);
2338 }
2339
2340 void
2341 set_gdbarch_register_bytes_ok (struct gdbarch *gdbarch,
2342                                gdbarch_register_bytes_ok_ftype register_bytes_ok)
2343 {
2344   gdbarch->register_bytes_ok = register_bytes_ok;
2345 }
2346
2347 int
2348 gdbarch_cannot_fetch_register (struct gdbarch *gdbarch, int regnum)
2349 {
2350   gdb_assert (gdbarch != NULL);
2351   gdb_assert (gdbarch->cannot_fetch_register != NULL);
2352   if (gdbarch_debug >= 2)
2353     fprintf_unfiltered (gdb_stdlog, "gdbarch_cannot_fetch_register called\n");
2354   return gdbarch->cannot_fetch_register (regnum);
2355 }
2356
2357 void
2358 set_gdbarch_cannot_fetch_register (struct gdbarch *gdbarch,
2359                                    gdbarch_cannot_fetch_register_ftype cannot_fetch_register)
2360 {
2361   gdbarch->cannot_fetch_register = cannot_fetch_register;
2362 }
2363
2364 int
2365 gdbarch_cannot_store_register (struct gdbarch *gdbarch, int regnum)
2366 {
2367   gdb_assert (gdbarch != NULL);
2368   gdb_assert (gdbarch->cannot_store_register != NULL);
2369   if (gdbarch_debug >= 2)
2370     fprintf_unfiltered (gdb_stdlog, "gdbarch_cannot_store_register called\n");
2371   return gdbarch->cannot_store_register (regnum);
2372 }
2373
2374 void
2375 set_gdbarch_cannot_store_register (struct gdbarch *gdbarch,
2376                                    gdbarch_cannot_store_register_ftype cannot_store_register)
2377 {
2378   gdbarch->cannot_store_register = cannot_store_register;
2379 }
2380
2381 int
2382 gdbarch_get_longjmp_target_p (struct gdbarch *gdbarch)
2383 {
2384   gdb_assert (gdbarch != NULL);
2385   return gdbarch->get_longjmp_target != NULL;
2386 }
2387
2388 int
2389 gdbarch_get_longjmp_target (struct gdbarch *gdbarch, CORE_ADDR *pc)
2390 {
2391   gdb_assert (gdbarch != NULL);
2392   gdb_assert (gdbarch->get_longjmp_target != NULL);
2393   if (gdbarch_debug >= 2)
2394     fprintf_unfiltered (gdb_stdlog, "gdbarch_get_longjmp_target called\n");
2395   return gdbarch->get_longjmp_target (pc);
2396 }
2397
2398 void
2399 set_gdbarch_get_longjmp_target (struct gdbarch *gdbarch,
2400                                 gdbarch_get_longjmp_target_ftype get_longjmp_target)
2401 {
2402   gdbarch->get_longjmp_target = get_longjmp_target;
2403 }
2404
2405 int
2406 gdbarch_believe_pcc_promotion (struct gdbarch *gdbarch)
2407 {
2408   gdb_assert (gdbarch != NULL);
2409   if (gdbarch_debug >= 2)
2410     fprintf_unfiltered (gdb_stdlog, "gdbarch_believe_pcc_promotion called\n");
2411   return gdbarch->believe_pcc_promotion;
2412 }
2413
2414 void
2415 set_gdbarch_believe_pcc_promotion (struct gdbarch *gdbarch,
2416                                    int believe_pcc_promotion)
2417 {
2418   gdbarch->believe_pcc_promotion = believe_pcc_promotion;
2419 }
2420
2421 int
2422 gdbarch_convert_register_p (struct gdbarch *gdbarch, int regnum, struct type *type)
2423 {
2424   gdb_assert (gdbarch != NULL);
2425   gdb_assert (gdbarch->convert_register_p != NULL);
2426   if (gdbarch_debug >= 2)
2427     fprintf_unfiltered (gdb_stdlog, "gdbarch_convert_register_p called\n");
2428   return gdbarch->convert_register_p (regnum, type);
2429 }
2430
2431 void
2432 set_gdbarch_convert_register_p (struct gdbarch *gdbarch,
2433                                 gdbarch_convert_register_p_ftype convert_register_p)
2434 {
2435   gdbarch->convert_register_p = convert_register_p;
2436 }
2437
2438 void
2439 gdbarch_register_to_value (struct gdbarch *gdbarch, struct frame_info *frame, int regnum, struct type *type, gdb_byte *buf)
2440 {
2441   gdb_assert (gdbarch != NULL);
2442   gdb_assert (gdbarch->register_to_value != NULL);
2443   if (gdbarch_debug >= 2)
2444     fprintf_unfiltered (gdb_stdlog, "gdbarch_register_to_value called\n");
2445   gdbarch->register_to_value (frame, regnum, type, buf);
2446 }
2447
2448 void
2449 set_gdbarch_register_to_value (struct gdbarch *gdbarch,
2450                                gdbarch_register_to_value_ftype register_to_value)
2451 {
2452   gdbarch->register_to_value = register_to_value;
2453 }
2454
2455 void
2456 gdbarch_value_to_register (struct gdbarch *gdbarch, struct frame_info *frame, int regnum, struct type *type, const gdb_byte *buf)
2457 {
2458   gdb_assert (gdbarch != NULL);
2459   gdb_assert (gdbarch->value_to_register != NULL);
2460   if (gdbarch_debug >= 2)
2461     fprintf_unfiltered (gdb_stdlog, "gdbarch_value_to_register called\n");
2462   gdbarch->value_to_register (frame, regnum, type, buf);
2463 }
2464
2465 void
2466 set_gdbarch_value_to_register (struct gdbarch *gdbarch,
2467                                gdbarch_value_to_register_ftype value_to_register)
2468 {
2469   gdbarch->value_to_register = value_to_register;
2470 }
2471
2472 struct value *
2473 gdbarch_value_from_register (struct gdbarch *gdbarch, struct type *type, int regnum, struct frame_info *frame)
2474 {
2475   gdb_assert (gdbarch != NULL);
2476   gdb_assert (gdbarch->value_from_register != NULL);
2477   if (gdbarch_debug >= 2)
2478     fprintf_unfiltered (gdb_stdlog, "gdbarch_value_from_register called\n");
2479   return gdbarch->value_from_register (type, regnum, frame);
2480 }
2481
2482 void
2483 set_gdbarch_value_from_register (struct gdbarch *gdbarch,
2484                                  gdbarch_value_from_register_ftype value_from_register)
2485 {
2486   gdbarch->value_from_register = value_from_register;
2487 }
2488
2489 CORE_ADDR
2490 gdbarch_pointer_to_address (struct gdbarch *gdbarch, struct type *type, const gdb_byte *buf)
2491 {
2492   gdb_assert (gdbarch != NULL);
2493   gdb_assert (gdbarch->pointer_to_address != NULL);
2494   if (gdbarch_debug >= 2)
2495     fprintf_unfiltered (gdb_stdlog, "gdbarch_pointer_to_address called\n");
2496   return gdbarch->pointer_to_address (type, buf);
2497 }
2498
2499 void
2500 set_gdbarch_pointer_to_address (struct gdbarch *gdbarch,
2501                                 gdbarch_pointer_to_address_ftype pointer_to_address)
2502 {
2503   gdbarch->pointer_to_address = pointer_to_address;
2504 }
2505
2506 void
2507 gdbarch_address_to_pointer (struct gdbarch *gdbarch, struct type *type, gdb_byte *buf, CORE_ADDR addr)
2508 {
2509   gdb_assert (gdbarch != NULL);
2510   gdb_assert (gdbarch->address_to_pointer != NULL);
2511   if (gdbarch_debug >= 2)
2512     fprintf_unfiltered (gdb_stdlog, "gdbarch_address_to_pointer called\n");
2513   gdbarch->address_to_pointer (type, buf, addr);
2514 }
2515
2516 void
2517 set_gdbarch_address_to_pointer (struct gdbarch *gdbarch,
2518                                 gdbarch_address_to_pointer_ftype address_to_pointer)
2519 {
2520   gdbarch->address_to_pointer = address_to_pointer;
2521 }
2522
2523 int
2524 gdbarch_integer_to_address_p (struct gdbarch *gdbarch)
2525 {
2526   gdb_assert (gdbarch != NULL);
2527   return gdbarch->integer_to_address != NULL;
2528 }
2529
2530 CORE_ADDR
2531 gdbarch_integer_to_address (struct gdbarch *gdbarch, struct type *type, const gdb_byte *buf)
2532 {
2533   gdb_assert (gdbarch != NULL);
2534   gdb_assert (gdbarch->integer_to_address != NULL);
2535   if (gdbarch_debug >= 2)
2536     fprintf_unfiltered (gdb_stdlog, "gdbarch_integer_to_address called\n");
2537   return gdbarch->integer_to_address (gdbarch, type, buf);
2538 }
2539
2540 void
2541 set_gdbarch_integer_to_address (struct gdbarch *gdbarch,
2542                                 gdbarch_integer_to_address_ftype integer_to_address)
2543 {
2544   gdbarch->integer_to_address = integer_to_address;
2545 }
2546
2547 int
2548 gdbarch_return_value_p (struct gdbarch *gdbarch)
2549 {
2550   gdb_assert (gdbarch != NULL);
2551   return gdbarch->return_value != legacy_return_value;
2552 }
2553
2554 enum return_value_convention
2555 gdbarch_return_value (struct gdbarch *gdbarch, struct type *valtype, struct regcache *regcache, gdb_byte *readbuf, const gdb_byte *writebuf)
2556 {
2557   gdb_assert (gdbarch != NULL);
2558   gdb_assert (gdbarch->return_value != NULL);
2559   /* Do not check predicate: gdbarch->return_value != legacy_return_value, allow call.  */
2560   if (gdbarch_debug >= 2)
2561     fprintf_unfiltered (gdb_stdlog, "gdbarch_return_value called\n");
2562   return gdbarch->return_value (gdbarch, valtype, regcache, readbuf, writebuf);
2563 }
2564
2565 void
2566 set_gdbarch_return_value (struct gdbarch *gdbarch,
2567                           gdbarch_return_value_ftype return_value)
2568 {
2569   gdbarch->return_value = return_value;
2570 }
2571
2572 void
2573 gdbarch_extract_return_value (struct gdbarch *gdbarch, struct type *type, struct regcache *regcache, gdb_byte *valbuf)
2574 {
2575   gdb_assert (gdbarch != NULL);
2576   gdb_assert (gdbarch->extract_return_value != NULL);
2577   if (gdbarch_debug >= 2)
2578     fprintf_unfiltered (gdb_stdlog, "gdbarch_extract_return_value called\n");
2579   gdbarch->extract_return_value (type, regcache, valbuf);
2580 }
2581
2582 void
2583 set_gdbarch_extract_return_value (struct gdbarch *gdbarch,
2584                                   gdbarch_extract_return_value_ftype extract_return_value)
2585 {
2586   gdbarch->extract_return_value = extract_return_value;
2587 }
2588
2589 void
2590 gdbarch_store_return_value (struct gdbarch *gdbarch, struct type *type, struct regcache *regcache, const gdb_byte *valbuf)
2591 {
2592   gdb_assert (gdbarch != NULL);
2593   gdb_assert (gdbarch->store_return_value != NULL);
2594   if (gdbarch_debug >= 2)
2595     fprintf_unfiltered (gdb_stdlog, "gdbarch_store_return_value called\n");
2596   gdbarch->store_return_value (type, regcache, valbuf);
2597 }
2598
2599 void
2600 set_gdbarch_store_return_value (struct gdbarch *gdbarch,
2601                                 gdbarch_store_return_value_ftype store_return_value)
2602 {
2603   gdbarch->store_return_value = store_return_value;
2604 }
2605
2606 int
2607 gdbarch_deprecated_use_struct_convention (struct gdbarch *gdbarch, int gcc_p, struct type *value_type)
2608 {
2609   gdb_assert (gdbarch != NULL);
2610   gdb_assert (gdbarch->deprecated_use_struct_convention != NULL);
2611   if (gdbarch_debug >= 2)
2612     fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_use_struct_convention called\n");
2613   return gdbarch->deprecated_use_struct_convention (gcc_p, value_type);
2614 }
2615
2616 void
2617 set_gdbarch_deprecated_use_struct_convention (struct gdbarch *gdbarch,
2618                                               gdbarch_deprecated_use_struct_convention_ftype deprecated_use_struct_convention)
2619 {
2620   gdbarch->deprecated_use_struct_convention = deprecated_use_struct_convention;
2621 }
2622
2623 int
2624 gdbarch_deprecated_extract_struct_value_address_p (struct gdbarch *gdbarch)
2625 {
2626   gdb_assert (gdbarch != NULL);
2627   return gdbarch->deprecated_extract_struct_value_address != NULL;
2628 }
2629
2630 CORE_ADDR
2631 gdbarch_deprecated_extract_struct_value_address (struct gdbarch *gdbarch, struct regcache *regcache)
2632 {
2633   gdb_assert (gdbarch != NULL);
2634   gdb_assert (gdbarch->deprecated_extract_struct_value_address != NULL);
2635   if (gdbarch_debug >= 2)
2636     fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_extract_struct_value_address called\n");
2637   return gdbarch->deprecated_extract_struct_value_address (regcache);
2638 }
2639
2640 void
2641 set_gdbarch_deprecated_extract_struct_value_address (struct gdbarch *gdbarch,
2642                                                      gdbarch_deprecated_extract_struct_value_address_ftype deprecated_extract_struct_value_address)
2643 {
2644   gdbarch->deprecated_extract_struct_value_address = deprecated_extract_struct_value_address;
2645 }
2646
2647 CORE_ADDR
2648 gdbarch_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR ip)
2649 {
2650   gdb_assert (gdbarch != NULL);
2651   gdb_assert (gdbarch->skip_prologue != NULL);
2652   if (gdbarch_debug >= 2)
2653     fprintf_unfiltered (gdb_stdlog, "gdbarch_skip_prologue called\n");
2654   return gdbarch->skip_prologue (ip);
2655 }
2656
2657 void
2658 set_gdbarch_skip_prologue (struct gdbarch *gdbarch,
2659                            gdbarch_skip_prologue_ftype skip_prologue)
2660 {
2661   gdbarch->skip_prologue = skip_prologue;
2662 }
2663
2664 int
2665 gdbarch_inner_than (struct gdbarch *gdbarch, CORE_ADDR lhs, CORE_ADDR rhs)
2666 {
2667   gdb_assert (gdbarch != NULL);
2668   gdb_assert (gdbarch->inner_than != NULL);
2669   if (gdbarch_debug >= 2)
2670     fprintf_unfiltered (gdb_stdlog, "gdbarch_inner_than called\n");
2671   return gdbarch->inner_than (lhs, rhs);
2672 }
2673
2674 void
2675 set_gdbarch_inner_than (struct gdbarch *gdbarch,
2676                         gdbarch_inner_than_ftype inner_than)
2677 {
2678   gdbarch->inner_than = inner_than;
2679 }
2680
2681 const gdb_byte *
2682 gdbarch_breakpoint_from_pc (struct gdbarch *gdbarch, CORE_ADDR *pcptr, int *lenptr)
2683 {
2684   gdb_assert (gdbarch != NULL);
2685   gdb_assert (gdbarch->breakpoint_from_pc != NULL);
2686   if (gdbarch_debug >= 2)
2687     fprintf_unfiltered (gdb_stdlog, "gdbarch_breakpoint_from_pc called\n");
2688   return gdbarch->breakpoint_from_pc (pcptr, lenptr);
2689 }
2690
2691 void
2692 set_gdbarch_breakpoint_from_pc (struct gdbarch *gdbarch,
2693                                 gdbarch_breakpoint_from_pc_ftype breakpoint_from_pc)
2694 {
2695   gdbarch->breakpoint_from_pc = breakpoint_from_pc;
2696 }
2697
2698 int
2699 gdbarch_adjust_breakpoint_address_p (struct gdbarch *gdbarch)
2700 {
2701   gdb_assert (gdbarch != NULL);
2702   return gdbarch->adjust_breakpoint_address != NULL;
2703 }
2704
2705 CORE_ADDR
2706 gdbarch_adjust_breakpoint_address (struct gdbarch *gdbarch, CORE_ADDR bpaddr)
2707 {
2708   gdb_assert (gdbarch != NULL);
2709   gdb_assert (gdbarch->adjust_breakpoint_address != NULL);
2710   if (gdbarch_debug >= 2)
2711     fprintf_unfiltered (gdb_stdlog, "gdbarch_adjust_breakpoint_address called\n");
2712   return gdbarch->adjust_breakpoint_address (gdbarch, bpaddr);
2713 }
2714
2715 void
2716 set_gdbarch_adjust_breakpoint_address (struct gdbarch *gdbarch,
2717                                        gdbarch_adjust_breakpoint_address_ftype adjust_breakpoint_address)
2718 {
2719   gdbarch->adjust_breakpoint_address = adjust_breakpoint_address;
2720 }
2721
2722 int
2723 gdbarch_memory_insert_breakpoint (struct gdbarch *gdbarch, struct bp_target_info *bp_tgt)
2724 {
2725   gdb_assert (gdbarch != NULL);
2726   gdb_assert (gdbarch->memory_insert_breakpoint != NULL);
2727   if (gdbarch_debug >= 2)
2728     fprintf_unfiltered (gdb_stdlog, "gdbarch_memory_insert_breakpoint called\n");
2729   return gdbarch->memory_insert_breakpoint (bp_tgt);
2730 }
2731
2732 void
2733 set_gdbarch_memory_insert_breakpoint (struct gdbarch *gdbarch,
2734                                       gdbarch_memory_insert_breakpoint_ftype memory_insert_breakpoint)
2735 {
2736   gdbarch->memory_insert_breakpoint = memory_insert_breakpoint;
2737 }
2738
2739 int
2740 gdbarch_memory_remove_breakpoint (struct gdbarch *gdbarch, struct bp_target_info *bp_tgt)
2741 {
2742   gdb_assert (gdbarch != NULL);
2743   gdb_assert (gdbarch->memory_remove_breakpoint != NULL);
2744   if (gdbarch_debug >= 2)
2745     fprintf_unfiltered (gdb_stdlog, "gdbarch_memory_remove_breakpoint called\n");
2746   return gdbarch->memory_remove_breakpoint (bp_tgt);
2747 }
2748
2749 void
2750 set_gdbarch_memory_remove_breakpoint (struct gdbarch *gdbarch,
2751                                       gdbarch_memory_remove_breakpoint_ftype memory_remove_breakpoint)
2752 {
2753   gdbarch->memory_remove_breakpoint = memory_remove_breakpoint;
2754 }
2755
2756 CORE_ADDR
2757 gdbarch_decr_pc_after_break (struct gdbarch *gdbarch)
2758 {
2759   gdb_assert (gdbarch != NULL);
2760   /* Skip verify of decr_pc_after_break, invalid_p == 0 */
2761   if (gdbarch_debug >= 2)
2762     fprintf_unfiltered (gdb_stdlog, "gdbarch_decr_pc_after_break called\n");
2763   return gdbarch->decr_pc_after_break;
2764 }
2765
2766 void
2767 set_gdbarch_decr_pc_after_break (struct gdbarch *gdbarch,
2768                                  CORE_ADDR decr_pc_after_break)
2769 {
2770   gdbarch->decr_pc_after_break = decr_pc_after_break;
2771 }
2772
2773 CORE_ADDR
2774 gdbarch_deprecated_function_start_offset (struct gdbarch *gdbarch)
2775 {
2776   gdb_assert (gdbarch != NULL);
2777   /* Skip verify of deprecated_function_start_offset, invalid_p == 0 */
2778   if (gdbarch_debug >= 2)
2779     fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_function_start_offset called\n");
2780   return gdbarch->deprecated_function_start_offset;
2781 }
2782
2783 void
2784 set_gdbarch_deprecated_function_start_offset (struct gdbarch *gdbarch,
2785                                               CORE_ADDR deprecated_function_start_offset)
2786 {
2787   gdbarch->deprecated_function_start_offset = deprecated_function_start_offset;
2788 }
2789
2790 int
2791 gdbarch_remote_register_number (struct gdbarch *gdbarch, int regno)
2792 {
2793   gdb_assert (gdbarch != NULL);
2794   gdb_assert (gdbarch->remote_register_number != NULL);
2795   if (gdbarch_debug >= 2)
2796     fprintf_unfiltered (gdb_stdlog, "gdbarch_remote_register_number called\n");
2797   return gdbarch->remote_register_number (gdbarch, regno);
2798 }
2799
2800 void
2801 set_gdbarch_remote_register_number (struct gdbarch *gdbarch,
2802                                     gdbarch_remote_register_number_ftype remote_register_number)
2803 {
2804   gdbarch->remote_register_number = remote_register_number;
2805 }
2806
2807 int
2808 gdbarch_fetch_tls_load_module_address_p (struct gdbarch *gdbarch)
2809 {
2810   gdb_assert (gdbarch != NULL);
2811   return gdbarch->fetch_tls_load_module_address != NULL;
2812 }
2813
2814 CORE_ADDR
2815 gdbarch_fetch_tls_load_module_address (struct gdbarch *gdbarch, struct objfile *objfile)
2816 {
2817   gdb_assert (gdbarch != NULL);
2818   gdb_assert (gdbarch->fetch_tls_load_module_address != NULL);
2819   if (gdbarch_debug >= 2)
2820     fprintf_unfiltered (gdb_stdlog, "gdbarch_fetch_tls_load_module_address called\n");
2821   return gdbarch->fetch_tls_load_module_address (objfile);
2822 }
2823
2824 void
2825 set_gdbarch_fetch_tls_load_module_address (struct gdbarch *gdbarch,
2826                                            gdbarch_fetch_tls_load_module_address_ftype fetch_tls_load_module_address)
2827 {
2828   gdbarch->fetch_tls_load_module_address = fetch_tls_load_module_address;
2829 }
2830
2831 CORE_ADDR
2832 gdbarch_frame_args_skip (struct gdbarch *gdbarch)
2833 {
2834   gdb_assert (gdbarch != NULL);
2835   /* Skip verify of frame_args_skip, invalid_p == 0 */
2836   if (gdbarch_debug >= 2)
2837     fprintf_unfiltered (gdb_stdlog, "gdbarch_frame_args_skip called\n");
2838   return gdbarch->frame_args_skip;
2839 }
2840
2841 void
2842 set_gdbarch_frame_args_skip (struct gdbarch *gdbarch,
2843                              CORE_ADDR frame_args_skip)
2844 {
2845   gdbarch->frame_args_skip = frame_args_skip;
2846 }
2847
2848 int
2849 gdbarch_unwind_pc_p (struct gdbarch *gdbarch)
2850 {
2851   gdb_assert (gdbarch != NULL);
2852   return gdbarch->unwind_pc != NULL;
2853 }
2854
2855 CORE_ADDR
2856 gdbarch_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame)
2857 {
2858   gdb_assert (gdbarch != NULL);
2859   gdb_assert (gdbarch->unwind_pc != NULL);
2860   if (gdbarch_debug >= 2)
2861     fprintf_unfiltered (gdb_stdlog, "gdbarch_unwind_pc called\n");
2862   return gdbarch->unwind_pc (gdbarch, next_frame);
2863 }
2864
2865 void
2866 set_gdbarch_unwind_pc (struct gdbarch *gdbarch,
2867                        gdbarch_unwind_pc_ftype unwind_pc)
2868 {
2869   gdbarch->unwind_pc = unwind_pc;
2870 }
2871
2872 int
2873 gdbarch_unwind_sp_p (struct gdbarch *gdbarch)
2874 {
2875   gdb_assert (gdbarch != NULL);
2876   return gdbarch->unwind_sp != NULL;
2877 }
2878
2879 CORE_ADDR
2880 gdbarch_unwind_sp (struct gdbarch *gdbarch, struct frame_info *next_frame)
2881 {
2882   gdb_assert (gdbarch != NULL);
2883   gdb_assert (gdbarch->unwind_sp != NULL);
2884   if (gdbarch_debug >= 2)
2885     fprintf_unfiltered (gdb_stdlog, "gdbarch_unwind_sp called\n");
2886   return gdbarch->unwind_sp (gdbarch, next_frame);
2887 }
2888
2889 void
2890 set_gdbarch_unwind_sp (struct gdbarch *gdbarch,
2891                        gdbarch_unwind_sp_ftype unwind_sp)
2892 {
2893   gdbarch->unwind_sp = unwind_sp;
2894 }
2895
2896 int
2897 gdbarch_frame_num_args_p (struct gdbarch *gdbarch)
2898 {
2899   gdb_assert (gdbarch != NULL);
2900   return gdbarch->frame_num_args != NULL;
2901 }
2902
2903 int
2904 gdbarch_frame_num_args (struct gdbarch *gdbarch, struct frame_info *frame)
2905 {
2906   gdb_assert (gdbarch != NULL);
2907   gdb_assert (gdbarch->frame_num_args != NULL);
2908   if (gdbarch_debug >= 2)
2909     fprintf_unfiltered (gdb_stdlog, "gdbarch_frame_num_args called\n");
2910   return gdbarch->frame_num_args (frame);
2911 }
2912
2913 void
2914 set_gdbarch_frame_num_args (struct gdbarch *gdbarch,
2915                             gdbarch_frame_num_args_ftype frame_num_args)
2916 {
2917   gdbarch->frame_num_args = frame_num_args;
2918 }
2919
2920 int
2921 gdbarch_deprecated_stack_align_p (struct gdbarch *gdbarch)
2922 {
2923   gdb_assert (gdbarch != NULL);
2924   return gdbarch->deprecated_stack_align != NULL;
2925 }
2926
2927 CORE_ADDR
2928 gdbarch_deprecated_stack_align (struct gdbarch *gdbarch, CORE_ADDR sp)
2929 {
2930   gdb_assert (gdbarch != NULL);
2931   gdb_assert (gdbarch->deprecated_stack_align != NULL);
2932   if (gdbarch_debug >= 2)
2933     fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_stack_align called\n");
2934   return gdbarch->deprecated_stack_align (sp);
2935 }
2936
2937 void
2938 set_gdbarch_deprecated_stack_align (struct gdbarch *gdbarch,
2939                                     gdbarch_deprecated_stack_align_ftype deprecated_stack_align)
2940 {
2941   gdbarch->deprecated_stack_align = deprecated_stack_align;
2942 }
2943
2944 int
2945 gdbarch_frame_align_p (struct gdbarch *gdbarch)
2946 {
2947   gdb_assert (gdbarch != NULL);
2948   return gdbarch->frame_align != NULL;
2949 }
2950
2951 CORE_ADDR
2952 gdbarch_frame_align (struct gdbarch *gdbarch, CORE_ADDR address)
2953 {
2954   gdb_assert (gdbarch != NULL);
2955   gdb_assert (gdbarch->frame_align != NULL);
2956   if (gdbarch_debug >= 2)
2957     fprintf_unfiltered (gdb_stdlog, "gdbarch_frame_align called\n");
2958   return gdbarch->frame_align (gdbarch, address);
2959 }
2960
2961 void
2962 set_gdbarch_frame_align (struct gdbarch *gdbarch,
2963                          gdbarch_frame_align_ftype frame_align)
2964 {
2965   gdbarch->frame_align = frame_align;
2966 }
2967
2968 int
2969 gdbarch_deprecated_reg_struct_has_addr_p (struct gdbarch *gdbarch)
2970 {
2971   gdb_assert (gdbarch != NULL);
2972   return gdbarch->deprecated_reg_struct_has_addr != NULL;
2973 }
2974
2975 int
2976 gdbarch_deprecated_reg_struct_has_addr (struct gdbarch *gdbarch, int gcc_p, struct type *type)
2977 {
2978   gdb_assert (gdbarch != NULL);
2979   gdb_assert (gdbarch->deprecated_reg_struct_has_addr != NULL);
2980   if (gdbarch_debug >= 2)
2981     fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_reg_struct_has_addr called\n");
2982   return gdbarch->deprecated_reg_struct_has_addr (gcc_p, type);
2983 }
2984
2985 void
2986 set_gdbarch_deprecated_reg_struct_has_addr (struct gdbarch *gdbarch,
2987                                             gdbarch_deprecated_reg_struct_has_addr_ftype deprecated_reg_struct_has_addr)
2988 {
2989   gdbarch->deprecated_reg_struct_has_addr = deprecated_reg_struct_has_addr;
2990 }
2991
2992 int
2993 gdbarch_stabs_argument_has_addr (struct gdbarch *gdbarch, struct type *type)
2994 {
2995   gdb_assert (gdbarch != NULL);
2996   gdb_assert (gdbarch->stabs_argument_has_addr != NULL);
2997   if (gdbarch_debug >= 2)
2998     fprintf_unfiltered (gdb_stdlog, "gdbarch_stabs_argument_has_addr called\n");
2999   return gdbarch->stabs_argument_has_addr (gdbarch, type);
3000 }
3001
3002 void
3003 set_gdbarch_stabs_argument_has_addr (struct gdbarch *gdbarch,
3004                                      gdbarch_stabs_argument_has_addr_ftype stabs_argument_has_addr)
3005 {
3006   gdbarch->stabs_argument_has_addr = stabs_argument_has_addr;
3007 }
3008
3009 int
3010 gdbarch_frame_red_zone_size (struct gdbarch *gdbarch)
3011 {
3012   gdb_assert (gdbarch != NULL);
3013   if (gdbarch_debug >= 2)
3014     fprintf_unfiltered (gdb_stdlog, "gdbarch_frame_red_zone_size called\n");
3015   return gdbarch->frame_red_zone_size;
3016 }
3017
3018 void
3019 set_gdbarch_frame_red_zone_size (struct gdbarch *gdbarch,
3020                                  int frame_red_zone_size)
3021 {
3022   gdbarch->frame_red_zone_size = frame_red_zone_size;
3023 }
3024
3025 CORE_ADDR
3026 gdbarch_convert_from_func_ptr_addr (struct gdbarch *gdbarch, CORE_ADDR addr, struct target_ops *targ)
3027 {
3028   gdb_assert (gdbarch != NULL);
3029   gdb_assert (gdbarch->convert_from_func_ptr_addr != NULL);
3030   if (gdbarch_debug >= 2)
3031     fprintf_unfiltered (gdb_stdlog, "gdbarch_convert_from_func_ptr_addr called\n");
3032   return gdbarch->convert_from_func_ptr_addr (gdbarch, addr, targ);
3033 }
3034
3035 void
3036 set_gdbarch_convert_from_func_ptr_addr (struct gdbarch *gdbarch,
3037                                         gdbarch_convert_from_func_ptr_addr_ftype convert_from_func_ptr_addr)
3038 {
3039   gdbarch->convert_from_func_ptr_addr = convert_from_func_ptr_addr;
3040 }
3041
3042 CORE_ADDR
3043 gdbarch_addr_bits_remove (struct gdbarch *gdbarch, CORE_ADDR addr)
3044 {
3045   gdb_assert (gdbarch != NULL);
3046   gdb_assert (gdbarch->addr_bits_remove != NULL);
3047   if (gdbarch_debug >= 2)
3048     fprintf_unfiltered (gdb_stdlog, "gdbarch_addr_bits_remove called\n");
3049   return gdbarch->addr_bits_remove (addr);
3050 }
3051
3052 void
3053 set_gdbarch_addr_bits_remove (struct gdbarch *gdbarch,
3054                               gdbarch_addr_bits_remove_ftype addr_bits_remove)
3055 {
3056   gdbarch->addr_bits_remove = addr_bits_remove;
3057 }
3058
3059 CORE_ADDR
3060 gdbarch_smash_text_address (struct gdbarch *gdbarch, CORE_ADDR addr)
3061 {
3062   gdb_assert (gdbarch != NULL);
3063   gdb_assert (gdbarch->smash_text_address != NULL);
3064   if (gdbarch_debug >= 2)
3065     fprintf_unfiltered (gdb_stdlog, "gdbarch_smash_text_address called\n");
3066   return gdbarch->smash_text_address (addr);
3067 }
3068
3069 void
3070 set_gdbarch_smash_text_address (struct gdbarch *gdbarch,
3071                                 gdbarch_smash_text_address_ftype smash_text_address)
3072 {
3073   gdbarch->smash_text_address = smash_text_address;
3074 }
3075
3076 int
3077 gdbarch_software_single_step_p (struct gdbarch *gdbarch)
3078 {
3079   gdb_assert (gdbarch != NULL);
3080   return gdbarch->software_single_step != NULL;
3081 }
3082
3083 int
3084 gdbarch_software_single_step (struct gdbarch *gdbarch, struct regcache *regcache)
3085 {
3086   gdb_assert (gdbarch != NULL);
3087   gdb_assert (gdbarch->software_single_step != NULL);
3088   if (gdbarch_debug >= 2)
3089     fprintf_unfiltered (gdb_stdlog, "gdbarch_software_single_step called\n");
3090   return gdbarch->software_single_step (regcache);
3091 }
3092
3093 void
3094 set_gdbarch_software_single_step (struct gdbarch *gdbarch,
3095                                   gdbarch_software_single_step_ftype software_single_step)
3096 {
3097   gdbarch->software_single_step = software_single_step;
3098 }
3099
3100 int
3101 gdbarch_single_step_through_delay_p (struct gdbarch *gdbarch)
3102 {
3103   gdb_assert (gdbarch != NULL);
3104   return gdbarch->single_step_through_delay != NULL;
3105 }
3106
3107 int
3108 gdbarch_single_step_through_delay (struct gdbarch *gdbarch, struct frame_info *frame)
3109 {
3110   gdb_assert (gdbarch != NULL);
3111   gdb_assert (gdbarch->single_step_through_delay != NULL);
3112   if (gdbarch_debug >= 2)
3113     fprintf_unfiltered (gdb_stdlog, "gdbarch_single_step_through_delay called\n");
3114   return gdbarch->single_step_through_delay (gdbarch, frame);
3115 }
3116
3117 void
3118 set_gdbarch_single_step_through_delay (struct gdbarch *gdbarch,
3119                                        gdbarch_single_step_through_delay_ftype single_step_through_delay)
3120 {
3121   gdbarch->single_step_through_delay = single_step_through_delay;
3122 }
3123
3124 int
3125 gdbarch_print_insn (struct gdbarch *gdbarch, bfd_vma vma, struct disassemble_info *info)
3126 {
3127   gdb_assert (gdbarch != NULL);
3128   gdb_assert (gdbarch->print_insn != NULL);
3129   if (gdbarch_debug >= 2)
3130     fprintf_unfiltered (gdb_stdlog, "gdbarch_print_insn called\n");
3131   return gdbarch->print_insn (vma, info);
3132 }
3133
3134 void
3135 set_gdbarch_print_insn (struct gdbarch *gdbarch,
3136                         gdbarch_print_insn_ftype print_insn)
3137 {
3138   gdbarch->print_insn = print_insn;
3139 }
3140
3141 CORE_ADDR
3142 gdbarch_skip_trampoline_code (struct gdbarch *gdbarch, CORE_ADDR pc)
3143 {
3144   gdb_assert (gdbarch != NULL);
3145   gdb_assert (gdbarch->skip_trampoline_code != NULL);
3146   if (gdbarch_debug >= 2)
3147     fprintf_unfiltered (gdb_stdlog, "gdbarch_skip_trampoline_code called\n");
3148   return gdbarch->skip_trampoline_code (pc);
3149 }
3150
3151 void
3152 set_gdbarch_skip_trampoline_code (struct gdbarch *gdbarch,
3153                                   gdbarch_skip_trampoline_code_ftype skip_trampoline_code)
3154 {
3155   gdbarch->skip_trampoline_code = skip_trampoline_code;
3156 }
3157
3158 CORE_ADDR
3159 gdbarch_skip_solib_resolver (struct gdbarch *gdbarch, CORE_ADDR pc)
3160 {
3161   gdb_assert (gdbarch != NULL);
3162   gdb_assert (gdbarch->skip_solib_resolver != NULL);
3163   if (gdbarch_debug >= 2)
3164     fprintf_unfiltered (gdb_stdlog, "gdbarch_skip_solib_resolver called\n");
3165   return gdbarch->skip_solib_resolver (gdbarch, pc);
3166 }
3167
3168 void
3169 set_gdbarch_skip_solib_resolver (struct gdbarch *gdbarch,
3170                                  gdbarch_skip_solib_resolver_ftype skip_solib_resolver)
3171 {
3172   gdbarch->skip_solib_resolver = skip_solib_resolver;
3173 }
3174
3175 int
3176 gdbarch_in_solib_return_trampoline (struct gdbarch *gdbarch, CORE_ADDR pc, char *name)
3177 {
3178   gdb_assert (gdbarch != NULL);
3179   gdb_assert (gdbarch->in_solib_return_trampoline != NULL);
3180   if (gdbarch_debug >= 2)
3181     fprintf_unfiltered (gdb_stdlog, "gdbarch_in_solib_return_trampoline called\n");
3182   return gdbarch->in_solib_return_trampoline (pc, name);
3183 }
3184
3185 void
3186 set_gdbarch_in_solib_return_trampoline (struct gdbarch *gdbarch,
3187                                         gdbarch_in_solib_return_trampoline_ftype in_solib_return_trampoline)
3188 {
3189   gdbarch->in_solib_return_trampoline = in_solib_return_trampoline;
3190 }
3191
3192 int
3193 gdbarch_in_function_epilogue_p (struct gdbarch *gdbarch, CORE_ADDR addr)
3194 {
3195   gdb_assert (gdbarch != NULL);
3196   gdb_assert (gdbarch->in_function_epilogue_p != NULL);
3197   if (gdbarch_debug >= 2)
3198     fprintf_unfiltered (gdb_stdlog, "gdbarch_in_function_epilogue_p called\n");
3199   return gdbarch->in_function_epilogue_p (gdbarch, addr);
3200 }
3201
3202 void
3203 set_gdbarch_in_function_epilogue_p (struct gdbarch *gdbarch,
3204                                     gdbarch_in_function_epilogue_p_ftype in_function_epilogue_p)
3205 {
3206   gdbarch->in_function_epilogue_p = in_function_epilogue_p;
3207 }
3208
3209 char *
3210 gdbarch_construct_inferior_arguments (struct gdbarch *gdbarch, int argc, char **argv)
3211 {
3212   gdb_assert (gdbarch != NULL);
3213   gdb_assert (gdbarch->construct_inferior_arguments != NULL);
3214   if (gdbarch_debug >= 2)
3215     fprintf_unfiltered (gdb_stdlog, "gdbarch_construct_inferior_arguments called\n");
3216   return gdbarch->construct_inferior_arguments (gdbarch, argc, argv);
3217 }
3218
3219 void
3220 set_gdbarch_construct_inferior_arguments (struct gdbarch *gdbarch,
3221                                           gdbarch_construct_inferior_arguments_ftype construct_inferior_arguments)
3222 {
3223   gdbarch->construct_inferior_arguments = construct_inferior_arguments;
3224 }
3225
3226 void
3227 gdbarch_elf_make_msymbol_special (struct gdbarch *gdbarch, asymbol *sym, struct minimal_symbol *msym)
3228 {
3229   gdb_assert (gdbarch != NULL);
3230   gdb_assert (gdbarch->elf_make_msymbol_special != NULL);
3231   if (gdbarch_debug >= 2)
3232     fprintf_unfiltered (gdb_stdlog, "gdbarch_elf_make_msymbol_special called\n");
3233   gdbarch->elf_make_msymbol_special (sym, msym);
3234 }
3235
3236 void
3237 set_gdbarch_elf_make_msymbol_special (struct gdbarch *gdbarch,
3238                                       gdbarch_elf_make_msymbol_special_ftype elf_make_msymbol_special)
3239 {
3240   gdbarch->elf_make_msymbol_special = elf_make_msymbol_special;
3241 }
3242
3243 void
3244 gdbarch_coff_make_msymbol_special (struct gdbarch *gdbarch, int val, struct minimal_symbol *msym)
3245 {
3246   gdb_assert (gdbarch != NULL);
3247   gdb_assert (gdbarch->coff_make_msymbol_special != NULL);
3248   if (gdbarch_debug >= 2)
3249     fprintf_unfiltered (gdb_stdlog, "gdbarch_coff_make_msymbol_special called\n");
3250   gdbarch->coff_make_msymbol_special (val, msym);
3251 }
3252
3253 void
3254 set_gdbarch_coff_make_msymbol_special (struct gdbarch *gdbarch,
3255                                        gdbarch_coff_make_msymbol_special_ftype coff_make_msymbol_special)
3256 {
3257   gdbarch->coff_make_msymbol_special = coff_make_msymbol_special;
3258 }
3259
3260 const char *
3261 gdbarch_name_of_malloc (struct gdbarch *gdbarch)
3262 {
3263   gdb_assert (gdbarch != NULL);
3264   /* Skip verify of name_of_malloc, invalid_p == 0 */
3265   if (gdbarch_debug >= 2)
3266     fprintf_unfiltered (gdb_stdlog, "gdbarch_name_of_malloc called\n");
3267   return gdbarch->name_of_malloc;
3268 }
3269
3270 void
3271 set_gdbarch_name_of_malloc (struct gdbarch *gdbarch,
3272                             const char * name_of_malloc)
3273 {
3274   gdbarch->name_of_malloc = name_of_malloc;
3275 }
3276
3277 int
3278 gdbarch_cannot_step_breakpoint (struct gdbarch *gdbarch)
3279 {
3280   gdb_assert (gdbarch != NULL);
3281   /* Skip verify of cannot_step_breakpoint, invalid_p == 0 */
3282   if (gdbarch_debug >= 2)
3283     fprintf_unfiltered (gdb_stdlog, "gdbarch_cannot_step_breakpoint called\n");
3284   return gdbarch->cannot_step_breakpoint;
3285 }
3286
3287 void
3288 set_gdbarch_cannot_step_breakpoint (struct gdbarch *gdbarch,
3289                                     int cannot_step_breakpoint)
3290 {
3291   gdbarch->cannot_step_breakpoint = cannot_step_breakpoint;
3292 }
3293
3294 int
3295 gdbarch_have_nonsteppable_watchpoint (struct gdbarch *gdbarch)
3296 {
3297   gdb_assert (gdbarch != NULL);
3298   /* Skip verify of have_nonsteppable_watchpoint, invalid_p == 0 */
3299   if (gdbarch_debug >= 2)
3300     fprintf_unfiltered (gdb_stdlog, "gdbarch_have_nonsteppable_watchpoint called\n");
3301   return gdbarch->have_nonsteppable_watchpoint;
3302 }
3303
3304 void
3305 set_gdbarch_have_nonsteppable_watchpoint (struct gdbarch *gdbarch,
3306                                           int have_nonsteppable_watchpoint)
3307 {
3308   gdbarch->have_nonsteppable_watchpoint = have_nonsteppable_watchpoint;
3309 }
3310
3311 int
3312 gdbarch_address_class_type_flags_p (struct gdbarch *gdbarch)
3313 {
3314   gdb_assert (gdbarch != NULL);
3315   return gdbarch->address_class_type_flags != NULL;
3316 }
3317
3318 int
3319 gdbarch_address_class_type_flags (struct gdbarch *gdbarch, int byte_size, int dwarf2_addr_class)
3320 {
3321   gdb_assert (gdbarch != NULL);
3322   gdb_assert (gdbarch->address_class_type_flags != NULL);
3323   if (gdbarch_debug >= 2)
3324     fprintf_unfiltered (gdb_stdlog, "gdbarch_address_class_type_flags called\n");
3325   return gdbarch->address_class_type_flags (byte_size, dwarf2_addr_class);
3326 }
3327
3328 void
3329 set_gdbarch_address_class_type_flags (struct gdbarch *gdbarch,
3330                                       gdbarch_address_class_type_flags_ftype address_class_type_flags)
3331 {
3332   gdbarch->address_class_type_flags = address_class_type_flags;
3333 }
3334
3335 int
3336 gdbarch_address_class_type_flags_to_name_p (struct gdbarch *gdbarch)
3337 {
3338   gdb_assert (gdbarch != NULL);
3339   return gdbarch->address_class_type_flags_to_name != NULL;
3340 }
3341
3342 const char *
3343 gdbarch_address_class_type_flags_to_name (struct gdbarch *gdbarch, int type_flags)
3344 {
3345   gdb_assert (gdbarch != NULL);
3346   gdb_assert (gdbarch->address_class_type_flags_to_name != NULL);
3347   if (gdbarch_debug >= 2)
3348     fprintf_unfiltered (gdb_stdlog, "gdbarch_address_class_type_flags_to_name called\n");
3349   return gdbarch->address_class_type_flags_to_name (gdbarch, type_flags);
3350 }
3351
3352 void
3353 set_gdbarch_address_class_type_flags_to_name (struct gdbarch *gdbarch,
3354                                               gdbarch_address_class_type_flags_to_name_ftype address_class_type_flags_to_name)
3355 {
3356   gdbarch->address_class_type_flags_to_name = address_class_type_flags_to_name;
3357 }
3358
3359 int
3360 gdbarch_address_class_name_to_type_flags_p (struct gdbarch *gdbarch)
3361 {
3362   gdb_assert (gdbarch != NULL);
3363   return gdbarch->address_class_name_to_type_flags != NULL;
3364 }
3365
3366 int
3367 gdbarch_address_class_name_to_type_flags (struct gdbarch *gdbarch, const char *name, int *type_flags_ptr)
3368 {
3369   gdb_assert (gdbarch != NULL);
3370   gdb_assert (gdbarch->address_class_name_to_type_flags != NULL);
3371   if (gdbarch_debug >= 2)
3372     fprintf_unfiltered (gdb_stdlog, "gdbarch_address_class_name_to_type_flags called\n");
3373   return gdbarch->address_class_name_to_type_flags (gdbarch, name, type_flags_ptr);
3374 }
3375
3376 void
3377 set_gdbarch_address_class_name_to_type_flags (struct gdbarch *gdbarch,
3378                                               gdbarch_address_class_name_to_type_flags_ftype address_class_name_to_type_flags)
3379 {
3380   gdbarch->address_class_name_to_type_flags = address_class_name_to_type_flags;
3381 }
3382
3383 int
3384 gdbarch_register_reggroup_p (struct gdbarch *gdbarch, int regnum, struct reggroup *reggroup)
3385 {
3386   gdb_assert (gdbarch != NULL);
3387   gdb_assert (gdbarch->register_reggroup_p != NULL);
3388   if (gdbarch_debug >= 2)
3389     fprintf_unfiltered (gdb_stdlog, "gdbarch_register_reggroup_p called\n");
3390   return gdbarch->register_reggroup_p (gdbarch, regnum, reggroup);
3391 }
3392
3393 void
3394 set_gdbarch_register_reggroup_p (struct gdbarch *gdbarch,
3395                                  gdbarch_register_reggroup_p_ftype register_reggroup_p)
3396 {
3397   gdbarch->register_reggroup_p = register_reggroup_p;
3398 }
3399
3400 int
3401 gdbarch_fetch_pointer_argument_p (struct gdbarch *gdbarch)
3402 {
3403   gdb_assert (gdbarch != NULL);
3404   return gdbarch->fetch_pointer_argument != NULL;
3405 }
3406
3407 CORE_ADDR
3408 gdbarch_fetch_pointer_argument (struct gdbarch *gdbarch, struct frame_info *frame, int argi, struct type *type)
3409 {
3410   gdb_assert (gdbarch != NULL);
3411   gdb_assert (gdbarch->fetch_pointer_argument != NULL);
3412   if (gdbarch_debug >= 2)
3413     fprintf_unfiltered (gdb_stdlog, "gdbarch_fetch_pointer_argument called\n");
3414   return gdbarch->fetch_pointer_argument (frame, argi, type);
3415 }
3416
3417 void
3418 set_gdbarch_fetch_pointer_argument (struct gdbarch *gdbarch,
3419                                     gdbarch_fetch_pointer_argument_ftype fetch_pointer_argument)
3420 {
3421   gdbarch->fetch_pointer_argument = fetch_pointer_argument;
3422 }
3423
3424 int
3425 gdbarch_regset_from_core_section_p (struct gdbarch *gdbarch)
3426 {
3427   gdb_assert (gdbarch != NULL);
3428   return gdbarch->regset_from_core_section != NULL;
3429 }
3430
3431 const struct regset *
3432 gdbarch_regset_from_core_section (struct gdbarch *gdbarch, const char *sect_name, size_t sect_size)
3433 {
3434   gdb_assert (gdbarch != NULL);
3435   gdb_assert (gdbarch->regset_from_core_section != NULL);
3436   if (gdbarch_debug >= 2)
3437     fprintf_unfiltered (gdb_stdlog, "gdbarch_regset_from_core_section called\n");
3438   return gdbarch->regset_from_core_section (gdbarch, sect_name, sect_size);
3439 }
3440
3441 void
3442 set_gdbarch_regset_from_core_section (struct gdbarch *gdbarch,
3443                                       gdbarch_regset_from_core_section_ftype regset_from_core_section)
3444 {
3445   gdbarch->regset_from_core_section = regset_from_core_section;
3446 }
3447
3448 int
3449 gdbarch_vtable_function_descriptors (struct gdbarch *gdbarch)
3450 {
3451   gdb_assert (gdbarch != NULL);
3452   /* Skip verify of vtable_function_descriptors, invalid_p == 0 */
3453   if (gdbarch_debug >= 2)
3454     fprintf_unfiltered (gdb_stdlog, "gdbarch_vtable_function_descriptors called\n");
3455   return gdbarch->vtable_function_descriptors;
3456 }
3457
3458 void
3459 set_gdbarch_vtable_function_descriptors (struct gdbarch *gdbarch,
3460                                          int vtable_function_descriptors)
3461 {
3462   gdbarch->vtable_function_descriptors = vtable_function_descriptors;
3463 }
3464
3465 int
3466 gdbarch_vbit_in_delta (struct gdbarch *gdbarch)
3467 {
3468   gdb_assert (gdbarch != NULL);
3469   /* Skip verify of vbit_in_delta, invalid_p == 0 */
3470   if (gdbarch_debug >= 2)
3471     fprintf_unfiltered (gdb_stdlog, "gdbarch_vbit_in_delta called\n");
3472   return gdbarch->vbit_in_delta;
3473 }
3474
3475 void
3476 set_gdbarch_vbit_in_delta (struct gdbarch *gdbarch,
3477                            int vbit_in_delta)
3478 {
3479   gdbarch->vbit_in_delta = vbit_in_delta;
3480 }
3481
3482 int
3483 gdbarch_skip_permanent_breakpoint_p (struct gdbarch *gdbarch)
3484 {
3485   gdb_assert (gdbarch != NULL);
3486   return gdbarch->skip_permanent_breakpoint != NULL;
3487 }
3488
3489 void
3490 gdbarch_skip_permanent_breakpoint (struct gdbarch *gdbarch, struct regcache *regcache)
3491 {
3492   gdb_assert (gdbarch != NULL);
3493   gdb_assert (gdbarch->skip_permanent_breakpoint != NULL);
3494   if (gdbarch_debug >= 2)
3495     fprintf_unfiltered (gdb_stdlog, "gdbarch_skip_permanent_breakpoint called\n");
3496   gdbarch->skip_permanent_breakpoint (regcache);
3497 }
3498
3499 void
3500 set_gdbarch_skip_permanent_breakpoint (struct gdbarch *gdbarch,
3501                                        gdbarch_skip_permanent_breakpoint_ftype skip_permanent_breakpoint)
3502 {
3503   gdbarch->skip_permanent_breakpoint = skip_permanent_breakpoint;
3504 }
3505
3506 int
3507 gdbarch_overlay_update_p (struct gdbarch *gdbarch)
3508 {
3509   gdb_assert (gdbarch != NULL);
3510   return gdbarch->overlay_update != NULL;
3511 }
3512
3513 void
3514 gdbarch_overlay_update (struct gdbarch *gdbarch, struct obj_section *osect)
3515 {
3516   gdb_assert (gdbarch != NULL);
3517   gdb_assert (gdbarch->overlay_update != NULL);
3518   if (gdbarch_debug >= 2)
3519     fprintf_unfiltered (gdb_stdlog, "gdbarch_overlay_update called\n");
3520   gdbarch->overlay_update (osect);
3521 }
3522
3523 void
3524 set_gdbarch_overlay_update (struct gdbarch *gdbarch,
3525                             gdbarch_overlay_update_ftype overlay_update)
3526 {
3527   gdbarch->overlay_update = overlay_update;
3528 }
3529
3530
3531 /* Keep a registry of per-architecture data-pointers required by GDB
3532    modules. */
3533
3534 struct gdbarch_data
3535 {
3536   unsigned index;
3537   int init_p;
3538   gdbarch_data_pre_init_ftype *pre_init;
3539   gdbarch_data_post_init_ftype *post_init;
3540 };
3541
3542 struct gdbarch_data_registration
3543 {
3544   struct gdbarch_data *data;
3545   struct gdbarch_data_registration *next;
3546 };
3547
3548 struct gdbarch_data_registry
3549 {
3550   unsigned nr;
3551   struct gdbarch_data_registration *registrations;
3552 };
3553
3554 struct gdbarch_data_registry gdbarch_data_registry =
3555 {
3556   0, NULL,
3557 };
3558
3559 static struct gdbarch_data *
3560 gdbarch_data_register (gdbarch_data_pre_init_ftype *pre_init,
3561                        gdbarch_data_post_init_ftype *post_init)
3562 {
3563   struct gdbarch_data_registration **curr;
3564   /* Append the new registraration.  */
3565   for (curr = &gdbarch_data_registry.registrations;
3566        (*curr) != NULL;
3567        curr = &(*curr)->next);
3568   (*curr) = XMALLOC (struct gdbarch_data_registration);
3569   (*curr)->next = NULL;
3570   (*curr)->data = XMALLOC (struct gdbarch_data);
3571   (*curr)->data->index = gdbarch_data_registry.nr++;
3572   (*curr)->data->pre_init = pre_init;
3573   (*curr)->data->post_init = post_init;
3574   (*curr)->data->init_p = 1;
3575   return (*curr)->data;
3576 }
3577
3578 struct gdbarch_data *
3579 gdbarch_data_register_pre_init (gdbarch_data_pre_init_ftype *pre_init)
3580 {
3581   return gdbarch_data_register (pre_init, NULL);
3582 }
3583
3584 struct gdbarch_data *
3585 gdbarch_data_register_post_init (gdbarch_data_post_init_ftype *post_init)
3586 {
3587   return gdbarch_data_register (NULL, post_init);
3588 }
3589
3590 /* Create/delete the gdbarch data vector. */
3591
3592 static void
3593 alloc_gdbarch_data (struct gdbarch *gdbarch)
3594 {
3595   gdb_assert (gdbarch->data == NULL);
3596   gdbarch->nr_data = gdbarch_data_registry.nr;
3597   gdbarch->data = GDBARCH_OBSTACK_CALLOC (gdbarch, gdbarch->nr_data, void *);
3598 }
3599
3600 /* Initialize the current value of the specified per-architecture
3601    data-pointer. */
3602
3603 void
3604 deprecated_set_gdbarch_data (struct gdbarch *gdbarch,
3605                              struct gdbarch_data *data,
3606                              void *pointer)
3607 {
3608   gdb_assert (data->index < gdbarch->nr_data);
3609   gdb_assert (gdbarch->data[data->index] == NULL);
3610   gdb_assert (data->pre_init == NULL);
3611   gdbarch->data[data->index] = pointer;
3612 }
3613
3614 /* Return the current value of the specified per-architecture
3615    data-pointer. */
3616
3617 void *
3618 gdbarch_data (struct gdbarch *gdbarch, struct gdbarch_data *data)
3619 {
3620   gdb_assert (data->index < gdbarch->nr_data);
3621   if (gdbarch->data[data->index] == NULL)
3622     {
3623       /* The data-pointer isn't initialized, call init() to get a
3624          value.  */
3625       if (data->pre_init != NULL)
3626         /* Mid architecture creation: pass just the obstack, and not
3627            the entire architecture, as that way it isn't possible for
3628            pre-init code to refer to undefined architecture
3629            fields.  */
3630         gdbarch->data[data->index] = data->pre_init (gdbarch->obstack);
3631       else if (gdbarch->initialized_p
3632                && data->post_init != NULL)
3633         /* Post architecture creation: pass the entire architecture
3634            (as all fields are valid), but be careful to also detect
3635            recursive references.  */
3636         {
3637           gdb_assert (data->init_p);
3638           data->init_p = 0;
3639           gdbarch->data[data->index] = data->post_init (gdbarch);
3640           data->init_p = 1;
3641         }
3642       else
3643         /* The architecture initialization hasn't completed - punt -
3644          hope that the caller knows what they are doing.  Once
3645          deprecated_set_gdbarch_data has been initialized, this can be
3646          changed to an internal error.  */
3647         return NULL;
3648       gdb_assert (gdbarch->data[data->index] != NULL);
3649     }
3650   return gdbarch->data[data->index];
3651 }
3652
3653
3654
3655 /* Keep a registry of swapped data required by GDB modules. */
3656
3657 struct gdbarch_swap
3658 {
3659   void *swap;
3660   struct gdbarch_swap_registration *source;
3661   struct gdbarch_swap *next;
3662 };
3663
3664 struct gdbarch_swap_registration
3665 {
3666   void *data;
3667   unsigned long sizeof_data;
3668   gdbarch_swap_ftype *init;
3669   struct gdbarch_swap_registration *next;
3670 };
3671
3672 struct gdbarch_swap_registry
3673 {
3674   int nr;
3675   struct gdbarch_swap_registration *registrations;
3676 };
3677
3678 struct gdbarch_swap_registry gdbarch_swap_registry =
3679 {
3680   0, NULL,
3681 };
3682
3683 void
3684 deprecated_register_gdbarch_swap (void *data,
3685                                   unsigned long sizeof_data,
3686                                   gdbarch_swap_ftype *init)
3687 {
3688   struct gdbarch_swap_registration **rego;
3689   for (rego = &gdbarch_swap_registry.registrations;
3690        (*rego) != NULL;
3691        rego = &(*rego)->next);
3692   (*rego) = XMALLOC (struct gdbarch_swap_registration);
3693   (*rego)->next = NULL;
3694   (*rego)->init = init;
3695   (*rego)->data = data;
3696   (*rego)->sizeof_data = sizeof_data;
3697 }
3698
3699 static void
3700 current_gdbarch_swap_init_hack (void)
3701 {
3702   struct gdbarch_swap_registration *rego;
3703   struct gdbarch_swap **curr = &current_gdbarch->swap;
3704   for (rego = gdbarch_swap_registry.registrations;
3705        rego != NULL;
3706        rego = rego->next)
3707     {
3708       if (rego->data != NULL)
3709         {
3710           (*curr) = GDBARCH_OBSTACK_ZALLOC (current_gdbarch,
3711                                             struct gdbarch_swap);
3712           (*curr)->source = rego;
3713           (*curr)->swap = gdbarch_obstack_zalloc (current_gdbarch,
3714                                                   rego->sizeof_data);
3715           (*curr)->next = NULL;
3716           curr = &(*curr)->next;
3717         }
3718       if (rego->init != NULL)
3719         rego->init ();
3720     }
3721 }
3722
3723 static struct gdbarch *
3724 current_gdbarch_swap_out_hack (void)
3725 {
3726   struct gdbarch *old_gdbarch = current_gdbarch;
3727   struct gdbarch_swap *curr;
3728
3729   gdb_assert (old_gdbarch != NULL);
3730   for (curr = old_gdbarch->swap;
3731        curr != NULL;
3732        curr = curr->next)
3733     {
3734       memcpy (curr->swap, curr->source->data, curr->source->sizeof_data);
3735       memset (curr->source->data, 0, curr->source->sizeof_data);
3736     }
3737   current_gdbarch = NULL;
3738   return old_gdbarch;
3739 }
3740
3741 static void
3742 current_gdbarch_swap_in_hack (struct gdbarch *new_gdbarch)
3743 {
3744   struct gdbarch_swap *curr;
3745
3746   gdb_assert (current_gdbarch == NULL);
3747   for (curr = new_gdbarch->swap;
3748        curr != NULL;
3749        curr = curr->next)
3750     memcpy (curr->source->data, curr->swap, curr->source->sizeof_data);
3751   current_gdbarch = new_gdbarch;
3752 }
3753
3754
3755 /* Keep a registry of the architectures known by GDB. */
3756
3757 struct gdbarch_registration
3758 {
3759   enum bfd_architecture bfd_architecture;
3760   gdbarch_init_ftype *init;
3761   gdbarch_dump_tdep_ftype *dump_tdep;
3762   struct gdbarch_list *arches;
3763   struct gdbarch_registration *next;
3764 };
3765
3766 static struct gdbarch_registration *gdbarch_registry = NULL;
3767
3768 static void
3769 append_name (const char ***buf, int *nr, const char *name)
3770 {
3771   *buf = xrealloc (*buf, sizeof (char**) * (*nr + 1));
3772   (*buf)[*nr] = name;
3773   *nr += 1;
3774 }
3775
3776 const char **
3777 gdbarch_printable_names (void)
3778 {
3779   /* Accumulate a list of names based on the registed list of
3780      architectures. */
3781   enum bfd_architecture a;
3782   int nr_arches = 0;
3783   const char **arches = NULL;
3784   struct gdbarch_registration *rego;
3785   for (rego = gdbarch_registry;
3786        rego != NULL;
3787        rego = rego->next)
3788     {
3789       const struct bfd_arch_info *ap;
3790       ap = bfd_lookup_arch (rego->bfd_architecture, 0);
3791       if (ap == NULL)
3792         internal_error (__FILE__, __LINE__,
3793                         _("gdbarch_architecture_names: multi-arch unknown"));
3794       do
3795         {
3796           append_name (&arches, &nr_arches, ap->printable_name);
3797           ap = ap->next;
3798         }
3799       while (ap != NULL);
3800     }
3801   append_name (&arches, &nr_arches, NULL);
3802   return arches;
3803 }
3804
3805
3806 void
3807 gdbarch_register (enum bfd_architecture bfd_architecture,
3808                   gdbarch_init_ftype *init,
3809                   gdbarch_dump_tdep_ftype *dump_tdep)
3810 {
3811   struct gdbarch_registration **curr;
3812   const struct bfd_arch_info *bfd_arch_info;
3813   /* Check that BFD recognizes this architecture */
3814   bfd_arch_info = bfd_lookup_arch (bfd_architecture, 0);
3815   if (bfd_arch_info == NULL)
3816     {
3817       internal_error (__FILE__, __LINE__,
3818                       _("gdbarch: Attempt to register unknown architecture (%d)"),
3819                       bfd_architecture);
3820     }
3821   /* Check that we haven't seen this architecture before */
3822   for (curr = &gdbarch_registry;
3823        (*curr) != NULL;
3824        curr = &(*curr)->next)
3825     {
3826       if (bfd_architecture == (*curr)->bfd_architecture)
3827         internal_error (__FILE__, __LINE__,
3828                         _("gdbarch: Duplicate registraration of architecture (%s)"),
3829                         bfd_arch_info->printable_name);
3830     }
3831   /* log it */
3832   if (gdbarch_debug)
3833     fprintf_unfiltered (gdb_stdlog, "register_gdbarch_init (%s, 0x%08lx)\n",
3834                         bfd_arch_info->printable_name,
3835                         (long) init);
3836   /* Append it */
3837   (*curr) = XMALLOC (struct gdbarch_registration);
3838   (*curr)->bfd_architecture = bfd_architecture;
3839   (*curr)->init = init;
3840   (*curr)->dump_tdep = dump_tdep;
3841   (*curr)->arches = NULL;
3842   (*curr)->next = NULL;
3843 }
3844
3845 void
3846 register_gdbarch_init (enum bfd_architecture bfd_architecture,
3847                        gdbarch_init_ftype *init)
3848 {
3849   gdbarch_register (bfd_architecture, init, NULL);
3850 }
3851
3852
3853 /* Look for an architecture using gdbarch_info.  */
3854
3855 struct gdbarch_list *
3856 gdbarch_list_lookup_by_info (struct gdbarch_list *arches,
3857                              const struct gdbarch_info *info)
3858 {
3859   for (; arches != NULL; arches = arches->next)
3860     {
3861       if (info->bfd_arch_info != arches->gdbarch->bfd_arch_info)
3862         continue;
3863       if (info->byte_order != arches->gdbarch->byte_order)
3864         continue;
3865       if (info->osabi != arches->gdbarch->osabi)
3866         continue;
3867       if (info->target_desc != arches->gdbarch->target_desc)
3868         continue;
3869       return arches;
3870     }
3871   return NULL;
3872 }
3873
3874
3875 /* Find an architecture that matches the specified INFO.  Create a new
3876    architecture if needed.  Return that new architecture.  Assumes
3877    that there is no current architecture.  */
3878
3879 static struct gdbarch *
3880 find_arch_by_info (struct gdbarch_info info)
3881 {
3882   struct gdbarch *new_gdbarch;
3883   struct gdbarch_registration *rego;
3884
3885   /* The existing architecture has been swapped out - all this code
3886      works from a clean slate.  */
3887   gdb_assert (current_gdbarch == NULL);
3888
3889   /* Fill in missing parts of the INFO struct using a number of
3890      sources: "set ..."; INFOabfd supplied; and the global
3891      defaults.  */
3892   gdbarch_info_fill (&info);
3893
3894   /* Must have found some sort of architecture. */
3895   gdb_assert (info.bfd_arch_info != NULL);
3896
3897   if (gdbarch_debug)
3898     {
3899       fprintf_unfiltered (gdb_stdlog,
3900                           "find_arch_by_info: info.bfd_arch_info %s\n",
3901                           (info.bfd_arch_info != NULL
3902                            ? info.bfd_arch_info->printable_name
3903                            : "(null)"));
3904       fprintf_unfiltered (gdb_stdlog,
3905                           "find_arch_by_info: info.byte_order %d (%s)\n",
3906                           info.byte_order,
3907                           (info.byte_order == BFD_ENDIAN_BIG ? "big"
3908                            : info.byte_order == BFD_ENDIAN_LITTLE ? "little"
3909                            : "default"));
3910       fprintf_unfiltered (gdb_stdlog,
3911                           "find_arch_by_info: info.osabi %d (%s)\n",
3912                           info.osabi, gdbarch_osabi_name (info.osabi));
3913       fprintf_unfiltered (gdb_stdlog,
3914                           "find_arch_by_info: info.abfd 0x%lx\n",
3915                           (long) info.abfd);
3916       fprintf_unfiltered (gdb_stdlog,
3917                           "find_arch_by_info: info.tdep_info 0x%lx\n",
3918                           (long) info.tdep_info);
3919     }
3920
3921   /* Find the tdep code that knows about this architecture.  */
3922   for (rego = gdbarch_registry;
3923        rego != NULL;
3924        rego = rego->next)
3925     if (rego->bfd_architecture == info.bfd_arch_info->arch)
3926       break;
3927   if (rego == NULL)
3928     {
3929       if (gdbarch_debug)
3930         fprintf_unfiltered (gdb_stdlog, "find_arch_by_info: "
3931                             "No matching architecture\n");
3932       return 0;
3933     }
3934
3935   /* Ask the tdep code for an architecture that matches "info".  */
3936   new_gdbarch = rego->init (info, rego->arches);
3937
3938   /* Did the tdep code like it?  No.  Reject the change and revert to
3939      the old architecture.  */
3940   if (new_gdbarch == NULL)
3941     {
3942       if (gdbarch_debug)
3943         fprintf_unfiltered (gdb_stdlog, "find_arch_by_info: "
3944                             "Target rejected architecture\n");
3945       return NULL;
3946     }
3947
3948   /* Is this a pre-existing architecture (as determined by already
3949      being initialized)?  Move it to the front of the architecture
3950      list (keeping the list sorted Most Recently Used).  */
3951   if (new_gdbarch->initialized_p)
3952     {
3953       struct gdbarch_list **list;
3954       struct gdbarch_list *this;
3955       if (gdbarch_debug)
3956         fprintf_unfiltered (gdb_stdlog, "find_arch_by_info: "
3957                             "Previous architecture 0x%08lx (%s) selected\n",
3958                             (long) new_gdbarch,
3959                             new_gdbarch->bfd_arch_info->printable_name);
3960       /* Find the existing arch in the list.  */
3961       for (list = &rego->arches;
3962            (*list) != NULL && (*list)->gdbarch != new_gdbarch;
3963            list = &(*list)->next);
3964       /* It had better be in the list of architectures.  */
3965       gdb_assert ((*list) != NULL && (*list)->gdbarch == new_gdbarch);
3966       /* Unlink THIS.  */
3967       this = (*list);
3968       (*list) = this->next;
3969       /* Insert THIS at the front.  */
3970       this->next = rego->arches;
3971       rego->arches = this;
3972       /* Return it.  */
3973       return new_gdbarch;
3974     }
3975
3976   /* It's a new architecture.  */
3977   if (gdbarch_debug)
3978     fprintf_unfiltered (gdb_stdlog, "find_arch_by_info: "
3979                         "New architecture 0x%08lx (%s) selected\n",
3980                         (long) new_gdbarch,
3981                         new_gdbarch->bfd_arch_info->printable_name);
3982
3983   /* Insert the new architecture into the front of the architecture
3984      list (keep the list sorted Most Recently Used).  */
3985   {
3986     struct gdbarch_list *this = XMALLOC (struct gdbarch_list);
3987     this->next = rego->arches;
3988     this->gdbarch = new_gdbarch;
3989     rego->arches = this;
3990   }
3991
3992   /* Check that the newly installed architecture is valid.  Plug in
3993      any post init values.  */
3994   new_gdbarch->dump_tdep = rego->dump_tdep;
3995   verify_gdbarch (new_gdbarch);
3996   new_gdbarch->initialized_p = 1;
3997
3998   /* Initialize any per-architecture swap areas.  This phase requires
3999      a valid global CURRENT_GDBARCH.  Set it momentarially, and then
4000      swap the entire architecture out.  */
4001   current_gdbarch = new_gdbarch;
4002   current_gdbarch_swap_init_hack ();
4003   current_gdbarch_swap_out_hack ();
4004
4005   if (gdbarch_debug)
4006     gdbarch_dump (new_gdbarch, gdb_stdlog);
4007
4008   return new_gdbarch;
4009 }
4010
4011 struct gdbarch *
4012 gdbarch_find_by_info (struct gdbarch_info info)
4013 {
4014   /* Save the previously selected architecture, setting the global to
4015      NULL.  This stops things like gdbarch->init() trying to use the
4016      previous architecture's configuration.  The previous architecture
4017      may not even be of the same architecture family.  The most recent
4018      architecture of the same family is found at the head of the
4019      rego->arches list.  */
4020   struct gdbarch *old_gdbarch = current_gdbarch_swap_out_hack ();
4021
4022   /* Find the specified architecture.  */
4023   struct gdbarch *new_gdbarch = find_arch_by_info (info);
4024
4025   /* Restore the existing architecture.  */
4026   gdb_assert (current_gdbarch == NULL);
4027   current_gdbarch_swap_in_hack (old_gdbarch);
4028
4029   return new_gdbarch;
4030 }
4031
4032 /* Make the specified architecture current, swapping the existing one
4033    out.  */
4034
4035 void
4036 deprecated_current_gdbarch_select_hack (struct gdbarch *new_gdbarch)
4037 {
4038   gdb_assert (new_gdbarch != NULL);
4039   gdb_assert (current_gdbarch != NULL);
4040   gdb_assert (new_gdbarch->initialized_p);
4041   current_gdbarch_swap_out_hack ();
4042   current_gdbarch_swap_in_hack (new_gdbarch);
4043   architecture_changed_event ();
4044   reinit_frame_cache ();
4045 }
4046
4047 extern void _initialize_gdbarch (void);
4048
4049 void
4050 _initialize_gdbarch (void)
4051 {
4052   struct cmd_list_element *c;
4053
4054   add_setshow_zinteger_cmd ("arch", class_maintenance, &gdbarch_debug, _("\
4055 Set architecture debugging."), _("\
4056 Show architecture debugging."), _("\
4057 When non-zero, architecture debugging is enabled."),
4058                             NULL,
4059                             show_gdbarch_debug,
4060                             &setdebuglist, &showdebuglist);
4061 }