gdb/gdbarch.c

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