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