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