gdb/gdbarch.c

   1 /* *INDENT-OFF* */ /* THIS FILE IS GENERATED */
   2
   3 /* Dynamic architecture support for GDB, the GNU debugger.
   4    Copyright 1998, 1999, 2000, 2001, 2002, 2003 Free Software Foundation, Inc.
   5
   6    This file is part of GDB.
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 2 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program; if not, write to the Free Software
  20    Foundation, Inc., 59 Temple Place - Suite 330,
  21    Boston, MA 02111-1307, USA.  */
  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 #if GDB_MULTI_ARCH
  40 #include "gdbcmd.h"
  41 #include "inferior.h" /* enum CALL_DUMMY_LOCATION et.al. */
  42 #else
  43 /* Just include everything in sight so that the every old definition
  44    of macro is visible. */
  45 #include "gdb_string.h"
  46 #include <ctype.h>
  47 #include "symtab.h"
  48 #include "frame.h"
  49 #include "inferior.h"
  50 #include "breakpoint.h"
  51 #include "gdb_wait.h"
  52 #include "gdbcore.h"
  53 #include "gdbcmd.h"
  54 #include "target.h"
  55 #include "gdbthread.h"
  56 #include "annotate.h"
  57 #include "symfile.h"            /* for overlay functions */
  58 #include "value.h"              /* For old tm.h/nm.h macros.  */
  59 #endif
  60 #include "symcat.h"
  61
  62 #include "floatformat.h"
  63
  64 #include "gdb_assert.h"
  65 #include "gdb_string.h"
  66 #include "gdb-events.h"
  67 #include "reggroups.h"
  68 #include "osabi.h"
  69
  70 /* Static function declarations */
  71
  72 static void verify_gdbarch (struct gdbarch *gdbarch);
  73 static void alloc_gdbarch_data (struct gdbarch *);
  74 static void free_gdbarch_data (struct gdbarch *);
  75 static void init_gdbarch_swap (struct gdbarch *);
  76 static void clear_gdbarch_swap (struct gdbarch *);
  77 static void swapout_gdbarch_swap (struct gdbarch *);
  78 static void swapin_gdbarch_swap (struct gdbarch *);
  79
  80 /* Non-zero if we want to trace architecture code.  */
  81
  82 #ifndef GDBARCH_DEBUG
  83 #define GDBARCH_DEBUG 0
  84 #endif
  85 int gdbarch_debug = GDBARCH_DEBUG;
  86
  87
  88 /* Maintain the struct gdbarch object */
  89
  90 struct gdbarch
  91 {
  92   /* Has this architecture been fully initialized?  */
  93   int initialized_p;
  94   /* basic architectural information */
  95   const struct bfd_arch_info * bfd_arch_info;
  96   int byte_order;
  97   enum gdb_osabi osabi;
  98
  99   /* target specific vector. */
 100   struct gdbarch_tdep *tdep;
 101   gdbarch_dump_tdep_ftype *dump_tdep;
 102
 103   /* per-architecture data-pointers */
 104   unsigned nr_data;
 105   void **data;
 106
 107   /* per-architecture swap-regions */
 108   struct gdbarch_swap *swap;
 109
 110   /* Multi-arch values.
 111
 112      When extending this structure you must:
 113
 114      Add the field below.
 115
 116      Declare set/get functions and define the corresponding
 117      macro in gdbarch.h.
 118
 119      gdbarch_alloc(): If zero/NULL is not a suitable default,
 120      initialize the new field.
 121
 122      verify_gdbarch(): Confirm that the target updated the field
 123      correctly.
 124
 125      gdbarch_dump(): Add a fprintf_unfiltered call so that the new
 126      field is dumped out
 127
 128      ``startup_gdbarch()'': Append an initial value to the static
 129      variable (base values on the host's c-type system).
 130
 131      get_gdbarch(): Implement the set/get functions (probably using
 132      the macro's as shortcuts).
 133
 134      */
 135
 136   int short_bit;
 137   int int_bit;
 138   int long_bit;
 139   int long_long_bit;
 140   int float_bit;
 141   int double_bit;
 142   int long_double_bit;
 143   int ptr_bit;
 144   int addr_bit;
 145   int bfd_vma_bit;
 146   int char_signed;
 147   gdbarch_read_pc_ftype *read_pc;
 148   gdbarch_write_pc_ftype *write_pc;
 149   gdbarch_read_fp_ftype *read_fp;
 150   gdbarch_read_sp_ftype *read_sp;
 151   gdbarch_write_sp_ftype *write_sp;
 152   gdbarch_virtual_frame_pointer_ftype *virtual_frame_pointer;
 153   gdbarch_pseudo_register_read_ftype *pseudo_register_read;
 154   gdbarch_pseudo_register_write_ftype *pseudo_register_write;
 155   int num_regs;
 156   int num_pseudo_regs;
 157   int sp_regnum;
 158   int fp_regnum;
 159   int pc_regnum;
 160   int ps_regnum;
 161   int fp0_regnum;
 162   int npc_regnum;
 163   gdbarch_stab_reg_to_regnum_ftype *stab_reg_to_regnum;
 164   gdbarch_ecoff_reg_to_regnum_ftype *ecoff_reg_to_regnum;
 165   gdbarch_dwarf_reg_to_regnum_ftype *dwarf_reg_to_regnum;
 166   gdbarch_sdb_reg_to_regnum_ftype *sdb_reg_to_regnum;
 167   gdbarch_dwarf2_reg_to_regnum_ftype *dwarf2_reg_to_regnum;
 168   gdbarch_register_name_ftype *register_name;
 169   int register_size;
 170   int register_bytes;
 171   gdbarch_register_byte_ftype *register_byte;
 172   gdbarch_register_raw_size_ftype *register_raw_size;
 173   int max_register_raw_size;
 174   gdbarch_register_virtual_size_ftype *register_virtual_size;
 175   int max_register_virtual_size;
 176   gdbarch_register_virtual_type_ftype *register_virtual_type;
 177   gdbarch_deprecated_do_registers_info_ftype *deprecated_do_registers_info;
 178   gdbarch_print_registers_info_ftype *print_registers_info;
 179   gdbarch_print_float_info_ftype *print_float_info;
 180   gdbarch_print_vector_info_ftype *print_vector_info;
 181   gdbarch_register_sim_regno_ftype *register_sim_regno;
 182   gdbarch_register_bytes_ok_ftype *register_bytes_ok;
 183   gdbarch_cannot_fetch_register_ftype *cannot_fetch_register;
 184   gdbarch_cannot_store_register_ftype *cannot_store_register;
 185   gdbarch_get_longjmp_target_ftype *get_longjmp_target;
 186   int deprecated_use_generic_dummy_frames;
 187   int call_dummy_location;
 188   gdbarch_call_dummy_address_ftype *call_dummy_address;
 189   CORE_ADDR call_dummy_start_offset;
 190   CORE_ADDR call_dummy_breakpoint_offset;
 191   int call_dummy_breakpoint_offset_p;
 192   int call_dummy_length;
 193   gdbarch_deprecated_pc_in_call_dummy_ftype *deprecated_pc_in_call_dummy;
 194   int call_dummy_p;
 195   LONGEST * call_dummy_words;
 196   int sizeof_call_dummy_words;
 197   int call_dummy_stack_adjust_p;
 198   int call_dummy_stack_adjust;
 199   gdbarch_fix_call_dummy_ftype *fix_call_dummy;
 200   gdbarch_deprecated_init_frame_pc_first_ftype *deprecated_init_frame_pc_first;
 201   gdbarch_deprecated_init_frame_pc_ftype *deprecated_init_frame_pc;
 202   int believe_pcc_promotion;
 203   int believe_pcc_promotion_type;
 204   gdbarch_get_saved_register_ftype *get_saved_register;
 205   gdbarch_register_convertible_ftype *register_convertible;
 206   gdbarch_register_convert_to_virtual_ftype *register_convert_to_virtual;
 207   gdbarch_register_convert_to_raw_ftype *register_convert_to_raw;
 208   gdbarch_convert_register_p_ftype *convert_register_p;
 209   gdbarch_register_to_value_ftype *register_to_value;
 210   gdbarch_value_to_register_ftype *value_to_register;
 211   gdbarch_pointer_to_address_ftype *pointer_to_address;
 212   gdbarch_address_to_pointer_ftype *address_to_pointer;
 213   gdbarch_integer_to_address_ftype *integer_to_address;
 214   gdbarch_return_value_on_stack_ftype *return_value_on_stack;
 215   gdbarch_push_arguments_ftype *push_arguments;
 216   gdbarch_push_dummy_frame_ftype *push_dummy_frame;
 217   gdbarch_push_return_address_ftype *push_return_address;
 218   gdbarch_pop_frame_ftype *pop_frame;
 219   gdbarch_store_struct_return_ftype *store_struct_return;
 220   gdbarch_extract_return_value_ftype *extract_return_value;
 221   gdbarch_store_return_value_ftype *store_return_value;
 222   gdbarch_deprecated_extract_return_value_ftype *deprecated_extract_return_value;
 223   gdbarch_deprecated_store_return_value_ftype *deprecated_store_return_value;
 224   gdbarch_extract_struct_value_address_ftype *extract_struct_value_address;
 225   gdbarch_deprecated_extract_struct_value_address_ftype *deprecated_extract_struct_value_address;
 226   gdbarch_use_struct_convention_ftype *use_struct_convention;
 227   gdbarch_frame_init_saved_regs_ftype *frame_init_saved_regs;
 228   gdbarch_init_extra_frame_info_ftype *init_extra_frame_info;
 229   gdbarch_skip_prologue_ftype *skip_prologue;
 230   gdbarch_prologue_frameless_p_ftype *prologue_frameless_p;
 231   gdbarch_inner_than_ftype *inner_than;
 232   gdbarch_breakpoint_from_pc_ftype *breakpoint_from_pc;
 233   gdbarch_memory_insert_breakpoint_ftype *memory_insert_breakpoint;
 234   gdbarch_memory_remove_breakpoint_ftype *memory_remove_breakpoint;
 235   CORE_ADDR decr_pc_after_break;
 236   gdbarch_prepare_to_proceed_ftype *prepare_to_proceed;
 237   CORE_ADDR function_start_offset;
 238   gdbarch_remote_translate_xfer_address_ftype *remote_translate_xfer_address;
 239   CORE_ADDR frame_args_skip;
 240   gdbarch_frameless_function_invocation_ftype *frameless_function_invocation;
 241   gdbarch_frame_chain_ftype *frame_chain;
 242   gdbarch_frame_chain_valid_ftype *frame_chain_valid;
 243   gdbarch_frame_saved_pc_ftype *frame_saved_pc;
 244   gdbarch_frame_args_address_ftype *frame_args_address;
 245   gdbarch_frame_locals_address_ftype *frame_locals_address;
 246   gdbarch_saved_pc_after_call_ftype *saved_pc_after_call;
 247   gdbarch_frame_num_args_ftype *frame_num_args;
 248   gdbarch_stack_align_ftype *stack_align;
 249   gdbarch_frame_align_ftype *frame_align;
 250   int extra_stack_alignment_needed;
 251   gdbarch_reg_struct_has_addr_ftype *reg_struct_has_addr;
 252   gdbarch_save_dummy_frame_tos_ftype *save_dummy_frame_tos;
 253   int parm_boundary;
 254   const struct floatformat * float_format;
 255   const struct floatformat * double_format;
 256   const struct floatformat * long_double_format;
 257   gdbarch_convert_from_func_ptr_addr_ftype *convert_from_func_ptr_addr;
 258   gdbarch_addr_bits_remove_ftype *addr_bits_remove;
 259   gdbarch_smash_text_address_ftype *smash_text_address;
 260   gdbarch_software_single_step_ftype *software_single_step;
 261   gdbarch_print_insn_ftype *print_insn;
 262   gdbarch_skip_trampoline_code_ftype *skip_trampoline_code;
 263   gdbarch_in_solib_call_trampoline_ftype *in_solib_call_trampoline;
 264   gdbarch_in_solib_return_trampoline_ftype *in_solib_return_trampoline;
 265   gdbarch_pc_in_sigtramp_ftype *pc_in_sigtramp;
 266   gdbarch_sigtramp_start_ftype *sigtramp_start;
 267   gdbarch_sigtramp_end_ftype *sigtramp_end;
 268   gdbarch_in_function_epilogue_p_ftype *in_function_epilogue_p;
 269   gdbarch_construct_inferior_arguments_ftype *construct_inferior_arguments;
 270   gdbarch_dwarf2_build_frame_info_ftype *dwarf2_build_frame_info;
 271   gdbarch_elf_make_msymbol_special_ftype *elf_make_msymbol_special;
 272   gdbarch_coff_make_msymbol_special_ftype *coff_make_msymbol_special;
 273   const char * name_of_malloc;
 274   int cannot_step_breakpoint;
 275   int have_nonsteppable_watchpoint;
 276   gdbarch_address_class_type_flags_ftype *address_class_type_flags;
 277   gdbarch_address_class_type_flags_to_name_ftype *address_class_type_flags_to_name;
 278   gdbarch_address_class_name_to_type_flags_ftype *address_class_name_to_type_flags;
 279   gdbarch_register_reggroup_p_ftype *register_reggroup_p;
 280 };
 281
 282
 283 /* The default architecture uses host values (for want of a better
 284    choice). */
 285
 286 extern const struct bfd_arch_info bfd_default_arch_struct;
 287
 288 struct gdbarch startup_gdbarch =
 289 {
 290   1, /* Always initialized.  */
 291   /* basic architecture information */
 292   &bfd_default_arch_struct,
 293   BFD_ENDIAN_BIG,
 294   GDB_OSABI_UNKNOWN,
 295   /* target specific vector and its dump routine */
 296   NULL, NULL,
 297   /*per-architecture data-pointers and swap regions */
 298   0, NULL, NULL,
 299   /* Multi-arch values */
 300   8 * sizeof (short),
 301   8 * sizeof (int),
 302   8 * sizeof (long),
 303   8 * sizeof (LONGEST),
 304   8 * sizeof (float),
 305   8 * sizeof (double),
 306   8 * sizeof (long double),
 307   8 * sizeof (void*),
 308   8 * sizeof (void*),
 309   8 * sizeof (void*),
 310   1,
 311   0,
 312   0,
 313   0,
 314   0,
 315   0,
 316   0,
 317   0,
 318   0,
 319   0,
 320   0,
 321   -1,
 322   -1,
 323   -1,
 324   -1,
 325   0,
 326   0,
 327   0,
 328   0,
 329   0,
 330   0,
 331   0,
 332   0,
 333   0,
 334   0,
 335   generic_register_byte,
 336   generic_register_size,
 337   0,
 338   generic_register_size,
 339   0,
 340   0,
 341   0,
 342   default_print_registers_info,
 343   0,
 344   0,
 345   0,
 346   0,
 347   0,
 348   0,
 349   0,
 350   0,
 351   0,
 352   0,
 353   0,
 354   0,
 355   0,
 356   0,
 357   generic_pc_in_call_dummy,
 358   0,
 359   0,
 360   0,
 361   0,
 362   0,
 363   0,
 364   0,
 365   0,
 366   0,
 367   0,
 368   0,
 369   0,
 370   0,
 371   0,
 372   0,
 373   0,
 374   0,
 375   0,
 376   0,
 377   0,
 378   0,
 379   0,
 380   0,
 381   0,
 382   0,
 383   0,
 384   0,
 385   0,
 386   0,
 387   0,
 388   0,
 389   0,
 390   0,
 391   0,
 392   0,
 393   0,
 394   0,
 395   0,
 396   0,
 397   0,
 398   0,
 399   0,
 400   0,
 401   0,
 402   0,
 403   0,
 404   0,
 405   0,
 406   0,
 407   0,
 408   0,
 409   0,
 410   0,
 411   0,
 412   0,
 413   0,
 414   0,
 415   0,
 416   0,
 417   0,
 418   0,
 419   0,
 420   0,
 421   0,
 422   0,
 423   0,
 424   0,
 425   0,
 426   0,
 427   0,
 428   0,
 429   0,
 430   0,
 431   0,
 432   generic_in_function_epilogue_p,
 433   construct_inferior_arguments,
 434   0,
 435   0,
 436   0,
 437   "malloc",
 438   0,
 439   0,
 440   0,
 441   0,
 442   0,
 443   default_register_reggroup_p,
 444   /* startup_gdbarch() */
 445 };
 446
 447 struct gdbarch *current_gdbarch = &startup_gdbarch;
 448
 449 /* Do any initialization needed for a non-multiarch configuration
 450    after the _initialize_MODULE functions have been run.  */
 451 void
 452 initialize_non_multiarch (void)
 453 {
 454   alloc_gdbarch_data (&startup_gdbarch);
 455   /* Ensure that all swap areas are zeroed so that they again think
 456      they are starting from scratch.  */
 457   clear_gdbarch_swap (&startup_gdbarch);
 458   init_gdbarch_swap (&startup_gdbarch);
 459 }
 460
 461
 462 /* Create a new ``struct gdbarch'' based on information provided by
 463    ``struct gdbarch_info''. */
 464
 465 struct gdbarch *
 466 gdbarch_alloc (const struct gdbarch_info *info,
 467                struct gdbarch_tdep *tdep)
 468 {
 469   /* NOTE: The new architecture variable is named ``current_gdbarch''
 470      so that macros such as TARGET_DOUBLE_BIT, when expanded, refer to
 471      the current local architecture and not the previous global
 472      architecture.  This ensures that the new architectures initial
 473      values are not influenced by the previous architecture.  Once
 474      everything is parameterised with gdbarch, this will go away.  */
 475   struct gdbarch *current_gdbarch = XMALLOC (struct gdbarch);
 476   memset (current_gdbarch, 0, sizeof (*current_gdbarch));
 477
 478   alloc_gdbarch_data (current_gdbarch);
 479
 480   current_gdbarch->tdep = tdep;
 481
 482   current_gdbarch->bfd_arch_info = info->bfd_arch_info;
 483   current_gdbarch->byte_order = info->byte_order;
 484   current_gdbarch->osabi = info->osabi;
 485
 486   /* Force the explicit initialization of these. */
 487   current_gdbarch->short_bit = 2*TARGET_CHAR_BIT;
 488   current_gdbarch->int_bit = 4*TARGET_CHAR_BIT;
 489   current_gdbarch->long_bit = 4*TARGET_CHAR_BIT;
 490   current_gdbarch->long_long_bit = 2*TARGET_LONG_BIT;
 491   current_gdbarch->float_bit = 4*TARGET_CHAR_BIT;
 492   current_gdbarch->double_bit = 8*TARGET_CHAR_BIT;
 493   current_gdbarch->long_double_bit = 8*TARGET_CHAR_BIT;
 494   current_gdbarch->ptr_bit = TARGET_INT_BIT;
 495   current_gdbarch->bfd_vma_bit = TARGET_ARCHITECTURE->bits_per_address;
 496   current_gdbarch->char_signed = -1;
 497   current_gdbarch->read_pc = generic_target_read_pc;
 498   current_gdbarch->write_pc = generic_target_write_pc;
 499   current_gdbarch->read_fp = generic_target_read_fp;
 500   current_gdbarch->read_sp = generic_target_read_sp;
 501   current_gdbarch->write_sp = generic_target_write_sp;
 502   current_gdbarch->virtual_frame_pointer = legacy_virtual_frame_pointer;
 503   current_gdbarch->num_regs = -1;
 504   current_gdbarch->sp_regnum = -1;
 505   current_gdbarch->fp_regnum = -1;
 506   current_gdbarch->pc_regnum = -1;
 507   current_gdbarch->ps_regnum = -1;
 508   current_gdbarch->fp0_regnum = -1;
 509   current_gdbarch->npc_regnum = -1;
 510   current_gdbarch->stab_reg_to_regnum = no_op_reg_to_regnum;
 511   current_gdbarch->ecoff_reg_to_regnum = no_op_reg_to_regnum;
 512   current_gdbarch->dwarf_reg_to_regnum = no_op_reg_to_regnum;
 513   current_gdbarch->sdb_reg_to_regnum = no_op_reg_to_regnum;
 514   current_gdbarch->dwarf2_reg_to_regnum = no_op_reg_to_regnum;
 515   current_gdbarch->register_name = legacy_register_name;
 516   current_gdbarch->register_size = -1;
 517   current_gdbarch->register_bytes = -1;
 518   current_gdbarch->register_byte = generic_register_byte;
 519   current_gdbarch->register_raw_size = generic_register_size;
 520   current_gdbarch->max_register_raw_size = -1;
 521   current_gdbarch->register_virtual_size = generic_register_size;
 522   current_gdbarch->max_register_virtual_size = -1;
 523   current_gdbarch->print_registers_info = default_print_registers_info;
 524   current_gdbarch->register_sim_regno = legacy_register_sim_regno;
 525   current_gdbarch->cannot_fetch_register = cannot_register_not;
 526   current_gdbarch->cannot_store_register = cannot_register_not;
 527   current_gdbarch->deprecated_use_generic_dummy_frames = 1;
 528   current_gdbarch->call_dummy_location = AT_ENTRY_POINT;
 529   current_gdbarch->call_dummy_start_offset = -1;
 530   current_gdbarch->call_dummy_breakpoint_offset = -1;
 531   current_gdbarch->call_dummy_breakpoint_offset_p = -1;
 532   current_gdbarch->call_dummy_length = -1;
 533   current_gdbarch->deprecated_pc_in_call_dummy = generic_pc_in_call_dummy;
 534   current_gdbarch->call_dummy_p = -1;
 535   current_gdbarch->call_dummy_words = legacy_call_dummy_words;
 536   current_gdbarch->sizeof_call_dummy_words = legacy_sizeof_call_dummy_words;
 537   current_gdbarch->call_dummy_stack_adjust_p = -1;
 538   current_gdbarch->register_convertible = generic_register_convertible_not;
 539   current_gdbarch->convert_register_p = legacy_convert_register_p;
 540   current_gdbarch->register_to_value = legacy_register_to_value;
 541   current_gdbarch->value_to_register = legacy_value_to_register;
 542   current_gdbarch->pointer_to_address = unsigned_pointer_to_address;
 543   current_gdbarch->address_to_pointer = unsigned_address_to_pointer;
 544   current_gdbarch->return_value_on_stack = generic_return_value_on_stack_not;
 545   current_gdbarch->push_arguments = default_push_arguments;
 546   current_gdbarch->extract_return_value = legacy_extract_return_value;
 547   current_gdbarch->store_return_value = legacy_store_return_value;
 548   current_gdbarch->use_struct_convention = generic_use_struct_convention;
 549   current_gdbarch->prologue_frameless_p = generic_prologue_frameless_p;
 550   current_gdbarch->breakpoint_from_pc = legacy_breakpoint_from_pc;
 551   current_gdbarch->memory_insert_breakpoint = default_memory_insert_breakpoint;
 552   current_gdbarch->memory_remove_breakpoint = default_memory_remove_breakpoint;
 553   current_gdbarch->decr_pc_after_break = -1;
 554   current_gdbarch->prepare_to_proceed = default_prepare_to_proceed;
 555   current_gdbarch->function_start_offset = -1;
 556   current_gdbarch->remote_translate_xfer_address = generic_remote_translate_xfer_address;
 557   current_gdbarch->frame_args_skip = -1;
 558   current_gdbarch->frameless_function_invocation = generic_frameless_function_invocation_not;
 559   current_gdbarch->frame_chain_valid = generic_func_frame_chain_valid;
 560   current_gdbarch->frame_args_address = get_frame_base;
 561   current_gdbarch->frame_locals_address = get_frame_base;
 562   current_gdbarch->extra_stack_alignment_needed = 1;
 563   current_gdbarch->convert_from_func_ptr_addr = core_addr_identity;
 564   current_gdbarch->addr_bits_remove = core_addr_identity;
 565   current_gdbarch->smash_text_address = core_addr_identity;
 566   current_gdbarch->print_insn = legacy_print_insn;
 567   current_gdbarch->skip_trampoline_code = generic_skip_trampoline_code;
 568   current_gdbarch->in_solib_call_trampoline = generic_in_solib_call_trampoline;
 569   current_gdbarch->in_solib_return_trampoline = generic_in_solib_return_trampoline;
 570   current_gdbarch->pc_in_sigtramp = legacy_pc_in_sigtramp;
 571   current_gdbarch->in_function_epilogue_p = generic_in_function_epilogue_p;
 572   current_gdbarch->construct_inferior_arguments = construct_inferior_arguments;
 573   current_gdbarch->elf_make_msymbol_special = default_elf_make_msymbol_special;
 574   current_gdbarch->coff_make_msymbol_special = default_coff_make_msymbol_special;
 575   current_gdbarch->name_of_malloc = "malloc";
 576   current_gdbarch->register_reggroup_p = default_register_reggroup_p;
 577   /* gdbarch_alloc() */
 578
 579   return current_gdbarch;
 580 }
 581
 582
 583 /* Free a gdbarch struct.  This should never happen in normal
 584    operation --- once you've created a gdbarch, you keep it around.
 585    However, if an architecture's init function encounters an error
 586    building the structure, it may need to clean up a partially
 587    constructed gdbarch.  */
 588
 589 void
 590 gdbarch_free (struct gdbarch *arch)
 591 {
 592   gdb_assert (arch != NULL);
 593   free_gdbarch_data (arch);
 594   xfree (arch);
 595 }
 596
 597
 598 /* Ensure that all values in a GDBARCH are reasonable. */
 599
 600 static void
 601 verify_gdbarch (struct gdbarch *gdbarch)
 602 {
 603   struct ui_file *log;
 604   struct cleanup *cleanups;
 605   long dummy;
 606   char *buf;
 607   /* Only perform sanity checks on a multi-arch target. */
 608   if (!GDB_MULTI_ARCH)
 609     return;
 610   log = mem_fileopen ();
 611   cleanups = make_cleanup_ui_file_delete (log);
 612   /* fundamental */
 613   if (gdbarch->byte_order == BFD_ENDIAN_UNKNOWN)
 614     fprintf_unfiltered (log, "\n\tbyte-order");
 615   if (gdbarch->bfd_arch_info == NULL)
 616     fprintf_unfiltered (log, "\n\tbfd_arch_info");
 617   /* Check those that need to be defined for the given multi-arch level. */
 618   /* Skip verify of short_bit, invalid_p == 0 */
 619   /* Skip verify of int_bit, invalid_p == 0 */
 620   /* Skip verify of long_bit, invalid_p == 0 */
 621   /* Skip verify of long_long_bit, invalid_p == 0 */
 622   /* Skip verify of float_bit, invalid_p == 0 */
 623   /* Skip verify of double_bit, invalid_p == 0 */
 624   /* Skip verify of long_double_bit, invalid_p == 0 */
 625   /* Skip verify of ptr_bit, invalid_p == 0 */
 626   if (gdbarch->addr_bit == 0)
 627     gdbarch->addr_bit = TARGET_PTR_BIT;
 628   /* Skip verify of bfd_vma_bit, invalid_p == 0 */
 629   if (gdbarch->char_signed == -1)
 630     gdbarch->char_signed = 1;
 631   /* Skip verify of read_pc, invalid_p == 0 */
 632   /* Skip verify of write_pc, invalid_p == 0 */
 633   /* Skip verify of read_fp, invalid_p == 0 */
 634   /* Skip verify of read_sp, invalid_p == 0 */
 635   /* Skip verify of write_sp, invalid_p == 0 */
 636   /* Skip verify of virtual_frame_pointer, invalid_p == 0 */
 637   /* Skip verify of pseudo_register_read, has predicate */
 638   /* Skip verify of pseudo_register_write, has predicate */
 639   if ((GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL)
 640       && (gdbarch->num_regs == -1))
 641     fprintf_unfiltered (log, "\n\tnum_regs");
 642   /* Skip verify of num_pseudo_regs, invalid_p == 0 */
 643   /* Skip verify of sp_regnum, invalid_p == 0 */
 644   /* Skip verify of fp_regnum, invalid_p == 0 */
 645   /* Skip verify of pc_regnum, invalid_p == 0 */
 646   /* Skip verify of ps_regnum, invalid_p == 0 */
 647   /* Skip verify of fp0_regnum, invalid_p == 0 */
 648   /* Skip verify of npc_regnum, invalid_p == 0 */
 649   /* Skip verify of stab_reg_to_regnum, invalid_p == 0 */
 650   /* Skip verify of ecoff_reg_to_regnum, invalid_p == 0 */
 651   /* Skip verify of dwarf_reg_to_regnum, invalid_p == 0 */
 652   /* Skip verify of sdb_reg_to_regnum, invalid_p == 0 */
 653   /* Skip verify of dwarf2_reg_to_regnum, invalid_p == 0 */
 654   /* Skip verify of register_name, invalid_p == 0 */
 655   if ((GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL)
 656       && (gdbarch->register_size == -1))
 657     fprintf_unfiltered (log, "\n\tregister_size");
 658   if ((GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL)
 659       && (gdbarch->register_bytes == -1))
 660     fprintf_unfiltered (log, "\n\tregister_bytes");
 661   /* Skip verify of register_byte, invalid_p == 0 */
 662   /* Skip verify of register_raw_size, invalid_p == 0 */
 663   if ((GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL)
 664       && (gdbarch->max_register_raw_size == -1))
 665     fprintf_unfiltered (log, "\n\tmax_register_raw_size");
 666   /* Skip verify of register_virtual_size, invalid_p == 0 */
 667   if ((GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL)
 668       && (gdbarch->max_register_virtual_size == -1))
 669     fprintf_unfiltered (log, "\n\tmax_register_virtual_size");
 670   if ((GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL)
 671       && (gdbarch->register_virtual_type == 0))
 672     fprintf_unfiltered (log, "\n\tregister_virtual_type");
 673   /* Skip verify of deprecated_do_registers_info, has predicate */
 674   /* Skip verify of print_registers_info, invalid_p == 0 */
 675   /* Skip verify of print_float_info, has predicate */
 676   /* Skip verify of print_vector_info, has predicate */
 677   /* Skip verify of register_sim_regno, invalid_p == 0 */
 678   /* Skip verify of register_bytes_ok, has predicate */
 679   /* Skip verify of cannot_fetch_register, invalid_p == 0 */
 680   /* Skip verify of cannot_store_register, invalid_p == 0 */
 681   /* Skip verify of get_longjmp_target, has predicate */
 682   /* Skip verify of deprecated_use_generic_dummy_frames, invalid_p == 0 */
 683   /* Skip verify of call_dummy_location, invalid_p == 0 */
 684   if ((GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL)
 685       && (gdbarch->call_dummy_location == AT_ENTRY_POINT && gdbarch->call_dummy_address == 0))
 686     fprintf_unfiltered (log, "\n\tcall_dummy_address");
 687   if ((GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL)
 688       && (gdbarch->call_dummy_start_offset == -1))
 689     fprintf_unfiltered (log, "\n\tcall_dummy_start_offset");
 690   if ((GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL)
 691       && (gdbarch->call_dummy_breakpoint_offset_p && gdbarch->call_dummy_breakpoint_offset == -1))
 692     fprintf_unfiltered (log, "\n\tcall_dummy_breakpoint_offset");
 693   if ((GDB_MULTI_ARCH >= GDB_MULTI_ARCH_PARTIAL)
 694       && (gdbarch->call_dummy_breakpoint_offset_p == -1))
 695     fprintf_unfiltered (log, "\n\tcall_dummy_breakpoint_offset_p");
 696   if ((GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL)
 697       && (gdbarch->call_dummy_length == -1))
 698     fprintf_unfiltered (log, "\n\tcall_dummy_length");
 699   /* Skip verify of deprecated_pc_in_call_dummy, has predicate */
 700   if ((GDB_MULTI_ARCH >= GDB_MULTI_ARCH_PARTIAL)
 701       && (gdbarch->call_dummy_p == -1))
 702     fprintf_unfiltered (log, "\n\tcall_dummy_p");
 703   /* Skip verify of call_dummy_words, invalid_p == 0 */
 704   /* Skip verify of sizeof_call_dummy_words, invalid_p == 0 */
 705   if ((GDB_MULTI_ARCH >= GDB_MULTI_ARCH_PARTIAL)
 706       && (gdbarch->call_dummy_stack_adjust_p == -1))
 707     fprintf_unfiltered (log, "\n\tcall_dummy_stack_adjust_p");
 708   if ((GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL)
 709       && (gdbarch->call_dummy_stack_adjust_p && gdbarch->call_dummy_stack_adjust == 0))
 710     fprintf_unfiltered (log, "\n\tcall_dummy_stack_adjust");
 711   if ((GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL)
 712       && (gdbarch->fix_call_dummy == 0))
 713     fprintf_unfiltered (log, "\n\tfix_call_dummy");
 714   /* Skip verify of deprecated_init_frame_pc_first, has predicate */
 715   /* Skip verify of deprecated_init_frame_pc, has predicate */
 716   /* Skip verify of get_saved_register, has predicate */
 717   /* Skip verify of register_convertible, invalid_p == 0 */
 718   /* Skip verify of register_convert_to_virtual, invalid_p == 0 */
 719   /* Skip verify of register_convert_to_raw, invalid_p == 0 */
 720   /* Skip verify of convert_register_p, invalid_p == 0 */
 721   /* Skip verify of register_to_value, invalid_p == 0 */
 722   /* Skip verify of value_to_register, invalid_p == 0 */
 723   /* Skip verify of pointer_to_address, invalid_p == 0 */
 724   /* Skip verify of address_to_pointer, invalid_p == 0 */
 725   /* Skip verify of integer_to_address, has predicate */
 726   /* Skip verify of return_value_on_stack, invalid_p == 0 */
 727   /* Skip verify of push_arguments, invalid_p == 0 */
 728   if ((GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL)
 729       && (gdbarch->push_dummy_frame == 0))
 730     fprintf_unfiltered (log, "\n\tpush_dummy_frame");
 731   /* Skip verify of push_return_address, has predicate */
 732   if ((GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL)
 733       && (gdbarch->pop_frame == 0))
 734     fprintf_unfiltered (log, "\n\tpop_frame");
 735   if ((GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL)
 736       && (gdbarch->store_struct_return == 0))
 737     fprintf_unfiltered (log, "\n\tstore_struct_return");
 738   /* Skip verify of extract_return_value, invalid_p == 0 */
 739   /* Skip verify of store_return_value, invalid_p == 0 */
 740   /* Skip verify of extract_struct_value_address, has predicate */
 741   /* Skip verify of deprecated_extract_struct_value_address, has predicate */
 742   /* Skip verify of use_struct_convention, invalid_p == 0 */
 743   if ((GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL)
 744       && (gdbarch->frame_init_saved_regs == 0))
 745     fprintf_unfiltered (log, "\n\tframe_init_saved_regs");
 746   /* Skip verify of init_extra_frame_info, has predicate */
 747   if ((GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL)
 748       && (gdbarch->skip_prologue == 0))
 749     fprintf_unfiltered (log, "\n\tskip_prologue");
 750   /* Skip verify of prologue_frameless_p, invalid_p == 0 */
 751   if ((GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL)
 752       && (gdbarch->inner_than == 0))
 753     fprintf_unfiltered (log, "\n\tinner_than");
 754   /* Skip verify of breakpoint_from_pc, invalid_p == 0 */
 755   /* Skip verify of memory_insert_breakpoint, invalid_p == 0 */
 756   /* Skip verify of memory_remove_breakpoint, invalid_p == 0 */
 757   if ((GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL)
 758       && (gdbarch->decr_pc_after_break == -1))
 759     fprintf_unfiltered (log, "\n\tdecr_pc_after_break");
 760   /* Skip verify of prepare_to_proceed, invalid_p == 0 */
 761   if ((GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL)
 762       && (gdbarch->function_start_offset == -1))
 763     fprintf_unfiltered (log, "\n\tfunction_start_offset");
 764   /* Skip verify of remote_translate_xfer_address, invalid_p == 0 */
 765   if ((GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL)
 766       && (gdbarch->frame_args_skip == -1))
 767     fprintf_unfiltered (log, "\n\tframe_args_skip");
 768   /* Skip verify of frameless_function_invocation, invalid_p == 0 */
 769   if ((GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL)
 770       && (gdbarch->frame_chain == 0))
 771     fprintf_unfiltered (log, "\n\tframe_chain");
 772   /* Skip verify of frame_chain_valid, invalid_p == 0 */
 773   if ((GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL)
 774       && (gdbarch->frame_saved_pc == 0))
 775     fprintf_unfiltered (log, "\n\tframe_saved_pc");
 776   /* Skip verify of frame_args_address, invalid_p == 0 */
 777   /* Skip verify of frame_locals_address, invalid_p == 0 */
 778   if ((GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL)
 779       && (gdbarch->saved_pc_after_call == 0))
 780     fprintf_unfiltered (log, "\n\tsaved_pc_after_call");
 781   if ((GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL)
 782       && (gdbarch->frame_num_args == 0))
 783     fprintf_unfiltered (log, "\n\tframe_num_args");
 784   /* Skip verify of stack_align, has predicate */
 785   /* Skip verify of frame_align, has predicate */
 786   /* Skip verify of extra_stack_alignment_needed, invalid_p == 0 */
 787   /* Skip verify of reg_struct_has_addr, has predicate */
 788   /* Skip verify of save_dummy_frame_tos, has predicate */
 789   if (gdbarch->float_format == 0)
 790     gdbarch->float_format = default_float_format (gdbarch);
 791   if (gdbarch->double_format == 0)
 792     gdbarch->double_format = default_double_format (gdbarch);
 793   if (gdbarch->long_double_format == 0)
 794     gdbarch->long_double_format = default_double_format (gdbarch);
 795   /* Skip verify of convert_from_func_ptr_addr, invalid_p == 0 */
 796   /* Skip verify of addr_bits_remove, invalid_p == 0 */
 797   /* Skip verify of smash_text_address, invalid_p == 0 */
 798   /* Skip verify of software_single_step, has predicate */
 799   /* Skip verify of print_insn, invalid_p == 0 */
 800   /* Skip verify of skip_trampoline_code, invalid_p == 0 */
 801   /* Skip verify of in_solib_call_trampoline, invalid_p == 0 */
 802   /* Skip verify of in_solib_return_trampoline, invalid_p == 0 */
 803   /* Skip verify of pc_in_sigtramp, invalid_p == 0 */
 804   /* Skip verify of sigtramp_start, has predicate */
 805   /* Skip verify of sigtramp_end, has predicate */
 806   /* Skip verify of in_function_epilogue_p, invalid_p == 0 */
 807   /* Skip verify of construct_inferior_arguments, invalid_p == 0 */
 808   /* Skip verify of dwarf2_build_frame_info, has predicate */
 809   /* Skip verify of elf_make_msymbol_special, invalid_p == 0 */
 810   /* Skip verify of coff_make_msymbol_special, invalid_p == 0 */
 811   /* Skip verify of name_of_malloc, invalid_p == 0 */
 812   /* Skip verify of cannot_step_breakpoint, invalid_p == 0 */
 813   /* Skip verify of have_nonsteppable_watchpoint, invalid_p == 0 */
 814   /* Skip verify of address_class_type_flags, has predicate */
 815   /* Skip verify of address_class_type_flags_to_name, has predicate */
 816   /* Skip verify of address_class_name_to_type_flags, has predicate */
 817   /* Skip verify of register_reggroup_p, invalid_p == 0 */
 818   buf = ui_file_xstrdup (log, &dummy);
 819   make_cleanup (xfree, buf);
 820   if (strlen (buf) > 0)
 821     internal_error (__FILE__, __LINE__,
 822                     "verify_gdbarch: the following are invalid ...%s",
 823                     buf);
 824   do_cleanups (cleanups);
 825 }
 826
 827
 828 /* Print out the details of the current architecture. */
 829
 830 /* NOTE/WARNING: The parameter is called ``current_gdbarch'' so that it
 831    just happens to match the global variable ``current_gdbarch''.  That
 832    way macros refering to that variable get the local and not the global
 833    version - ulgh.  Once everything is parameterised with gdbarch, this
 834    will go away. */
 835
 836 void
 837 gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file)
 838 {
 839   fprintf_unfiltered (file,
 840                       "gdbarch_dump: GDB_MULTI_ARCH = %d\n",
 841                       GDB_MULTI_ARCH);
 842   if (GDB_MULTI_ARCH)
 843     fprintf_unfiltered (file,
 844                         "gdbarch_dump: gdbarch_frame_align_p() = %d\n",
 845                         gdbarch_frame_align_p (current_gdbarch));
 846   if (GDB_MULTI_ARCH)
 847     fprintf_unfiltered (file,
 848                         "gdbarch_dump: frame_align = 0x%08lx\n",
 849                         (long) current_gdbarch->frame_align);
 850   if (GDB_MULTI_ARCH)
 851     fprintf_unfiltered (file,
 852                         "gdbarch_dump: in_function_epilogue_p = 0x%08lx\n",
 853                         (long) current_gdbarch->in_function_epilogue_p);
 854   if (GDB_MULTI_ARCH)
 855     fprintf_unfiltered (file,
 856                         "gdbarch_dump: register_reggroup_p = 0x%08lx\n",
 857                         (long) current_gdbarch->register_reggroup_p);
 858   if (GDB_MULTI_ARCH)
 859     fprintf_unfiltered (file,
 860                         "gdbarch_dump: gdbarch_pseudo_register_read_p() = %d\n",
 861                         gdbarch_pseudo_register_read_p (current_gdbarch));
 862   if (GDB_MULTI_ARCH)
 863     fprintf_unfiltered (file,
 864                         "gdbarch_dump: pseudo_register_read = 0x%08lx\n",
 865                         (long) current_gdbarch->pseudo_register_read);
 866   if (GDB_MULTI_ARCH)
 867     fprintf_unfiltered (file,
 868                         "gdbarch_dump: gdbarch_pseudo_register_write_p() = %d\n",
 869                         gdbarch_pseudo_register_write_p (current_gdbarch));
 870   if (GDB_MULTI_ARCH)
 871     fprintf_unfiltered (file,
 872                         "gdbarch_dump: pseudo_register_write = 0x%08lx\n",
 873                         (long) current_gdbarch->pseudo_register_write);
 874   if (GDB_MULTI_ARCH)
 875     fprintf_unfiltered (file,
 876                         "gdbarch_dump: gdbarch_address_class_name_to_type_flags_p() = %d\n",
 877                         gdbarch_address_class_name_to_type_flags_p (current_gdbarch));
 878   if (GDB_MULTI_ARCH)
 879     fprintf_unfiltered (file,
 880                         "gdbarch_dump: address_class_name_to_type_flags = 0x%08lx\n",
 881                         (long) current_gdbarch->address_class_name_to_type_flags);
 882 #ifdef ADDRESS_CLASS_TYPE_FLAGS_P
 883   fprintf_unfiltered (file,
 884                       "gdbarch_dump: %s # %s\n",
 885                       "ADDRESS_CLASS_TYPE_FLAGS_P()",
 886                       XSTRING (ADDRESS_CLASS_TYPE_FLAGS_P ()));
 887   fprintf_unfiltered (file,
 888                       "gdbarch_dump: ADDRESS_CLASS_TYPE_FLAGS_P() = %d\n",
 889                       ADDRESS_CLASS_TYPE_FLAGS_P ());
 890 #endif
 891 #ifdef ADDRESS_CLASS_TYPE_FLAGS
 892   fprintf_unfiltered (file,
 893                       "gdbarch_dump: %s # %s\n",
 894                       "ADDRESS_CLASS_TYPE_FLAGS(byte_size, dwarf2_addr_class)",
 895                       XSTRING (ADDRESS_CLASS_TYPE_FLAGS (byte_size, dwarf2_addr_class)));
 896   if (GDB_MULTI_ARCH)
 897     fprintf_unfiltered (file,
 898                         "gdbarch_dump: ADDRESS_CLASS_TYPE_FLAGS = <0x%08lx>\n",
 899                         (long) current_gdbarch->address_class_type_flags
 900                         /*ADDRESS_CLASS_TYPE_FLAGS ()*/);
 901 #endif
 902   if (GDB_MULTI_ARCH)
 903     fprintf_unfiltered (file,
 904                         "gdbarch_dump: gdbarch_address_class_type_flags_to_name_p() = %d\n",
 905                         gdbarch_address_class_type_flags_to_name_p (current_gdbarch));
 906   if (GDB_MULTI_ARCH)
 907     fprintf_unfiltered (file,
 908                         "gdbarch_dump: address_class_type_flags_to_name = 0x%08lx\n",
 909                         (long) current_gdbarch->address_class_type_flags_to_name);
 910 #ifdef ADDRESS_TO_POINTER
 911 #if GDB_MULTI_ARCH
 912   /* Macro might contain `[{}]' when not multi-arch */
 913   fprintf_unfiltered (file,
 914                       "gdbarch_dump: %s # %s\n",
 915                       "ADDRESS_TO_POINTER(type, buf, addr)",
 916                       XSTRING (ADDRESS_TO_POINTER (type, buf, addr)));
 917 #endif
 918   if (GDB_MULTI_ARCH)
 919     fprintf_unfiltered (file,
 920                         "gdbarch_dump: ADDRESS_TO_POINTER = <0x%08lx>\n",
 921                         (long) current_gdbarch->address_to_pointer
 922                         /*ADDRESS_TO_POINTER ()*/);
 923 #endif
 924 #ifdef ADDR_BITS_REMOVE
 925   fprintf_unfiltered (file,
 926                       "gdbarch_dump: %s # %s\n",
 927                       "ADDR_BITS_REMOVE(addr)",
 928                       XSTRING (ADDR_BITS_REMOVE (addr)));
 929   if (GDB_MULTI_ARCH)
 930     fprintf_unfiltered (file,
 931                         "gdbarch_dump: ADDR_BITS_REMOVE = <0x%08lx>\n",
 932                         (long) current_gdbarch->addr_bits_remove
 933                         /*ADDR_BITS_REMOVE ()*/);
 934 #endif
 935 #ifdef BELIEVE_PCC_PROMOTION
 936   fprintf_unfiltered (file,
 937                       "gdbarch_dump: BELIEVE_PCC_PROMOTION # %s\n",
 938                       XSTRING (BELIEVE_PCC_PROMOTION));
 939   fprintf_unfiltered (file,
 940                       "gdbarch_dump: BELIEVE_PCC_PROMOTION = %d\n",
 941                       BELIEVE_PCC_PROMOTION);
 942 #endif
 943 #ifdef BELIEVE_PCC_PROMOTION_TYPE
 944   fprintf_unfiltered (file,
 945                       "gdbarch_dump: BELIEVE_PCC_PROMOTION_TYPE # %s\n",
 946                       XSTRING (BELIEVE_PCC_PROMOTION_TYPE));
 947   fprintf_unfiltered (file,
 948                       "gdbarch_dump: BELIEVE_PCC_PROMOTION_TYPE = %d\n",
 949                       BELIEVE_PCC_PROMOTION_TYPE);
 950 #endif
 951 #ifdef BREAKPOINT_FROM_PC
 952   fprintf_unfiltered (file,
 953                       "gdbarch_dump: %s # %s\n",
 954                       "BREAKPOINT_FROM_PC(pcptr, lenptr)",
 955                       XSTRING (BREAKPOINT_FROM_PC (pcptr, lenptr)));
 956   if (GDB_MULTI_ARCH)
 957     fprintf_unfiltered (file,
 958                         "gdbarch_dump: BREAKPOINT_FROM_PC = <0x%08lx>\n",
 959                         (long) current_gdbarch->breakpoint_from_pc
 960                         /*BREAKPOINT_FROM_PC ()*/);
 961 #endif
 962 #ifdef CALL_DUMMY_ADDRESS
 963   fprintf_unfiltered (file,
 964                       "gdbarch_dump: %s # %s\n",
 965                       "CALL_DUMMY_ADDRESS()",
 966                       XSTRING (CALL_DUMMY_ADDRESS ()));
 967   if (GDB_MULTI_ARCH)
 968     fprintf_unfiltered (file,
 969                         "gdbarch_dump: CALL_DUMMY_ADDRESS = <0x%08lx>\n",
 970                         (long) current_gdbarch->call_dummy_address
 971                         /*CALL_DUMMY_ADDRESS ()*/);
 972 #endif
 973 #ifdef CALL_DUMMY_BREAKPOINT_OFFSET
 974   fprintf_unfiltered (file,
 975                       "gdbarch_dump: CALL_DUMMY_BREAKPOINT_OFFSET # %s\n",
 976                       XSTRING (CALL_DUMMY_BREAKPOINT_OFFSET));
 977   if (CALL_DUMMY_BREAKPOINT_OFFSET_P)
 978     fprintf_unfiltered (file,
 979                         "gdbarch_dump: CALL_DUMMY_BREAKPOINT_OFFSET = 0x%08lx\n",
 980                         (long) CALL_DUMMY_BREAKPOINT_OFFSET);
 981 #endif
 982 #ifdef CALL_DUMMY_BREAKPOINT_OFFSET_P
 983   fprintf_unfiltered (file,
 984                       "gdbarch_dump: CALL_DUMMY_BREAKPOINT_OFFSET_P # %s\n",
 985                       XSTRING (CALL_DUMMY_BREAKPOINT_OFFSET_P));
 986   fprintf_unfiltered (file,
 987                       "gdbarch_dump: CALL_DUMMY_BREAKPOINT_OFFSET_P = %d\n",
 988                       CALL_DUMMY_BREAKPOINT_OFFSET_P);
 989 #endif
 990 #ifdef CALL_DUMMY_LENGTH
 991   fprintf_unfiltered (file,
 992                       "gdbarch_dump: CALL_DUMMY_LENGTH # %s\n",
 993                       XSTRING (CALL_DUMMY_LENGTH));
 994   if (CALL_DUMMY_LOCATION == BEFORE_TEXT_END || CALL_DUMMY_LOCATION == AFTER_TEXT_END)
 995     fprintf_unfiltered (file,
 996                         "gdbarch_dump: CALL_DUMMY_LENGTH = %d\n",
 997                         CALL_DUMMY_LENGTH);
 998 #endif
 999 #ifdef CALL_DUMMY_LOCATION
1000   fprintf_unfiltered (file,
1001                       "gdbarch_dump: CALL_DUMMY_LOCATION # %s\n",
1002                       XSTRING (CALL_DUMMY_LOCATION));
1003   fprintf_unfiltered (file,
1004                       "gdbarch_dump: CALL_DUMMY_LOCATION = %d\n",
1005                       CALL_DUMMY_LOCATION);
1006 #endif
1007 #ifdef CALL_DUMMY_P
1008   fprintf_unfiltered (file,
1009                       "gdbarch_dump: CALL_DUMMY_P # %s\n",
1010                       XSTRING (CALL_DUMMY_P));
1011   fprintf_unfiltered (file,
1012                       "gdbarch_dump: CALL_DUMMY_P = %d\n",
1013                       CALL_DUMMY_P);
1014 #endif
1015 #ifdef CALL_DUMMY_STACK_ADJUST
1016   fprintf_unfiltered (file,
1017                       "gdbarch_dump: CALL_DUMMY_STACK_ADJUST # %s\n",
1018                       XSTRING (CALL_DUMMY_STACK_ADJUST));
1019   if (CALL_DUMMY_STACK_ADJUST_P)
1020     fprintf_unfiltered (file,
1021                         "gdbarch_dump: CALL_DUMMY_STACK_ADJUST = 0x%08lx\n",
1022                         (long) CALL_DUMMY_STACK_ADJUST);
1023 #endif
1024 #ifdef CALL_DUMMY_STACK_ADJUST_P
1025   fprintf_unfiltered (file,
1026                       "gdbarch_dump: CALL_DUMMY_STACK_ADJUST_P # %s\n",
1027                       XSTRING (CALL_DUMMY_STACK_ADJUST_P));
1028   fprintf_unfiltered (file,
1029                       "gdbarch_dump: CALL_DUMMY_STACK_ADJUST_P = 0x%08lx\n",
1030                       (long) CALL_DUMMY_STACK_ADJUST_P);
1031 #endif
1032 #ifdef CALL_DUMMY_START_OFFSET
1033   fprintf_unfiltered (file,
1034                       "gdbarch_dump: CALL_DUMMY_START_OFFSET # %s\n",
1035                       XSTRING (CALL_DUMMY_START_OFFSET));
1036   fprintf_unfiltered (file,
1037                       "gdbarch_dump: CALL_DUMMY_START_OFFSET = 0x%08lx\n",
1038                       (long) CALL_DUMMY_START_OFFSET);
1039 #endif
1040 #ifdef CALL_DUMMY_WORDS
1041   fprintf_unfiltered (file,
1042                       "gdbarch_dump: CALL_DUMMY_WORDS # %s\n",
1043                       XSTRING (CALL_DUMMY_WORDS));
1044   fprintf_unfiltered (file,
1045                       "gdbarch_dump: CALL_DUMMY_WORDS = 0x%08lx\n",
1046                       (long) CALL_DUMMY_WORDS);
1047 #endif
1048 #ifdef CANNOT_FETCH_REGISTER
1049   fprintf_unfiltered (file,
1050                       "gdbarch_dump: %s # %s\n",
1051                       "CANNOT_FETCH_REGISTER(regnum)",
1052                       XSTRING (CANNOT_FETCH_REGISTER (regnum)));
1053   if (GDB_MULTI_ARCH)
1054     fprintf_unfiltered (file,
1055                         "gdbarch_dump: CANNOT_FETCH_REGISTER = <0x%08lx>\n",
1056                         (long) current_gdbarch->cannot_fetch_register
1057                         /*CANNOT_FETCH_REGISTER ()*/);
1058 #endif
1059 #ifdef CANNOT_STEP_BREAKPOINT
1060   fprintf_unfiltered (file,
1061                       "gdbarch_dump: CANNOT_STEP_BREAKPOINT # %s\n",
1062                       XSTRING (CANNOT_STEP_BREAKPOINT));
1063   fprintf_unfiltered (file,
1064                       "gdbarch_dump: CANNOT_STEP_BREAKPOINT = %d\n",
1065                       CANNOT_STEP_BREAKPOINT);
1066 #endif
1067 #ifdef CANNOT_STORE_REGISTER
1068   fprintf_unfiltered (file,
1069                       "gdbarch_dump: %s # %s\n",
1070                       "CANNOT_STORE_REGISTER(regnum)",
1071                       XSTRING (CANNOT_STORE_REGISTER (regnum)));
1072   if (GDB_MULTI_ARCH)
1073     fprintf_unfiltered (file,
1074                         "gdbarch_dump: CANNOT_STORE_REGISTER = <0x%08lx>\n",
1075                         (long) current_gdbarch->cannot_store_register
1076                         /*CANNOT_STORE_REGISTER ()*/);
1077 #endif
1078 #ifdef COFF_MAKE_MSYMBOL_SPECIAL
1079 #if GDB_MULTI_ARCH
1080   /* Macro might contain `[{}]' when not multi-arch */
1081   fprintf_unfiltered (file,
1082                       "gdbarch_dump: %s # %s\n",
1083                       "COFF_MAKE_MSYMBOL_SPECIAL(val, msym)",
1084                       XSTRING (COFF_MAKE_MSYMBOL_SPECIAL (val, msym)));
1085 #endif
1086   if (GDB_MULTI_ARCH)
1087     fprintf_unfiltered (file,
1088                         "gdbarch_dump: COFF_MAKE_MSYMBOL_SPECIAL = <0x%08lx>\n",
1089                         (long) current_gdbarch->coff_make_msymbol_special
1090                         /*COFF_MAKE_MSYMBOL_SPECIAL ()*/);
1091 #endif
1092   if (GDB_MULTI_ARCH)
1093     fprintf_unfiltered (file,
1094                         "gdbarch_dump: construct_inferior_arguments = 0x%08lx\n",
1095                         (long) current_gdbarch->construct_inferior_arguments);
1096 #ifdef CONVERT_FROM_FUNC_PTR_ADDR
1097   fprintf_unfiltered (file,
1098                       "gdbarch_dump: %s # %s\n",
1099                       "CONVERT_FROM_FUNC_PTR_ADDR(addr)",
1100                       XSTRING (CONVERT_FROM_FUNC_PTR_ADDR (addr)));
1101   if (GDB_MULTI_ARCH)
1102     fprintf_unfiltered (file,
1103                         "gdbarch_dump: CONVERT_FROM_FUNC_PTR_ADDR = <0x%08lx>\n",
1104                         (long) current_gdbarch->convert_from_func_ptr_addr
1105                         /*CONVERT_FROM_FUNC_PTR_ADDR ()*/);
1106 #endif
1107 #ifdef CONVERT_REGISTER_P
1108   fprintf_unfiltered (file,
1109                       "gdbarch_dump: %s # %s\n",
1110                       "CONVERT_REGISTER_P(regnum)",
1111                       XSTRING (CONVERT_REGISTER_P (regnum)));
1112   if (GDB_MULTI_ARCH)
1113     fprintf_unfiltered (file,
1114                         "gdbarch_dump: CONVERT_REGISTER_P = <0x%08lx>\n",
1115                         (long) current_gdbarch->convert_register_p
1116                         /*CONVERT_REGISTER_P ()*/);
1117 #endif
1118 #ifdef DECR_PC_AFTER_BREAK
1119   fprintf_unfiltered (file,
1120                       "gdbarch_dump: DECR_PC_AFTER_BREAK # %s\n",
1121                       XSTRING (DECR_PC_AFTER_BREAK));
1122   fprintf_unfiltered (file,
1123                       "gdbarch_dump: DECR_PC_AFTER_BREAK = %ld\n",
1124                       (long) DECR_PC_AFTER_BREAK);
1125 #endif
1126 #ifdef DEPRECATED_DO_REGISTERS_INFO_P
1127   fprintf_unfiltered (file,
1128                       "gdbarch_dump: %s # %s\n",
1129                       "DEPRECATED_DO_REGISTERS_INFO_P()",
1130                       XSTRING (DEPRECATED_DO_REGISTERS_INFO_P ()));
1131   fprintf_unfiltered (file,
1132                       "gdbarch_dump: DEPRECATED_DO_REGISTERS_INFO_P() = %d\n",
1133                       DEPRECATED_DO_REGISTERS_INFO_P ());
1134 #endif
1135 #ifdef DEPRECATED_DO_REGISTERS_INFO
1136 #if GDB_MULTI_ARCH
1137   /* Macro might contain `[{}]' when not multi-arch */
1138   fprintf_unfiltered (file,
1139                       "gdbarch_dump: %s # %s\n",
1140                       "DEPRECATED_DO_REGISTERS_INFO(reg_nr, fpregs)",
1141                       XSTRING (DEPRECATED_DO_REGISTERS_INFO (reg_nr, fpregs)));
1142 #endif
1143   if (GDB_MULTI_ARCH)
1144     fprintf_unfiltered (file,
1145                         "gdbarch_dump: DEPRECATED_DO_REGISTERS_INFO = <0x%08lx>\n",
1146                         (long) current_gdbarch->deprecated_do_registers_info
1147                         /*DEPRECATED_DO_REGISTERS_INFO ()*/);
1148 #endif
1149 #ifdef DEPRECATED_EXTRACT_RETURN_VALUE
1150 #if GDB_MULTI_ARCH
1151   /* Macro might contain `[{}]' when not multi-arch */
1152   fprintf_unfiltered (file,
1153                       "gdbarch_dump: %s # %s\n",
1154                       "DEPRECATED_EXTRACT_RETURN_VALUE(type, regbuf, valbuf)",
1155                       XSTRING (DEPRECATED_EXTRACT_RETURN_VALUE (type, regbuf, valbuf)));
1156 #endif
1157   if (GDB_MULTI_ARCH)
1158     fprintf_unfiltered (file,
1159                         "gdbarch_dump: DEPRECATED_EXTRACT_RETURN_VALUE = <0x%08lx>\n",
1160                         (long) current_gdbarch->deprecated_extract_return_value
1161                         /*DEPRECATED_EXTRACT_RETURN_VALUE ()*/);
1162 #endif
1163 #ifdef DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS_P
1164   fprintf_unfiltered (file,
1165                       "gdbarch_dump: %s # %s\n",
1166                       "DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS_P()",
1167                       XSTRING (DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS_P ()));
1168   fprintf_unfiltered (file,
1169                       "gdbarch_dump: DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS_P() = %d\n",
1170                       DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS_P ());
1171 #endif
1172 #ifdef DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS
1173   fprintf_unfiltered (file,
1174                       "gdbarch_dump: %s # %s\n",
1175                       "DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS(regbuf)",
1176                       XSTRING (DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS (regbuf)));
1177   if (GDB_MULTI_ARCH)
1178     fprintf_unfiltered (file,
1179                         "gdbarch_dump: DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS = <0x%08lx>\n",
1180                         (long) current_gdbarch->deprecated_extract_struct_value_address
1181                         /*DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS ()*/);
1182 #endif
1183 #ifdef DEPRECATED_INIT_FRAME_PC_P
1184   fprintf_unfiltered (file,
1185                       "gdbarch_dump: %s # %s\n",
1186                       "DEPRECATED_INIT_FRAME_PC_P()",
1187                       XSTRING (DEPRECATED_INIT_FRAME_PC_P ()));
1188   fprintf_unfiltered (file,
1189                       "gdbarch_dump: DEPRECATED_INIT_FRAME_PC_P() = %d\n",
1190                       DEPRECATED_INIT_FRAME_PC_P ());
1191 #endif
1192 #ifdef DEPRECATED_INIT_FRAME_PC
1193   fprintf_unfiltered (file,
1194                       "gdbarch_dump: %s # %s\n",
1195                       "DEPRECATED_INIT_FRAME_PC(fromleaf, prev)",
1196                       XSTRING (DEPRECATED_INIT_FRAME_PC (fromleaf, prev)));
1197   if (GDB_MULTI_ARCH)
1198     fprintf_unfiltered (file,
1199                         "gdbarch_dump: DEPRECATED_INIT_FRAME_PC = <0x%08lx>\n",
1200                         (long) current_gdbarch->deprecated_init_frame_pc
1201                         /*DEPRECATED_INIT_FRAME_PC ()*/);
1202 #endif
1203 #ifdef DEPRECATED_INIT_FRAME_PC_FIRST_P
1204   fprintf_unfiltered (file,
1205                       "gdbarch_dump: %s # %s\n",
1206                       "DEPRECATED_INIT_FRAME_PC_FIRST_P()",
1207                       XSTRING (DEPRECATED_INIT_FRAME_PC_FIRST_P ()));
1208   fprintf_unfiltered (file,
1209                       "gdbarch_dump: DEPRECATED_INIT_FRAME_PC_FIRST_P() = %d\n",
1210                       DEPRECATED_INIT_FRAME_PC_FIRST_P ());
1211 #endif
1212 #ifdef DEPRECATED_INIT_FRAME_PC_FIRST
1213   fprintf_unfiltered (file,
1214                       "gdbarch_dump: %s # %s\n",
1215                       "DEPRECATED_INIT_FRAME_PC_FIRST(fromleaf, prev)",
1216                       XSTRING (DEPRECATED_INIT_FRAME_PC_FIRST (fromleaf, prev)));
1217   if (GDB_MULTI_ARCH)
1218     fprintf_unfiltered (file,
1219                         "gdbarch_dump: DEPRECATED_INIT_FRAME_PC_FIRST = <0x%08lx>\n",
1220                         (long) current_gdbarch->deprecated_init_frame_pc_first
1221                         /*DEPRECATED_INIT_FRAME_PC_FIRST ()*/);
1222 #endif
1223 #ifdef DEPRECATED_PC_IN_CALL_DUMMY_P
1224   fprintf_unfiltered (file,
1225                       "gdbarch_dump: %s # %s\n",
1226                       "DEPRECATED_PC_IN_CALL_DUMMY_P()",
1227                       XSTRING (DEPRECATED_PC_IN_CALL_DUMMY_P ()));
1228   fprintf_unfiltered (file,
1229                       "gdbarch_dump: DEPRECATED_PC_IN_CALL_DUMMY_P() = %d\n",
1230                       DEPRECATED_PC_IN_CALL_DUMMY_P ());
1231 #endif
1232 #ifdef DEPRECATED_PC_IN_CALL_DUMMY
1233   fprintf_unfiltered (file,
1234                       "gdbarch_dump: %s # %s\n",
1235                       "DEPRECATED_PC_IN_CALL_DUMMY(pc, sp, frame_address)",
1236                       XSTRING (DEPRECATED_PC_IN_CALL_DUMMY (pc, sp, frame_address)));
1237   if (GDB_MULTI_ARCH)
1238     fprintf_unfiltered (file,
1239                         "gdbarch_dump: DEPRECATED_PC_IN_CALL_DUMMY = <0x%08lx>\n",
1240                         (long) current_gdbarch->deprecated_pc_in_call_dummy
1241                         /*DEPRECATED_PC_IN_CALL_DUMMY ()*/);
1242 #endif
1243 #ifdef DEPRECATED_STORE_RETURN_VALUE
1244 #if GDB_MULTI_ARCH
1245   /* Macro might contain `[{}]' when not multi-arch */
1246   fprintf_unfiltered (file,
1247                       "gdbarch_dump: %s # %s\n",
1248                       "DEPRECATED_STORE_RETURN_VALUE(type, valbuf)",
1249                       XSTRING (DEPRECATED_STORE_RETURN_VALUE (type, valbuf)));
1250 #endif
1251   if (GDB_MULTI_ARCH)
1252     fprintf_unfiltered (file,
1253                         "gdbarch_dump: DEPRECATED_STORE_RETURN_VALUE = <0x%08lx>\n",
1254                         (long) current_gdbarch->deprecated_store_return_value
1255                         /*DEPRECATED_STORE_RETURN_VALUE ()*/);
1256 #endif
1257 #ifdef DEPRECATED_USE_GENERIC_DUMMY_FRAMES
1258   fprintf_unfiltered (file,
1259                       "gdbarch_dump: DEPRECATED_USE_GENERIC_DUMMY_FRAMES # %s\n",
1260                       XSTRING (DEPRECATED_USE_GENERIC_DUMMY_FRAMES));
1261   fprintf_unfiltered (file,
1262                       "gdbarch_dump: DEPRECATED_USE_GENERIC_DUMMY_FRAMES = %d\n",
1263                       DEPRECATED_USE_GENERIC_DUMMY_FRAMES);
1264 #endif
1265 #ifdef DWARF2_BUILD_FRAME_INFO_P
1266   fprintf_unfiltered (file,
1267                       "gdbarch_dump: %s # %s\n",
1268                       "DWARF2_BUILD_FRAME_INFO_P()",
1269                       XSTRING (DWARF2_BUILD_FRAME_INFO_P ()));
1270   fprintf_unfiltered (file,
1271                       "gdbarch_dump: DWARF2_BUILD_FRAME_INFO_P() = %d\n",
1272                       DWARF2_BUILD_FRAME_INFO_P ());
1273 #endif
1274 #ifdef DWARF2_BUILD_FRAME_INFO
1275 #if GDB_MULTI_ARCH
1276   /* Macro might contain `[{}]' when not multi-arch */
1277   fprintf_unfiltered (file,
1278                       "gdbarch_dump: %s # %s\n",
1279                       "DWARF2_BUILD_FRAME_INFO(objfile)",
1280                       XSTRING (DWARF2_BUILD_FRAME_INFO (objfile)));
1281 #endif
1282   if (GDB_MULTI_ARCH)
1283     fprintf_unfiltered (file,
1284                         "gdbarch_dump: DWARF2_BUILD_FRAME_INFO = <0x%08lx>\n",
1285                         (long) current_gdbarch->dwarf2_build_frame_info
1286                         /*DWARF2_BUILD_FRAME_INFO ()*/);
1287 #endif
1288 #ifdef DWARF2_REG_TO_REGNUM
1289   fprintf_unfiltered (file,
1290                       "gdbarch_dump: %s # %s\n",
1291                       "DWARF2_REG_TO_REGNUM(dwarf2_regnr)",
1292                       XSTRING (DWARF2_REG_TO_REGNUM (dwarf2_regnr)));
1293   if (GDB_MULTI_ARCH)
1294     fprintf_unfiltered (file,
1295                         "gdbarch_dump: DWARF2_REG_TO_REGNUM = <0x%08lx>\n",
1296                         (long) current_gdbarch->dwarf2_reg_to_regnum
1297                         /*DWARF2_REG_TO_REGNUM ()*/);
1298 #endif
1299 #ifdef DWARF_REG_TO_REGNUM
1300   fprintf_unfiltered (file,
1301                       "gdbarch_dump: %s # %s\n",
1302                       "DWARF_REG_TO_REGNUM(dwarf_regnr)",
1303                       XSTRING (DWARF_REG_TO_REGNUM (dwarf_regnr)));
1304   if (GDB_MULTI_ARCH)
1305     fprintf_unfiltered (file,
1306                         "gdbarch_dump: DWARF_REG_TO_REGNUM = <0x%08lx>\n",
1307                         (long) current_gdbarch->dwarf_reg_to_regnum
1308                         /*DWARF_REG_TO_REGNUM ()*/);
1309 #endif
1310 #ifdef ECOFF_REG_TO_REGNUM
1311   fprintf_unfiltered (file,
1312                       "gdbarch_dump: %s # %s\n",
1313                       "ECOFF_REG_TO_REGNUM(ecoff_regnr)",
1314                       XSTRING (ECOFF_REG_TO_REGNUM (ecoff_regnr)));
1315   if (GDB_MULTI_ARCH)
1316     fprintf_unfiltered (file,
1317                         "gdbarch_dump: ECOFF_REG_TO_REGNUM = <0x%08lx>\n",
1318                         (long) current_gdbarch->ecoff_reg_to_regnum
1319                         /*ECOFF_REG_TO_REGNUM ()*/);
1320 #endif
1321 #ifdef ELF_MAKE_MSYMBOL_SPECIAL
1322 #if GDB_MULTI_ARCH
1323   /* Macro might contain `[{}]' when not multi-arch */
1324   fprintf_unfiltered (file,
1325                       "gdbarch_dump: %s # %s\n",
1326                       "ELF_MAKE_MSYMBOL_SPECIAL(sym, msym)",
1327                       XSTRING (ELF_MAKE_MSYMBOL_SPECIAL (sym, msym)));
1328 #endif
1329   if (GDB_MULTI_ARCH)
1330     fprintf_unfiltered (file,
1331                         "gdbarch_dump: ELF_MAKE_MSYMBOL_SPECIAL = <0x%08lx>\n",
1332                         (long) current_gdbarch->elf_make_msymbol_special
1333                         /*ELF_MAKE_MSYMBOL_SPECIAL ()*/);
1334 #endif
1335 #ifdef EXTRACT_RETURN_VALUE
1336 #if GDB_MULTI_ARCH
1337   /* Macro might contain `[{}]' when not multi-arch */
1338   fprintf_unfiltered (file,
1339                       "gdbarch_dump: %s # %s\n",
1340                       "EXTRACT_RETURN_VALUE(type, regcache, valbuf)",
1341                       XSTRING (EXTRACT_RETURN_VALUE (type, regcache, valbuf)));
1342 #endif
1343   if (GDB_MULTI_ARCH)
1344     fprintf_unfiltered (file,
1345                         "gdbarch_dump: EXTRACT_RETURN_VALUE = <0x%08lx>\n",
1346                         (long) current_gdbarch->extract_return_value
1347                         /*EXTRACT_RETURN_VALUE ()*/);
1348 #endif
1349 #ifdef EXTRACT_STRUCT_VALUE_ADDRESS_P
1350   fprintf_unfiltered (file,
1351                       "gdbarch_dump: %s # %s\n",
1352                       "EXTRACT_STRUCT_VALUE_ADDRESS_P()",
1353                       XSTRING (EXTRACT_STRUCT_VALUE_ADDRESS_P ()));
1354   fprintf_unfiltered (file,
1355                       "gdbarch_dump: EXTRACT_STRUCT_VALUE_ADDRESS_P() = %d\n",
1356                       EXTRACT_STRUCT_VALUE_ADDRESS_P ());
1357 #endif
1358 #ifdef EXTRACT_STRUCT_VALUE_ADDRESS
1359   fprintf_unfiltered (file,
1360                       "gdbarch_dump: %s # %s\n",
1361                       "EXTRACT_STRUCT_VALUE_ADDRESS(regcache)",
1362                       XSTRING (EXTRACT_STRUCT_VALUE_ADDRESS (regcache)));
1363   if (GDB_MULTI_ARCH)
1364     fprintf_unfiltered (file,
1365                         "gdbarch_dump: EXTRACT_STRUCT_VALUE_ADDRESS = <0x%08lx>\n",
1366                         (long) current_gdbarch->extract_struct_value_address
1367                         /*EXTRACT_STRUCT_VALUE_ADDRESS ()*/);
1368 #endif
1369 #ifdef EXTRA_STACK_ALIGNMENT_NEEDED
1370   fprintf_unfiltered (file,
1371                       "gdbarch_dump: EXTRA_STACK_ALIGNMENT_NEEDED # %s\n",
1372                       XSTRING (EXTRA_STACK_ALIGNMENT_NEEDED));
1373   fprintf_unfiltered (file,
1374                       "gdbarch_dump: EXTRA_STACK_ALIGNMENT_NEEDED = %d\n",
1375                       EXTRA_STACK_ALIGNMENT_NEEDED);
1376 #endif
1377 #ifdef FIX_CALL_DUMMY
1378 #if GDB_MULTI_ARCH
1379   /* Macro might contain `[{}]' when not multi-arch */
1380   fprintf_unfiltered (file,
1381                       "gdbarch_dump: %s # %s\n",
1382                       "FIX_CALL_DUMMY(dummy, pc, fun, nargs, args, type, gcc_p)",
1383                       XSTRING (FIX_CALL_DUMMY (dummy, pc, fun, nargs, args, type, gcc_p)));
1384 #endif
1385   if (GDB_MULTI_ARCH)
1386     fprintf_unfiltered (file,
1387                         "gdbarch_dump: FIX_CALL_DUMMY = <0x%08lx>\n",
1388                         (long) current_gdbarch->fix_call_dummy
1389                         /*FIX_CALL_DUMMY ()*/);
1390 #endif
1391 #ifdef FP0_REGNUM
1392   fprintf_unfiltered (file,
1393                       "gdbarch_dump: FP0_REGNUM # %s\n",
1394                       XSTRING (FP0_REGNUM));
1395   fprintf_unfiltered (file,
1396                       "gdbarch_dump: FP0_REGNUM = %d\n",
1397                       FP0_REGNUM);
1398 #endif
1399 #ifdef FP_REGNUM
1400   fprintf_unfiltered (file,
1401                       "gdbarch_dump: FP_REGNUM # %s\n",
1402                       XSTRING (FP_REGNUM));
1403   fprintf_unfiltered (file,
1404                       "gdbarch_dump: FP_REGNUM = %d\n",
1405                       FP_REGNUM);
1406 #endif
1407 #ifdef FRAMELESS_FUNCTION_INVOCATION
1408   fprintf_unfiltered (file,
1409                       "gdbarch_dump: %s # %s\n",
1410                       "FRAMELESS_FUNCTION_INVOCATION(fi)",
1411                       XSTRING (FRAMELESS_FUNCTION_INVOCATION (fi)));
1412   if (GDB_MULTI_ARCH)
1413     fprintf_unfiltered (file,
1414                         "gdbarch_dump: FRAMELESS_FUNCTION_INVOCATION = <0x%08lx>\n",
1415                         (long) current_gdbarch->frameless_function_invocation
1416                         /*FRAMELESS_FUNCTION_INVOCATION ()*/);
1417 #endif
1418 #ifdef FRAME_ARGS_ADDRESS
1419   fprintf_unfiltered (file,
1420                       "gdbarch_dump: %s # %s\n",
1421                       "FRAME_ARGS_ADDRESS(fi)",
1422                       XSTRING (FRAME_ARGS_ADDRESS (fi)));
1423   if (GDB_MULTI_ARCH)
1424     fprintf_unfiltered (file,
1425                         "gdbarch_dump: FRAME_ARGS_ADDRESS = <0x%08lx>\n",
1426                         (long) current_gdbarch->frame_args_address
1427                         /*FRAME_ARGS_ADDRESS ()*/);
1428 #endif
1429 #ifdef FRAME_ARGS_SKIP
1430   fprintf_unfiltered (file,
1431                       "gdbarch_dump: FRAME_ARGS_SKIP # %s\n",
1432                       XSTRING (FRAME_ARGS_SKIP));
1433   fprintf_unfiltered (file,
1434                       "gdbarch_dump: FRAME_ARGS_SKIP = %ld\n",
1435                       (long) FRAME_ARGS_SKIP);
1436 #endif
1437 #ifdef FRAME_CHAIN
1438   fprintf_unfiltered (file,
1439                       "gdbarch_dump: %s # %s\n",
1440                       "FRAME_CHAIN(frame)",
1441                       XSTRING (FRAME_CHAIN (frame)));
1442   if (GDB_MULTI_ARCH)
1443     fprintf_unfiltered (file,
1444                         "gdbarch_dump: FRAME_CHAIN = <0x%08lx>\n",
1445                         (long) current_gdbarch->frame_chain
1446                         /*FRAME_CHAIN ()*/);
1447 #endif
1448 #ifdef FRAME_CHAIN_VALID
1449   fprintf_unfiltered (file,
1450                       "gdbarch_dump: %s # %s\n",
1451                       "FRAME_CHAIN_VALID(chain, thisframe)",
1452                       XSTRING (FRAME_CHAIN_VALID (chain, thisframe)));
1453   if (GDB_MULTI_ARCH)
1454     fprintf_unfiltered (file,
1455                         "gdbarch_dump: FRAME_CHAIN_VALID = <0x%08lx>\n",
1456                         (long) current_gdbarch->frame_chain_valid
1457                         /*FRAME_CHAIN_VALID ()*/);
1458 #endif
1459 #ifdef FRAME_INIT_SAVED_REGS
1460 #if GDB_MULTI_ARCH
1461   /* Macro might contain `[{}]' when not multi-arch */
1462   fprintf_unfiltered (file,
1463                       "gdbarch_dump: %s # %s\n",
1464                       "FRAME_INIT_SAVED_REGS(frame)",
1465                       XSTRING (FRAME_INIT_SAVED_REGS (frame)));
1466 #endif
1467   if (GDB_MULTI_ARCH)
1468     fprintf_unfiltered (file,
1469                         "gdbarch_dump: FRAME_INIT_SAVED_REGS = <0x%08lx>\n",
1470                         (long) current_gdbarch->frame_init_saved_regs
1471                         /*FRAME_INIT_SAVED_REGS ()*/);
1472 #endif
1473 #ifdef FRAME_LOCALS_ADDRESS
1474   fprintf_unfiltered (file,
1475                       "gdbarch_dump: %s # %s\n",
1476                       "FRAME_LOCALS_ADDRESS(fi)",
1477                       XSTRING (FRAME_LOCALS_ADDRESS (fi)));
1478   if (GDB_MULTI_ARCH)
1479     fprintf_unfiltered (file,
1480                         "gdbarch_dump: FRAME_LOCALS_ADDRESS = <0x%08lx>\n",
1481                         (long) current_gdbarch->frame_locals_address
1482                         /*FRAME_LOCALS_ADDRESS ()*/);
1483 #endif
1484 #ifdef FRAME_NUM_ARGS
1485   fprintf_unfiltered (file,
1486                       "gdbarch_dump: %s # %s\n",
1487                       "FRAME_NUM_ARGS(frame)",
1488                       XSTRING (FRAME_NUM_ARGS (frame)));
1489   if (GDB_MULTI_ARCH)
1490     fprintf_unfiltered (file,
1491                         "gdbarch_dump: FRAME_NUM_ARGS = <0x%08lx>\n",
1492                         (long) current_gdbarch->frame_num_args
1493                         /*FRAME_NUM_ARGS ()*/);
1494 #endif
1495 #ifdef FRAME_SAVED_PC
1496   fprintf_unfiltered (file,
1497                       "gdbarch_dump: %s # %s\n",
1498                       "FRAME_SAVED_PC(fi)",
1499                       XSTRING (FRAME_SAVED_PC (fi)));
1500   if (GDB_MULTI_ARCH)
1501     fprintf_unfiltered (file,
1502                         "gdbarch_dump: FRAME_SAVED_PC = <0x%08lx>\n",
1503                         (long) current_gdbarch->frame_saved_pc
1504                         /*FRAME_SAVED_PC ()*/);
1505 #endif
1506 #ifdef FUNCTION_START_OFFSET
1507   fprintf_unfiltered (file,
1508                       "gdbarch_dump: FUNCTION_START_OFFSET # %s\n",
1509                       XSTRING (FUNCTION_START_OFFSET));
1510   fprintf_unfiltered (file,
1511                       "gdbarch_dump: FUNCTION_START_OFFSET = %ld\n",
1512                       (long) FUNCTION_START_OFFSET);
1513 #endif
1514 #ifdef GET_LONGJMP_TARGET_P
1515   fprintf_unfiltered (file,
1516                       "gdbarch_dump: %s # %s\n",
1517                       "GET_LONGJMP_TARGET_P()",
1518                       XSTRING (GET_LONGJMP_TARGET_P ()));
1519   fprintf_unfiltered (file,
1520                       "gdbarch_dump: GET_LONGJMP_TARGET_P() = %d\n",
1521                       GET_LONGJMP_TARGET_P ());
1522 #endif
1523 #ifdef GET_LONGJMP_TARGET
1524   fprintf_unfiltered (file,
1525                       "gdbarch_dump: %s # %s\n",
1526                       "GET_LONGJMP_TARGET(pc)",
1527                       XSTRING (GET_LONGJMP_TARGET (pc)));
1528   if (GDB_MULTI_ARCH)
1529     fprintf_unfiltered (file,
1530                         "gdbarch_dump: GET_LONGJMP_TARGET = <0x%08lx>\n",
1531                         (long) current_gdbarch->get_longjmp_target
1532                         /*GET_LONGJMP_TARGET ()*/);
1533 #endif
1534 #ifdef GET_SAVED_REGISTER_P
1535   fprintf_unfiltered (file,
1536                       "gdbarch_dump: %s # %s\n",
1537                       "GET_SAVED_REGISTER_P()",
1538                       XSTRING (GET_SAVED_REGISTER_P ()));
1539   fprintf_unfiltered (file,
1540                       "gdbarch_dump: GET_SAVED_REGISTER_P() = %d\n",
1541                       GET_SAVED_REGISTER_P ());
1542 #endif
1543 #ifdef GET_SAVED_REGISTER
1544 #if GDB_MULTI_ARCH
1545   /* Macro might contain `[{}]' when not multi-arch */
1546   fprintf_unfiltered (file,
1547                       "gdbarch_dump: %s # %s\n",
1548                       "GET_SAVED_REGISTER(raw_buffer, optimized, addrp, frame, regnum, lval)",
1549                       XSTRING (GET_SAVED_REGISTER (raw_buffer, optimized, addrp, frame, regnum, lval)));
1550 #endif
1551   if (GDB_MULTI_ARCH)
1552     fprintf_unfiltered (file,
1553                         "gdbarch_dump: GET_SAVED_REGISTER = <0x%08lx>\n",
1554                         (long) current_gdbarch->get_saved_register
1555                         /*GET_SAVED_REGISTER ()*/);
1556 #endif
1557 #ifdef HAVE_NONSTEPPABLE_WATCHPOINT
1558   fprintf_unfiltered (file,
1559                       "gdbarch_dump: HAVE_NONSTEPPABLE_WATCHPOINT # %s\n",
1560                       XSTRING (HAVE_NONSTEPPABLE_WATCHPOINT));
1561   fprintf_unfiltered (file,
1562                       "gdbarch_dump: HAVE_NONSTEPPABLE_WATCHPOINT = %d\n",
1563                       HAVE_NONSTEPPABLE_WATCHPOINT);
1564 #endif
1565 #ifdef INIT_EXTRA_FRAME_INFO_P
1566   fprintf_unfiltered (file,
1567                       "gdbarch_dump: %s # %s\n",
1568                       "INIT_EXTRA_FRAME_INFO_P()",
1569                       XSTRING (INIT_EXTRA_FRAME_INFO_P ()));
1570   fprintf_unfiltered (file,
1571                       "gdbarch_dump: INIT_EXTRA_FRAME_INFO_P() = %d\n",
1572                       INIT_EXTRA_FRAME_INFO_P ());
1573 #endif
1574 #ifdef INIT_EXTRA_FRAME_INFO
1575 #if GDB_MULTI_ARCH
1576   /* Macro might contain `[{}]' when not multi-arch */
1577   fprintf_unfiltered (file,
1578                       "gdbarch_dump: %s # %s\n",
1579                       "INIT_EXTRA_FRAME_INFO(fromleaf, frame)",
1580                       XSTRING (INIT_EXTRA_FRAME_INFO (fromleaf, frame)));
1581 #endif
1582   if (GDB_MULTI_ARCH)
1583     fprintf_unfiltered (file,
1584                         "gdbarch_dump: INIT_EXTRA_FRAME_INFO = <0x%08lx>\n",
1585                         (long) current_gdbarch->init_extra_frame_info
1586                         /*INIT_EXTRA_FRAME_INFO ()*/);
1587 #endif
1588 #ifdef INNER_THAN
1589   fprintf_unfiltered (file,
1590                       "gdbarch_dump: %s # %s\n",
1591                       "INNER_THAN(lhs, rhs)",
1592                       XSTRING (INNER_THAN (lhs, rhs)));
1593   if (GDB_MULTI_ARCH)
1594     fprintf_unfiltered (file,
1595                         "gdbarch_dump: INNER_THAN = <0x%08lx>\n",
1596                         (long) current_gdbarch->inner_than
1597                         /*INNER_THAN ()*/);
1598 #endif
1599 #ifdef INTEGER_TO_ADDRESS_P
1600   fprintf_unfiltered (file,
1601                       "gdbarch_dump: %s # %s\n",
1602                       "INTEGER_TO_ADDRESS_P()",
1603                       XSTRING (INTEGER_TO_ADDRESS_P ()));
1604   fprintf_unfiltered (file,
1605                       "gdbarch_dump: INTEGER_TO_ADDRESS_P() = %d\n",
1606                       INTEGER_TO_ADDRESS_P ());
1607 #endif
1608 #ifdef INTEGER_TO_ADDRESS
1609   fprintf_unfiltered (file,
1610                       "gdbarch_dump: %s # %s\n",
1611                       "INTEGER_TO_ADDRESS(type, buf)",
1612                       XSTRING (INTEGER_TO_ADDRESS (type, buf)));
1613   if (GDB_MULTI_ARCH)
1614     fprintf_unfiltered (file,
1615                         "gdbarch_dump: INTEGER_TO_ADDRESS = <0x%08lx>\n",
1616                         (long) current_gdbarch->integer_to_address
1617                         /*INTEGER_TO_ADDRESS ()*/);
1618 #endif
1619 #ifdef IN_SOLIB_CALL_TRAMPOLINE
1620   fprintf_unfiltered (file,
1621                       "gdbarch_dump: %s # %s\n",
1622                       "IN_SOLIB_CALL_TRAMPOLINE(pc, name)",
1623                       XSTRING (IN_SOLIB_CALL_TRAMPOLINE (pc, name)));
1624   if (GDB_MULTI_ARCH)
1625     fprintf_unfiltered (file,
1626                         "gdbarch_dump: IN_SOLIB_CALL_TRAMPOLINE = <0x%08lx>\n",
1627                         (long) current_gdbarch->in_solib_call_trampoline
1628                         /*IN_SOLIB_CALL_TRAMPOLINE ()*/);
1629 #endif
1630 #ifdef IN_SOLIB_RETURN_TRAMPOLINE
1631   fprintf_unfiltered (file,
1632                       "gdbarch_dump: %s # %s\n",
1633                       "IN_SOLIB_RETURN_TRAMPOLINE(pc, name)",
1634                       XSTRING (IN_SOLIB_RETURN_TRAMPOLINE (pc, name)));
1635   if (GDB_MULTI_ARCH)
1636     fprintf_unfiltered (file,
1637                         "gdbarch_dump: IN_SOLIB_RETURN_TRAMPOLINE = <0x%08lx>\n",
1638                         (long) current_gdbarch->in_solib_return_trampoline
1639                         /*IN_SOLIB_RETURN_TRAMPOLINE ()*/);
1640 #endif
1641 #ifdef MAX_REGISTER_RAW_SIZE
1642   fprintf_unfiltered (file,
1643                       "gdbarch_dump: MAX_REGISTER_RAW_SIZE # %s\n",
1644                       XSTRING (MAX_REGISTER_RAW_SIZE));
1645   fprintf_unfiltered (file,
1646                       "gdbarch_dump: MAX_REGISTER_RAW_SIZE = %d\n",
1647                       MAX_REGISTER_RAW_SIZE);
1648 #endif
1649 #ifdef MAX_REGISTER_VIRTUAL_SIZE
1650   fprintf_unfiltered (file,
1651                       "gdbarch_dump: MAX_REGISTER_VIRTUAL_SIZE # %s\n",
1652                       XSTRING (MAX_REGISTER_VIRTUAL_SIZE));
1653   fprintf_unfiltered (file,
1654                       "gdbarch_dump: MAX_REGISTER_VIRTUAL_SIZE = %d\n",
1655                       MAX_REGISTER_VIRTUAL_SIZE);
1656 #endif
1657 #ifdef MEMORY_INSERT_BREAKPOINT
1658   fprintf_unfiltered (file,
1659                       "gdbarch_dump: %s # %s\n",
1660                       "MEMORY_INSERT_BREAKPOINT(addr, contents_cache)",
1661                       XSTRING (MEMORY_INSERT_BREAKPOINT (addr, contents_cache)));
1662   if (GDB_MULTI_ARCH)
1663     fprintf_unfiltered (file,
1664                         "gdbarch_dump: MEMORY_INSERT_BREAKPOINT = <0x%08lx>\n",
1665                         (long) current_gdbarch->memory_insert_breakpoint
1666                         /*MEMORY_INSERT_BREAKPOINT ()*/);
1667 #endif
1668 #ifdef MEMORY_REMOVE_BREAKPOINT
1669   fprintf_unfiltered (file,
1670                       "gdbarch_dump: %s # %s\n",
1671                       "MEMORY_REMOVE_BREAKPOINT(addr, contents_cache)",
1672                       XSTRING (MEMORY_REMOVE_BREAKPOINT (addr, contents_cache)));
1673   if (GDB_MULTI_ARCH)
1674     fprintf_unfiltered (file,
1675                         "gdbarch_dump: MEMORY_REMOVE_BREAKPOINT = <0x%08lx>\n",
1676                         (long) current_gdbarch->memory_remove_breakpoint
1677                         /*MEMORY_REMOVE_BREAKPOINT ()*/);
1678 #endif
1679 #ifdef NAME_OF_MALLOC
1680   fprintf_unfiltered (file,
1681                       "gdbarch_dump: NAME_OF_MALLOC # %s\n",
1682                       XSTRING (NAME_OF_MALLOC));
1683   fprintf_unfiltered (file,
1684                       "gdbarch_dump: NAME_OF_MALLOC = %s\n",
1685                       NAME_OF_MALLOC);
1686 #endif
1687 #ifdef NPC_REGNUM
1688   fprintf_unfiltered (file,
1689                       "gdbarch_dump: NPC_REGNUM # %s\n",
1690                       XSTRING (NPC_REGNUM));
1691   fprintf_unfiltered (file,
1692                       "gdbarch_dump: NPC_REGNUM = %d\n",
1693                       NPC_REGNUM);
1694 #endif
1695 #ifdef NUM_PSEUDO_REGS
1696   fprintf_unfiltered (file,
1697                       "gdbarch_dump: NUM_PSEUDO_REGS # %s\n",
1698                       XSTRING (NUM_PSEUDO_REGS));
1699   fprintf_unfiltered (file,
1700                       "gdbarch_dump: NUM_PSEUDO_REGS = %d\n",
1701                       NUM_PSEUDO_REGS);
1702 #endif
1703 #ifdef NUM_REGS
1704   fprintf_unfiltered (file,
1705                       "gdbarch_dump: NUM_REGS # %s\n",
1706                       XSTRING (NUM_REGS));
1707   fprintf_unfiltered (file,
1708                       "gdbarch_dump: NUM_REGS = %d\n",
1709                       NUM_REGS);
1710 #endif
1711 #ifdef PARM_BOUNDARY
1712   fprintf_unfiltered (file,
1713                       "gdbarch_dump: PARM_BOUNDARY # %s\n",
1714                       XSTRING (PARM_BOUNDARY));
1715   fprintf_unfiltered (file,
1716                       "gdbarch_dump: PARM_BOUNDARY = %d\n",
1717                       PARM_BOUNDARY);
1718 #endif
1719 #ifdef PC_IN_SIGTRAMP
1720   fprintf_unfiltered (file,
1721                       "gdbarch_dump: %s # %s\n",
1722                       "PC_IN_SIGTRAMP(pc, name)",
1723                       XSTRING (PC_IN_SIGTRAMP (pc, name)));
1724   if (GDB_MULTI_ARCH)
1725     fprintf_unfiltered (file,
1726                         "gdbarch_dump: PC_IN_SIGTRAMP = <0x%08lx>\n",
1727                         (long) current_gdbarch->pc_in_sigtramp
1728                         /*PC_IN_SIGTRAMP ()*/);
1729 #endif
1730 #ifdef PC_REGNUM
1731   fprintf_unfiltered (file,
1732                       "gdbarch_dump: PC_REGNUM # %s\n",
1733                       XSTRING (PC_REGNUM));
1734   fprintf_unfiltered (file,
1735                       "gdbarch_dump: PC_REGNUM = %d\n",
1736                       PC_REGNUM);
1737 #endif
1738 #ifdef POINTER_TO_ADDRESS
1739   fprintf_unfiltered (file,
1740                       "gdbarch_dump: %s # %s\n",
1741                       "POINTER_TO_ADDRESS(type, buf)",
1742                       XSTRING (POINTER_TO_ADDRESS (type, buf)));
1743   if (GDB_MULTI_ARCH)
1744     fprintf_unfiltered (file,
1745                         "gdbarch_dump: POINTER_TO_ADDRESS = <0x%08lx>\n",
1746                         (long) current_gdbarch->pointer_to_address
1747                         /*POINTER_TO_ADDRESS ()*/);
1748 #endif
1749 #ifdef POP_FRAME
1750 #if GDB_MULTI_ARCH
1751   /* Macro might contain `[{}]' when not multi-arch */
1752   fprintf_unfiltered (file,
1753                       "gdbarch_dump: %s # %s\n",
1754                       "POP_FRAME(-)",
1755                       XSTRING (POP_FRAME (-)));
1756 #endif
1757   if (GDB_MULTI_ARCH)
1758     fprintf_unfiltered (file,
1759                         "gdbarch_dump: POP_FRAME = <0x%08lx>\n",
1760                         (long) current_gdbarch->pop_frame
1761                         /*POP_FRAME ()*/);
1762 #endif
1763 #ifdef PREPARE_TO_PROCEED
1764   fprintf_unfiltered (file,
1765                       "gdbarch_dump: %s # %s\n",
1766                       "PREPARE_TO_PROCEED(select_it)",
1767                       XSTRING (PREPARE_TO_PROCEED (select_it)));
1768   if (GDB_MULTI_ARCH)
1769     fprintf_unfiltered (file,
1770                         "gdbarch_dump: PREPARE_TO_PROCEED = <0x%08lx>\n",
1771                         (long) current_gdbarch->prepare_to_proceed
1772                         /*PREPARE_TO_PROCEED ()*/);
1773 #endif
1774   if (GDB_MULTI_ARCH)
1775     fprintf_unfiltered (file,
1776                         "gdbarch_dump: gdbarch_print_float_info_p() = %d\n",
1777                         gdbarch_print_float_info_p (current_gdbarch));
1778   if (GDB_MULTI_ARCH)
1779     fprintf_unfiltered (file,
1780                         "gdbarch_dump: print_float_info = 0x%08lx\n",
1781                         (long) current_gdbarch->print_float_info);
1782   if (GDB_MULTI_ARCH)
1783     fprintf_unfiltered (file,
1784                         "gdbarch_dump: print_registers_info = 0x%08lx\n",
1785                         (long) current_gdbarch->print_registers_info);
1786   if (GDB_MULTI_ARCH)
1787     fprintf_unfiltered (file,
1788                         "gdbarch_dump: gdbarch_print_vector_info_p() = %d\n",
1789                         gdbarch_print_vector_info_p (current_gdbarch));
1790   if (GDB_MULTI_ARCH)
1791     fprintf_unfiltered (file,
1792                         "gdbarch_dump: print_vector_info = 0x%08lx\n",
1793                         (long) current_gdbarch->print_vector_info);
1794 #ifdef PROLOGUE_FRAMELESS_P
1795   fprintf_unfiltered (file,
1796                       "gdbarch_dump: %s # %s\n",
1797                       "PROLOGUE_FRAMELESS_P(ip)",
1798                       XSTRING (PROLOGUE_FRAMELESS_P (ip)));
1799   if (GDB_MULTI_ARCH)
1800     fprintf_unfiltered (file,
1801                         "gdbarch_dump: PROLOGUE_FRAMELESS_P = <0x%08lx>\n",
1802                         (long) current_gdbarch->prologue_frameless_p
1803                         /*PROLOGUE_FRAMELESS_P ()*/);
1804 #endif
1805 #ifdef PS_REGNUM
1806   fprintf_unfiltered (file,
1807                       "gdbarch_dump: PS_REGNUM # %s\n",
1808                       XSTRING (PS_REGNUM));
1809   fprintf_unfiltered (file,
1810                       "gdbarch_dump: PS_REGNUM = %d\n",
1811                       PS_REGNUM);
1812 #endif
1813 #ifdef PUSH_ARGUMENTS
1814   fprintf_unfiltered (file,
1815                       "gdbarch_dump: %s # %s\n",
1816                       "PUSH_ARGUMENTS(nargs, args, sp, struct_return, struct_addr)",
1817                       XSTRING (PUSH_ARGUMENTS (nargs, args, sp, struct_return, struct_addr)));
1818   if (GDB_MULTI_ARCH)
1819     fprintf_unfiltered (file,
1820                         "gdbarch_dump: PUSH_ARGUMENTS = <0x%08lx>\n",
1821                         (long) current_gdbarch->push_arguments
1822                         /*PUSH_ARGUMENTS ()*/);
1823 #endif
1824 #ifdef PUSH_DUMMY_FRAME
1825 #if GDB_MULTI_ARCH
1826   /* Macro might contain `[{}]' when not multi-arch */
1827   fprintf_unfiltered (file,
1828                       "gdbarch_dump: %s # %s\n",
1829                       "PUSH_DUMMY_FRAME(-)",
1830                       XSTRING (PUSH_DUMMY_FRAME (-)));
1831 #endif
1832   if (GDB_MULTI_ARCH)
1833     fprintf_unfiltered (file,
1834                         "gdbarch_dump: PUSH_DUMMY_FRAME = <0x%08lx>\n",
1835                         (long) current_gdbarch->push_dummy_frame
1836                         /*PUSH_DUMMY_FRAME ()*/);
1837 #endif
1838 #ifdef PUSH_RETURN_ADDRESS_P
1839   fprintf_unfiltered (file,
1840                       "gdbarch_dump: %s # %s\n",
1841                       "PUSH_RETURN_ADDRESS_P()",
1842                       XSTRING (PUSH_RETURN_ADDRESS_P ()));
1843   fprintf_unfiltered (file,
1844                       "gdbarch_dump: PUSH_RETURN_ADDRESS_P() = %d\n",
1845                       PUSH_RETURN_ADDRESS_P ());
1846 #endif
1847 #ifdef PUSH_RETURN_ADDRESS
1848   fprintf_unfiltered (file,
1849                       "gdbarch_dump: %s # %s\n",
1850                       "PUSH_RETURN_ADDRESS(pc, sp)",
1851                       XSTRING (PUSH_RETURN_ADDRESS (pc, sp)));
1852   if (GDB_MULTI_ARCH)
1853     fprintf_unfiltered (file,
1854                         "gdbarch_dump: PUSH_RETURN_ADDRESS = <0x%08lx>\n",
1855                         (long) current_gdbarch->push_return_address
1856                         /*PUSH_RETURN_ADDRESS ()*/);
1857 #endif
1858 #ifdef REGISTER_BYTE
1859   fprintf_unfiltered (file,
1860                       "gdbarch_dump: %s # %s\n",
1861                       "REGISTER_BYTE(reg_nr)",
1862                       XSTRING (REGISTER_BYTE (reg_nr)));
1863   if (GDB_MULTI_ARCH)
1864     fprintf_unfiltered (file,
1865                         "gdbarch_dump: REGISTER_BYTE = <0x%08lx>\n",
1866                         (long) current_gdbarch->register_byte
1867                         /*REGISTER_BYTE ()*/);
1868 #endif
1869 #ifdef REGISTER_BYTES
1870   fprintf_unfiltered (file,
1871                       "gdbarch_dump: REGISTER_BYTES # %s\n",
1872                       XSTRING (REGISTER_BYTES));
1873   fprintf_unfiltered (file,
1874                       "gdbarch_dump: REGISTER_BYTES = %d\n",
1875                       REGISTER_BYTES);
1876 #endif
1877 #ifdef REGISTER_BYTES_OK_P
1878   fprintf_unfiltered (file,
1879                       "gdbarch_dump: %s # %s\n",
1880                       "REGISTER_BYTES_OK_P()",
1881                       XSTRING (REGISTER_BYTES_OK_P ()));
1882   fprintf_unfiltered (file,
1883                       "gdbarch_dump: REGISTER_BYTES_OK_P() = %d\n",
1884                       REGISTER_BYTES_OK_P ());
1885 #endif
1886 #ifdef REGISTER_BYTES_OK
1887   fprintf_unfiltered (file,
1888                       "gdbarch_dump: %s # %s\n",
1889                       "REGISTER_BYTES_OK(nr_bytes)",
1890                       XSTRING (REGISTER_BYTES_OK (nr_bytes)));
1891   if (GDB_MULTI_ARCH)
1892     fprintf_unfiltered (file,
1893                         "gdbarch_dump: REGISTER_BYTES_OK = <0x%08lx>\n",
1894                         (long) current_gdbarch->register_bytes_ok
1895                         /*REGISTER_BYTES_OK ()*/);
1896 #endif
1897 #ifdef REGISTER_CONVERTIBLE
1898   fprintf_unfiltered (file,
1899                       "gdbarch_dump: %s # %s\n",
1900                       "REGISTER_CONVERTIBLE(nr)",
1901                       XSTRING (REGISTER_CONVERTIBLE (nr)));
1902   if (GDB_MULTI_ARCH)
1903     fprintf_unfiltered (file,
1904                         "gdbarch_dump: REGISTER_CONVERTIBLE = <0x%08lx>\n",
1905                         (long) current_gdbarch->register_convertible
1906                         /*REGISTER_CONVERTIBLE ()*/);
1907 #endif
1908 #ifdef REGISTER_CONVERT_TO_RAW
1909 #if GDB_MULTI_ARCH
1910   /* Macro might contain `[{}]' when not multi-arch */
1911   fprintf_unfiltered (file,
1912                       "gdbarch_dump: %s # %s\n",
1913                       "REGISTER_CONVERT_TO_RAW(type, regnum, from, to)",
1914                       XSTRING (REGISTER_CONVERT_TO_RAW (type, regnum, from, to)));
1915 #endif
1916   if (GDB_MULTI_ARCH)
1917     fprintf_unfiltered (file,
1918                         "gdbarch_dump: REGISTER_CONVERT_TO_RAW = <0x%08lx>\n",
1919                         (long) current_gdbarch->register_convert_to_raw
1920                         /*REGISTER_CONVERT_TO_RAW ()*/);
1921 #endif
1922 #ifdef REGISTER_CONVERT_TO_VIRTUAL
1923 #if GDB_MULTI_ARCH
1924   /* Macro might contain `[{}]' when not multi-arch */
1925   fprintf_unfiltered (file,
1926                       "gdbarch_dump: %s # %s\n",
1927                       "REGISTER_CONVERT_TO_VIRTUAL(regnum, type, from, to)",
1928                       XSTRING (REGISTER_CONVERT_TO_VIRTUAL (regnum, type, from, to)));
1929 #endif
1930   if (GDB_MULTI_ARCH)
1931     fprintf_unfiltered (file,
1932                         "gdbarch_dump: REGISTER_CONVERT_TO_VIRTUAL = <0x%08lx>\n",
1933                         (long) current_gdbarch->register_convert_to_virtual
1934                         /*REGISTER_CONVERT_TO_VIRTUAL ()*/);
1935 #endif
1936 #ifdef REGISTER_NAME
1937   fprintf_unfiltered (file,
1938                       "gdbarch_dump: %s # %s\n",
1939                       "REGISTER_NAME(regnr)",
1940                       XSTRING (REGISTER_NAME (regnr)));
1941   if (GDB_MULTI_ARCH)
1942     fprintf_unfiltered (file,
1943                         "gdbarch_dump: REGISTER_NAME = <0x%08lx>\n",
1944                         (long) current_gdbarch->register_name
1945                         /*REGISTER_NAME ()*/);
1946 #endif
1947 #ifdef REGISTER_RAW_SIZE
1948   fprintf_unfiltered (file,
1949                       "gdbarch_dump: %s # %s\n",
1950                       "REGISTER_RAW_SIZE(reg_nr)",
1951                       XSTRING (REGISTER_RAW_SIZE (reg_nr)));
1952   if (GDB_MULTI_ARCH)
1953     fprintf_unfiltered (file,
1954                         "gdbarch_dump: REGISTER_RAW_SIZE = <0x%08lx>\n",
1955                         (long) current_gdbarch->register_raw_size
1956                         /*REGISTER_RAW_SIZE ()*/);
1957 #endif
1958 #ifdef REGISTER_SIM_REGNO
1959   fprintf_unfiltered (file,
1960                       "gdbarch_dump: %s # %s\n",
1961                       "REGISTER_SIM_REGNO(reg_nr)",
1962                       XSTRING (REGISTER_SIM_REGNO (reg_nr)));
1963   if (GDB_MULTI_ARCH)
1964     fprintf_unfiltered (file,
1965                         "gdbarch_dump: REGISTER_SIM_REGNO = <0x%08lx>\n",
1966                         (long) current_gdbarch->register_sim_regno
1967                         /*REGISTER_SIM_REGNO ()*/);
1968 #endif
1969 #ifdef REGISTER_SIZE
1970   fprintf_unfiltered (file,
1971                       "gdbarch_dump: REGISTER_SIZE # %s\n",
1972                       XSTRING (REGISTER_SIZE));
1973   fprintf_unfiltered (file,
1974                       "gdbarch_dump: REGISTER_SIZE = %d\n",
1975                       REGISTER_SIZE);
1976 #endif
1977 #ifdef REGISTER_TO_VALUE
1978 #if GDB_MULTI_ARCH
1979   /* Macro might contain `[{}]' when not multi-arch */
1980   fprintf_unfiltered (file,
1981                       "gdbarch_dump: %s # %s\n",
1982                       "REGISTER_TO_VALUE(regnum, type, from, to)",
1983                       XSTRING (REGISTER_TO_VALUE (regnum, type, from, to)));
1984 #endif
1985   if (GDB_MULTI_ARCH)
1986     fprintf_unfiltered (file,
1987                         "gdbarch_dump: REGISTER_TO_VALUE = <0x%08lx>\n",
1988                         (long) current_gdbarch->register_to_value
1989                         /*REGISTER_TO_VALUE ()*/);
1990 #endif
1991 #ifdef REGISTER_VIRTUAL_SIZE
1992   fprintf_unfiltered (file,
1993                       "gdbarch_dump: %s # %s\n",
1994                       "REGISTER_VIRTUAL_SIZE(reg_nr)",
1995                       XSTRING (REGISTER_VIRTUAL_SIZE (reg_nr)));
1996   if (GDB_MULTI_ARCH)
1997     fprintf_unfiltered (file,
1998                         "gdbarch_dump: REGISTER_VIRTUAL_SIZE = <0x%08lx>\n",
1999                         (long) current_gdbarch->register_virtual_size
2000                         /*REGISTER_VIRTUAL_SIZE ()*/);
2001 #endif
2002 #ifdef REGISTER_VIRTUAL_TYPE
2003   fprintf_unfiltered (file,
2004                       "gdbarch_dump: %s # %s\n",
2005                       "REGISTER_VIRTUAL_TYPE(reg_nr)",
2006                       XSTRING (REGISTER_VIRTUAL_TYPE (reg_nr)));
2007   if (GDB_MULTI_ARCH)
2008     fprintf_unfiltered (file,
2009                         "gdbarch_dump: REGISTER_VIRTUAL_TYPE = <0x%08lx>\n",
2010                         (long) current_gdbarch->register_virtual_type
2011                         /*REGISTER_VIRTUAL_TYPE ()*/);
2012 #endif
2013 #ifdef REG_STRUCT_HAS_ADDR_P
2014   fprintf_unfiltered (file,
2015                       "gdbarch_dump: %s # %s\n",
2016                       "REG_STRUCT_HAS_ADDR_P()",
2017                       XSTRING (REG_STRUCT_HAS_ADDR_P ()));
2018   fprintf_unfiltered (file,
2019                       "gdbarch_dump: REG_STRUCT_HAS_ADDR_P() = %d\n",
2020                       REG_STRUCT_HAS_ADDR_P ());
2021 #endif
2022 #ifdef REG_STRUCT_HAS_ADDR
2023   fprintf_unfiltered (file,
2024                       "gdbarch_dump: %s # %s\n",
2025                       "REG_STRUCT_HAS_ADDR(gcc_p, type)",
2026                       XSTRING (REG_STRUCT_HAS_ADDR (gcc_p, type)));
2027   if (GDB_MULTI_ARCH)
2028     fprintf_unfiltered (file,
2029                         "gdbarch_dump: REG_STRUCT_HAS_ADDR = <0x%08lx>\n",
2030                         (long) current_gdbarch->reg_struct_has_addr
2031                         /*REG_STRUCT_HAS_ADDR ()*/);
2032 #endif
2033 #ifdef REMOTE_TRANSLATE_XFER_ADDRESS
2034 #if GDB_MULTI_ARCH
2035   /* Macro might contain `[{}]' when not multi-arch */
2036   fprintf_unfiltered (file,
2037                       "gdbarch_dump: %s # %s\n",
2038                       "REMOTE_TRANSLATE_XFER_ADDRESS(gdb_addr, gdb_len, rem_addr, rem_len)",
2039                       XSTRING (REMOTE_TRANSLATE_XFER_ADDRESS (gdb_addr, gdb_len, rem_addr, rem_len)));
2040 #endif
2041   if (GDB_MULTI_ARCH)
2042     fprintf_unfiltered (file,
2043                         "gdbarch_dump: REMOTE_TRANSLATE_XFER_ADDRESS = <0x%08lx>\n",
2044                         (long) current_gdbarch->remote_translate_xfer_address
2045                         /*REMOTE_TRANSLATE_XFER_ADDRESS ()*/);
2046 #endif
2047 #ifdef RETURN_VALUE_ON_STACK
2048   fprintf_unfiltered (file,
2049                       "gdbarch_dump: %s # %s\n",
2050                       "RETURN_VALUE_ON_STACK(type)",
2051                       XSTRING (RETURN_VALUE_ON_STACK (type)));
2052   if (GDB_MULTI_ARCH)
2053     fprintf_unfiltered (file,
2054                         "gdbarch_dump: RETURN_VALUE_ON_STACK = <0x%08lx>\n",
2055                         (long) current_gdbarch->return_value_on_stack
2056                         /*RETURN_VALUE_ON_STACK ()*/);
2057 #endif
2058 #ifdef SAVED_PC_AFTER_CALL
2059   fprintf_unfiltered (file,
2060                       "gdbarch_dump: %s # %s\n",
2061                       "SAVED_PC_AFTER_CALL(frame)",
2062                       XSTRING (SAVED_PC_AFTER_CALL (frame)));
2063   if (GDB_MULTI_ARCH)
2064     fprintf_unfiltered (file,
2065                         "gdbarch_dump: SAVED_PC_AFTER_CALL = <0x%08lx>\n",
2066                         (long) current_gdbarch->saved_pc_after_call
2067                         /*SAVED_PC_AFTER_CALL ()*/);
2068 #endif
2069 #ifdef SAVE_DUMMY_FRAME_TOS_P
2070   fprintf_unfiltered (file,
2071                       "gdbarch_dump: %s # %s\n",
2072                       "SAVE_DUMMY_FRAME_TOS_P()",
2073                       XSTRING (SAVE_DUMMY_FRAME_TOS_P ()));
2074   fprintf_unfiltered (file,
2075                       "gdbarch_dump: SAVE_DUMMY_FRAME_TOS_P() = %d\n",
2076                       SAVE_DUMMY_FRAME_TOS_P ());
2077 #endif
2078 #ifdef SAVE_DUMMY_FRAME_TOS
2079 #if GDB_MULTI_ARCH
2080   /* Macro might contain `[{}]' when not multi-arch */
2081   fprintf_unfiltered (file,
2082                       "gdbarch_dump: %s # %s\n",
2083                       "SAVE_DUMMY_FRAME_TOS(sp)",
2084                       XSTRING (SAVE_DUMMY_FRAME_TOS (sp)));
2085 #endif
2086   if (GDB_MULTI_ARCH)
2087     fprintf_unfiltered (file,
2088                         "gdbarch_dump: SAVE_DUMMY_FRAME_TOS = <0x%08lx>\n",
2089                         (long) current_gdbarch->save_dummy_frame_tos
2090                         /*SAVE_DUMMY_FRAME_TOS ()*/);
2091 #endif
2092 #ifdef SDB_REG_TO_REGNUM
2093   fprintf_unfiltered (file,
2094                       "gdbarch_dump: %s # %s\n",
2095                       "SDB_REG_TO_REGNUM(sdb_regnr)",
2096                       XSTRING (SDB_REG_TO_REGNUM (sdb_regnr)));
2097   if (GDB_MULTI_ARCH)
2098     fprintf_unfiltered (file,
2099                         "gdbarch_dump: SDB_REG_TO_REGNUM = <0x%08lx>\n",
2100                         (long) current_gdbarch->sdb_reg_to_regnum
2101                         /*SDB_REG_TO_REGNUM ()*/);
2102 #endif
2103 #ifdef SIGTRAMP_END_P
2104   fprintf_unfiltered (file,
2105                       "gdbarch_dump: %s # %s\n",
2106                       "SIGTRAMP_END_P()",
2107                       XSTRING (SIGTRAMP_END_P ()));
2108   fprintf_unfiltered (file,
2109                       "gdbarch_dump: SIGTRAMP_END_P() = %d\n",
2110                       SIGTRAMP_END_P ());
2111 #endif
2112 #ifdef SIGTRAMP_END
2113   fprintf_unfiltered (file,
2114                       "gdbarch_dump: %s # %s\n",
2115                       "SIGTRAMP_END(pc)",
2116                       XSTRING (SIGTRAMP_END (pc)));
2117   if (GDB_MULTI_ARCH)
2118     fprintf_unfiltered (file,
2119                         "gdbarch_dump: SIGTRAMP_END = <0x%08lx>\n",
2120                         (long) current_gdbarch->sigtramp_end
2121                         /*SIGTRAMP_END ()*/);
2122 #endif
2123 #ifdef SIGTRAMP_START_P
2124   fprintf_unfiltered (file,
2125                       "gdbarch_dump: %s # %s\n",
2126                       "SIGTRAMP_START_P()",
2127                       XSTRING (SIGTRAMP_START_P ()));
2128   fprintf_unfiltered (file,
2129                       "gdbarch_dump: SIGTRAMP_START_P() = %d\n",
2130                       SIGTRAMP_START_P ());
2131 #endif
2132 #ifdef SIGTRAMP_START
2133   fprintf_unfiltered (file,
2134                       "gdbarch_dump: %s # %s\n",
2135                       "SIGTRAMP_START(pc)",
2136                       XSTRING (SIGTRAMP_START (pc)));
2137   if (GDB_MULTI_ARCH)
2138     fprintf_unfiltered (file,
2139                         "gdbarch_dump: SIGTRAMP_START = <0x%08lx>\n",
2140                         (long) current_gdbarch->sigtramp_start
2141                         /*SIGTRAMP_START ()*/);
2142 #endif
2143 #ifdef SIZEOF_CALL_DUMMY_WORDS
2144   fprintf_unfiltered (file,
2145                       "gdbarch_dump: SIZEOF_CALL_DUMMY_WORDS # %s\n",
2146                       XSTRING (SIZEOF_CALL_DUMMY_WORDS));
2147   fprintf_unfiltered (file,
2148                       "gdbarch_dump: SIZEOF_CALL_DUMMY_WORDS = 0x%08lx\n",
2149                       (long) SIZEOF_CALL_DUMMY_WORDS);
2150 #endif
2151 #ifdef SKIP_PROLOGUE
2152   fprintf_unfiltered (file,
2153                       "gdbarch_dump: %s # %s\n",
2154                       "SKIP_PROLOGUE(ip)",
2155                       XSTRING (SKIP_PROLOGUE (ip)));
2156   if (GDB_MULTI_ARCH)
2157     fprintf_unfiltered (file,
2158                         "gdbarch_dump: SKIP_PROLOGUE = <0x%08lx>\n",
2159                         (long) current_gdbarch->skip_prologue
2160                         /*SKIP_PROLOGUE ()*/);
2161 #endif
2162 #ifdef SKIP_TRAMPOLINE_CODE
2163   fprintf_unfiltered (file,
2164                       "gdbarch_dump: %s # %s\n",
2165                       "SKIP_TRAMPOLINE_CODE(pc)",
2166                       XSTRING (SKIP_TRAMPOLINE_CODE (pc)));
2167   if (GDB_MULTI_ARCH)
2168     fprintf_unfiltered (file,
2169                         "gdbarch_dump: SKIP_TRAMPOLINE_CODE = <0x%08lx>\n",
2170                         (long) current_gdbarch->skip_trampoline_code
2171                         /*SKIP_TRAMPOLINE_CODE ()*/);
2172 #endif
2173 #ifdef SMASH_TEXT_ADDRESS
2174   fprintf_unfiltered (file,
2175                       "gdbarch_dump: %s # %s\n",
2176                       "SMASH_TEXT_ADDRESS(addr)",
2177                       XSTRING (SMASH_TEXT_ADDRESS (addr)));
2178   if (GDB_MULTI_ARCH)
2179     fprintf_unfiltered (file,
2180                         "gdbarch_dump: SMASH_TEXT_ADDRESS = <0x%08lx>\n",
2181                         (long) current_gdbarch->smash_text_address
2182                         /*SMASH_TEXT_ADDRESS ()*/);
2183 #endif
2184 #ifdef SOFTWARE_SINGLE_STEP_P
2185   fprintf_unfiltered (file,
2186                       "gdbarch_dump: %s # %s\n",
2187                       "SOFTWARE_SINGLE_STEP_P()",
2188                       XSTRING (SOFTWARE_SINGLE_STEP_P ()));
2189   fprintf_unfiltered (file,
2190                       "gdbarch_dump: SOFTWARE_SINGLE_STEP_P() = %d\n",
2191                       SOFTWARE_SINGLE_STEP_P ());
2192 #endif
2193 #ifdef SOFTWARE_SINGLE_STEP
2194 #if GDB_MULTI_ARCH
2195   /* Macro might contain `[{}]' when not multi-arch */
2196   fprintf_unfiltered (file,
2197                       "gdbarch_dump: %s # %s\n",
2198                       "SOFTWARE_SINGLE_STEP(sig, insert_breakpoints_p)",
2199                       XSTRING (SOFTWARE_SINGLE_STEP (sig, insert_breakpoints_p)));
2200 #endif
2201   if (GDB_MULTI_ARCH)
2202     fprintf_unfiltered (file,
2203                         "gdbarch_dump: SOFTWARE_SINGLE_STEP = <0x%08lx>\n",
2204                         (long) current_gdbarch->software_single_step
2205                         /*SOFTWARE_SINGLE_STEP ()*/);
2206 #endif
2207 #ifdef SP_REGNUM
2208   fprintf_unfiltered (file,
2209                       "gdbarch_dump: SP_REGNUM # %s\n",
2210                       XSTRING (SP_REGNUM));
2211   fprintf_unfiltered (file,
2212                       "gdbarch_dump: SP_REGNUM = %d\n",
2213                       SP_REGNUM);
2214 #endif
2215 #ifdef STAB_REG_TO_REGNUM
2216   fprintf_unfiltered (file,
2217                       "gdbarch_dump: %s # %s\n",
2218                       "STAB_REG_TO_REGNUM(stab_regnr)",
2219                       XSTRING (STAB_REG_TO_REGNUM (stab_regnr)));
2220   if (GDB_MULTI_ARCH)
2221     fprintf_unfiltered (file,
2222                         "gdbarch_dump: STAB_REG_TO_REGNUM = <0x%08lx>\n",
2223                         (long) current_gdbarch->stab_reg_to_regnum
2224                         /*STAB_REG_TO_REGNUM ()*/);
2225 #endif
2226 #ifdef STACK_ALIGN_P
2227   fprintf_unfiltered (file,
2228                       "gdbarch_dump: %s # %s\n",
2229                       "STACK_ALIGN_P()",
2230                       XSTRING (STACK_ALIGN_P ()));
2231   fprintf_unfiltered (file,
2232                       "gdbarch_dump: STACK_ALIGN_P() = %d\n",
2233                       STACK_ALIGN_P ());
2234 #endif
2235 #ifdef STACK_ALIGN
2236   fprintf_unfiltered (file,
2237                       "gdbarch_dump: %s # %s\n",
2238                       "STACK_ALIGN(sp)",
2239                       XSTRING (STACK_ALIGN (sp)));
2240   if (GDB_MULTI_ARCH)
2241     fprintf_unfiltered (file,
2242                         "gdbarch_dump: STACK_ALIGN = <0x%08lx>\n",
2243                         (long) current_gdbarch->stack_align
2244                         /*STACK_ALIGN ()*/);
2245 #endif
2246 #ifdef STORE_RETURN_VALUE
2247 #if GDB_MULTI_ARCH
2248   /* Macro might contain `[{}]' when not multi-arch */
2249   fprintf_unfiltered (file,
2250                       "gdbarch_dump: %s # %s\n",
2251                       "STORE_RETURN_VALUE(type, regcache, valbuf)",
2252                       XSTRING (STORE_RETURN_VALUE (type, regcache, valbuf)));
2253 #endif
2254   if (GDB_MULTI_ARCH)
2255     fprintf_unfiltered (file,
2256                         "gdbarch_dump: STORE_RETURN_VALUE = <0x%08lx>\n",
2257                         (long) current_gdbarch->store_return_value
2258                         /*STORE_RETURN_VALUE ()*/);
2259 #endif
2260 #ifdef STORE_STRUCT_RETURN
2261 #if GDB_MULTI_ARCH
2262   /* Macro might contain `[{}]' when not multi-arch */
2263   fprintf_unfiltered (file,
2264                       "gdbarch_dump: %s # %s\n",
2265                       "STORE_STRUCT_RETURN(addr, sp)",
2266                       XSTRING (STORE_STRUCT_RETURN (addr, sp)));
2267 #endif
2268   if (GDB_MULTI_ARCH)
2269     fprintf_unfiltered (file,
2270                         "gdbarch_dump: STORE_STRUCT_RETURN = <0x%08lx>\n",
2271                         (long) current_gdbarch->store_struct_return
2272                         /*STORE_STRUCT_RETURN ()*/);
2273 #endif
2274 #ifdef TARGET_ADDR_BIT
2275   fprintf_unfiltered (file,
2276                       "gdbarch_dump: TARGET_ADDR_BIT # %s\n",
2277                       XSTRING (TARGET_ADDR_BIT));
2278   fprintf_unfiltered (file,
2279                       "gdbarch_dump: TARGET_ADDR_BIT = %d\n",
2280                       TARGET_ADDR_BIT);
2281 #endif
2282 #ifdef TARGET_ARCHITECTURE
2283   fprintf_unfiltered (file,
2284                       "gdbarch_dump: TARGET_ARCHITECTURE # %s\n",
2285                       XSTRING (TARGET_ARCHITECTURE));
2286   if (TARGET_ARCHITECTURE != NULL)
2287     fprintf_unfiltered (file,
2288                         "gdbarch_dump: TARGET_ARCHITECTURE = %s\n",
2289                         TARGET_ARCHITECTURE->printable_name);
2290 #endif
2291 #ifdef TARGET_BFD_VMA_BIT
2292   fprintf_unfiltered (file,
2293                       "gdbarch_dump: TARGET_BFD_VMA_BIT # %s\n",
2294                       XSTRING (TARGET_BFD_VMA_BIT));
2295   fprintf_unfiltered (file,
2296                       "gdbarch_dump: TARGET_BFD_VMA_BIT = %d\n",
2297                       TARGET_BFD_VMA_BIT);
2298 #endif
2299 #ifdef TARGET_BYTE_ORDER
2300   fprintf_unfiltered (file,
2301                       "gdbarch_dump: TARGET_BYTE_ORDER # %s\n",
2302                       XSTRING (TARGET_BYTE_ORDER));
2303   fprintf_unfiltered (file,
2304                       "gdbarch_dump: TARGET_BYTE_ORDER = %ld\n",
2305                       (long) TARGET_BYTE_ORDER);
2306 #endif
2307 #ifdef TARGET_CHAR_SIGNED
2308   fprintf_unfiltered (file,
2309                       "gdbarch_dump: TARGET_CHAR_SIGNED # %s\n",
2310                       XSTRING (TARGET_CHAR_SIGNED));
2311   fprintf_unfiltered (file,
2312                       "gdbarch_dump: TARGET_CHAR_SIGNED = %d\n",
2313                       TARGET_CHAR_SIGNED);
2314 #endif
2315 #ifdef TARGET_DOUBLE_BIT
2316   fprintf_unfiltered (file,
2317                       "gdbarch_dump: TARGET_DOUBLE_BIT # %s\n",
2318                       XSTRING (TARGET_DOUBLE_BIT));
2319   fprintf_unfiltered (file,
2320                       "gdbarch_dump: TARGET_DOUBLE_BIT = %d\n",
2321                       TARGET_DOUBLE_BIT);
2322 #endif
2323 #ifdef TARGET_DOUBLE_FORMAT
2324   fprintf_unfiltered (file,
2325                       "gdbarch_dump: TARGET_DOUBLE_FORMAT # %s\n",
2326                       XSTRING (TARGET_DOUBLE_FORMAT));
2327   fprintf_unfiltered (file,
2328                       "gdbarch_dump: TARGET_DOUBLE_FORMAT = %s\n",
2329                       (TARGET_DOUBLE_FORMAT)->name);
2330 #endif
2331 #ifdef TARGET_FLOAT_BIT
2332   fprintf_unfiltered (file,
2333                       "gdbarch_dump: TARGET_FLOAT_BIT # %s\n",
2334                       XSTRING (TARGET_FLOAT_BIT));
2335   fprintf_unfiltered (file,
2336                       "gdbarch_dump: TARGET_FLOAT_BIT = %d\n",
2337                       TARGET_FLOAT_BIT);
2338 #endif
2339 #ifdef TARGET_FLOAT_FORMAT
2340   fprintf_unfiltered (file,
2341                       "gdbarch_dump: TARGET_FLOAT_FORMAT # %s\n",
2342                       XSTRING (TARGET_FLOAT_FORMAT));
2343   fprintf_unfiltered (file,
2344                       "gdbarch_dump: TARGET_FLOAT_FORMAT = %s\n",
2345                       (TARGET_FLOAT_FORMAT)->name);
2346 #endif
2347 #ifdef TARGET_INT_BIT
2348   fprintf_unfiltered (file,
2349                       "gdbarch_dump: TARGET_INT_BIT # %s\n",
2350                       XSTRING (TARGET_INT_BIT));
2351   fprintf_unfiltered (file,
2352                       "gdbarch_dump: TARGET_INT_BIT = %d\n",
2353                       TARGET_INT_BIT);
2354 #endif
2355 #ifdef TARGET_LONG_BIT
2356   fprintf_unfiltered (file,
2357                       "gdbarch_dump: TARGET_LONG_BIT # %s\n",
2358                       XSTRING (TARGET_LONG_BIT));
2359   fprintf_unfiltered (file,
2360                       "gdbarch_dump: TARGET_LONG_BIT = %d\n",
2361                       TARGET_LONG_BIT);
2362 #endif
2363 #ifdef TARGET_LONG_DOUBLE_BIT
2364   fprintf_unfiltered (file,
2365                       "gdbarch_dump: TARGET_LONG_DOUBLE_BIT # %s\n",
2366                       XSTRING (TARGET_LONG_DOUBLE_BIT));
2367   fprintf_unfiltered (file,
2368                       "gdbarch_dump: TARGET_LONG_DOUBLE_BIT = %d\n",
2369                       TARGET_LONG_DOUBLE_BIT);
2370 #endif
2371 #ifdef TARGET_LONG_DOUBLE_FORMAT
2372   fprintf_unfiltered (file,
2373                       "gdbarch_dump: TARGET_LONG_DOUBLE_FORMAT # %s\n",
2374                       XSTRING (TARGET_LONG_DOUBLE_FORMAT));
2375   fprintf_unfiltered (file,
2376                       "gdbarch_dump: TARGET_LONG_DOUBLE_FORMAT = %s\n",
2377                       (TARGET_LONG_DOUBLE_FORMAT)->name);
2378 #endif
2379 #ifdef TARGET_LONG_LONG_BIT
2380   fprintf_unfiltered (file,
2381                       "gdbarch_dump: TARGET_LONG_LONG_BIT # %s\n",
2382                       XSTRING (TARGET_LONG_LONG_BIT));
2383   fprintf_unfiltered (file,
2384                       "gdbarch_dump: TARGET_LONG_LONG_BIT = %d\n",
2385                       TARGET_LONG_LONG_BIT);
2386 #endif
2387 #ifdef TARGET_OSABI
2388   fprintf_unfiltered (file,
2389                       "gdbarch_dump: TARGET_OSABI # %s\n",
2390                       XSTRING (TARGET_OSABI));
2391   fprintf_unfiltered (file,
2392                       "gdbarch_dump: TARGET_OSABI = %ld\n",
2393                       (long) TARGET_OSABI);
2394 #endif
2395 #ifdef TARGET_PRINT_INSN
2396   fprintf_unfiltered (file,
2397                       "gdbarch_dump: %s # %s\n",
2398                       "TARGET_PRINT_INSN(vma, info)",
2399                       XSTRING (TARGET_PRINT_INSN (vma, info)));
2400   if (GDB_MULTI_ARCH)
2401     fprintf_unfiltered (file,
2402                         "gdbarch_dump: TARGET_PRINT_INSN = <0x%08lx>\n",
2403                         (long) current_gdbarch->print_insn
2404                         /*TARGET_PRINT_INSN ()*/);
2405 #endif
2406 #ifdef TARGET_PTR_BIT
2407   fprintf_unfiltered (file,
2408                       "gdbarch_dump: TARGET_PTR_BIT # %s\n",
2409                       XSTRING (TARGET_PTR_BIT));
2410   fprintf_unfiltered (file,
2411                       "gdbarch_dump: TARGET_PTR_BIT = %d\n",
2412                       TARGET_PTR_BIT);
2413 #endif
2414 #ifdef TARGET_READ_FP
2415   fprintf_unfiltered (file,
2416                       "gdbarch_dump: %s # %s\n",
2417                       "TARGET_READ_FP()",
2418                       XSTRING (TARGET_READ_FP ()));
2419   if (GDB_MULTI_ARCH)
2420     fprintf_unfiltered (file,
2421                         "gdbarch_dump: TARGET_READ_FP = <0x%08lx>\n",
2422                         (long) current_gdbarch->read_fp
2423                         /*TARGET_READ_FP ()*/);
2424 #endif
2425 #ifdef TARGET_READ_PC
2426   fprintf_unfiltered (file,
2427                       "gdbarch_dump: %s # %s\n",
2428                       "TARGET_READ_PC(ptid)",
2429                       XSTRING (TARGET_READ_PC (ptid)));
2430   if (GDB_MULTI_ARCH)
2431     fprintf_unfiltered (file,
2432                         "gdbarch_dump: TARGET_READ_PC = <0x%08lx>\n",
2433                         (long) current_gdbarch->read_pc
2434                         /*TARGET_READ_PC ()*/);
2435 #endif
2436 #ifdef TARGET_READ_SP
2437   fprintf_unfiltered (file,
2438                       "gdbarch_dump: %s # %s\n",
2439                       "TARGET_READ_SP()",
2440                       XSTRING (TARGET_READ_SP ()));
2441   if (GDB_MULTI_ARCH)
2442     fprintf_unfiltered (file,
2443                         "gdbarch_dump: TARGET_READ_SP = <0x%08lx>\n",
2444                         (long) current_gdbarch->read_sp
2445                         /*TARGET_READ_SP ()*/);
2446 #endif
2447 #ifdef TARGET_SHORT_BIT
2448   fprintf_unfiltered (file,
2449                       "gdbarch_dump: TARGET_SHORT_BIT # %s\n",
2450                       XSTRING (TARGET_SHORT_BIT));
2451   fprintf_unfiltered (file,
2452                       "gdbarch_dump: TARGET_SHORT_BIT = %d\n",
2453                       TARGET_SHORT_BIT);
2454 #endif
2455 #ifdef TARGET_VIRTUAL_FRAME_POINTER
2456 #if GDB_MULTI_ARCH
2457   /* Macro might contain `[{}]' when not multi-arch */
2458   fprintf_unfiltered (file,
2459                       "gdbarch_dump: %s # %s\n",
2460                       "TARGET_VIRTUAL_FRAME_POINTER(pc, frame_regnum, frame_offset)",
2461                       XSTRING (TARGET_VIRTUAL_FRAME_POINTER (pc, frame_regnum, frame_offset)));
2462 #endif
2463   if (GDB_MULTI_ARCH)
2464     fprintf_unfiltered (file,
2465                         "gdbarch_dump: TARGET_VIRTUAL_FRAME_POINTER = <0x%08lx>\n",
2466                         (long) current_gdbarch->virtual_frame_pointer
2467                         /*TARGET_VIRTUAL_FRAME_POINTER ()*/);
2468 #endif
2469 #ifdef TARGET_WRITE_PC
2470 #if GDB_MULTI_ARCH
2471   /* Macro might contain `[{}]' when not multi-arch */
2472   fprintf_unfiltered (file,
2473                       "gdbarch_dump: %s # %s\n",
2474                       "TARGET_WRITE_PC(val, ptid)",
2475                       XSTRING (TARGET_WRITE_PC (val, ptid)));
2476 #endif
2477   if (GDB_MULTI_ARCH)
2478     fprintf_unfiltered (file,
2479                         "gdbarch_dump: TARGET_WRITE_PC = <0x%08lx>\n",
2480                         (long) current_gdbarch->write_pc
2481                         /*TARGET_WRITE_PC ()*/);
2482 #endif
2483 #ifdef TARGET_WRITE_SP
2484 #if GDB_MULTI_ARCH
2485   /* Macro might contain `[{}]' when not multi-arch */
2486   fprintf_unfiltered (file,
2487                       "gdbarch_dump: %s # %s\n",
2488                       "TARGET_WRITE_SP(val)",
2489                       XSTRING (TARGET_WRITE_SP (val)));
2490 #endif
2491   if (GDB_MULTI_ARCH)
2492     fprintf_unfiltered (file,
2493                         "gdbarch_dump: TARGET_WRITE_SP = <0x%08lx>\n",
2494                         (long) current_gdbarch->write_sp
2495                         /*TARGET_WRITE_SP ()*/);
2496 #endif
2497 #ifdef USE_STRUCT_CONVENTION
2498   fprintf_unfiltered (file,
2499                       "gdbarch_dump: %s # %s\n",
2500                       "USE_STRUCT_CONVENTION(gcc_p, value_type)",
2501                       XSTRING (USE_STRUCT_CONVENTION (gcc_p, value_type)));
2502   if (GDB_MULTI_ARCH)
2503     fprintf_unfiltered (file,
2504                         "gdbarch_dump: USE_STRUCT_CONVENTION = <0x%08lx>\n",
2505                         (long) current_gdbarch->use_struct_convention
2506                         /*USE_STRUCT_CONVENTION ()*/);
2507 #endif
2508 #ifdef VALUE_TO_REGISTER
2509 #if GDB_MULTI_ARCH
2510   /* Macro might contain `[{}]' when not multi-arch */
2511   fprintf_unfiltered (file,
2512                       "gdbarch_dump: %s # %s\n",
2513                       "VALUE_TO_REGISTER(type, regnum, from, to)",
2514                       XSTRING (VALUE_TO_REGISTER (type, regnum, from, to)));
2515 #endif
2516   if (GDB_MULTI_ARCH)
2517     fprintf_unfiltered (file,
2518                         "gdbarch_dump: VALUE_TO_REGISTER = <0x%08lx>\n",
2519                         (long) current_gdbarch->value_to_register
2520                         /*VALUE_TO_REGISTER ()*/);
2521 #endif
2522   if (current_gdbarch->dump_tdep != NULL)
2523     current_gdbarch->dump_tdep (current_gdbarch, file);
2524 }
2525
2526 struct gdbarch_tdep *
2527 gdbarch_tdep (struct gdbarch *gdbarch)
2528 {
2529   if (gdbarch_debug >= 2)
2530     fprintf_unfiltered (gdb_stdlog, "gdbarch_tdep called\n");
2531   return gdbarch->tdep;
2532 }
2533
2534
2535 const struct bfd_arch_info *
2536 gdbarch_bfd_arch_info (struct gdbarch *gdbarch)
2537 {
2538   gdb_assert (gdbarch != NULL);
2539   if (gdbarch_debug >= 2)
2540     fprintf_unfiltered (gdb_stdlog, "gdbarch_bfd_arch_info called\n");
2541   return gdbarch->bfd_arch_info;
2542 }
2543
2544 int
2545 gdbarch_byte_order (struct gdbarch *gdbarch)
2546 {
2547   gdb_assert (gdbarch != NULL);
2548   if (gdbarch_debug >= 2)
2549     fprintf_unfiltered (gdb_stdlog, "gdbarch_byte_order called\n");
2550   return gdbarch->byte_order;
2551 }
2552
2553 enum gdb_osabi
2554 gdbarch_osabi (struct gdbarch *gdbarch)
2555 {
2556   gdb_assert (gdbarch != NULL);
2557   if (gdbarch_debug >= 2)
2558     fprintf_unfiltered (gdb_stdlog, "gdbarch_osabi called\n");
2559   return gdbarch->osabi;
2560 }
2561
2562 int
2563 gdbarch_short_bit (struct gdbarch *gdbarch)
2564 {
2565   gdb_assert (gdbarch != NULL);
2566   /* Skip verify of short_bit, invalid_p == 0 */
2567   if (gdbarch_debug >= 2)
2568     fprintf_unfiltered (gdb_stdlog, "gdbarch_short_bit called\n");
2569   return gdbarch->short_bit;
2570 }
2571
2572 void
2573 set_gdbarch_short_bit (struct gdbarch *gdbarch,
2574                        int short_bit)
2575 {
2576   gdbarch->short_bit = short_bit;
2577 }
2578
2579 int
2580 gdbarch_int_bit (struct gdbarch *gdbarch)
2581 {
2582   gdb_assert (gdbarch != NULL);
2583   /* Skip verify of int_bit, invalid_p == 0 */
2584   if (gdbarch_debug >= 2)
2585     fprintf_unfiltered (gdb_stdlog, "gdbarch_int_bit called\n");
2586   return gdbarch->int_bit;
2587 }
2588
2589 void
2590 set_gdbarch_int_bit (struct gdbarch *gdbarch,
2591                      int int_bit)
2592 {
2593   gdbarch->int_bit = int_bit;
2594 }
2595
2596 int
2597 gdbarch_long_bit (struct gdbarch *gdbarch)
2598 {
2599   gdb_assert (gdbarch != NULL);
2600   /* Skip verify of long_bit, invalid_p == 0 */
2601   if (gdbarch_debug >= 2)
2602     fprintf_unfiltered (gdb_stdlog, "gdbarch_long_bit called\n");
2603   return gdbarch->long_bit;
2604 }
2605
2606 void
2607 set_gdbarch_long_bit (struct gdbarch *gdbarch,
2608                       int long_bit)
2609 {
2610   gdbarch->long_bit = long_bit;
2611 }
2612
2613 int
2614 gdbarch_long_long_bit (struct gdbarch *gdbarch)
2615 {
2616   gdb_assert (gdbarch != NULL);
2617   /* Skip verify of long_long_bit, invalid_p == 0 */
2618   if (gdbarch_debug >= 2)
2619     fprintf_unfiltered (gdb_stdlog, "gdbarch_long_long_bit called\n");
2620   return gdbarch->long_long_bit;
2621 }
2622
2623 void
2624 set_gdbarch_long_long_bit (struct gdbarch *gdbarch,
2625                            int long_long_bit)
2626 {
2627   gdbarch->long_long_bit = long_long_bit;
2628 }
2629
2630 int
2631 gdbarch_float_bit (struct gdbarch *gdbarch)
2632 {
2633   gdb_assert (gdbarch != NULL);
2634   /* Skip verify of float_bit, invalid_p == 0 */
2635   if (gdbarch_debug >= 2)
2636     fprintf_unfiltered (gdb_stdlog, "gdbarch_float_bit called\n");
2637   return gdbarch->float_bit;
2638 }
2639
2640 void
2641 set_gdbarch_float_bit (struct gdbarch *gdbarch,
2642                        int float_bit)
2643 {
2644   gdbarch->float_bit = float_bit;
2645 }
2646
2647 int
2648 gdbarch_double_bit (struct gdbarch *gdbarch)
2649 {
2650   gdb_assert (gdbarch != NULL);
2651   /* Skip verify of double_bit, invalid_p == 0 */
2652   if (gdbarch_debug >= 2)
2653     fprintf_unfiltered (gdb_stdlog, "gdbarch_double_bit called\n");
2654   return gdbarch->double_bit;
2655 }
2656
2657 void
2658 set_gdbarch_double_bit (struct gdbarch *gdbarch,
2659                         int double_bit)
2660 {
2661   gdbarch->double_bit = double_bit;
2662 }
2663
2664 int
2665 gdbarch_long_double_bit (struct gdbarch *gdbarch)
2666 {
2667   gdb_assert (gdbarch != NULL);
2668   /* Skip verify of long_double_bit, invalid_p == 0 */
2669   if (gdbarch_debug >= 2)
2670     fprintf_unfiltered (gdb_stdlog, "gdbarch_long_double_bit called\n");
2671   return gdbarch->long_double_bit;
2672 }
2673
2674 void
2675 set_gdbarch_long_double_bit (struct gdbarch *gdbarch,
2676                              int long_double_bit)
2677 {
2678   gdbarch->long_double_bit = long_double_bit;
2679 }
2680
2681 int
2682 gdbarch_ptr_bit (struct gdbarch *gdbarch)
2683 {
2684   gdb_assert (gdbarch != NULL);
2685   /* Skip verify of ptr_bit, invalid_p == 0 */
2686   if (gdbarch_debug >= 2)
2687     fprintf_unfiltered (gdb_stdlog, "gdbarch_ptr_bit called\n");
2688   return gdbarch->ptr_bit;
2689 }
2690
2691 void
2692 set_gdbarch_ptr_bit (struct gdbarch *gdbarch,
2693                      int ptr_bit)
2694 {
2695   gdbarch->ptr_bit = ptr_bit;
2696 }
2697
2698 int
2699 gdbarch_addr_bit (struct gdbarch *gdbarch)
2700 {
2701   gdb_assert (gdbarch != NULL);
2702   if (gdbarch->addr_bit == 0)
2703     internal_error (__FILE__, __LINE__,
2704                     "gdbarch: gdbarch_addr_bit invalid");
2705   if (gdbarch_debug >= 2)
2706     fprintf_unfiltered (gdb_stdlog, "gdbarch_addr_bit called\n");
2707   return gdbarch->addr_bit;
2708 }
2709
2710 void
2711 set_gdbarch_addr_bit (struct gdbarch *gdbarch,
2712                       int addr_bit)
2713 {
2714   gdbarch->addr_bit = addr_bit;
2715 }
2716
2717 int
2718 gdbarch_bfd_vma_bit (struct gdbarch *gdbarch)
2719 {
2720   gdb_assert (gdbarch != NULL);
2721   /* Skip verify of bfd_vma_bit, invalid_p == 0 */
2722   if (gdbarch_debug >= 2)
2723     fprintf_unfiltered (gdb_stdlog, "gdbarch_bfd_vma_bit called\n");
2724   return gdbarch->bfd_vma_bit;
2725 }
2726
2727 void
2728 set_gdbarch_bfd_vma_bit (struct gdbarch *gdbarch,
2729                          int bfd_vma_bit)
2730 {
2731   gdbarch->bfd_vma_bit = bfd_vma_bit;
2732 }
2733
2734 int
2735 gdbarch_char_signed (struct gdbarch *gdbarch)
2736 {
2737   gdb_assert (gdbarch != NULL);
2738   if (gdbarch->char_signed == -1)
2739     internal_error (__FILE__, __LINE__,
2740                     "gdbarch: gdbarch_char_signed invalid");
2741   if (gdbarch_debug >= 2)
2742     fprintf_unfiltered (gdb_stdlog, "gdbarch_char_signed called\n");
2743   return gdbarch->char_signed;
2744 }
2745
2746 void
2747 set_gdbarch_char_signed (struct gdbarch *gdbarch,
2748                          int char_signed)
2749 {
2750   gdbarch->char_signed = char_signed;
2751 }
2752
2753 CORE_ADDR
2754 gdbarch_read_pc (struct gdbarch *gdbarch, ptid_t ptid)
2755 {
2756   gdb_assert (gdbarch != NULL);
2757   if (gdbarch->read_pc == 0)
2758     internal_error (__FILE__, __LINE__,
2759                     "gdbarch: gdbarch_read_pc invalid");
2760   if (gdbarch_debug >= 2)
2761     fprintf_unfiltered (gdb_stdlog, "gdbarch_read_pc called\n");
2762   return gdbarch->read_pc (ptid);
2763 }
2764
2765 void
2766 set_gdbarch_read_pc (struct gdbarch *gdbarch,
2767                      gdbarch_read_pc_ftype read_pc)
2768 {
2769   gdbarch->read_pc = read_pc;
2770 }
2771
2772 void
2773 gdbarch_write_pc (struct gdbarch *gdbarch, CORE_ADDR val, ptid_t ptid)
2774 {
2775   gdb_assert (gdbarch != NULL);
2776   if (gdbarch->write_pc == 0)
2777     internal_error (__FILE__, __LINE__,
2778                     "gdbarch: gdbarch_write_pc invalid");
2779   if (gdbarch_debug >= 2)
2780     fprintf_unfiltered (gdb_stdlog, "gdbarch_write_pc called\n");
2781   gdbarch->write_pc (val, ptid);
2782 }
2783
2784 void
2785 set_gdbarch_write_pc (struct gdbarch *gdbarch,
2786                       gdbarch_write_pc_ftype write_pc)
2787 {
2788   gdbarch->write_pc = write_pc;
2789 }
2790
2791 CORE_ADDR
2792 gdbarch_read_fp (struct gdbarch *gdbarch)
2793 {
2794   gdb_assert (gdbarch != NULL);
2795   if (gdbarch->read_fp == 0)
2796     internal_error (__FILE__, __LINE__,
2797                     "gdbarch: gdbarch_read_fp invalid");
2798   if (gdbarch_debug >= 2)
2799     fprintf_unfiltered (gdb_stdlog, "gdbarch_read_fp called\n");
2800   return gdbarch->read_fp ();
2801 }
2802
2803 void
2804 set_gdbarch_read_fp (struct gdbarch *gdbarch,
2805                      gdbarch_read_fp_ftype read_fp)
2806 {
2807   gdbarch->read_fp = read_fp;
2808 }
2809
2810 CORE_ADDR
2811 gdbarch_read_sp (struct gdbarch *gdbarch)
2812 {
2813   gdb_assert (gdbarch != NULL);
2814   if (gdbarch->read_sp == 0)
2815     internal_error (__FILE__, __LINE__,
2816                     "gdbarch: gdbarch_read_sp invalid");
2817   if (gdbarch_debug >= 2)
2818     fprintf_unfiltered (gdb_stdlog, "gdbarch_read_sp called\n");
2819   return gdbarch->read_sp ();
2820 }
2821
2822 void
2823 set_gdbarch_read_sp (struct gdbarch *gdbarch,
2824                      gdbarch_read_sp_ftype read_sp)
2825 {
2826   gdbarch->read_sp = read_sp;
2827 }
2828
2829 void
2830 gdbarch_write_sp (struct gdbarch *gdbarch, CORE_ADDR val)
2831 {
2832   gdb_assert (gdbarch != NULL);
2833   if (gdbarch->write_sp == 0)
2834     internal_error (__FILE__, __LINE__,
2835                     "gdbarch: gdbarch_write_sp invalid");
2836   if (gdbarch_debug >= 2)
2837     fprintf_unfiltered (gdb_stdlog, "gdbarch_write_sp called\n");
2838   gdbarch->write_sp (val);
2839 }
2840
2841 void
2842 set_gdbarch_write_sp (struct gdbarch *gdbarch,
2843                       gdbarch_write_sp_ftype write_sp)
2844 {
2845   gdbarch->write_sp = write_sp;
2846 }
2847
2848 void
2849 gdbarch_virtual_frame_pointer (struct gdbarch *gdbarch, CORE_ADDR pc, int *frame_regnum, LONGEST *frame_offset)
2850 {
2851   gdb_assert (gdbarch != NULL);
2852   if (gdbarch->virtual_frame_pointer == 0)
2853     internal_error (__FILE__, __LINE__,
2854                     "gdbarch: gdbarch_virtual_frame_pointer invalid");
2855   if (gdbarch_debug >= 2)
2856     fprintf_unfiltered (gdb_stdlog, "gdbarch_virtual_frame_pointer called\n");
2857   gdbarch->virtual_frame_pointer (pc, frame_regnum, frame_offset);
2858 }
2859
2860 void
2861 set_gdbarch_virtual_frame_pointer (struct gdbarch *gdbarch,
2862                                    gdbarch_virtual_frame_pointer_ftype virtual_frame_pointer)
2863 {
2864   gdbarch->virtual_frame_pointer = virtual_frame_pointer;
2865 }
2866
2867 int
2868 gdbarch_pseudo_register_read_p (struct gdbarch *gdbarch)
2869 {
2870   gdb_assert (gdbarch != NULL);
2871   return gdbarch->pseudo_register_read != 0;
2872 }
2873
2874 void
2875 gdbarch_pseudo_register_read (struct gdbarch *gdbarch, struct regcache *regcache, int cookednum, void *buf)
2876 {
2877   gdb_assert (gdbarch != NULL);
2878   if (gdbarch->pseudo_register_read == 0)
2879     internal_error (__FILE__, __LINE__,
2880                     "gdbarch: gdbarch_pseudo_register_read invalid");
2881   if (gdbarch_debug >= 2)
2882     fprintf_unfiltered (gdb_stdlog, "gdbarch_pseudo_register_read called\n");
2883   gdbarch->pseudo_register_read (gdbarch, regcache, cookednum, buf);
2884 }
2885
2886 void
2887 set_gdbarch_pseudo_register_read (struct gdbarch *gdbarch,
2888                                   gdbarch_pseudo_register_read_ftype pseudo_register_read)
2889 {
2890   gdbarch->pseudo_register_read = pseudo_register_read;
2891 }
2892
2893 int
2894 gdbarch_pseudo_register_write_p (struct gdbarch *gdbarch)
2895 {
2896   gdb_assert (gdbarch != NULL);
2897   return gdbarch->pseudo_register_write != 0;
2898 }
2899
2900 void
2901 gdbarch_pseudo_register_write (struct gdbarch *gdbarch, struct regcache *regcache, int cookednum, const void *buf)
2902 {
2903   gdb_assert (gdbarch != NULL);
2904   if (gdbarch->pseudo_register_write == 0)
2905     internal_error (__FILE__, __LINE__,
2906                     "gdbarch: gdbarch_pseudo_register_write invalid");
2907   if (gdbarch_debug >= 2)
2908     fprintf_unfiltered (gdb_stdlog, "gdbarch_pseudo_register_write called\n");
2909   gdbarch->pseudo_register_write (gdbarch, regcache, cookednum, buf);
2910 }
2911
2912 void
2913 set_gdbarch_pseudo_register_write (struct gdbarch *gdbarch,
2914                                    gdbarch_pseudo_register_write_ftype pseudo_register_write)
2915 {
2916   gdbarch->pseudo_register_write = pseudo_register_write;
2917 }
2918
2919 int
2920 gdbarch_num_regs (struct gdbarch *gdbarch)
2921 {
2922   gdb_assert (gdbarch != NULL);
2923   if (gdbarch->num_regs == -1)
2924     internal_error (__FILE__, __LINE__,
2925                     "gdbarch: gdbarch_num_regs invalid");
2926   if (gdbarch_debug >= 2)
2927     fprintf_unfiltered (gdb_stdlog, "gdbarch_num_regs called\n");
2928   return gdbarch->num_regs;
2929 }
2930
2931 void
2932 set_gdbarch_num_regs (struct gdbarch *gdbarch,
2933                       int num_regs)
2934 {
2935   gdbarch->num_regs = num_regs;
2936 }
2937
2938 int
2939 gdbarch_num_pseudo_regs (struct gdbarch *gdbarch)
2940 {
2941   gdb_assert (gdbarch != NULL);
2942   /* Skip verify of num_pseudo_regs, invalid_p == 0 */
2943   if (gdbarch_debug >= 2)
2944     fprintf_unfiltered (gdb_stdlog, "gdbarch_num_pseudo_regs called\n");
2945   return gdbarch->num_pseudo_regs;
2946 }
2947
2948 void
2949 set_gdbarch_num_pseudo_regs (struct gdbarch *gdbarch,
2950                              int num_pseudo_regs)
2951 {
2952   gdbarch->num_pseudo_regs = num_pseudo_regs;
2953 }
2954
2955 int
2956 gdbarch_sp_regnum (struct gdbarch *gdbarch)
2957 {
2958   gdb_assert (gdbarch != NULL);
2959   /* Skip verify of sp_regnum, invalid_p == 0 */
2960   if (gdbarch_debug >= 2)
2961     fprintf_unfiltered (gdb_stdlog, "gdbarch_sp_regnum called\n");
2962   return gdbarch->sp_regnum;
2963 }
2964
2965 void
2966 set_gdbarch_sp_regnum (struct gdbarch *gdbarch,
2967                        int sp_regnum)
2968 {
2969   gdbarch->sp_regnum = sp_regnum;
2970 }
2971
2972 int
2973 gdbarch_fp_regnum (struct gdbarch *gdbarch)
2974 {
2975   gdb_assert (gdbarch != NULL);
2976   /* Skip verify of fp_regnum, invalid_p == 0 */
2977   if (gdbarch_debug >= 2)
2978     fprintf_unfiltered (gdb_stdlog, "gdbarch_fp_regnum called\n");
2979   return gdbarch->fp_regnum;
2980 }
2981
2982 void
2983 set_gdbarch_fp_regnum (struct gdbarch *gdbarch,
2984                        int fp_regnum)
2985 {
2986   gdbarch->fp_regnum = fp_regnum;
2987 }
2988
2989 int
2990 gdbarch_pc_regnum (struct gdbarch *gdbarch)
2991 {
2992   gdb_assert (gdbarch != NULL);
2993   /* Skip verify of pc_regnum, invalid_p == 0 */
2994   if (gdbarch_debug >= 2)
2995     fprintf_unfiltered (gdb_stdlog, "gdbarch_pc_regnum called\n");
2996   return gdbarch->pc_regnum;
2997 }
2998
2999 void
3000 set_gdbarch_pc_regnum (struct gdbarch *gdbarch,
3001                        int pc_regnum)
3002 {
3003   gdbarch->pc_regnum = pc_regnum;
3004 }
3005
3006 int
3007 gdbarch_ps_regnum (struct gdbarch *gdbarch)
3008 {
3009   gdb_assert (gdbarch != NULL);
3010   /* Skip verify of ps_regnum, invalid_p == 0 */
3011   if (gdbarch_debug >= 2)
3012     fprintf_unfiltered (gdb_stdlog, "gdbarch_ps_regnum called\n");
3013   return gdbarch->ps_regnum;
3014 }
3015
3016 void
3017 set_gdbarch_ps_regnum (struct gdbarch *gdbarch,
3018                        int ps_regnum)
3019 {
3020   gdbarch->ps_regnum = ps_regnum;
3021 }
3022
3023 int
3024 gdbarch_fp0_regnum (struct gdbarch *gdbarch)
3025 {
3026   gdb_assert (gdbarch != NULL);
3027   /* Skip verify of fp0_regnum, invalid_p == 0 */
3028   if (gdbarch_debug >= 2)
3029     fprintf_unfiltered (gdb_stdlog, "gdbarch_fp0_regnum called\n");
3030   return gdbarch->fp0_regnum;
3031 }
3032
3033 void
3034 set_gdbarch_fp0_regnum (struct gdbarch *gdbarch,
3035                         int fp0_regnum)
3036 {
3037   gdbarch->fp0_regnum = fp0_regnum;
3038 }
3039
3040 int
3041 gdbarch_npc_regnum (struct gdbarch *gdbarch)
3042 {
3043   gdb_assert (gdbarch != NULL);
3044   /* Skip verify of npc_regnum, invalid_p == 0 */
3045   if (gdbarch_debug >= 2)
3046     fprintf_unfiltered (gdb_stdlog, "gdbarch_npc_regnum called\n");
3047   return gdbarch->npc_regnum;
3048 }
3049
3050 void
3051 set_gdbarch_npc_regnum (struct gdbarch *gdbarch,
3052                         int npc_regnum)
3053 {
3054   gdbarch->npc_regnum = npc_regnum;
3055 }
3056
3057 int
3058 gdbarch_stab_reg_to_regnum (struct gdbarch *gdbarch, int stab_regnr)
3059 {
3060   gdb_assert (gdbarch != NULL);
3061   if (gdbarch->stab_reg_to_regnum == 0)
3062     internal_error (__FILE__, __LINE__,
3063                     "gdbarch: gdbarch_stab_reg_to_regnum invalid");
3064   if (gdbarch_debug >= 2)
3065     fprintf_unfiltered (gdb_stdlog, "gdbarch_stab_reg_to_regnum called\n");
3066   return gdbarch->stab_reg_to_regnum (stab_regnr);
3067 }
3068
3069 void
3070 set_gdbarch_stab_reg_to_regnum (struct gdbarch *gdbarch,
3071                                 gdbarch_stab_reg_to_regnum_ftype stab_reg_to_regnum)
3072 {
3073   gdbarch->stab_reg_to_regnum = stab_reg_to_regnum;
3074 }
3075
3076 int
3077 gdbarch_ecoff_reg_to_regnum (struct gdbarch *gdbarch, int ecoff_regnr)
3078 {
3079   gdb_assert (gdbarch != NULL);
3080   if (gdbarch->ecoff_reg_to_regnum == 0)
3081     internal_error (__FILE__, __LINE__,
3082                     "gdbarch: gdbarch_ecoff_reg_to_regnum invalid");
3083   if (gdbarch_debug >= 2)
3084     fprintf_unfiltered (gdb_stdlog, "gdbarch_ecoff_reg_to_regnum called\n");
3085   return gdbarch->ecoff_reg_to_regnum (ecoff_regnr);
3086 }
3087
3088 void
3089 set_gdbarch_ecoff_reg_to_regnum (struct gdbarch *gdbarch,
3090                                  gdbarch_ecoff_reg_to_regnum_ftype ecoff_reg_to_regnum)
3091 {
3092   gdbarch->ecoff_reg_to_regnum = ecoff_reg_to_regnum;
3093 }
3094
3095 int
3096 gdbarch_dwarf_reg_to_regnum (struct gdbarch *gdbarch, int dwarf_regnr)
3097 {
3098   gdb_assert (gdbarch != NULL);
3099   if (gdbarch->dwarf_reg_to_regnum == 0)
3100     internal_error (__FILE__, __LINE__,
3101                     "gdbarch: gdbarch_dwarf_reg_to_regnum invalid");
3102   if (gdbarch_debug >= 2)
3103     fprintf_unfiltered (gdb_stdlog, "gdbarch_dwarf_reg_to_regnum called\n");
3104   return gdbarch->dwarf_reg_to_regnum (dwarf_regnr);
3105 }
3106
3107 void
3108 set_gdbarch_dwarf_reg_to_regnum (struct gdbarch *gdbarch,
3109                                  gdbarch_dwarf_reg_to_regnum_ftype dwarf_reg_to_regnum)
3110 {
3111   gdbarch->dwarf_reg_to_regnum = dwarf_reg_to_regnum;
3112 }
3113
3114 int
3115 gdbarch_sdb_reg_to_regnum (struct gdbarch *gdbarch, int sdb_regnr)
3116 {
3117   gdb_assert (gdbarch != NULL);
3118   if (gdbarch->sdb_reg_to_regnum == 0)
3119     internal_error (__FILE__, __LINE__,
3120                     "gdbarch: gdbarch_sdb_reg_to_regnum invalid");
3121   if (gdbarch_debug >= 2)
3122     fprintf_unfiltered (gdb_stdlog, "gdbarch_sdb_reg_to_regnum called\n");
3123   return gdbarch->sdb_reg_to_regnum (sdb_regnr);
3124 }
3125
3126 void
3127 set_gdbarch_sdb_reg_to_regnum (struct gdbarch *gdbarch,
3128                                gdbarch_sdb_reg_to_regnum_ftype sdb_reg_to_regnum)
3129 {
3130   gdbarch->sdb_reg_to_regnum = sdb_reg_to_regnum;
3131 }
3132
3133 int
3134 gdbarch_dwarf2_reg_to_regnum (struct gdbarch *gdbarch, int dwarf2_regnr)
3135 {
3136   gdb_assert (gdbarch != NULL);
3137   if (gdbarch->dwarf2_reg_to_regnum == 0)
3138     internal_error (__FILE__, __LINE__,
3139                     "gdbarch: gdbarch_dwarf2_reg_to_regnum invalid");
3140   if (gdbarch_debug >= 2)
3141     fprintf_unfiltered (gdb_stdlog, "gdbarch_dwarf2_reg_to_regnum called\n");
3142   return gdbarch->dwarf2_reg_to_regnum (dwarf2_regnr);
3143 }
3144
3145 void
3146 set_gdbarch_dwarf2_reg_to_regnum (struct gdbarch *gdbarch,
3147                                   gdbarch_dwarf2_reg_to_regnum_ftype dwarf2_reg_to_regnum)
3148 {
3149   gdbarch->dwarf2_reg_to_regnum = dwarf2_reg_to_regnum;
3150 }
3151
3152 const char *
3153 gdbarch_register_name (struct gdbarch *gdbarch, int regnr)
3154 {
3155   gdb_assert (gdbarch != NULL);
3156   if (gdbarch->register_name == 0)
3157     internal_error (__FILE__, __LINE__,
3158                     "gdbarch: gdbarch_register_name invalid");
3159   if (gdbarch_debug >= 2)
3160     fprintf_unfiltered (gdb_stdlog, "gdbarch_register_name called\n");
3161   return gdbarch->register_name (regnr);
3162 }
3163
3164 void
3165 set_gdbarch_register_name (struct gdbarch *gdbarch,
3166                            gdbarch_register_name_ftype register_name)
3167 {
3168   gdbarch->register_name = register_name;
3169 }
3170
3171 int
3172 gdbarch_register_size (struct gdbarch *gdbarch)
3173 {
3174   gdb_assert (gdbarch != NULL);
3175   if (gdbarch->register_size == -1)
3176     internal_error (__FILE__, __LINE__,
3177                     "gdbarch: gdbarch_register_size invalid");
3178   if (gdbarch_debug >= 2)
3179     fprintf_unfiltered (gdb_stdlog, "gdbarch_register_size called\n");
3180   return gdbarch->register_size;
3181 }
3182
3183 void
3184 set_gdbarch_register_size (struct gdbarch *gdbarch,
3185                            int register_size)
3186 {
3187   gdbarch->register_size = register_size;
3188 }
3189
3190 int
3191 gdbarch_register_bytes (struct gdbarch *gdbarch)
3192 {
3193   gdb_assert (gdbarch != NULL);
3194   if (gdbarch->register_bytes == -1)
3195     internal_error (__FILE__, __LINE__,
3196                     "gdbarch: gdbarch_register_bytes invalid");
3197   if (gdbarch_debug >= 2)
3198     fprintf_unfiltered (gdb_stdlog, "gdbarch_register_bytes called\n");
3199   return gdbarch->register_bytes;
3200 }
3201
3202 void
3203 set_gdbarch_register_bytes (struct gdbarch *gdbarch,
3204                             int register_bytes)
3205 {
3206   gdbarch->register_bytes = register_bytes;
3207 }
3208
3209 int
3210 gdbarch_register_byte (struct gdbarch *gdbarch, int reg_nr)
3211 {
3212   gdb_assert (gdbarch != NULL);
3213   if (gdbarch->register_byte == 0)
3214     internal_error (__FILE__, __LINE__,
3215                     "gdbarch: gdbarch_register_byte invalid");
3216   if (gdbarch_debug >= 2)
3217     fprintf_unfiltered (gdb_stdlog, "gdbarch_register_byte called\n");
3218   return gdbarch->register_byte (reg_nr);
3219 }
3220
3221 void
3222 set_gdbarch_register_byte (struct gdbarch *gdbarch,
3223                            gdbarch_register_byte_ftype register_byte)
3224 {
3225   gdbarch->register_byte = register_byte;
3226 }
3227
3228 int
3229 gdbarch_register_raw_size (struct gdbarch *gdbarch, int reg_nr)
3230 {
3231   gdb_assert (gdbarch != NULL);
3232   if (gdbarch->register_raw_size == 0)
3233     internal_error (__FILE__, __LINE__,
3234                     "gdbarch: gdbarch_register_raw_size invalid");
3235   if (gdbarch_debug >= 2)
3236     fprintf_unfiltered (gdb_stdlog, "gdbarch_register_raw_size called\n");
3237   return gdbarch->register_raw_size (reg_nr);
3238 }
3239
3240 void
3241 set_gdbarch_register_raw_size (struct gdbarch *gdbarch,
3242                                gdbarch_register_raw_size_ftype register_raw_size)
3243 {
3244   gdbarch->register_raw_size = register_raw_size;
3245 }
3246
3247 int
3248 gdbarch_max_register_raw_size (struct gdbarch *gdbarch)
3249 {
3250   gdb_assert (gdbarch != NULL);
3251   if (gdbarch->max_register_raw_size == -1)
3252     internal_error (__FILE__, __LINE__,
3253                     "gdbarch: gdbarch_max_register_raw_size invalid");
3254   if (gdbarch_debug >= 2)
3255     fprintf_unfiltered (gdb_stdlog, "gdbarch_max_register_raw_size called\n");
3256   return gdbarch->max_register_raw_size;
3257 }
3258
3259 void
3260 set_gdbarch_max_register_raw_size (struct gdbarch *gdbarch,
3261                                    int max_register_raw_size)
3262 {
3263   gdbarch->max_register_raw_size = max_register_raw_size;
3264 }
3265
3266 int
3267 gdbarch_register_virtual_size (struct gdbarch *gdbarch, int reg_nr)
3268 {
3269   gdb_assert (gdbarch != NULL);
3270   if (gdbarch->register_virtual_size == 0)
3271     internal_error (__FILE__, __LINE__,
3272                     "gdbarch: gdbarch_register_virtual_size invalid");
3273   if (gdbarch_debug >= 2)
3274     fprintf_unfiltered (gdb_stdlog, "gdbarch_register_virtual_size called\n");
3275   return gdbarch->register_virtual_size (reg_nr);
3276 }
3277
3278 void
3279 set_gdbarch_register_virtual_size (struct gdbarch *gdbarch,
3280                                    gdbarch_register_virtual_size_ftype register_virtual_size)
3281 {
3282   gdbarch->register_virtual_size = register_virtual_size;
3283 }
3284
3285 int
3286 gdbarch_max_register_virtual_size (struct gdbarch *gdbarch)
3287 {
3288   gdb_assert (gdbarch != NULL);
3289   if (gdbarch->max_register_virtual_size == -1)
3290     internal_error (__FILE__, __LINE__,
3291                     "gdbarch: gdbarch_max_register_virtual_size invalid");
3292   if (gdbarch_debug >= 2)
3293     fprintf_unfiltered (gdb_stdlog, "gdbarch_max_register_virtual_size called\n");
3294   return gdbarch->max_register_virtual_size;
3295 }
3296
3297 void
3298 set_gdbarch_max_register_virtual_size (struct gdbarch *gdbarch,
3299                                        int max_register_virtual_size)
3300 {
3301   gdbarch->max_register_virtual_size = max_register_virtual_size;
3302 }
3303
3304 struct type *
3305 gdbarch_register_virtual_type (struct gdbarch *gdbarch, int reg_nr)
3306 {
3307   gdb_assert (gdbarch != NULL);
3308   if (gdbarch->register_virtual_type == 0)
3309     internal_error (__FILE__, __LINE__,
3310                     "gdbarch: gdbarch_register_virtual_type invalid");
3311   if (gdbarch_debug >= 2)
3312     fprintf_unfiltered (gdb_stdlog, "gdbarch_register_virtual_type called\n");
3313   return gdbarch->register_virtual_type (reg_nr);
3314 }
3315
3316 void
3317 set_gdbarch_register_virtual_type (struct gdbarch *gdbarch,
3318                                    gdbarch_register_virtual_type_ftype register_virtual_type)
3319 {
3320   gdbarch->register_virtual_type = register_virtual_type;
3321 }
3322
3323 int
3324 gdbarch_deprecated_do_registers_info_p (struct gdbarch *gdbarch)
3325 {
3326   gdb_assert (gdbarch != NULL);
3327   return gdbarch->deprecated_do_registers_info != 0;
3328 }
3329
3330 void
3331 gdbarch_deprecated_do_registers_info (struct gdbarch *gdbarch, int reg_nr, int fpregs)
3332 {
3333   gdb_assert (gdbarch != NULL);
3334   if (gdbarch->deprecated_do_registers_info == 0)
3335     internal_error (__FILE__, __LINE__,
3336                     "gdbarch: gdbarch_deprecated_do_registers_info invalid");
3337   if (gdbarch_debug >= 2)
3338     fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_do_registers_info called\n");
3339   gdbarch->deprecated_do_registers_info (reg_nr, fpregs);
3340 }
3341
3342 void
3343 set_gdbarch_deprecated_do_registers_info (struct gdbarch *gdbarch,
3344                                           gdbarch_deprecated_do_registers_info_ftype deprecated_do_registers_info)
3345 {
3346   gdbarch->deprecated_do_registers_info = deprecated_do_registers_info;
3347 }
3348
3349 void
3350 gdbarch_print_registers_info (struct gdbarch *gdbarch, struct ui_file *file, struct frame_info *frame, int regnum, int all)
3351 {
3352   gdb_assert (gdbarch != NULL);
3353   if (gdbarch->print_registers_info == 0)
3354     internal_error (__FILE__, __LINE__,
3355                     "gdbarch: gdbarch_print_registers_info invalid");
3356   if (gdbarch_debug >= 2)
3357     fprintf_unfiltered (gdb_stdlog, "gdbarch_print_registers_info called\n");
3358   gdbarch->print_registers_info (gdbarch, file, frame, regnum, all);
3359 }
3360
3361 void
3362 set_gdbarch_print_registers_info (struct gdbarch *gdbarch,
3363                                   gdbarch_print_registers_info_ftype print_registers_info)
3364 {
3365   gdbarch->print_registers_info = print_registers_info;
3366 }
3367
3368 int
3369 gdbarch_print_float_info_p (struct gdbarch *gdbarch)
3370 {
3371   gdb_assert (gdbarch != NULL);
3372   return gdbarch->print_float_info != 0;
3373 }
3374
3375 void
3376 gdbarch_print_float_info (struct gdbarch *gdbarch, struct ui_file *file, struct frame_info *frame, const char *args)
3377 {
3378   gdb_assert (gdbarch != NULL);
3379   if (gdbarch->print_float_info == 0)
3380     internal_error (__FILE__, __LINE__,
3381                     "gdbarch: gdbarch_print_float_info invalid");
3382   if (gdbarch_debug >= 2)
3383     fprintf_unfiltered (gdb_stdlog, "gdbarch_print_float_info called\n");
3384   gdbarch->print_float_info (gdbarch, file, frame, args);
3385 }
3386
3387 void
3388 set_gdbarch_print_float_info (struct gdbarch *gdbarch,
3389                               gdbarch_print_float_info_ftype print_float_info)
3390 {
3391   gdbarch->print_float_info = print_float_info;
3392 }
3393
3394 int
3395 gdbarch_print_vector_info_p (struct gdbarch *gdbarch)
3396 {
3397   gdb_assert (gdbarch != NULL);
3398   return gdbarch->print_vector_info != 0;
3399 }
3400
3401 void
3402 gdbarch_print_vector_info (struct gdbarch *gdbarch, struct ui_file *file, struct frame_info *frame, const char *args)
3403 {
3404   gdb_assert (gdbarch != NULL);
3405   if (gdbarch->print_vector_info == 0)
3406     internal_error (__FILE__, __LINE__,
3407                     "gdbarch: gdbarch_print_vector_info invalid");
3408   if (gdbarch_debug >= 2)
3409     fprintf_unfiltered (gdb_stdlog, "gdbarch_print_vector_info called\n");
3410   gdbarch->print_vector_info (gdbarch, file, frame, args);
3411 }
3412
3413 void
3414 set_gdbarch_print_vector_info (struct gdbarch *gdbarch,
3415                                gdbarch_print_vector_info_ftype print_vector_info)
3416 {
3417   gdbarch->print_vector_info = print_vector_info;
3418 }
3419
3420 int
3421 gdbarch_register_sim_regno (struct gdbarch *gdbarch, int reg_nr)
3422 {
3423   gdb_assert (gdbarch != NULL);
3424   if (gdbarch->register_sim_regno == 0)
3425     internal_error (__FILE__, __LINE__,
3426                     "gdbarch: gdbarch_register_sim_regno invalid");
3427   if (gdbarch_debug >= 2)
3428     fprintf_unfiltered (gdb_stdlog, "gdbarch_register_sim_regno called\n");
3429   return gdbarch->register_sim_regno (reg_nr);
3430 }
3431
3432 void
3433 set_gdbarch_register_sim_regno (struct gdbarch *gdbarch,
3434                                 gdbarch_register_sim_regno_ftype register_sim_regno)
3435 {
3436   gdbarch->register_sim_regno = register_sim_regno;
3437 }
3438
3439 int
3440 gdbarch_register_bytes_ok_p (struct gdbarch *gdbarch)
3441 {
3442   gdb_assert (gdbarch != NULL);
3443   return gdbarch->register_bytes_ok != 0;
3444 }
3445
3446 int
3447 gdbarch_register_bytes_ok (struct gdbarch *gdbarch, long nr_bytes)
3448 {
3449   gdb_assert (gdbarch != NULL);
3450   if (gdbarch->register_bytes_ok == 0)
3451     internal_error (__FILE__, __LINE__,
3452                     "gdbarch: gdbarch_register_bytes_ok invalid");
3453   if (gdbarch_debug >= 2)
3454     fprintf_unfiltered (gdb_stdlog, "gdbarch_register_bytes_ok called\n");
3455   return gdbarch->register_bytes_ok (nr_bytes);
3456 }
3457
3458 void
3459 set_gdbarch_register_bytes_ok (struct gdbarch *gdbarch,
3460                                gdbarch_register_bytes_ok_ftype register_bytes_ok)
3461 {
3462   gdbarch->register_bytes_ok = register_bytes_ok;
3463 }
3464
3465 int
3466 gdbarch_cannot_fetch_register (struct gdbarch *gdbarch, int regnum)
3467 {
3468   gdb_assert (gdbarch != NULL);
3469   if (gdbarch->cannot_fetch_register == 0)
3470     internal_error (__FILE__, __LINE__,
3471                     "gdbarch: gdbarch_cannot_fetch_register invalid");
3472   if (gdbarch_debug >= 2)
3473     fprintf_unfiltered (gdb_stdlog, "gdbarch_cannot_fetch_register called\n");
3474   return gdbarch->cannot_fetch_register (regnum);
3475 }
3476
3477 void
3478 set_gdbarch_cannot_fetch_register (struct gdbarch *gdbarch,
3479                                    gdbarch_cannot_fetch_register_ftype cannot_fetch_register)
3480 {
3481   gdbarch->cannot_fetch_register = cannot_fetch_register;
3482 }
3483
3484 int
3485 gdbarch_cannot_store_register (struct gdbarch *gdbarch, int regnum)
3486 {
3487   gdb_assert (gdbarch != NULL);
3488   if (gdbarch->cannot_store_register == 0)
3489     internal_error (__FILE__, __LINE__,
3490                     "gdbarch: gdbarch_cannot_store_register invalid");
3491   if (gdbarch_debug >= 2)
3492     fprintf_unfiltered (gdb_stdlog, "gdbarch_cannot_store_register called\n");
3493   return gdbarch->cannot_store_register (regnum);
3494 }
3495
3496 void
3497 set_gdbarch_cannot_store_register (struct gdbarch *gdbarch,
3498                                    gdbarch_cannot_store_register_ftype cannot_store_register)
3499 {
3500   gdbarch->cannot_store_register = cannot_store_register;
3501 }
3502
3503 int
3504 gdbarch_get_longjmp_target_p (struct gdbarch *gdbarch)
3505 {
3506   gdb_assert (gdbarch != NULL);
3507   return gdbarch->get_longjmp_target != 0;
3508 }
3509
3510 int
3511 gdbarch_get_longjmp_target (struct gdbarch *gdbarch, CORE_ADDR *pc)
3512 {
3513   gdb_assert (gdbarch != NULL);
3514   if (gdbarch->get_longjmp_target == 0)
3515     internal_error (__FILE__, __LINE__,
3516                     "gdbarch: gdbarch_get_longjmp_target invalid");
3517   if (gdbarch_debug >= 2)
3518     fprintf_unfiltered (gdb_stdlog, "gdbarch_get_longjmp_target called\n");
3519   return gdbarch->get_longjmp_target (pc);
3520 }
3521
3522 void
3523 set_gdbarch_get_longjmp_target (struct gdbarch *gdbarch,
3524                                 gdbarch_get_longjmp_target_ftype get_longjmp_target)
3525 {
3526   gdbarch->get_longjmp_target = get_longjmp_target;
3527 }
3528
3529 int
3530 gdbarch_deprecated_use_generic_dummy_frames (struct gdbarch *gdbarch)
3531 {
3532   gdb_assert (gdbarch != NULL);
3533   /* Skip verify of deprecated_use_generic_dummy_frames, invalid_p == 0 */
3534   if (gdbarch_debug >= 2)
3535     fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_use_generic_dummy_frames called\n");
3536   return gdbarch->deprecated_use_generic_dummy_frames;
3537 }
3538
3539 void
3540 set_gdbarch_deprecated_use_generic_dummy_frames (struct gdbarch *gdbarch,
3541                                                  int deprecated_use_generic_dummy_frames)
3542 {
3543   gdbarch->deprecated_use_generic_dummy_frames = deprecated_use_generic_dummy_frames;
3544 }
3545
3546 int
3547 gdbarch_call_dummy_location (struct gdbarch *gdbarch)
3548 {
3549   gdb_assert (gdbarch != NULL);
3550   /* Skip verify of call_dummy_location, invalid_p == 0 */
3551   if (gdbarch_debug >= 2)
3552     fprintf_unfiltered (gdb_stdlog, "gdbarch_call_dummy_location called\n");
3553   return gdbarch->call_dummy_location;
3554 }
3555
3556 void
3557 set_gdbarch_call_dummy_location (struct gdbarch *gdbarch,
3558                                  int call_dummy_location)
3559 {
3560   gdbarch->call_dummy_location = call_dummy_location;
3561 }
3562
3563 CORE_ADDR
3564 gdbarch_call_dummy_address (struct gdbarch *gdbarch)
3565 {
3566   gdb_assert (gdbarch != NULL);
3567   if (gdbarch->call_dummy_address == 0)
3568     internal_error (__FILE__, __LINE__,
3569                     "gdbarch: gdbarch_call_dummy_address invalid");
3570   if (gdbarch_debug >= 2)
3571     fprintf_unfiltered (gdb_stdlog, "gdbarch_call_dummy_address called\n");
3572   return gdbarch->call_dummy_address ();
3573 }
3574
3575 void
3576 set_gdbarch_call_dummy_address (struct gdbarch *gdbarch,
3577                                 gdbarch_call_dummy_address_ftype call_dummy_address)
3578 {
3579   gdbarch->call_dummy_address = call_dummy_address;
3580 }
3581
3582 CORE_ADDR
3583 gdbarch_call_dummy_start_offset (struct gdbarch *gdbarch)
3584 {
3585   gdb_assert (gdbarch != NULL);
3586   if (gdbarch->call_dummy_start_offset == -1)
3587     internal_error (__FILE__, __LINE__,
3588                     "gdbarch: gdbarch_call_dummy_start_offset invalid");
3589   if (gdbarch_debug >= 2)
3590     fprintf_unfiltered (gdb_stdlog, "gdbarch_call_dummy_start_offset called\n");
3591   return gdbarch->call_dummy_start_offset;
3592 }
3593
3594 void
3595 set_gdbarch_call_dummy_start_offset (struct gdbarch *gdbarch,
3596                                      CORE_ADDR call_dummy_start_offset)
3597 {
3598   gdbarch->call_dummy_start_offset = call_dummy_start_offset;
3599 }
3600
3601 CORE_ADDR
3602 gdbarch_call_dummy_breakpoint_offset (struct gdbarch *gdbarch)
3603 {
3604   gdb_assert (gdbarch != NULL);
3605   if (gdbarch->call_dummy_breakpoint_offset_p && gdbarch->call_dummy_breakpoint_offset == -1)
3606     internal_error (__FILE__, __LINE__,
3607                     "gdbarch: gdbarch_call_dummy_breakpoint_offset invalid");
3608   if (gdbarch_debug >= 2)
3609     fprintf_unfiltered (gdb_stdlog, "gdbarch_call_dummy_breakpoint_offset called\n");
3610   return gdbarch->call_dummy_breakpoint_offset;
3611 }
3612
3613 void
3614 set_gdbarch_call_dummy_breakpoint_offset (struct gdbarch *gdbarch,
3615                                           CORE_ADDR call_dummy_breakpoint_offset)
3616 {
3617   gdbarch->call_dummy_breakpoint_offset = call_dummy_breakpoint_offset;
3618 }
3619
3620 int
3621 gdbarch_call_dummy_breakpoint_offset_p (struct gdbarch *gdbarch)
3622 {
3623   gdb_assert (gdbarch != NULL);
3624   if (gdbarch->call_dummy_breakpoint_offset_p == -1)
3625     internal_error (__FILE__, __LINE__,
3626                     "gdbarch: gdbarch_call_dummy_breakpoint_offset_p invalid");
3627   if (gdbarch_debug >= 2)
3628     fprintf_unfiltered (gdb_stdlog, "gdbarch_call_dummy_breakpoint_offset_p called\n");
3629   return gdbarch->call_dummy_breakpoint_offset_p;
3630 }
3631
3632 void
3633 set_gdbarch_call_dummy_breakpoint_offset_p (struct gdbarch *gdbarch,
3634                                             int call_dummy_breakpoint_offset_p)
3635 {
3636   gdbarch->call_dummy_breakpoint_offset_p = call_dummy_breakpoint_offset_p;
3637 }
3638
3639 int
3640 gdbarch_call_dummy_length (struct gdbarch *gdbarch)
3641 {
3642   gdb_assert (gdbarch != NULL);
3643   if (gdbarch->call_dummy_length == -1)
3644     internal_error (__FILE__, __LINE__,
3645                     "gdbarch: gdbarch_call_dummy_length invalid");
3646   if (gdbarch_debug >= 2)
3647     fprintf_unfiltered (gdb_stdlog, "gdbarch_call_dummy_length called\n");
3648   return gdbarch->call_dummy_length;
3649 }
3650
3651 void
3652 set_gdbarch_call_dummy_length (struct gdbarch *gdbarch,
3653                                int call_dummy_length)
3654 {
3655   gdbarch->call_dummy_length = call_dummy_length;
3656 }
3657
3658 int
3659 gdbarch_deprecated_pc_in_call_dummy_p (struct gdbarch *gdbarch)
3660 {
3661   gdb_assert (gdbarch != NULL);
3662   return gdbarch->deprecated_pc_in_call_dummy != generic_pc_in_call_dummy;
3663 }
3664
3665 int
3666 gdbarch_deprecated_pc_in_call_dummy (struct gdbarch *gdbarch, CORE_ADDR pc, CORE_ADDR sp, CORE_ADDR frame_address)
3667 {
3668   gdb_assert (gdbarch != NULL);
3669   if (gdbarch->deprecated_pc_in_call_dummy == 0)
3670     internal_error (__FILE__, __LINE__,
3671                     "gdbarch: gdbarch_deprecated_pc_in_call_dummy invalid");
3672   /* Ignore predicate (gdbarch->deprecated_pc_in_call_dummy != generic_pc_in_call_dummy).  */
3673   if (gdbarch_debug >= 2)
3674     fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_pc_in_call_dummy called\n");
3675   return gdbarch->deprecated_pc_in_call_dummy (pc, sp, frame_address);
3676 }
3677
3678 void
3679 set_gdbarch_deprecated_pc_in_call_dummy (struct gdbarch *gdbarch,
3680                                          gdbarch_deprecated_pc_in_call_dummy_ftype deprecated_pc_in_call_dummy)
3681 {
3682   gdbarch->deprecated_pc_in_call_dummy = deprecated_pc_in_call_dummy;
3683 }
3684
3685 int
3686 gdbarch_call_dummy_p (struct gdbarch *gdbarch)
3687 {
3688   gdb_assert (gdbarch != NULL);
3689   if (gdbarch->call_dummy_p == -1)
3690     internal_error (__FILE__, __LINE__,
3691                     "gdbarch: gdbarch_call_dummy_p invalid");
3692   if (gdbarch_debug >= 2)
3693     fprintf_unfiltered (gdb_stdlog, "gdbarch_call_dummy_p called\n");
3694   return gdbarch->call_dummy_p;
3695 }
3696
3697 void
3698 set_gdbarch_call_dummy_p (struct gdbarch *gdbarch,
3699                           int call_dummy_p)
3700 {
3701   gdbarch->call_dummy_p = call_dummy_p;
3702 }
3703
3704 LONGEST *
3705 gdbarch_call_dummy_words (struct gdbarch *gdbarch)
3706 {
3707   gdb_assert (gdbarch != NULL);
3708   /* Skip verify of call_dummy_words, invalid_p == 0 */
3709   if (gdbarch_debug >= 2)
3710     fprintf_unfiltered (gdb_stdlog, "gdbarch_call_dummy_words called\n");
3711   return gdbarch->call_dummy_words;
3712 }
3713
3714 void
3715 set_gdbarch_call_dummy_words (struct gdbarch *gdbarch,
3716                               LONGEST * call_dummy_words)
3717 {
3718   gdbarch->call_dummy_words = call_dummy_words;
3719 }
3720
3721 int
3722 gdbarch_sizeof_call_dummy_words (struct gdbarch *gdbarch)
3723 {
3724   gdb_assert (gdbarch != NULL);
3725   /* Skip verify of sizeof_call_dummy_words, invalid_p == 0 */
3726   if (gdbarch_debug >= 2)
3727     fprintf_unfiltered (gdb_stdlog, "gdbarch_sizeof_call_dummy_words called\n");
3728   return gdbarch->sizeof_call_dummy_words;
3729 }
3730
3731 void
3732 set_gdbarch_sizeof_call_dummy_words (struct gdbarch *gdbarch,
3733                                      int sizeof_call_dummy_words)
3734 {
3735   gdbarch->sizeof_call_dummy_words = sizeof_call_dummy_words;
3736 }
3737
3738 int
3739 gdbarch_call_dummy_stack_adjust_p (struct gdbarch *gdbarch)
3740 {
3741   gdb_assert (gdbarch != NULL);
3742   if (gdbarch->call_dummy_stack_adjust_p == -1)
3743     internal_error (__FILE__, __LINE__,
3744                     "gdbarch: gdbarch_call_dummy_stack_adjust_p invalid");
3745   if (gdbarch_debug >= 2)
3746     fprintf_unfiltered (gdb_stdlog, "gdbarch_call_dummy_stack_adjust_p called\n");
3747   return gdbarch->call_dummy_stack_adjust_p;
3748 }
3749
3750 void
3751 set_gdbarch_call_dummy_stack_adjust_p (struct gdbarch *gdbarch,
3752                                        int call_dummy_stack_adjust_p)
3753 {
3754   gdbarch->call_dummy_stack_adjust_p = call_dummy_stack_adjust_p;
3755 }
3756
3757 int
3758 gdbarch_call_dummy_stack_adjust (struct gdbarch *gdbarch)
3759 {
3760   gdb_assert (gdbarch != NULL);
3761   if (gdbarch->call_dummy_stack_adjust_p && gdbarch->call_dummy_stack_adjust == 0)
3762     internal_error (__FILE__, __LINE__,
3763                     "gdbarch: gdbarch_call_dummy_stack_adjust invalid");
3764   if (gdbarch_debug >= 2)
3765     fprintf_unfiltered (gdb_stdlog, "gdbarch_call_dummy_stack_adjust called\n");
3766   return gdbarch->call_dummy_stack_adjust;
3767 }
3768
3769 void
3770 set_gdbarch_call_dummy_stack_adjust (struct gdbarch *gdbarch,
3771                                      int call_dummy_stack_adjust)
3772 {
3773   gdbarch->call_dummy_stack_adjust = call_dummy_stack_adjust;
3774 }
3775
3776 void
3777 gdbarch_fix_call_dummy (struct gdbarch *gdbarch, char *dummy, CORE_ADDR pc, CORE_ADDR fun, int nargs, struct value **args, struct type *type, int gcc_p)
3778 {
3779   gdb_assert (gdbarch != NULL);
3780   if (gdbarch->fix_call_dummy == 0)
3781     internal_error (__FILE__, __LINE__,
3782                     "gdbarch: gdbarch_fix_call_dummy invalid");
3783   if (gdbarch_debug >= 2)
3784     fprintf_unfiltered (gdb_stdlog, "gdbarch_fix_call_dummy called\n");
3785   gdbarch->fix_call_dummy (dummy, pc, fun, nargs, args, type, gcc_p);
3786 }
3787
3788 void
3789 set_gdbarch_fix_call_dummy (struct gdbarch *gdbarch,
3790                             gdbarch_fix_call_dummy_ftype fix_call_dummy)
3791 {
3792   gdbarch->fix_call_dummy = fix_call_dummy;
3793 }
3794
3795 int
3796 gdbarch_deprecated_init_frame_pc_first_p (struct gdbarch *gdbarch)
3797 {
3798   gdb_assert (gdbarch != NULL);
3799   return gdbarch->deprecated_init_frame_pc_first != 0;
3800 }
3801
3802 CORE_ADDR
3803 gdbarch_deprecated_init_frame_pc_first (struct gdbarch *gdbarch, int fromleaf, struct frame_info *prev)
3804 {
3805   gdb_assert (gdbarch != NULL);
3806   if (gdbarch->deprecated_init_frame_pc_first == 0)
3807     internal_error (__FILE__, __LINE__,
3808                     "gdbarch: gdbarch_deprecated_init_frame_pc_first invalid");
3809   if (gdbarch_debug >= 2)
3810     fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_init_frame_pc_first called\n");
3811   return gdbarch->deprecated_init_frame_pc_first (fromleaf, prev);
3812 }
3813
3814 void
3815 set_gdbarch_deprecated_init_frame_pc_first (struct gdbarch *gdbarch,
3816                                             gdbarch_deprecated_init_frame_pc_first_ftype deprecated_init_frame_pc_first)
3817 {
3818   gdbarch->deprecated_init_frame_pc_first = deprecated_init_frame_pc_first;
3819 }
3820
3821 int
3822 gdbarch_deprecated_init_frame_pc_p (struct gdbarch *gdbarch)
3823 {
3824   gdb_assert (gdbarch != NULL);
3825   return gdbarch->deprecated_init_frame_pc != 0;
3826 }
3827
3828 CORE_ADDR
3829 gdbarch_deprecated_init_frame_pc (struct gdbarch *gdbarch, int fromleaf, struct frame_info *prev)
3830 {
3831   gdb_assert (gdbarch != NULL);
3832   if (gdbarch->deprecated_init_frame_pc == 0)
3833     internal_error (__FILE__, __LINE__,
3834                     "gdbarch: gdbarch_deprecated_init_frame_pc invalid");
3835   if (gdbarch_debug >= 2)
3836     fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_init_frame_pc called\n");
3837   return gdbarch->deprecated_init_frame_pc (fromleaf, prev);
3838 }
3839
3840 void
3841 set_gdbarch_deprecated_init_frame_pc (struct gdbarch *gdbarch,
3842                                       gdbarch_deprecated_init_frame_pc_ftype deprecated_init_frame_pc)
3843 {
3844   gdbarch->deprecated_init_frame_pc = deprecated_init_frame_pc;
3845 }
3846
3847 int
3848 gdbarch_believe_pcc_promotion (struct gdbarch *gdbarch)
3849 {
3850   gdb_assert (gdbarch != NULL);
3851   if (gdbarch_debug >= 2)
3852     fprintf_unfiltered (gdb_stdlog, "gdbarch_believe_pcc_promotion called\n");
3853   return gdbarch->believe_pcc_promotion;
3854 }
3855
3856 void
3857 set_gdbarch_believe_pcc_promotion (struct gdbarch *gdbarch,
3858                                    int believe_pcc_promotion)
3859 {
3860   gdbarch->believe_pcc_promotion = believe_pcc_promotion;
3861 }
3862
3863 int
3864 gdbarch_believe_pcc_promotion_type (struct gdbarch *gdbarch)
3865 {
3866   gdb_assert (gdbarch != NULL);
3867   if (gdbarch_debug >= 2)
3868     fprintf_unfiltered (gdb_stdlog, "gdbarch_believe_pcc_promotion_type called\n");
3869   return gdbarch->believe_pcc_promotion_type;
3870 }
3871
3872 void
3873 set_gdbarch_believe_pcc_promotion_type (struct gdbarch *gdbarch,
3874                                         int believe_pcc_promotion_type)
3875 {
3876   gdbarch->believe_pcc_promotion_type = believe_pcc_promotion_type;
3877 }
3878
3879 int
3880 gdbarch_get_saved_register_p (struct gdbarch *gdbarch)
3881 {
3882   gdb_assert (gdbarch != NULL);
3883   return gdbarch->get_saved_register != 0;
3884 }
3885
3886 void
3887 gdbarch_get_saved_register (struct gdbarch *gdbarch, char *raw_buffer, int *optimized, CORE_ADDR *addrp, struct frame_info *frame, int regnum, enum lval_type *lval)
3888 {
3889   gdb_assert (gdbarch != NULL);
3890   if (gdbarch->get_saved_register == 0)
3891     internal_error (__FILE__, __LINE__,
3892                     "gdbarch: gdbarch_get_saved_register invalid");
3893   if (gdbarch_debug >= 2)
3894     fprintf_unfiltered (gdb_stdlog, "gdbarch_get_saved_register called\n");
3895   gdbarch->get_saved_register (raw_buffer, optimized, addrp, frame, regnum, lval);
3896 }
3897
3898 void
3899 set_gdbarch_get_saved_register (struct gdbarch *gdbarch,
3900                                 gdbarch_get_saved_register_ftype get_saved_register)
3901 {
3902   gdbarch->get_saved_register = get_saved_register;
3903 }
3904
3905 int
3906 gdbarch_register_convertible (struct gdbarch *gdbarch, int nr)
3907 {
3908   gdb_assert (gdbarch != NULL);
3909   if (gdbarch->register_convertible == 0)
3910     internal_error (__FILE__, __LINE__,
3911                     "gdbarch: gdbarch_register_convertible invalid");
3912   if (gdbarch_debug >= 2)
3913     fprintf_unfiltered (gdb_stdlog, "gdbarch_register_convertible called\n");
3914   return gdbarch->register_convertible (nr);
3915 }
3916
3917 void
3918 set_gdbarch_register_convertible (struct gdbarch *gdbarch,
3919                                   gdbarch_register_convertible_ftype register_convertible)
3920 {
3921   gdbarch->register_convertible = register_convertible;
3922 }
3923
3924 void
3925 gdbarch_register_convert_to_virtual (struct gdbarch *gdbarch, int regnum, struct type *type, char *from, char *to)
3926 {
3927   gdb_assert (gdbarch != NULL);
3928   if (gdbarch->register_convert_to_virtual == 0)
3929     internal_error (__FILE__, __LINE__,
3930                     "gdbarch: gdbarch_register_convert_to_virtual invalid");
3931   if (gdbarch_debug >= 2)
3932     fprintf_unfiltered (gdb_stdlog, "gdbarch_register_convert_to_virtual called\n");
3933   gdbarch->register_convert_to_virtual (regnum, type, from, to);
3934 }
3935
3936 void
3937 set_gdbarch_register_convert_to_virtual (struct gdbarch *gdbarch,
3938                                          gdbarch_register_convert_to_virtual_ftype register_convert_to_virtual)
3939 {
3940   gdbarch->register_convert_to_virtual = register_convert_to_virtual;
3941 }
3942
3943 void
3944 gdbarch_register_convert_to_raw (struct gdbarch *gdbarch, struct type *type, int regnum, char *from, char *to)
3945 {
3946   gdb_assert (gdbarch != NULL);
3947   if (gdbarch->register_convert_to_raw == 0)
3948     internal_error (__FILE__, __LINE__,
3949                     "gdbarch: gdbarch_register_convert_to_raw invalid");
3950   if (gdbarch_debug >= 2)
3951     fprintf_unfiltered (gdb_stdlog, "gdbarch_register_convert_to_raw called\n");
3952   gdbarch->register_convert_to_raw (type, regnum, from, to);
3953 }
3954
3955 void
3956 set_gdbarch_register_convert_to_raw (struct gdbarch *gdbarch,
3957                                      gdbarch_register_convert_to_raw_ftype register_convert_to_raw)
3958 {
3959   gdbarch->register_convert_to_raw = register_convert_to_raw;
3960 }
3961
3962 int
3963 gdbarch_convert_register_p (struct gdbarch *gdbarch, int regnum)
3964 {
3965   gdb_assert (gdbarch != NULL);
3966   if (gdbarch->convert_register_p == 0)
3967     internal_error (__FILE__, __LINE__,
3968                     "gdbarch: gdbarch_convert_register_p invalid");
3969   if (gdbarch_debug >= 2)
3970     fprintf_unfiltered (gdb_stdlog, "gdbarch_convert_register_p called\n");
3971   return gdbarch->convert_register_p (regnum);
3972 }
3973
3974 void
3975 set_gdbarch_convert_register_p (struct gdbarch *gdbarch,
3976                                 gdbarch_convert_register_p_ftype convert_register_p)
3977 {
3978   gdbarch->convert_register_p = convert_register_p;
3979 }
3980
3981 void
3982 gdbarch_register_to_value (struct gdbarch *gdbarch, int regnum, struct type *type, char *from, char *to)
3983 {
3984   gdb_assert (gdbarch != NULL);
3985   if (gdbarch->register_to_value == 0)
3986     internal_error (__FILE__, __LINE__,
3987                     "gdbarch: gdbarch_register_to_value invalid");
3988   if (gdbarch_debug >= 2)
3989     fprintf_unfiltered (gdb_stdlog, "gdbarch_register_to_value called\n");
3990   gdbarch->register_to_value (regnum, type, from, to);
3991 }
3992
3993 void
3994 set_gdbarch_register_to_value (struct gdbarch *gdbarch,
3995                                gdbarch_register_to_value_ftype register_to_value)
3996 {
3997   gdbarch->register_to_value = register_to_value;
3998 }
3999
4000 void
4001 gdbarch_value_to_register (struct gdbarch *gdbarch, struct type *type, int regnum, char *from, char *to)
4002 {
4003   gdb_assert (gdbarch != NULL);
4004   if (gdbarch->value_to_register == 0)
4005     internal_error (__FILE__, __LINE__,
4006                     "gdbarch: gdbarch_value_to_register invalid");
4007   if (gdbarch_debug >= 2)
4008     fprintf_unfiltered (gdb_stdlog, "gdbarch_value_to_register called\n");
4009   gdbarch->value_to_register (type, regnum, from, to);
4010 }
4011
4012 void
4013 set_gdbarch_value_to_register (struct gdbarch *gdbarch,
4014                                gdbarch_value_to_register_ftype value_to_register)
4015 {
4016   gdbarch->value_to_register = value_to_register;
4017 }
4018
4019 CORE_ADDR
4020 gdbarch_pointer_to_address (struct gdbarch *gdbarch, struct type *type, void *buf)
4021 {
4022   gdb_assert (gdbarch != NULL);
4023   if (gdbarch->pointer_to_address == 0)
4024     internal_error (__FILE__, __LINE__,
4025                     "gdbarch: gdbarch_pointer_to_address invalid");
4026   if (gdbarch_debug >= 2)
4027     fprintf_unfiltered (gdb_stdlog, "gdbarch_pointer_to_address called\n");
4028   return gdbarch->pointer_to_address (type, buf);
4029 }
4030
4031 void
4032 set_gdbarch_pointer_to_address (struct gdbarch *gdbarch,
4033                                 gdbarch_pointer_to_address_ftype pointer_to_address)
4034 {
4035   gdbarch->pointer_to_address = pointer_to_address;
4036 }
4037
4038 void
4039 gdbarch_address_to_pointer (struct gdbarch *gdbarch, struct type *type, void *buf, CORE_ADDR addr)
4040 {
4041   gdb_assert (gdbarch != NULL);
4042   if (gdbarch->address_to_pointer == 0)
4043     internal_error (__FILE__, __LINE__,
4044                     "gdbarch: gdbarch_address_to_pointer invalid");
4045   if (gdbarch_debug >= 2)
4046     fprintf_unfiltered (gdb_stdlog, "gdbarch_address_to_pointer called\n");
4047   gdbarch->address_to_pointer (type, buf, addr);
4048 }
4049
4050 void
4051 set_gdbarch_address_to_pointer (struct gdbarch *gdbarch,
4052                                 gdbarch_address_to_pointer_ftype address_to_pointer)
4053 {
4054   gdbarch->address_to_pointer = address_to_pointer;
4055 }
4056
4057 int
4058 gdbarch_integer_to_address_p (struct gdbarch *gdbarch)
4059 {
4060   gdb_assert (gdbarch != NULL);
4061   return gdbarch->integer_to_address != 0;
4062 }
4063
4064 CORE_ADDR
4065 gdbarch_integer_to_address (struct gdbarch *gdbarch, struct type *type, void *buf)
4066 {
4067   gdb_assert (gdbarch != NULL);
4068   if (gdbarch->integer_to_address == 0)
4069     internal_error (__FILE__, __LINE__,
4070                     "gdbarch: gdbarch_integer_to_address invalid");
4071   if (gdbarch_debug >= 2)
4072     fprintf_unfiltered (gdb_stdlog, "gdbarch_integer_to_address called\n");
4073   return gdbarch->integer_to_address (type, buf);
4074 }
4075
4076 void
4077 set_gdbarch_integer_to_address (struct gdbarch *gdbarch,
4078                                 gdbarch_integer_to_address_ftype integer_to_address)
4079 {
4080   gdbarch->integer_to_address = integer_to_address;
4081 }
4082
4083 int
4084 gdbarch_return_value_on_stack (struct gdbarch *gdbarch, struct type *type)
4085 {
4086   gdb_assert (gdbarch != NULL);
4087   if (gdbarch->return_value_on_stack == 0)
4088     internal_error (__FILE__, __LINE__,
4089                     "gdbarch: gdbarch_return_value_on_stack invalid");
4090   if (gdbarch_debug >= 2)
4091     fprintf_unfiltered (gdb_stdlog, "gdbarch_return_value_on_stack called\n");
4092   return gdbarch->return_value_on_stack (type);
4093 }
4094
4095 void
4096 set_gdbarch_return_value_on_stack (struct gdbarch *gdbarch,
4097                                    gdbarch_return_value_on_stack_ftype return_value_on_stack)
4098 {
4099   gdbarch->return_value_on_stack = return_value_on_stack;
4100 }
4101
4102 CORE_ADDR
4103 gdbarch_push_arguments (struct gdbarch *gdbarch, int nargs, struct value **args, CORE_ADDR sp, int struct_return, CORE_ADDR struct_addr)
4104 {
4105   gdb_assert (gdbarch != NULL);
4106   if (gdbarch->push_arguments == 0)
4107     internal_error (__FILE__, __LINE__,
4108                     "gdbarch: gdbarch_push_arguments invalid");
4109   if (gdbarch_debug >= 2)
4110     fprintf_unfiltered (gdb_stdlog, "gdbarch_push_arguments called\n");
4111   return gdbarch->push_arguments (nargs, args, sp, struct_return, struct_addr);
4112 }
4113
4114 void
4115 set_gdbarch_push_arguments (struct gdbarch *gdbarch,
4116                             gdbarch_push_arguments_ftype push_arguments)
4117 {
4118   gdbarch->push_arguments = push_arguments;
4119 }
4120
4121 void
4122 gdbarch_push_dummy_frame (struct gdbarch *gdbarch)
4123 {
4124   gdb_assert (gdbarch != NULL);
4125   if (gdbarch->push_dummy_frame == 0)
4126     internal_error (__FILE__, __LINE__,
4127                     "gdbarch: gdbarch_push_dummy_frame invalid");
4128   if (gdbarch_debug >= 2)
4129     fprintf_unfiltered (gdb_stdlog, "gdbarch_push_dummy_frame called\n");
4130   gdbarch->push_dummy_frame ();
4131 }
4132
4133 void
4134 set_gdbarch_push_dummy_frame (struct gdbarch *gdbarch,
4135                               gdbarch_push_dummy_frame_ftype push_dummy_frame)
4136 {
4137   gdbarch->push_dummy_frame = push_dummy_frame;
4138 }
4139
4140 int
4141 gdbarch_push_return_address_p (struct gdbarch *gdbarch)
4142 {
4143   gdb_assert (gdbarch != NULL);
4144   return gdbarch->push_return_address != 0;
4145 }
4146
4147 CORE_ADDR
4148 gdbarch_push_return_address (struct gdbarch *gdbarch, CORE_ADDR pc, CORE_ADDR sp)
4149 {
4150   gdb_assert (gdbarch != NULL);
4151   if (gdbarch->push_return_address == 0)
4152     internal_error (__FILE__, __LINE__,
4153                     "gdbarch: gdbarch_push_return_address invalid");
4154   if (gdbarch_debug >= 2)
4155     fprintf_unfiltered (gdb_stdlog, "gdbarch_push_return_address called\n");
4156   return gdbarch->push_return_address (pc, sp);
4157 }
4158
4159 void
4160 set_gdbarch_push_return_address (struct gdbarch *gdbarch,
4161                                  gdbarch_push_return_address_ftype push_return_address)
4162 {
4163   gdbarch->push_return_address = push_return_address;
4164 }
4165
4166 void
4167 gdbarch_pop_frame (struct gdbarch *gdbarch)
4168 {
4169   gdb_assert (gdbarch != NULL);
4170   if (gdbarch->pop_frame == 0)
4171     internal_error (__FILE__, __LINE__,
4172                     "gdbarch: gdbarch_pop_frame invalid");
4173   if (gdbarch_debug >= 2)
4174     fprintf_unfiltered (gdb_stdlog, "gdbarch_pop_frame called\n");
4175   gdbarch->pop_frame ();
4176 }
4177
4178 void
4179 set_gdbarch_pop_frame (struct gdbarch *gdbarch,
4180                        gdbarch_pop_frame_ftype pop_frame)
4181 {
4182   gdbarch->pop_frame = pop_frame;
4183 }
4184
4185 void
4186 gdbarch_store_struct_return (struct gdbarch *gdbarch, CORE_ADDR addr, CORE_ADDR sp)
4187 {
4188   gdb_assert (gdbarch != NULL);
4189   if (gdbarch->store_struct_return == 0)
4190     internal_error (__FILE__, __LINE__,
4191                     "gdbarch: gdbarch_store_struct_return invalid");
4192   if (gdbarch_debug >= 2)
4193     fprintf_unfiltered (gdb_stdlog, "gdbarch_store_struct_return called\n");
4194   gdbarch->store_struct_return (addr, sp);
4195 }
4196
4197 void
4198 set_gdbarch_store_struct_return (struct gdbarch *gdbarch,
4199                                  gdbarch_store_struct_return_ftype store_struct_return)
4200 {
4201   gdbarch->store_struct_return = store_struct_return;
4202 }
4203
4204 void
4205 gdbarch_extract_return_value (struct gdbarch *gdbarch, struct type *type, struct regcache *regcache, void *valbuf)
4206 {
4207   gdb_assert (gdbarch != NULL);
4208   if (gdbarch->extract_return_value == 0)
4209     internal_error (__FILE__, __LINE__,
4210                     "gdbarch: gdbarch_extract_return_value invalid");
4211   if (gdbarch_debug >= 2)
4212     fprintf_unfiltered (gdb_stdlog, "gdbarch_extract_return_value called\n");
4213   gdbarch->extract_return_value (type, regcache, valbuf);
4214 }
4215
4216 void
4217 set_gdbarch_extract_return_value (struct gdbarch *gdbarch,
4218                                   gdbarch_extract_return_value_ftype extract_return_value)
4219 {
4220   gdbarch->extract_return_value = extract_return_value;
4221 }
4222
4223 void
4224 gdbarch_store_return_value (struct gdbarch *gdbarch, struct type *type, struct regcache *regcache, const void *valbuf)
4225 {
4226   gdb_assert (gdbarch != NULL);
4227   if (gdbarch->store_return_value == 0)
4228     internal_error (__FILE__, __LINE__,
4229                     "gdbarch: gdbarch_store_return_value invalid");
4230   if (gdbarch_debug >= 2)
4231     fprintf_unfiltered (gdb_stdlog, "gdbarch_store_return_value called\n");
4232   gdbarch->store_return_value (type, regcache, valbuf);
4233 }
4234
4235 void
4236 set_gdbarch_store_return_value (struct gdbarch *gdbarch,
4237                                 gdbarch_store_return_value_ftype store_return_value)
4238 {
4239   gdbarch->store_return_value = store_return_value;
4240 }
4241
4242 void
4243 gdbarch_deprecated_extract_return_value (struct gdbarch *gdbarch, struct type *type, char *regbuf, char *valbuf)
4244 {
4245   gdb_assert (gdbarch != NULL);
4246   if (gdbarch->deprecated_extract_return_value == 0)
4247     internal_error (__FILE__, __LINE__,
4248                     "gdbarch: gdbarch_deprecated_extract_return_value invalid");
4249   if (gdbarch_debug >= 2)
4250     fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_extract_return_value called\n");
4251   gdbarch->deprecated_extract_return_value (type, regbuf, valbuf);
4252 }
4253
4254 void
4255 set_gdbarch_deprecated_extract_return_value (struct gdbarch *gdbarch,
4256                                              gdbarch_deprecated_extract_return_value_ftype deprecated_extract_return_value)
4257 {
4258   gdbarch->deprecated_extract_return_value = deprecated_extract_return_value;
4259 }
4260
4261 void
4262 gdbarch_deprecated_store_return_value (struct gdbarch *gdbarch, struct type *type, char *valbuf)
4263 {
4264   gdb_assert (gdbarch != NULL);
4265   if (gdbarch->deprecated_store_return_value == 0)
4266     internal_error (__FILE__, __LINE__,
4267                     "gdbarch: gdbarch_deprecated_store_return_value invalid");
4268   if (gdbarch_debug >= 2)
4269     fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_store_return_value called\n");
4270   gdbarch->deprecated_store_return_value (type, valbuf);
4271 }
4272
4273 void
4274 set_gdbarch_deprecated_store_return_value (struct gdbarch *gdbarch,
4275                                            gdbarch_deprecated_store_return_value_ftype deprecated_store_return_value)
4276 {
4277   gdbarch->deprecated_store_return_value = deprecated_store_return_value;
4278 }
4279
4280 int
4281 gdbarch_extract_struct_value_address_p (struct gdbarch *gdbarch)
4282 {
4283   gdb_assert (gdbarch != NULL);
4284   return gdbarch->extract_struct_value_address != 0;
4285 }
4286
4287 CORE_ADDR
4288 gdbarch_extract_struct_value_address (struct gdbarch *gdbarch, struct regcache *regcache)
4289 {
4290   gdb_assert (gdbarch != NULL);
4291   if (gdbarch->extract_struct_value_address == 0)
4292     internal_error (__FILE__, __LINE__,
4293                     "gdbarch: gdbarch_extract_struct_value_address invalid");
4294   if (gdbarch_debug >= 2)
4295     fprintf_unfiltered (gdb_stdlog, "gdbarch_extract_struct_value_address called\n");
4296   return gdbarch->extract_struct_value_address (regcache);
4297 }
4298
4299 void
4300 set_gdbarch_extract_struct_value_address (struct gdbarch *gdbarch,
4301                                           gdbarch_extract_struct_value_address_ftype extract_struct_value_address)
4302 {
4303   gdbarch->extract_struct_value_address = extract_struct_value_address;
4304 }
4305
4306 int
4307 gdbarch_deprecated_extract_struct_value_address_p (struct gdbarch *gdbarch)
4308 {
4309   gdb_assert (gdbarch != NULL);
4310   return gdbarch->deprecated_extract_struct_value_address != 0;
4311 }
4312
4313 CORE_ADDR
4314 gdbarch_deprecated_extract_struct_value_address (struct gdbarch *gdbarch, char *regbuf)
4315 {
4316   gdb_assert (gdbarch != NULL);
4317   if (gdbarch->deprecated_extract_struct_value_address == 0)
4318     internal_error (__FILE__, __LINE__,
4319                     "gdbarch: gdbarch_deprecated_extract_struct_value_address invalid");
4320   if (gdbarch_debug >= 2)
4321     fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_extract_struct_value_address called\n");
4322   return gdbarch->deprecated_extract_struct_value_address (regbuf);
4323 }
4324
4325 void
4326 set_gdbarch_deprecated_extract_struct_value_address (struct gdbarch *gdbarch,
4327                                                      gdbarch_deprecated_extract_struct_value_address_ftype deprecated_extract_struct_value_address)
4328 {
4329   gdbarch->deprecated_extract_struct_value_address = deprecated_extract_struct_value_address;
4330 }
4331
4332 int
4333 gdbarch_use_struct_convention (struct gdbarch *gdbarch, int gcc_p, struct type *value_type)
4334 {
4335   gdb_assert (gdbarch != NULL);
4336   if (gdbarch->use_struct_convention == 0)
4337     internal_error (__FILE__, __LINE__,
4338                     "gdbarch: gdbarch_use_struct_convention invalid");
4339   if (gdbarch_debug >= 2)
4340     fprintf_unfiltered (gdb_stdlog, "gdbarch_use_struct_convention called\n");
4341   return gdbarch->use_struct_convention (gcc_p, value_type);
4342 }
4343
4344 void
4345 set_gdbarch_use_struct_convention (struct gdbarch *gdbarch,
4346                                    gdbarch_use_struct_convention_ftype use_struct_convention)
4347 {
4348   gdbarch->use_struct_convention = use_struct_convention;
4349 }
4350
4351 void
4352 gdbarch_frame_init_saved_regs (struct gdbarch *gdbarch, struct frame_info *frame)
4353 {
4354   gdb_assert (gdbarch != NULL);
4355   if (gdbarch->frame_init_saved_regs == 0)
4356     internal_error (__FILE__, __LINE__,
4357                     "gdbarch: gdbarch_frame_init_saved_regs invalid");
4358   if (gdbarch_debug >= 2)
4359     fprintf_unfiltered (gdb_stdlog, "gdbarch_frame_init_saved_regs called\n");
4360   gdbarch->frame_init_saved_regs (frame);
4361 }
4362
4363 void
4364 set_gdbarch_frame_init_saved_regs (struct gdbarch *gdbarch,
4365                                    gdbarch_frame_init_saved_regs_ftype frame_init_saved_regs)
4366 {
4367   gdbarch->frame_init_saved_regs = frame_init_saved_regs;
4368 }
4369
4370 int
4371 gdbarch_init_extra_frame_info_p (struct gdbarch *gdbarch)
4372 {
4373   gdb_assert (gdbarch != NULL);
4374   return gdbarch->init_extra_frame_info != 0;
4375 }
4376
4377 void
4378 gdbarch_init_extra_frame_info (struct gdbarch *gdbarch, int fromleaf, struct frame_info *frame)
4379 {
4380   gdb_assert (gdbarch != NULL);
4381   if (gdbarch->init_extra_frame_info == 0)
4382     internal_error (__FILE__, __LINE__,
4383                     "gdbarch: gdbarch_init_extra_frame_info invalid");
4384   if (gdbarch_debug >= 2)
4385     fprintf_unfiltered (gdb_stdlog, "gdbarch_init_extra_frame_info called\n");
4386   gdbarch->init_extra_frame_info (fromleaf, frame);
4387 }
4388
4389 void
4390 set_gdbarch_init_extra_frame_info (struct gdbarch *gdbarch,
4391                                    gdbarch_init_extra_frame_info_ftype init_extra_frame_info)
4392 {
4393   gdbarch->init_extra_frame_info = init_extra_frame_info;
4394 }
4395
4396 CORE_ADDR
4397 gdbarch_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR ip)
4398 {
4399   gdb_assert (gdbarch != NULL);
4400   if (gdbarch->skip_prologue == 0)
4401     internal_error (__FILE__, __LINE__,
4402                     "gdbarch: gdbarch_skip_prologue invalid");
4403   if (gdbarch_debug >= 2)
4404     fprintf_unfiltered (gdb_stdlog, "gdbarch_skip_prologue called\n");
4405   return gdbarch->skip_prologue (ip);
4406 }
4407
4408 void
4409 set_gdbarch_skip_prologue (struct gdbarch *gdbarch,
4410                            gdbarch_skip_prologue_ftype skip_prologue)
4411 {
4412   gdbarch->skip_prologue = skip_prologue;
4413 }
4414
4415 int
4416 gdbarch_prologue_frameless_p (struct gdbarch *gdbarch, CORE_ADDR ip)
4417 {
4418   gdb_assert (gdbarch != NULL);
4419   if (gdbarch->prologue_frameless_p == 0)
4420     internal_error (__FILE__, __LINE__,
4421                     "gdbarch: gdbarch_prologue_frameless_p invalid");
4422   if (gdbarch_debug >= 2)
4423     fprintf_unfiltered (gdb_stdlog, "gdbarch_prologue_frameless_p called\n");
4424   return gdbarch->prologue_frameless_p (ip);
4425 }
4426
4427 void
4428 set_gdbarch_prologue_frameless_p (struct gdbarch *gdbarch,
4429                                   gdbarch_prologue_frameless_p_ftype prologue_frameless_p)
4430 {
4431   gdbarch->prologue_frameless_p = prologue_frameless_p;
4432 }
4433
4434 int
4435 gdbarch_inner_than (struct gdbarch *gdbarch, CORE_ADDR lhs, CORE_ADDR rhs)
4436 {
4437   gdb_assert (gdbarch != NULL);
4438   if (gdbarch->inner_than == 0)
4439     internal_error (__FILE__, __LINE__,
4440                     "gdbarch: gdbarch_inner_than invalid");
4441   if (gdbarch_debug >= 2)
4442     fprintf_unfiltered (gdb_stdlog, "gdbarch_inner_than called\n");
4443   return gdbarch->inner_than (lhs, rhs);
4444 }
4445
4446 void
4447 set_gdbarch_inner_than (struct gdbarch *gdbarch,
4448                         gdbarch_inner_than_ftype inner_than)
4449 {
4450   gdbarch->inner_than = inner_than;
4451 }
4452
4453 const unsigned char *
4454 gdbarch_breakpoint_from_pc (struct gdbarch *gdbarch, CORE_ADDR *pcptr, int *lenptr)
4455 {
4456   gdb_assert (gdbarch != NULL);
4457   if (gdbarch->breakpoint_from_pc == 0)
4458     internal_error (__FILE__, __LINE__,
4459                     "gdbarch: gdbarch_breakpoint_from_pc invalid");
4460   if (gdbarch_debug >= 2)
4461     fprintf_unfiltered (gdb_stdlog, "gdbarch_breakpoint_from_pc called\n");
4462   return gdbarch->breakpoint_from_pc (pcptr, lenptr);
4463 }
4464
4465 void
4466 set_gdbarch_breakpoint_from_pc (struct gdbarch *gdbarch,
4467                                 gdbarch_breakpoint_from_pc_ftype breakpoint_from_pc)
4468 {
4469   gdbarch->breakpoint_from_pc = breakpoint_from_pc;
4470 }
4471
4472 int
4473 gdbarch_memory_insert_breakpoint (struct gdbarch *gdbarch, CORE_ADDR addr, char *contents_cache)
4474 {
4475   gdb_assert (gdbarch != NULL);
4476   if (gdbarch->memory_insert_breakpoint == 0)
4477     internal_error (__FILE__, __LINE__,
4478                     "gdbarch: gdbarch_memory_insert_breakpoint invalid");
4479   if (gdbarch_debug >= 2)
4480     fprintf_unfiltered (gdb_stdlog, "gdbarch_memory_insert_breakpoint called\n");
4481   return gdbarch->memory_insert_breakpoint (addr, contents_cache);
4482 }
4483
4484 void
4485 set_gdbarch_memory_insert_breakpoint (struct gdbarch *gdbarch,
4486                                       gdbarch_memory_insert_breakpoint_ftype memory_insert_breakpoint)
4487 {
4488   gdbarch->memory_insert_breakpoint = memory_insert_breakpoint;
4489 }
4490
4491 int
4492 gdbarch_memory_remove_breakpoint (struct gdbarch *gdbarch, CORE_ADDR addr, char *contents_cache)
4493 {
4494   gdb_assert (gdbarch != NULL);
4495   if (gdbarch->memory_remove_breakpoint == 0)
4496     internal_error (__FILE__, __LINE__,
4497                     "gdbarch: gdbarch_memory_remove_breakpoint invalid");
4498   if (gdbarch_debug >= 2)
4499     fprintf_unfiltered (gdb_stdlog, "gdbarch_memory_remove_breakpoint called\n");
4500   return gdbarch->memory_remove_breakpoint (addr, contents_cache);
4501 }
4502
4503 void
4504 set_gdbarch_memory_remove_breakpoint (struct gdbarch *gdbarch,
4505                                       gdbarch_memory_remove_breakpoint_ftype memory_remove_breakpoint)
4506 {
4507   gdbarch->memory_remove_breakpoint = memory_remove_breakpoint;
4508 }
4509
4510 CORE_ADDR
4511 gdbarch_decr_pc_after_break (struct gdbarch *gdbarch)
4512 {
4513   gdb_assert (gdbarch != NULL);
4514   if (gdbarch->decr_pc_after_break == -1)
4515     internal_error (__FILE__, __LINE__,
4516                     "gdbarch: gdbarch_decr_pc_after_break invalid");
4517   if (gdbarch_debug >= 2)
4518     fprintf_unfiltered (gdb_stdlog, "gdbarch_decr_pc_after_break called\n");
4519   return gdbarch->decr_pc_after_break;
4520 }
4521
4522 void
4523 set_gdbarch_decr_pc_after_break (struct gdbarch *gdbarch,
4524                                  CORE_ADDR decr_pc_after_break)
4525 {
4526   gdbarch->decr_pc_after_break = decr_pc_after_break;
4527 }
4528
4529 int
4530 gdbarch_prepare_to_proceed (struct gdbarch *gdbarch, int select_it)
4531 {
4532   gdb_assert (gdbarch != NULL);
4533   if (gdbarch->prepare_to_proceed == 0)
4534     internal_error (__FILE__, __LINE__,
4535                     "gdbarch: gdbarch_prepare_to_proceed invalid");
4536   if (gdbarch_debug >= 2)
4537     fprintf_unfiltered (gdb_stdlog, "gdbarch_prepare_to_proceed called\n");
4538   return gdbarch->prepare_to_proceed (select_it);
4539 }
4540
4541 void
4542 set_gdbarch_prepare_to_proceed (struct gdbarch *gdbarch,
4543                                 gdbarch_prepare_to_proceed_ftype prepare_to_proceed)
4544 {
4545   gdbarch->prepare_to_proceed = prepare_to_proceed;
4546 }
4547
4548 CORE_ADDR
4549 gdbarch_function_start_offset (struct gdbarch *gdbarch)
4550 {
4551   gdb_assert (gdbarch != NULL);
4552   if (gdbarch->function_start_offset == -1)
4553     internal_error (__FILE__, __LINE__,
4554                     "gdbarch: gdbarch_function_start_offset invalid");
4555   if (gdbarch_debug >= 2)
4556     fprintf_unfiltered (gdb_stdlog, "gdbarch_function_start_offset called\n");
4557   return gdbarch->function_start_offset;
4558 }
4559
4560 void
4561 set_gdbarch_function_start_offset (struct gdbarch *gdbarch,
4562                                    CORE_ADDR function_start_offset)
4563 {
4564   gdbarch->function_start_offset = function_start_offset;
4565 }
4566
4567 void
4568 gdbarch_remote_translate_xfer_address (struct gdbarch *gdbarch, CORE_ADDR gdb_addr, int gdb_len, CORE_ADDR *rem_addr, int *rem_len)
4569 {
4570   gdb_assert (gdbarch != NULL);
4571   if (gdbarch->remote_translate_xfer_address == 0)
4572     internal_error (__FILE__, __LINE__,
4573                     "gdbarch: gdbarch_remote_translate_xfer_address invalid");
4574   if (gdbarch_debug >= 2)
4575     fprintf_unfiltered (gdb_stdlog, "gdbarch_remote_translate_xfer_address called\n");
4576   gdbarch->remote_translate_xfer_address (gdb_addr, gdb_len, rem_addr, rem_len);
4577 }
4578
4579 void
4580 set_gdbarch_remote_translate_xfer_address (struct gdbarch *gdbarch,
4581                                            gdbarch_remote_translate_xfer_address_ftype remote_translate_xfer_address)
4582 {
4583   gdbarch->remote_translate_xfer_address = remote_translate_xfer_address;
4584 }
4585
4586 CORE_ADDR
4587 gdbarch_frame_args_skip (struct gdbarch *gdbarch)
4588 {
4589   gdb_assert (gdbarch != NULL);
4590   if (gdbarch->frame_args_skip == -1)
4591     internal_error (__FILE__, __LINE__,
4592                     "gdbarch: gdbarch_frame_args_skip invalid");
4593   if (gdbarch_debug >= 2)
4594     fprintf_unfiltered (gdb_stdlog, "gdbarch_frame_args_skip called\n");
4595   return gdbarch->frame_args_skip;
4596 }
4597
4598 void
4599 set_gdbarch_frame_args_skip (struct gdbarch *gdbarch,
4600                              CORE_ADDR frame_args_skip)
4601 {
4602   gdbarch->frame_args_skip = frame_args_skip;
4603 }
4604
4605 int
4606 gdbarch_frameless_function_invocation (struct gdbarch *gdbarch, struct frame_info *fi)
4607 {
4608   gdb_assert (gdbarch != NULL);
4609   if (gdbarch->frameless_function_invocation == 0)
4610     internal_error (__FILE__, __LINE__,
4611                     "gdbarch: gdbarch_frameless_function_invocation invalid");
4612   if (gdbarch_debug >= 2)
4613     fprintf_unfiltered (gdb_stdlog, "gdbarch_frameless_function_invocation called\n");
4614   return gdbarch->frameless_function_invocation (fi);
4615 }
4616
4617 void
4618 set_gdbarch_frameless_function_invocation (struct gdbarch *gdbarch,
4619                                            gdbarch_frameless_function_invocation_ftype frameless_function_invocation)
4620 {
4621   gdbarch->frameless_function_invocation = frameless_function_invocation;
4622 }
4623
4624 CORE_ADDR
4625 gdbarch_frame_chain (struct gdbarch *gdbarch, struct frame_info *frame)
4626 {
4627   gdb_assert (gdbarch != NULL);
4628   if (gdbarch->frame_chain == 0)
4629     internal_error (__FILE__, __LINE__,
4630                     "gdbarch: gdbarch_frame_chain invalid");
4631   if (gdbarch_debug >= 2)
4632     fprintf_unfiltered (gdb_stdlog, "gdbarch_frame_chain called\n");
4633   return gdbarch->frame_chain (frame);
4634 }
4635
4636 void
4637 set_gdbarch_frame_chain (struct gdbarch *gdbarch,
4638                          gdbarch_frame_chain_ftype frame_chain)
4639 {
4640   gdbarch->frame_chain = frame_chain;
4641 }
4642
4643 int
4644 gdbarch_frame_chain_valid (struct gdbarch *gdbarch, CORE_ADDR chain, struct frame_info *thisframe)
4645 {
4646   gdb_assert (gdbarch != NULL);
4647   if (gdbarch->frame_chain_valid == 0)
4648     internal_error (__FILE__, __LINE__,
4649                     "gdbarch: gdbarch_frame_chain_valid invalid");
4650   if (gdbarch_debug >= 2)
4651     fprintf_unfiltered (gdb_stdlog, "gdbarch_frame_chain_valid called\n");
4652   return gdbarch->frame_chain_valid (chain, thisframe);
4653 }
4654
4655 void
4656 set_gdbarch_frame_chain_valid (struct gdbarch *gdbarch,
4657                                gdbarch_frame_chain_valid_ftype frame_chain_valid)
4658 {
4659   gdbarch->frame_chain_valid = frame_chain_valid;
4660 }
4661
4662 CORE_ADDR
4663 gdbarch_frame_saved_pc (struct gdbarch *gdbarch, struct frame_info *fi)
4664 {
4665   gdb_assert (gdbarch != NULL);
4666   if (gdbarch->frame_saved_pc == 0)
4667     internal_error (__FILE__, __LINE__,
4668                     "gdbarch: gdbarch_frame_saved_pc invalid");
4669   if (gdbarch_debug >= 2)
4670     fprintf_unfiltered (gdb_stdlog, "gdbarch_frame_saved_pc called\n");
4671   return gdbarch->frame_saved_pc (fi);
4672 }
4673
4674 void
4675 set_gdbarch_frame_saved_pc (struct gdbarch *gdbarch,
4676                             gdbarch_frame_saved_pc_ftype frame_saved_pc)
4677 {
4678   gdbarch->frame_saved_pc = frame_saved_pc;
4679 }
4680
4681 CORE_ADDR
4682 gdbarch_frame_args_address (struct gdbarch *gdbarch, struct frame_info *fi)
4683 {
4684   gdb_assert (gdbarch != NULL);
4685   if (gdbarch->frame_args_address == 0)
4686     internal_error (__FILE__, __LINE__,
4687                     "gdbarch: gdbarch_frame_args_address invalid");
4688   if (gdbarch_debug >= 2)
4689     fprintf_unfiltered (gdb_stdlog, "gdbarch_frame_args_address called\n");
4690   return gdbarch->frame_args_address (fi);
4691 }
4692
4693 void
4694 set_gdbarch_frame_args_address (struct gdbarch *gdbarch,
4695                                 gdbarch_frame_args_address_ftype frame_args_address)
4696 {
4697   gdbarch->frame_args_address = frame_args_address;
4698 }
4699
4700 CORE_ADDR
4701 gdbarch_frame_locals_address (struct gdbarch *gdbarch, struct frame_info *fi)
4702 {
4703   gdb_assert (gdbarch != NULL);
4704   if (gdbarch->frame_locals_address == 0)
4705     internal_error (__FILE__, __LINE__,
4706                     "gdbarch: gdbarch_frame_locals_address invalid");
4707   if (gdbarch_debug >= 2)
4708     fprintf_unfiltered (gdb_stdlog, "gdbarch_frame_locals_address called\n");
4709   return gdbarch->frame_locals_address (fi);
4710 }
4711
4712 void
4713 set_gdbarch_frame_locals_address (struct gdbarch *gdbarch,
4714                                   gdbarch_frame_locals_address_ftype frame_locals_address)
4715 {
4716   gdbarch->frame_locals_address = frame_locals_address;
4717 }
4718
4719 CORE_ADDR
4720 gdbarch_saved_pc_after_call (struct gdbarch *gdbarch, struct frame_info *frame)
4721 {
4722   gdb_assert (gdbarch != NULL);
4723   if (gdbarch->saved_pc_after_call == 0)
4724     internal_error (__FILE__, __LINE__,
4725                     "gdbarch: gdbarch_saved_pc_after_call invalid");
4726   if (gdbarch_debug >= 2)
4727     fprintf_unfiltered (gdb_stdlog, "gdbarch_saved_pc_after_call called\n");
4728   return gdbarch->saved_pc_after_call (frame);
4729 }
4730
4731 void
4732 set_gdbarch_saved_pc_after_call (struct gdbarch *gdbarch,
4733                                  gdbarch_saved_pc_after_call_ftype saved_pc_after_call)
4734 {
4735   gdbarch->saved_pc_after_call = saved_pc_after_call;
4736 }
4737
4738 int
4739 gdbarch_frame_num_args (struct gdbarch *gdbarch, struct frame_info *frame)
4740 {
4741   gdb_assert (gdbarch != NULL);
4742   if (gdbarch->frame_num_args == 0)
4743     internal_error (__FILE__, __LINE__,
4744                     "gdbarch: gdbarch_frame_num_args invalid");
4745   if (gdbarch_debug >= 2)
4746     fprintf_unfiltered (gdb_stdlog, "gdbarch_frame_num_args called\n");
4747   return gdbarch->frame_num_args (frame);
4748 }
4749
4750 void
4751 set_gdbarch_frame_num_args (struct gdbarch *gdbarch,
4752                             gdbarch_frame_num_args_ftype frame_num_args)
4753 {
4754   gdbarch->frame_num_args = frame_num_args;
4755 }
4756
4757 int
4758 gdbarch_stack_align_p (struct gdbarch *gdbarch)
4759 {
4760   gdb_assert (gdbarch != NULL);
4761   return gdbarch->stack_align != 0;
4762 }
4763
4764 CORE_ADDR
4765 gdbarch_stack_align (struct gdbarch *gdbarch, CORE_ADDR sp)
4766 {
4767   gdb_assert (gdbarch != NULL);
4768   if (gdbarch->stack_align == 0)
4769     internal_error (__FILE__, __LINE__,
4770                     "gdbarch: gdbarch_stack_align invalid");
4771   if (gdbarch_debug >= 2)
4772     fprintf_unfiltered (gdb_stdlog, "gdbarch_stack_align called\n");
4773   return gdbarch->stack_align (sp);
4774 }
4775
4776 void
4777 set_gdbarch_stack_align (struct gdbarch *gdbarch,
4778                          gdbarch_stack_align_ftype stack_align)
4779 {
4780   gdbarch->stack_align = stack_align;
4781 }
4782
4783 int
4784 gdbarch_frame_align_p (struct gdbarch *gdbarch)
4785 {
4786   gdb_assert (gdbarch != NULL);
4787   return gdbarch->frame_align != 0;
4788 }
4789
4790 CORE_ADDR
4791 gdbarch_frame_align (struct gdbarch *gdbarch, CORE_ADDR address)
4792 {
4793   gdb_assert (gdbarch != NULL);
4794   if (gdbarch->frame_align == 0)
4795     internal_error (__FILE__, __LINE__,
4796                     "gdbarch: gdbarch_frame_align invalid");
4797   if (gdbarch_debug >= 2)
4798     fprintf_unfiltered (gdb_stdlog, "gdbarch_frame_align called\n");
4799   return gdbarch->frame_align (gdbarch, address);
4800 }
4801
4802 void
4803 set_gdbarch_frame_align (struct gdbarch *gdbarch,
4804                          gdbarch_frame_align_ftype frame_align)
4805 {
4806   gdbarch->frame_align = frame_align;
4807 }
4808
4809 int
4810 gdbarch_extra_stack_alignment_needed (struct gdbarch *gdbarch)
4811 {
4812   gdb_assert (gdbarch != NULL);
4813   /* Skip verify of extra_stack_alignment_needed, invalid_p == 0 */
4814   if (gdbarch_debug >= 2)
4815     fprintf_unfiltered (gdb_stdlog, "gdbarch_extra_stack_alignment_needed called\n");
4816   return gdbarch->extra_stack_alignment_needed;
4817 }
4818
4819 void
4820 set_gdbarch_extra_stack_alignment_needed (struct gdbarch *gdbarch,
4821                                           int extra_stack_alignment_needed)
4822 {
4823   gdbarch->extra_stack_alignment_needed = extra_stack_alignment_needed;
4824 }
4825
4826 int
4827 gdbarch_reg_struct_has_addr_p (struct gdbarch *gdbarch)
4828 {
4829   gdb_assert (gdbarch != NULL);
4830   return gdbarch->reg_struct_has_addr != 0;
4831 }
4832
4833 int
4834 gdbarch_reg_struct_has_addr (struct gdbarch *gdbarch, int gcc_p, struct type *type)
4835 {
4836   gdb_assert (gdbarch != NULL);
4837   if (gdbarch->reg_struct_has_addr == 0)
4838     internal_error (__FILE__, __LINE__,
4839                     "gdbarch: gdbarch_reg_struct_has_addr invalid");
4840   if (gdbarch_debug >= 2)
4841     fprintf_unfiltered (gdb_stdlog, "gdbarch_reg_struct_has_addr called\n");
4842   return gdbarch->reg_struct_has_addr (gcc_p, type);
4843 }
4844
4845 void
4846 set_gdbarch_reg_struct_has_addr (struct gdbarch *gdbarch,
4847                                  gdbarch_reg_struct_has_addr_ftype reg_struct_has_addr)
4848 {
4849   gdbarch->reg_struct_has_addr = reg_struct_has_addr;
4850 }
4851
4852 int
4853 gdbarch_save_dummy_frame_tos_p (struct gdbarch *gdbarch)
4854 {
4855   gdb_assert (gdbarch != NULL);
4856   return gdbarch->save_dummy_frame_tos != 0;
4857 }
4858
4859 void
4860 gdbarch_save_dummy_frame_tos (struct gdbarch *gdbarch, CORE_ADDR sp)
4861 {
4862   gdb_assert (gdbarch != NULL);
4863   if (gdbarch->save_dummy_frame_tos == 0)
4864     internal_error (__FILE__, __LINE__,
4865                     "gdbarch: gdbarch_save_dummy_frame_tos invalid");
4866   if (gdbarch_debug >= 2)
4867     fprintf_unfiltered (gdb_stdlog, "gdbarch_save_dummy_frame_tos called\n");
4868   gdbarch->save_dummy_frame_tos (sp);
4869 }
4870
4871 void
4872 set_gdbarch_save_dummy_frame_tos (struct gdbarch *gdbarch,
4873                                   gdbarch_save_dummy_frame_tos_ftype save_dummy_frame_tos)
4874 {
4875   gdbarch->save_dummy_frame_tos = save_dummy_frame_tos;
4876 }
4877
4878 int
4879 gdbarch_parm_boundary (struct gdbarch *gdbarch)
4880 {
4881   gdb_assert (gdbarch != NULL);
4882   if (gdbarch_debug >= 2)
4883     fprintf_unfiltered (gdb_stdlog, "gdbarch_parm_boundary called\n");
4884   return gdbarch->parm_boundary;
4885 }
4886
4887 void
4888 set_gdbarch_parm_boundary (struct gdbarch *gdbarch,
4889                            int parm_boundary)
4890 {
4891   gdbarch->parm_boundary = parm_boundary;
4892 }
4893
4894 const struct floatformat *
4895 gdbarch_float_format (struct gdbarch *gdbarch)
4896 {
4897   gdb_assert (gdbarch != NULL);
4898   if (gdbarch_debug >= 2)
4899     fprintf_unfiltered (gdb_stdlog, "gdbarch_float_format called\n");
4900   return gdbarch->float_format;
4901 }
4902
4903 void
4904 set_gdbarch_float_format (struct gdbarch *gdbarch,
4905                           const struct floatformat * float_format)
4906 {
4907   gdbarch->float_format = float_format;
4908 }
4909
4910 const struct floatformat *
4911 gdbarch_double_format (struct gdbarch *gdbarch)
4912 {
4913   gdb_assert (gdbarch != NULL);
4914   if (gdbarch_debug >= 2)
4915     fprintf_unfiltered (gdb_stdlog, "gdbarch_double_format called\n");
4916   return gdbarch->double_format;
4917 }
4918
4919 void
4920 set_gdbarch_double_format (struct gdbarch *gdbarch,
4921                            const struct floatformat * double_format)
4922 {
4923   gdbarch->double_format = double_format;
4924 }
4925
4926 const struct floatformat *
4927 gdbarch_long_double_format (struct gdbarch *gdbarch)
4928 {
4929   gdb_assert (gdbarch != NULL);
4930   if (gdbarch_debug >= 2)
4931     fprintf_unfiltered (gdb_stdlog, "gdbarch_long_double_format called\n");
4932   return gdbarch->long_double_format;
4933 }
4934
4935 void
4936 set_gdbarch_long_double_format (struct gdbarch *gdbarch,
4937                                 const struct floatformat * long_double_format)
4938 {
4939   gdbarch->long_double_format = long_double_format;
4940 }
4941
4942 CORE_ADDR
4943 gdbarch_convert_from_func_ptr_addr (struct gdbarch *gdbarch, CORE_ADDR addr)
4944 {
4945   gdb_assert (gdbarch != NULL);
4946   if (gdbarch->convert_from_func_ptr_addr == 0)
4947     internal_error (__FILE__, __LINE__,
4948                     "gdbarch: gdbarch_convert_from_func_ptr_addr invalid");
4949   if (gdbarch_debug >= 2)
4950     fprintf_unfiltered (gdb_stdlog, "gdbarch_convert_from_func_ptr_addr called\n");
4951   return gdbarch->convert_from_func_ptr_addr (addr);
4952 }
4953
4954 void
4955 set_gdbarch_convert_from_func_ptr_addr (struct gdbarch *gdbarch,
4956                                         gdbarch_convert_from_func_ptr_addr_ftype convert_from_func_ptr_addr)
4957 {
4958   gdbarch->convert_from_func_ptr_addr = convert_from_func_ptr_addr;
4959 }
4960
4961 CORE_ADDR
4962 gdbarch_addr_bits_remove (struct gdbarch *gdbarch, CORE_ADDR addr)
4963 {
4964   gdb_assert (gdbarch != NULL);
4965   if (gdbarch->addr_bits_remove == 0)
4966     internal_error (__FILE__, __LINE__,
4967                     "gdbarch: gdbarch_addr_bits_remove invalid");
4968   if (gdbarch_debug >= 2)
4969     fprintf_unfiltered (gdb_stdlog, "gdbarch_addr_bits_remove called\n");
4970   return gdbarch->addr_bits_remove (addr);
4971 }
4972
4973 void
4974 set_gdbarch_addr_bits_remove (struct gdbarch *gdbarch,
4975                               gdbarch_addr_bits_remove_ftype addr_bits_remove)
4976 {
4977   gdbarch->addr_bits_remove = addr_bits_remove;
4978 }
4979
4980 CORE_ADDR
4981 gdbarch_smash_text_address (struct gdbarch *gdbarch, CORE_ADDR addr)
4982 {
4983   gdb_assert (gdbarch != NULL);
4984   if (gdbarch->smash_text_address == 0)
4985     internal_error (__FILE__, __LINE__,
4986                     "gdbarch: gdbarch_smash_text_address invalid");
4987   if (gdbarch_debug >= 2)
4988     fprintf_unfiltered (gdb_stdlog, "gdbarch_smash_text_address called\n");
4989   return gdbarch->smash_text_address (addr);
4990 }
4991
4992 void
4993 set_gdbarch_smash_text_address (struct gdbarch *gdbarch,
4994                                 gdbarch_smash_text_address_ftype smash_text_address)
4995 {
4996   gdbarch->smash_text_address = smash_text_address;
4997 }
4998
4999 int
5000 gdbarch_software_single_step_p (struct gdbarch *gdbarch)
5001 {
5002   gdb_assert (gdbarch != NULL);
5003   return gdbarch->software_single_step != 0;
5004 }
5005
5006 void
5007 gdbarch_software_single_step (struct gdbarch *gdbarch, enum target_signal sig, int insert_breakpoints_p)
5008 {
5009   gdb_assert (gdbarch != NULL);
5010   if (gdbarch->software_single_step == 0)
5011     internal_error (__FILE__, __LINE__,
5012                     "gdbarch: gdbarch_software_single_step invalid");
5013   if (gdbarch_debug >= 2)
5014     fprintf_unfiltered (gdb_stdlog, "gdbarch_software_single_step called\n");
5015   gdbarch->software_single_step (sig, insert_breakpoints_p);
5016 }
5017
5018 void
5019 set_gdbarch_software_single_step (struct gdbarch *gdbarch,
5020                                   gdbarch_software_single_step_ftype software_single_step)
5021 {
5022   gdbarch->software_single_step = software_single_step;
5023 }
5024
5025 int
5026 gdbarch_print_insn (struct gdbarch *gdbarch, bfd_vma vma, disassemble_info *info)
5027 {
5028   gdb_assert (gdbarch != NULL);
5029   if (gdbarch->print_insn == 0)
5030     internal_error (__FILE__, __LINE__,
5031                     "gdbarch: gdbarch_print_insn invalid");
5032   if (gdbarch_debug >= 2)
5033     fprintf_unfiltered (gdb_stdlog, "gdbarch_print_insn called\n");
5034   return gdbarch->print_insn (vma, info);
5035 }
5036
5037 void
5038 set_gdbarch_print_insn (struct gdbarch *gdbarch,
5039                         gdbarch_print_insn_ftype print_insn)
5040 {
5041   gdbarch->print_insn = print_insn;
5042 }
5043
5044 CORE_ADDR
5045 gdbarch_skip_trampoline_code (struct gdbarch *gdbarch, CORE_ADDR pc)
5046 {
5047   gdb_assert (gdbarch != NULL);
5048   if (gdbarch->skip_trampoline_code == 0)
5049     internal_error (__FILE__, __LINE__,
5050                     "gdbarch: gdbarch_skip_trampoline_code invalid");
5051   if (gdbarch_debug >= 2)
5052     fprintf_unfiltered (gdb_stdlog, "gdbarch_skip_trampoline_code called\n");
5053   return gdbarch->skip_trampoline_code (pc);
5054 }
5055
5056 void
5057 set_gdbarch_skip_trampoline_code (struct gdbarch *gdbarch,
5058                                   gdbarch_skip_trampoline_code_ftype skip_trampoline_code)
5059 {
5060   gdbarch->skip_trampoline_code = skip_trampoline_code;
5061 }
5062
5063 int
5064 gdbarch_in_solib_call_trampoline (struct gdbarch *gdbarch, CORE_ADDR pc, char *name)
5065 {
5066   gdb_assert (gdbarch != NULL);
5067   if (gdbarch->in_solib_call_trampoline == 0)
5068     internal_error (__FILE__, __LINE__,
5069                     "gdbarch: gdbarch_in_solib_call_trampoline invalid");
5070   if (gdbarch_debug >= 2)
5071     fprintf_unfiltered (gdb_stdlog, "gdbarch_in_solib_call_trampoline called\n");
5072   return gdbarch->in_solib_call_trampoline (pc, name);
5073 }
5074
5075 void
5076 set_gdbarch_in_solib_call_trampoline (struct gdbarch *gdbarch,
5077                                       gdbarch_in_solib_call_trampoline_ftype in_solib_call_trampoline)
5078 {
5079   gdbarch->in_solib_call_trampoline = in_solib_call_trampoline;
5080 }
5081
5082 int
5083 gdbarch_in_solib_return_trampoline (struct gdbarch *gdbarch, CORE_ADDR pc, char *name)
5084 {
5085   gdb_assert (gdbarch != NULL);
5086   if (gdbarch->in_solib_return_trampoline == 0)
5087     internal_error (__FILE__, __LINE__,
5088                     "gdbarch: gdbarch_in_solib_return_trampoline invalid");
5089   if (gdbarch_debug >= 2)
5090     fprintf_unfiltered (gdb_stdlog, "gdbarch_in_solib_return_trampoline called\n");
5091   return gdbarch->in_solib_return_trampoline (pc, name);
5092 }
5093
5094 void
5095 set_gdbarch_in_solib_return_trampoline (struct gdbarch *gdbarch,
5096                                         gdbarch_in_solib_return_trampoline_ftype in_solib_return_trampoline)
5097 {
5098   gdbarch->in_solib_return_trampoline = in_solib_return_trampoline;
5099 }
5100
5101 int
5102 gdbarch_pc_in_sigtramp (struct gdbarch *gdbarch, CORE_ADDR pc, char *name)
5103 {
5104   gdb_assert (gdbarch != NULL);
5105   if (gdbarch->pc_in_sigtramp == 0)
5106     internal_error (__FILE__, __LINE__,
5107                     "gdbarch: gdbarch_pc_in_sigtramp invalid");
5108   if (gdbarch_debug >= 2)
5109     fprintf_unfiltered (gdb_stdlog, "gdbarch_pc_in_sigtramp called\n");
5110   return gdbarch->pc_in_sigtramp (pc, name);
5111 }
5112
5113 void
5114 set_gdbarch_pc_in_sigtramp (struct gdbarch *gdbarch,
5115                             gdbarch_pc_in_sigtramp_ftype pc_in_sigtramp)
5116 {
5117   gdbarch->pc_in_sigtramp = pc_in_sigtramp;
5118 }
5119
5120 int
5121 gdbarch_sigtramp_start_p (struct gdbarch *gdbarch)
5122 {
5123   gdb_assert (gdbarch != NULL);
5124   return gdbarch->sigtramp_start != 0;
5125 }
5126
5127 CORE_ADDR
5128 gdbarch_sigtramp_start (struct gdbarch *gdbarch, CORE_ADDR pc)
5129 {
5130   gdb_assert (gdbarch != NULL);
5131   if (gdbarch->sigtramp_start == 0)
5132     internal_error (__FILE__, __LINE__,
5133                     "gdbarch: gdbarch_sigtramp_start invalid");
5134   if (gdbarch_debug >= 2)
5135     fprintf_unfiltered (gdb_stdlog, "gdbarch_sigtramp_start called\n");
5136   return gdbarch->sigtramp_start (pc);
5137 }
5138
5139 void
5140 set_gdbarch_sigtramp_start (struct gdbarch *gdbarch,
5141                             gdbarch_sigtramp_start_ftype sigtramp_start)
5142 {
5143   gdbarch->sigtramp_start = sigtramp_start;
5144 }
5145
5146 int
5147 gdbarch_sigtramp_end_p (struct gdbarch *gdbarch)
5148 {
5149   gdb_assert (gdbarch != NULL);
5150   return gdbarch->sigtramp_end != 0;
5151 }
5152
5153 CORE_ADDR
5154 gdbarch_sigtramp_end (struct gdbarch *gdbarch, CORE_ADDR pc)
5155 {
5156   gdb_assert (gdbarch != NULL);
5157   if (gdbarch->sigtramp_end == 0)
5158     internal_error (__FILE__, __LINE__,
5159                     "gdbarch: gdbarch_sigtramp_end invalid");
5160   if (gdbarch_debug >= 2)
5161     fprintf_unfiltered (gdb_stdlog, "gdbarch_sigtramp_end called\n");
5162   return gdbarch->sigtramp_end (pc);
5163 }
5164
5165 void
5166 set_gdbarch_sigtramp_end (struct gdbarch *gdbarch,
5167                           gdbarch_sigtramp_end_ftype sigtramp_end)
5168 {
5169   gdbarch->sigtramp_end = sigtramp_end;
5170 }
5171
5172 int
5173 gdbarch_in_function_epilogue_p (struct gdbarch *gdbarch, CORE_ADDR addr)
5174 {
5175   gdb_assert (gdbarch != NULL);
5176   if (gdbarch->in_function_epilogue_p == 0)
5177     internal_error (__FILE__, __LINE__,
5178                     "gdbarch: gdbarch_in_function_epilogue_p invalid");
5179   if (gdbarch_debug >= 2)
5180     fprintf_unfiltered (gdb_stdlog, "gdbarch_in_function_epilogue_p called\n");
5181   return gdbarch->in_function_epilogue_p (gdbarch, addr);
5182 }
5183
5184 void
5185 set_gdbarch_in_function_epilogue_p (struct gdbarch *gdbarch,
5186                                     gdbarch_in_function_epilogue_p_ftype in_function_epilogue_p)
5187 {
5188   gdbarch->in_function_epilogue_p = in_function_epilogue_p;
5189 }
5190
5191 char *
5192 gdbarch_construct_inferior_arguments (struct gdbarch *gdbarch, int argc, char **argv)
5193 {
5194   gdb_assert (gdbarch != NULL);
5195   if (gdbarch->construct_inferior_arguments == 0)
5196     internal_error (__FILE__, __LINE__,
5197                     "gdbarch: gdbarch_construct_inferior_arguments invalid");
5198   if (gdbarch_debug >= 2)
5199     fprintf_unfiltered (gdb_stdlog, "gdbarch_construct_inferior_arguments called\n");
5200   return gdbarch->construct_inferior_arguments (gdbarch, argc, argv);
5201 }
5202
5203 void
5204 set_gdbarch_construct_inferior_arguments (struct gdbarch *gdbarch,
5205                                           gdbarch_construct_inferior_arguments_ftype construct_inferior_arguments)
5206 {
5207   gdbarch->construct_inferior_arguments = construct_inferior_arguments;
5208 }
5209
5210 int
5211 gdbarch_dwarf2_build_frame_info_p (struct gdbarch *gdbarch)
5212 {
5213   gdb_assert (gdbarch != NULL);
5214   return gdbarch->dwarf2_build_frame_info != 0;
5215 }
5216
5217 void
5218 gdbarch_dwarf2_build_frame_info (struct gdbarch *gdbarch, struct objfile *objfile)
5219 {
5220   gdb_assert (gdbarch != NULL);
5221   if (gdbarch->dwarf2_build_frame_info == 0)
5222     internal_error (__FILE__, __LINE__,
5223                     "gdbarch: gdbarch_dwarf2_build_frame_info invalid");
5224   if (gdbarch_debug >= 2)
5225     fprintf_unfiltered (gdb_stdlog, "gdbarch_dwarf2_build_frame_info called\n");
5226   gdbarch->dwarf2_build_frame_info (objfile);
5227 }
5228
5229 void
5230 set_gdbarch_dwarf2_build_frame_info (struct gdbarch *gdbarch,
5231                                      gdbarch_dwarf2_build_frame_info_ftype dwarf2_build_frame_info)
5232 {
5233   gdbarch->dwarf2_build_frame_info = dwarf2_build_frame_info;
5234 }
5235
5236 void
5237 gdbarch_elf_make_msymbol_special (struct gdbarch *gdbarch, asymbol *sym, struct minimal_symbol *msym)
5238 {
5239   gdb_assert (gdbarch != NULL);
5240   if (gdbarch->elf_make_msymbol_special == 0)
5241     internal_error (__FILE__, __LINE__,
5242                     "gdbarch: gdbarch_elf_make_msymbol_special invalid");
5243   if (gdbarch_debug >= 2)
5244     fprintf_unfiltered (gdb_stdlog, "gdbarch_elf_make_msymbol_special called\n");
5245   gdbarch->elf_make_msymbol_special (sym, msym);
5246 }
5247
5248 void
5249 set_gdbarch_elf_make_msymbol_special (struct gdbarch *gdbarch,
5250                                       gdbarch_elf_make_msymbol_special_ftype elf_make_msymbol_special)
5251 {
5252   gdbarch->elf_make_msymbol_special = elf_make_msymbol_special;
5253 }
5254
5255 void
5256 gdbarch_coff_make_msymbol_special (struct gdbarch *gdbarch, int val, struct minimal_symbol *msym)
5257 {
5258   gdb_assert (gdbarch != NULL);
5259   if (gdbarch->coff_make_msymbol_special == 0)
5260     internal_error (__FILE__, __LINE__,
5261                     "gdbarch: gdbarch_coff_make_msymbol_special invalid");
5262   if (gdbarch_debug >= 2)
5263     fprintf_unfiltered (gdb_stdlog, "gdbarch_coff_make_msymbol_special called\n");
5264   gdbarch->coff_make_msymbol_special (val, msym);
5265 }
5266
5267 void
5268 set_gdbarch_coff_make_msymbol_special (struct gdbarch *gdbarch,
5269                                        gdbarch_coff_make_msymbol_special_ftype coff_make_msymbol_special)
5270 {
5271   gdbarch->coff_make_msymbol_special = coff_make_msymbol_special;
5272 }
5273
5274 const char *
5275 gdbarch_name_of_malloc (struct gdbarch *gdbarch)
5276 {
5277   gdb_assert (gdbarch != NULL);
5278   /* Skip verify of name_of_malloc, invalid_p == 0 */
5279   if (gdbarch_debug >= 2)
5280     fprintf_unfiltered (gdb_stdlog, "gdbarch_name_of_malloc called\n");
5281   return gdbarch->name_of_malloc;
5282 }
5283
5284 void
5285 set_gdbarch_name_of_malloc (struct gdbarch *gdbarch,
5286                             const char * name_of_malloc)
5287 {
5288   gdbarch->name_of_malloc = name_of_malloc;
5289 }
5290
5291 int
5292 gdbarch_cannot_step_breakpoint (struct gdbarch *gdbarch)
5293 {
5294   gdb_assert (gdbarch != NULL);
5295   /* Skip verify of cannot_step_breakpoint, invalid_p == 0 */
5296   if (gdbarch_debug >= 2)
5297     fprintf_unfiltered (gdb_stdlog, "gdbarch_cannot_step_breakpoint called\n");
5298   return gdbarch->cannot_step_breakpoint;
5299 }
5300
5301 void
5302 set_gdbarch_cannot_step_breakpoint (struct gdbarch *gdbarch,
5303                                     int cannot_step_breakpoint)
5304 {
5305   gdbarch->cannot_step_breakpoint = cannot_step_breakpoint;
5306 }
5307
5308 int
5309 gdbarch_have_nonsteppable_watchpoint (struct gdbarch *gdbarch)
5310 {
5311   gdb_assert (gdbarch != NULL);
5312   /* Skip verify of have_nonsteppable_watchpoint, invalid_p == 0 */
5313   if (gdbarch_debug >= 2)
5314     fprintf_unfiltered (gdb_stdlog, "gdbarch_have_nonsteppable_watchpoint called\n");
5315   return gdbarch->have_nonsteppable_watchpoint;
5316 }
5317
5318 void
5319 set_gdbarch_have_nonsteppable_watchpoint (struct gdbarch *gdbarch,
5320                                           int have_nonsteppable_watchpoint)
5321 {
5322   gdbarch->have_nonsteppable_watchpoint = have_nonsteppable_watchpoint;
5323 }
5324
5325 int
5326 gdbarch_address_class_type_flags_p (struct gdbarch *gdbarch)
5327 {
5328   gdb_assert (gdbarch != NULL);
5329   return gdbarch->address_class_type_flags != 0;
5330 }
5331
5332 int
5333 gdbarch_address_class_type_flags (struct gdbarch *gdbarch, int byte_size, int dwarf2_addr_class)
5334 {
5335   gdb_assert (gdbarch != NULL);
5336   if (gdbarch->address_class_type_flags == 0)
5337     internal_error (__FILE__, __LINE__,
5338                     "gdbarch: gdbarch_address_class_type_flags invalid");
5339   if (gdbarch_debug >= 2)
5340     fprintf_unfiltered (gdb_stdlog, "gdbarch_address_class_type_flags called\n");
5341   return gdbarch->address_class_type_flags (byte_size, dwarf2_addr_class);
5342 }
5343
5344 void
5345 set_gdbarch_address_class_type_flags (struct gdbarch *gdbarch,
5346                                       gdbarch_address_class_type_flags_ftype address_class_type_flags)
5347 {
5348   gdbarch->address_class_type_flags = address_class_type_flags;
5349 }
5350
5351 int
5352 gdbarch_address_class_type_flags_to_name_p (struct gdbarch *gdbarch)
5353 {
5354   gdb_assert (gdbarch != NULL);
5355   return gdbarch->address_class_type_flags_to_name != 0;
5356 }
5357
5358 const char *
5359 gdbarch_address_class_type_flags_to_name (struct gdbarch *gdbarch, int type_flags)
5360 {
5361   gdb_assert (gdbarch != NULL);
5362   if (gdbarch->address_class_type_flags_to_name == 0)
5363     internal_error (__FILE__, __LINE__,
5364                     "gdbarch: gdbarch_address_class_type_flags_to_name invalid");
5365   if (gdbarch_debug >= 2)
5366     fprintf_unfiltered (gdb_stdlog, "gdbarch_address_class_type_flags_to_name called\n");
5367   return gdbarch->address_class_type_flags_to_name (gdbarch, type_flags);
5368 }
5369
5370 void
5371 set_gdbarch_address_class_type_flags_to_name (struct gdbarch *gdbarch,
5372                                               gdbarch_address_class_type_flags_to_name_ftype address_class_type_flags_to_name)
5373 {
5374   gdbarch->address_class_type_flags_to_name = address_class_type_flags_to_name;
5375 }
5376
5377 int
5378 gdbarch_address_class_name_to_type_flags_p (struct gdbarch *gdbarch)
5379 {
5380   gdb_assert (gdbarch != NULL);
5381   return gdbarch->address_class_name_to_type_flags != 0;
5382 }
5383
5384 int
5385 gdbarch_address_class_name_to_type_flags (struct gdbarch *gdbarch, const char *name, int *type_flags_ptr)
5386 {
5387   gdb_assert (gdbarch != NULL);
5388   if (gdbarch->address_class_name_to_type_flags == 0)
5389     internal_error (__FILE__, __LINE__,
5390                     "gdbarch: gdbarch_address_class_name_to_type_flags invalid");
5391   if (gdbarch_debug >= 2)
5392     fprintf_unfiltered (gdb_stdlog, "gdbarch_address_class_name_to_type_flags called\n");
5393   return gdbarch->address_class_name_to_type_flags (gdbarch, name, type_flags_ptr);
5394 }
5395
5396 void
5397 set_gdbarch_address_class_name_to_type_flags (struct gdbarch *gdbarch,
5398                                               gdbarch_address_class_name_to_type_flags_ftype address_class_name_to_type_flags)
5399 {
5400   gdbarch->address_class_name_to_type_flags = address_class_name_to_type_flags;
5401 }
5402
5403 int
5404 gdbarch_register_reggroup_p (struct gdbarch *gdbarch, int regnum, struct reggroup *reggroup)
5405 {
5406   gdb_assert (gdbarch != NULL);
5407   if (gdbarch->register_reggroup_p == 0)
5408     internal_error (__FILE__, __LINE__,
5409                     "gdbarch: gdbarch_register_reggroup_p invalid");
5410   if (gdbarch_debug >= 2)
5411     fprintf_unfiltered (gdb_stdlog, "gdbarch_register_reggroup_p called\n");
5412   return gdbarch->register_reggroup_p (gdbarch, regnum, reggroup);
5413 }
5414
5415 void
5416 set_gdbarch_register_reggroup_p (struct gdbarch *gdbarch,
5417                                  gdbarch_register_reggroup_p_ftype register_reggroup_p)
5418 {
5419   gdbarch->register_reggroup_p = register_reggroup_p;
5420 }
5421
5422
5423 /* Keep a registry of per-architecture data-pointers required by GDB
5424    modules. */
5425
5426 struct gdbarch_data
5427 {
5428   unsigned index;
5429   int init_p;
5430   gdbarch_data_init_ftype *init;
5431   gdbarch_data_free_ftype *free;
5432 };
5433
5434 struct gdbarch_data_registration
5435 {
5436   struct gdbarch_data *data;
5437   struct gdbarch_data_registration *next;
5438 };
5439
5440 struct gdbarch_data_registry
5441 {
5442   unsigned nr;
5443   struct gdbarch_data_registration *registrations;
5444 };
5445
5446 struct gdbarch_data_registry gdbarch_data_registry =
5447 {
5448   0, NULL,
5449 };
5450
5451 struct gdbarch_data *
5452 register_gdbarch_data (gdbarch_data_init_ftype *init,
5453                        gdbarch_data_free_ftype *free)
5454 {
5455   struct gdbarch_data_registration **curr;
5456   /* Append the new registraration.  */
5457   for (curr = &gdbarch_data_registry.registrations;
5458        (*curr) != NULL;
5459        curr = &(*curr)->next);
5460   (*curr) = XMALLOC (struct gdbarch_data_registration);
5461   (*curr)->next = NULL;
5462   (*curr)->data = XMALLOC (struct gdbarch_data);
5463   (*curr)->data->index = gdbarch_data_registry.nr++;
5464   (*curr)->data->init = init;
5465   (*curr)->data->init_p = 1;
5466   (*curr)->data->free = free;
5467   return (*curr)->data;
5468 }
5469
5470
5471 /* Create/delete the gdbarch data vector. */
5472
5473 static void
5474 alloc_gdbarch_data (struct gdbarch *gdbarch)
5475 {
5476   gdb_assert (gdbarch->data == NULL);
5477   gdbarch->nr_data = gdbarch_data_registry.nr;
5478   gdbarch->data = xcalloc (gdbarch->nr_data, sizeof (void*));
5479 }
5480
5481 static void
5482 free_gdbarch_data (struct gdbarch *gdbarch)
5483 {
5484   struct gdbarch_data_registration *rego;
5485   gdb_assert (gdbarch->data != NULL);
5486   for (rego = gdbarch_data_registry.registrations;
5487        rego != NULL;
5488        rego = rego->next)
5489     {
5490       struct gdbarch_data *data = rego->data;
5491       gdb_assert (data->index < gdbarch->nr_data);
5492       if (data->free != NULL && gdbarch->data[data->index] != NULL)
5493         {
5494           data->free (gdbarch, gdbarch->data[data->index]);
5495           gdbarch->data[data->index] = NULL;
5496         }
5497     }
5498   xfree (gdbarch->data);
5499   gdbarch->data = NULL;
5500 }
5501
5502
5503 /* Initialize the current value of the specified per-architecture
5504    data-pointer. */
5505
5506 void
5507 set_gdbarch_data (struct gdbarch *gdbarch,
5508                   struct gdbarch_data *data,
5509                   void *pointer)
5510 {
5511   gdb_assert (data->index < gdbarch->nr_data);
5512   if (gdbarch->data[data->index] != NULL)
5513     {
5514       gdb_assert (data->free != NULL);
5515       data->free (gdbarch, gdbarch->data[data->index]);
5516     }
5517   gdbarch->data[data->index] = pointer;
5518 }
5519
5520 /* Return the current value of the specified per-architecture
5521    data-pointer. */
5522
5523 void *
5524 gdbarch_data (struct gdbarch *gdbarch, struct gdbarch_data *data)
5525 {
5526   gdb_assert (data->index < gdbarch->nr_data);
5527   /* The data-pointer isn't initialized, call init() to get a value but
5528      only if the architecture initializaiton has completed.  Otherwise
5529      punt - hope that the caller knows what they are doing.  */
5530   if (gdbarch->data[data->index] == NULL
5531       && gdbarch->initialized_p)
5532     {
5533       /* Be careful to detect an initialization cycle.  */
5534       gdb_assert (data->init_p);
5535       data->init_p = 0;
5536       gdb_assert (data->init != NULL);
5537       gdbarch->data[data->index] = data->init (gdbarch);
5538       data->init_p = 1;
5539       gdb_assert (gdbarch->data[data->index] != NULL);
5540     }
5541   return gdbarch->data[data->index];
5542 }
5543
5544
5545
5546 /* Keep a registry of swapped data required by GDB modules. */
5547
5548 struct gdbarch_swap
5549 {
5550   void *swap;
5551   struct gdbarch_swap_registration *source;
5552   struct gdbarch_swap *next;
5553 };
5554
5555 struct gdbarch_swap_registration
5556 {
5557   void *data;
5558   unsigned long sizeof_data;
5559   gdbarch_swap_ftype *init;
5560   struct gdbarch_swap_registration *next;
5561 };
5562
5563 struct gdbarch_swap_registry
5564 {
5565   int nr;
5566   struct gdbarch_swap_registration *registrations;
5567 };
5568
5569 struct gdbarch_swap_registry gdbarch_swap_registry =
5570 {
5571   0, NULL,
5572 };
5573
5574 void
5575 register_gdbarch_swap (void *data,
5576                        unsigned long sizeof_data,
5577                        gdbarch_swap_ftype *init)
5578 {
5579   struct gdbarch_swap_registration **rego;
5580   for (rego = &gdbarch_swap_registry.registrations;
5581        (*rego) != NULL;
5582        rego = &(*rego)->next);
5583   (*rego) = XMALLOC (struct gdbarch_swap_registration);
5584   (*rego)->next = NULL;
5585   (*rego)->init = init;
5586   (*rego)->data = data;
5587   (*rego)->sizeof_data = sizeof_data;
5588 }
5589
5590 static void
5591 clear_gdbarch_swap (struct gdbarch *gdbarch)
5592 {
5593   struct gdbarch_swap *curr;
5594   for (curr = gdbarch->swap;
5595        curr != NULL;
5596        curr = curr->next)
5597     {
5598       memset (curr->source->data, 0, curr->source->sizeof_data);
5599     }
5600 }
5601
5602 static void
5603 init_gdbarch_swap (struct gdbarch *gdbarch)
5604 {
5605   struct gdbarch_swap_registration *rego;
5606   struct gdbarch_swap **curr = &gdbarch->swap;
5607   for (rego = gdbarch_swap_registry.registrations;
5608        rego != NULL;
5609        rego = rego->next)
5610     {
5611       if (rego->data != NULL)
5612         {
5613           (*curr) = XMALLOC (struct gdbarch_swap);
5614           (*curr)->source = rego;
5615           (*curr)->swap = xmalloc (rego->sizeof_data);
5616           (*curr)->next = NULL;
5617           curr = &(*curr)->next;
5618         }
5619       if (rego->init != NULL)
5620         rego->init ();
5621     }
5622 }
5623
5624 static void
5625 swapout_gdbarch_swap (struct gdbarch *gdbarch)
5626 {
5627   struct gdbarch_swap *curr;
5628   for (curr = gdbarch->swap;
5629        curr != NULL;
5630        curr = curr->next)
5631     memcpy (curr->swap, curr->source->data, curr->source->sizeof_data);
5632 }
5633
5634 static void
5635 swapin_gdbarch_swap (struct gdbarch *gdbarch)
5636 {
5637   struct gdbarch_swap *curr;
5638   for (curr = gdbarch->swap;
5639        curr != NULL;
5640        curr = curr->next)
5641     memcpy (curr->source->data, curr->swap, curr->source->sizeof_data);
5642 }
5643
5644
5645 /* Keep a registry of the architectures known by GDB. */
5646
5647 struct gdbarch_registration
5648 {
5649   enum bfd_architecture bfd_architecture;
5650   gdbarch_init_ftype *init;
5651   gdbarch_dump_tdep_ftype *dump_tdep;
5652   struct gdbarch_list *arches;
5653   struct gdbarch_registration *next;
5654 };
5655
5656 static struct gdbarch_registration *gdbarch_registry = NULL;
5657
5658 static void
5659 append_name (const char ***buf, int *nr, const char *name)
5660 {
5661   *buf = xrealloc (*buf, sizeof (char**) * (*nr + 1));
5662   (*buf)[*nr] = name;
5663   *nr += 1;
5664 }
5665
5666 const char **
5667 gdbarch_printable_names (void)
5668 {
5669   if (GDB_MULTI_ARCH)
5670     {
5671       /* Accumulate a list of names based on the registed list of
5672          architectures. */
5673       enum bfd_architecture a;
5674       int nr_arches = 0;
5675       const char **arches = NULL;
5676       struct gdbarch_registration *rego;
5677       for (rego = gdbarch_registry;
5678            rego != NULL;
5679            rego = rego->next)
5680         {
5681           const struct bfd_arch_info *ap;
5682           ap = bfd_lookup_arch (rego->bfd_architecture, 0);
5683           if (ap == NULL)
5684             internal_error (__FILE__, __LINE__,
5685                             "gdbarch_architecture_names: multi-arch unknown");
5686           do
5687             {
5688               append_name (&arches, &nr_arches, ap->printable_name);
5689               ap = ap->next;
5690             }
5691           while (ap != NULL);
5692         }
5693       append_name (&arches, &nr_arches, NULL);
5694       return arches;
5695     }
5696   else
5697     /* Just return all the architectures that BFD knows.  Assume that
5698        the legacy architecture framework supports them. */
5699     return bfd_arch_list ();
5700 }
5701
5702
5703 void
5704 gdbarch_register (enum bfd_architecture bfd_architecture,
5705                   gdbarch_init_ftype *init,
5706                   gdbarch_dump_tdep_ftype *dump_tdep)
5707 {
5708   struct gdbarch_registration **curr;
5709   const struct bfd_arch_info *bfd_arch_info;
5710   /* Check that BFD recognizes this architecture */
5711   bfd_arch_info = bfd_lookup_arch (bfd_architecture, 0);
5712   if (bfd_arch_info == NULL)
5713     {
5714       internal_error (__FILE__, __LINE__,
5715                       "gdbarch: Attempt to register unknown architecture (%d)",
5716                       bfd_architecture);
5717     }
5718   /* Check that we haven't seen this architecture before */
5719   for (curr = &gdbarch_registry;
5720        (*curr) != NULL;
5721        curr = &(*curr)->next)
5722     {
5723       if (bfd_architecture == (*curr)->bfd_architecture)
5724         internal_error (__FILE__, __LINE__,
5725                         "gdbarch: Duplicate registraration of architecture (%s)",
5726                         bfd_arch_info->printable_name);
5727     }
5728   /* log it */
5729   if (gdbarch_debug)
5730     fprintf_unfiltered (gdb_stdlog, "register_gdbarch_init (%s, 0x%08lx)\n",
5731                         bfd_arch_info->printable_name,
5732                         (long) init);
5733   /* Append it */
5734   (*curr) = XMALLOC (struct gdbarch_registration);
5735   (*curr)->bfd_architecture = bfd_architecture;
5736   (*curr)->init = init;
5737   (*curr)->dump_tdep = dump_tdep;
5738   (*curr)->arches = NULL;
5739   (*curr)->next = NULL;
5740   /* When non- multi-arch, install whatever target dump routine we've
5741      been provided - hopefully that routine has been written correctly
5742      and works regardless of multi-arch. */
5743   if (!GDB_MULTI_ARCH && dump_tdep != NULL
5744       && startup_gdbarch.dump_tdep == NULL)
5745     startup_gdbarch.dump_tdep = dump_tdep;
5746 }
5747
5748 void
5749 register_gdbarch_init (enum bfd_architecture bfd_architecture,
5750                        gdbarch_init_ftype *init)
5751 {
5752   gdbarch_register (bfd_architecture, init, NULL);
5753 }
5754
5755
5756 /* Look for an architecture using gdbarch_info.  Base search on only
5757    BFD_ARCH_INFO and BYTE_ORDER. */
5758
5759 struct gdbarch_list *
5760 gdbarch_list_lookup_by_info (struct gdbarch_list *arches,
5761                              const struct gdbarch_info *info)
5762 {
5763   for (; arches != NULL; arches = arches->next)
5764     {
5765       if (info->bfd_arch_info != arches->gdbarch->bfd_arch_info)
5766         continue;
5767       if (info->byte_order != arches->gdbarch->byte_order)
5768         continue;
5769       if (info->osabi != arches->gdbarch->osabi)
5770         continue;
5771       return arches;
5772     }
5773   return NULL;
5774 }
5775
5776
5777 /* Update the current architecture. Return ZERO if the update request
5778    failed. */
5779
5780 int
5781 gdbarch_update_p (struct gdbarch_info info)
5782 {
5783   struct gdbarch *new_gdbarch;
5784   struct gdbarch *old_gdbarch;
5785   struct gdbarch_registration *rego;
5786
5787   /* Fill in missing parts of the INFO struct using a number of
5788      sources: ``set ...''; INFOabfd supplied; existing target.  */
5789
5790   /* ``(gdb) set architecture ...'' */
5791   if (info.bfd_arch_info == NULL
5792       && !TARGET_ARCHITECTURE_AUTO)
5793     info.bfd_arch_info = TARGET_ARCHITECTURE;
5794   if (info.bfd_arch_info == NULL
5795       && info.abfd != NULL
5796       && bfd_get_arch (info.abfd) != bfd_arch_unknown
5797       && bfd_get_arch (info.abfd) != bfd_arch_obscure)
5798     info.bfd_arch_info = bfd_get_arch_info (info.abfd);
5799   if (info.bfd_arch_info == NULL)
5800     info.bfd_arch_info = TARGET_ARCHITECTURE;
5801
5802   /* ``(gdb) set byte-order ...'' */
5803   if (info.byte_order == BFD_ENDIAN_UNKNOWN
5804       && !TARGET_BYTE_ORDER_AUTO)
5805     info.byte_order = TARGET_BYTE_ORDER;
5806   /* From the INFO struct. */
5807   if (info.byte_order == BFD_ENDIAN_UNKNOWN
5808       && info.abfd != NULL)
5809     info.byte_order = (bfd_big_endian (info.abfd) ? BFD_ENDIAN_BIG
5810                        : bfd_little_endian (info.abfd) ? BFD_ENDIAN_LITTLE
5811                        : BFD_ENDIAN_UNKNOWN);
5812   /* From the current target. */
5813   if (info.byte_order == BFD_ENDIAN_UNKNOWN)
5814     info.byte_order = TARGET_BYTE_ORDER;
5815
5816   /* ``(gdb) set osabi ...'' is handled by gdbarch_lookup_osabi.  */
5817   if (info.osabi == GDB_OSABI_UNINITIALIZED)
5818     info.osabi = gdbarch_lookup_osabi (info.abfd);
5819   if (info.osabi == GDB_OSABI_UNINITIALIZED)
5820     info.osabi = current_gdbarch->osabi;
5821
5822   /* Must have found some sort of architecture. */
5823   gdb_assert (info.bfd_arch_info != NULL);
5824
5825   if (gdbarch_debug)
5826     {
5827       fprintf_unfiltered (gdb_stdlog,
5828                           "gdbarch_update: info.bfd_arch_info %s\n",
5829                           (info.bfd_arch_info != NULL
5830                            ? info.bfd_arch_info->printable_name
5831                            : "(null)"));
5832       fprintf_unfiltered (gdb_stdlog,
5833                           "gdbarch_update: info.byte_order %d (%s)\n",
5834                           info.byte_order,
5835                           (info.byte_order == BFD_ENDIAN_BIG ? "big"
5836                            : info.byte_order == BFD_ENDIAN_LITTLE ? "little"
5837                            : "default"));
5838       fprintf_unfiltered (gdb_stdlog,
5839                           "gdbarch_update: info.osabi %d (%s)\n",
5840                           info.osabi, gdbarch_osabi_name (info.osabi));
5841       fprintf_unfiltered (gdb_stdlog,
5842                           "gdbarch_update: info.abfd 0x%lx\n",
5843                           (long) info.abfd);
5844       fprintf_unfiltered (gdb_stdlog,
5845                           "gdbarch_update: info.tdep_info 0x%lx\n",
5846                           (long) info.tdep_info);
5847     }
5848
5849   /* Find the target that knows about this architecture. */
5850   for (rego = gdbarch_registry;
5851        rego != NULL;
5852        rego = rego->next)
5853     if (rego->bfd_architecture == info.bfd_arch_info->arch)
5854       break;
5855   if (rego == NULL)
5856     {
5857       if (gdbarch_debug)
5858         fprintf_unfiltered (gdb_stdlog, "gdbarch_update: No matching architecture\n");
5859       return 0;
5860     }
5861
5862   /* Swap the data belonging to the old target out setting the
5863      installed data to zero.  This stops the ->init() function trying
5864      to refer to the previous architecture's global data structures.  */
5865   swapout_gdbarch_swap (current_gdbarch);
5866   clear_gdbarch_swap (current_gdbarch);
5867
5868   /* Save the previously selected architecture, setting the global to
5869      NULL.  This stops ->init() trying to use the previous
5870      architecture's configuration.  The previous architecture may not
5871      even be of the same architecture family.  The most recent
5872      architecture of the same family is found at the head of the
5873      rego->arches list.  */
5874   old_gdbarch = current_gdbarch;
5875   current_gdbarch = NULL;
5876
5877   /* Ask the target for a replacement architecture. */
5878   new_gdbarch = rego->init (info, rego->arches);
5879
5880   /* Did the target like it?  No. Reject the change and revert to the
5881      old architecture.  */
5882   if (new_gdbarch == NULL)
5883     {
5884       if (gdbarch_debug)
5885         fprintf_unfiltered (gdb_stdlog, "gdbarch_update: Target rejected architecture\n");
5886       swapin_gdbarch_swap (old_gdbarch);
5887       current_gdbarch = old_gdbarch;
5888       return 0;
5889     }
5890
5891   /* Did the architecture change?  No.  Oops, put the old architecture
5892      back.  */
5893   if (old_gdbarch == new_gdbarch)
5894     {
5895       if (gdbarch_debug)
5896         fprintf_unfiltered (gdb_stdlog, "gdbarch_update: Architecture 0x%08lx (%s) unchanged\n",
5897                             (long) new_gdbarch,
5898                             new_gdbarch->bfd_arch_info->printable_name);
5899       swapin_gdbarch_swap (old_gdbarch);
5900       current_gdbarch = old_gdbarch;
5901       return 1;
5902     }
5903
5904   /* Is this a pre-existing architecture?  Yes. Move it to the front
5905      of the list of architectures (keeping the list sorted Most
5906      Recently Used) and then copy it in.  */
5907   {
5908     struct gdbarch_list **list;
5909     for (list = &rego->arches;
5910          (*list) != NULL;
5911          list = &(*list)->next)
5912       {
5913         if ((*list)->gdbarch == new_gdbarch)
5914           {
5915             struct gdbarch_list *this;
5916             if (gdbarch_debug)
5917               fprintf_unfiltered (gdb_stdlog,
5918                                   "gdbarch_update: Previous architecture 0x%08lx (%s) selected\n",
5919                                   (long) new_gdbarch,
5920                                   new_gdbarch->bfd_arch_info->printable_name);
5921             /* Unlink this.  */
5922             this = (*list);
5923             (*list) = this->next;
5924             /* Insert in the front.  */
5925             this->next = rego->arches;
5926             rego->arches = this;
5927             /* Copy the new architecture in.  */
5928             current_gdbarch = new_gdbarch;
5929             swapin_gdbarch_swap (new_gdbarch);
5930             architecture_changed_event ();
5931             return 1;
5932           }
5933       }
5934   }
5935
5936   /* Prepend this new architecture to the architecture list (keep the
5937      list sorted Most Recently Used).  */
5938   {
5939     struct gdbarch_list *this = XMALLOC (struct gdbarch_list);
5940     this->next = rego->arches;
5941     this->gdbarch = new_gdbarch;
5942     rego->arches = this;
5943   }
5944
5945   /* Switch to this new architecture marking it initialized.  */
5946   current_gdbarch = new_gdbarch;
5947   current_gdbarch->initialized_p = 1;
5948   if (gdbarch_debug)
5949     {
5950       fprintf_unfiltered (gdb_stdlog,
5951                           "gdbarch_update: New architecture 0x%08lx (%s) selected\n",
5952                           (long) new_gdbarch,
5953                           new_gdbarch->bfd_arch_info->printable_name);
5954     }
5955
5956   /* Check that the newly installed architecture is valid.  Plug in
5957      any post init values.  */
5958   new_gdbarch->dump_tdep = rego->dump_tdep;
5959   verify_gdbarch (new_gdbarch);
5960
5961   /* Initialize the per-architecture memory (swap) areas.
5962      CURRENT_GDBARCH must be update before these modules are
5963      called. */
5964   init_gdbarch_swap (new_gdbarch);
5965
5966   /* Initialize the per-architecture data.  CURRENT_GDBARCH
5967      must be updated before these modules are called. */
5968   architecture_changed_event ();
5969
5970   if (gdbarch_debug)
5971     gdbarch_dump (current_gdbarch, gdb_stdlog);
5972
5973   return 1;
5974 }
5975
5976
5977 /* Disassembler */
5978
5979 /* Pointer to the target-dependent disassembly function.  */
5980 int (*tm_print_insn) (bfd_vma, disassemble_info *);
5981 disassemble_info tm_print_insn_info;
5982
5983
5984 extern void _initialize_gdbarch (void);
5985
5986 void
5987 _initialize_gdbarch (void)
5988 {
5989   struct cmd_list_element *c;
5990
5991   INIT_DISASSEMBLE_INFO_NO_ARCH (tm_print_insn_info, gdb_stdout, (fprintf_ftype)fprintf_filtered);
5992   tm_print_insn_info.flavour = bfd_target_unknown_flavour;
5993   tm_print_insn_info.read_memory_func = dis_asm_read_memory;
5994   tm_print_insn_info.memory_error_func = dis_asm_memory_error;
5995   tm_print_insn_info.print_address_func = dis_asm_print_address;
5996
5997   add_show_from_set (add_set_cmd ("arch",
5998                                   class_maintenance,
5999                                   var_zinteger,
6000                                   (char *)&gdbarch_debug,
6001                                   "Set architecture debugging.\n\
6002 When non-zero, architecture debugging is enabled.", &setdebuglist),
6003                      &showdebuglist);
6004   c = add_set_cmd ("archdebug",
6005                    class_maintenance,
6006                    var_zinteger,
6007                    (char *)&gdbarch_debug,
6008                    "Set architecture debugging.\n\
6009 When non-zero, architecture debugging is enabled.", &setlist);
6010
6011   deprecate_cmd (c, "set debug arch");
6012   deprecate_cmd (add_show_from_set (c, &showlist), "show debug arch");
6013 }