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