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