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