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