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