gdb/gdbarch.c

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