gdb/gdbarch.c

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