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