gdb/gdbarch.c

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