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