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