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