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