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