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