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