gdb/gdbarch.c

   1 /* *INDENT-OFF* */ /* THIS FILE IS GENERATED */
   2
   3 /* Dynamic architecture support for GDB, the GNU debugger.
   4    Copyright 1998-1999, 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 bourn 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 makeing 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 #endif
  59 #include "symcat.h"
  60
  61
  62 /* Static function declarations */
  63
  64 static void verify_gdbarch (struct gdbarch *gdbarch);
  65 static void init_gdbarch_data (struct gdbarch *);
  66 static void init_gdbarch_swap (struct gdbarch *);
  67 static void swapout_gdbarch_swap (struct gdbarch *);
  68 static void swapin_gdbarch_swap (struct gdbarch *);
  69
  70 /* Convenience macro for allocting typesafe memory. */
  71
  72 #ifndef XMALLOC
  73 #define XMALLOC(TYPE) (TYPE*) xmalloc (sizeof (TYPE))
  74 #endif
  75
  76
  77 /* Non-zero if we want to trace architecture code.  */
  78
  79 #ifndef GDBARCH_DEBUG
  80 #define GDBARCH_DEBUG 0
  81 #endif
  82 int gdbarch_debug = GDBARCH_DEBUG;
  83
  84
  85 /* Maintain the struct gdbarch object */
  86
  87 struct gdbarch
  88 {
  89   /* basic architectural information */
  90   const struct bfd_arch_info * bfd_arch_info;
  91   int byte_order;
  92
  93   /* target specific vector. */
  94   struct gdbarch_tdep *tdep;
  95
  96   /* per-architecture data-pointers */
  97   int nr_data;
  98   void **data;
  99
 100   /* per-architecture swap-regions */
 101   struct gdbarch_swap *swap;
 102
 103   /* Multi-arch values.
 104
 105      When extending this structure you must:
 106
 107      Add the field below.
 108
 109      Declare set/get functions and define the corresponding
 110      macro in gdbarch.h.
 111
 112      gdbarch_alloc(): If zero/NULL is not a suitable default,
 113      initialize the new field.
 114
 115      verify_gdbarch(): Confirm that the target updated the field
 116      correctly.
 117
 118      gdbarch_dump(): Add a fprintf_unfiltered call to so that the new
 119      field is dumped out
 120
 121      ``startup_gdbarch()'': Append an initial value to the static
 122      variable (base values on the host's c-type system).
 123
 124      get_gdbarch(): Implement the set/get functions (probably using
 125      the macro's as shortcuts).
 126
 127      */
 128
 129   int bfd_vma_bit;
 130   int ptr_bit;
 131   int short_bit;
 132   int int_bit;
 133   int long_bit;
 134   int long_long_bit;
 135   int float_bit;
 136   int double_bit;
 137   int long_double_bit;
 138   int ieee_float;
 139   gdbarch_read_pc_ftype *read_pc;
 140   gdbarch_write_pc_ftype *write_pc;
 141   gdbarch_read_fp_ftype *read_fp;
 142   gdbarch_write_fp_ftype *write_fp;
 143   gdbarch_read_sp_ftype *read_sp;
 144   gdbarch_write_sp_ftype *write_sp;
 145   int num_regs;
 146   int sp_regnum;
 147   int fp_regnum;
 148   int pc_regnum;
 149   gdbarch_register_name_ftype *register_name;
 150   int register_size;
 151   int register_bytes;
 152   gdbarch_register_byte_ftype *register_byte;
 153   gdbarch_register_raw_size_ftype *register_raw_size;
 154   int max_register_raw_size;
 155   gdbarch_register_virtual_size_ftype *register_virtual_size;
 156   int max_register_virtual_size;
 157   gdbarch_register_virtual_type_ftype *register_virtual_type;
 158   int use_generic_dummy_frames;
 159   int call_dummy_location;
 160   gdbarch_call_dummy_address_ftype *call_dummy_address;
 161   CORE_ADDR call_dummy_start_offset;
 162   CORE_ADDR call_dummy_breakpoint_offset;
 163   int call_dummy_breakpoint_offset_p;
 164   int call_dummy_length;
 165   gdbarch_pc_in_call_dummy_ftype *pc_in_call_dummy;
 166   int call_dummy_p;
 167   LONGEST * call_dummy_words;
 168   int sizeof_call_dummy_words;
 169   int call_dummy_stack_adjust_p;
 170   int call_dummy_stack_adjust;
 171   gdbarch_fix_call_dummy_ftype *fix_call_dummy;
 172   int believe_pcc_promotion;
 173   int believe_pcc_promotion_type;
 174   gdbarch_coerce_float_to_double_ftype *coerce_float_to_double;
 175   gdbarch_get_saved_register_ftype *get_saved_register;
 176   gdbarch_register_convertible_ftype *register_convertible;
 177   gdbarch_register_convert_to_virtual_ftype *register_convert_to_virtual;
 178   gdbarch_register_convert_to_raw_ftype *register_convert_to_raw;
 179   gdbarch_pointer_to_address_ftype *pointer_to_address;
 180   gdbarch_address_to_pointer_ftype *address_to_pointer;
 181   gdbarch_return_value_on_stack_ftype *return_value_on_stack;
 182   gdbarch_extract_return_value_ftype *extract_return_value;
 183   gdbarch_push_arguments_ftype *push_arguments;
 184   gdbarch_push_dummy_frame_ftype *push_dummy_frame;
 185   gdbarch_push_return_address_ftype *push_return_address;
 186   gdbarch_pop_frame_ftype *pop_frame;
 187   gdbarch_d10v_make_daddr_ftype *d10v_make_daddr;
 188   gdbarch_d10v_make_iaddr_ftype *d10v_make_iaddr;
 189   gdbarch_d10v_daddr_p_ftype *d10v_daddr_p;
 190   gdbarch_d10v_iaddr_p_ftype *d10v_iaddr_p;
 191   gdbarch_d10v_convert_daddr_to_raw_ftype *d10v_convert_daddr_to_raw;
 192   gdbarch_d10v_convert_iaddr_to_raw_ftype *d10v_convert_iaddr_to_raw;
 193   gdbarch_store_struct_return_ftype *store_struct_return;
 194   gdbarch_store_return_value_ftype *store_return_value;
 195   gdbarch_extract_struct_value_address_ftype *extract_struct_value_address;
 196   gdbarch_use_struct_convention_ftype *use_struct_convention;
 197   gdbarch_frame_init_saved_regs_ftype *frame_init_saved_regs;
 198   gdbarch_init_extra_frame_info_ftype *init_extra_frame_info;
 199   gdbarch_skip_prologue_ftype *skip_prologue;
 200   gdbarch_inner_than_ftype *inner_than;
 201   gdbarch_breakpoint_from_pc_ftype *breakpoint_from_pc;
 202   gdbarch_memory_insert_breakpoint_ftype *memory_insert_breakpoint;
 203   gdbarch_memory_remove_breakpoint_ftype *memory_remove_breakpoint;
 204   CORE_ADDR decr_pc_after_break;
 205   CORE_ADDR function_start_offset;
 206   gdbarch_remote_translate_xfer_address_ftype *remote_translate_xfer_address;
 207   CORE_ADDR frame_args_skip;
 208   gdbarch_frameless_function_invocation_ftype *frameless_function_invocation;
 209   gdbarch_frame_chain_ftype *frame_chain;
 210   gdbarch_frame_chain_valid_ftype *frame_chain_valid;
 211   gdbarch_frame_saved_pc_ftype *frame_saved_pc;
 212   gdbarch_frame_args_address_ftype *frame_args_address;
 213   gdbarch_frame_locals_address_ftype *frame_locals_address;
 214   gdbarch_saved_pc_after_call_ftype *saved_pc_after_call;
 215   gdbarch_frame_num_args_ftype *frame_num_args;
 216   gdbarch_stack_align_ftype *stack_align;
 217   gdbarch_reg_struct_has_addr_ftype *reg_struct_has_addr;
 218 };
 219
 220
 221 /* The default architecture uses host values (for want of a better
 222    choice). */
 223
 224 extern const struct bfd_arch_info bfd_default_arch_struct;
 225
 226 struct gdbarch startup_gdbarch = {
 227   /* basic architecture information */
 228   &bfd_default_arch_struct,
 229   BIG_ENDIAN,
 230   /* target specific vector */
 231   NULL,
 232   /*per-architecture data-pointers and swap regions */
 233   0, NULL, NULL,
 234   /* Multi-arch values */
 235   8 * sizeof (void*),
 236   8 * sizeof (void*),
 237   8 * sizeof (short),
 238   8 * sizeof (int),
 239   8 * sizeof (long),
 240   8 * sizeof (LONGEST),
 241   8 * sizeof (float),
 242   8 * sizeof (double),
 243   8 * sizeof (long double),
 244   0,
 245   0,
 246   0,
 247   0,
 248   0,
 249   0,
 250   0,
 251   0,
 252   0,
 253   0,
 254   0,
 255   0,
 256   0,
 257   0,
 258   0,
 259   0,
 260   0,
 261   0,
 262   0,
 263   0,
 264   0,
 265   0,
 266   0,
 267   0,
 268   0,
 269   0,
 270   0,
 271   0,
 272   0,
 273   0,
 274   0,
 275   0,
 276   0,
 277   0,
 278   0,
 279   0,
 280   0,
 281   generic_get_saved_register,
 282   0,
 283   0,
 284   0,
 285   0,
 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   /* startup_gdbarch() */
 325 };
 326 struct gdbarch *current_gdbarch = &startup_gdbarch;
 327
 328
 329 /* Create a new ``struct gdbarch'' based in information provided by
 330    ``struct gdbarch_info''. */
 331
 332 struct gdbarch *
 333 gdbarch_alloc (const struct gdbarch_info *info,
 334                struct gdbarch_tdep *tdep)
 335 {
 336   struct gdbarch *gdbarch = XMALLOC (struct gdbarch);
 337   memset (gdbarch, 0, sizeof (*gdbarch));
 338
 339   gdbarch->tdep = tdep;
 340
 341   gdbarch->bfd_arch_info = info->bfd_arch_info;
 342   gdbarch->byte_order = info->byte_order;
 343
 344   /* Force the explicit initialization of these. */
 345   gdbarch->bfd_vma_bit = TARGET_ARCHITECTURE->bits_per_address;
 346   gdbarch->num_regs = -1;
 347   gdbarch->sp_regnum = -1;
 348   gdbarch->fp_regnum = -1;
 349   gdbarch->pc_regnum = -1;
 350   gdbarch->register_name = legacy_register_name;
 351   gdbarch->register_size = -1;
 352   gdbarch->register_bytes = -1;
 353   gdbarch->max_register_raw_size = -1;
 354   gdbarch->max_register_virtual_size = -1;
 355   gdbarch->use_generic_dummy_frames = -1;
 356   gdbarch->call_dummy_start_offset = -1;
 357   gdbarch->call_dummy_breakpoint_offset = -1;
 358   gdbarch->call_dummy_breakpoint_offset_p = -1;
 359   gdbarch->call_dummy_length = -1;
 360   gdbarch->call_dummy_p = -1;
 361   gdbarch->call_dummy_words = legacy_call_dummy_words;
 362   gdbarch->sizeof_call_dummy_words = legacy_sizeof_call_dummy_words;
 363   gdbarch->call_dummy_stack_adjust_p = -1;
 364   gdbarch->coerce_float_to_double = default_coerce_float_to_double;
 365   gdbarch->register_convertible = generic_register_convertible_not;
 366   gdbarch->pointer_to_address = generic_pointer_to_address;
 367   gdbarch->address_to_pointer = generic_address_to_pointer;
 368   gdbarch->return_value_on_stack = generic_return_value_on_stack_not;
 369   gdbarch->breakpoint_from_pc = legacy_breakpoint_from_pc;
 370   gdbarch->memory_insert_breakpoint = default_memory_insert_breakpoint;
 371   gdbarch->memory_remove_breakpoint = default_memory_remove_breakpoint;
 372   gdbarch->decr_pc_after_break = -1;
 373   gdbarch->function_start_offset = -1;
 374   gdbarch->remote_translate_xfer_address = generic_remote_translate_xfer_address;
 375   gdbarch->frame_args_skip = -1;
 376   gdbarch->frameless_function_invocation = generic_frameless_function_invocation_not;
 377   /* gdbarch_alloc() */
 378
 379   return gdbarch;
 380 }
 381
 382
 383 /* Free a gdbarch struct.  This should never happen in normal
 384    operation --- once you've created a gdbarch, you keep it around.
 385    However, if an architecture's init function encounters an error
 386    building the structure, it may need to clean up a partially
 387    constructed gdbarch.  */
 388 void
 389 gdbarch_free (struct gdbarch *arch)
 390 {
 391   /* At the moment, this is trivial.  */
 392   free (arch);
 393 }
 394
 395
 396 /* Ensure that all values in a GDBARCH are reasonable. */
 397
 398 static void
 399 verify_gdbarch (struct gdbarch *gdbarch)
 400 {
 401   /* Only perform sanity checks on a multi-arch target. */
 402   if (GDB_MULTI_ARCH <= 0)
 403     return;
 404   /* fundamental */
 405   if (gdbarch->byte_order == 0)
 406     internal_error ("verify_gdbarch: byte-order unset");
 407   if (gdbarch->bfd_arch_info == NULL)
 408     internal_error ("verify_gdbarch: bfd_arch_info unset");
 409   /* Check those that need to be defined for the given multi-arch level. */
 410   /* Skip verify of bfd_vma_bit, invalid_p == 0 */
 411   if ((GDB_MULTI_ARCH >= 1)
 412       && (gdbarch->ptr_bit == 0))
 413     internal_error ("gdbarch: verify_gdbarch: ptr_bit invalid");
 414   if ((GDB_MULTI_ARCH >= 1)
 415       && (gdbarch->short_bit == 0))
 416     internal_error ("gdbarch: verify_gdbarch: short_bit invalid");
 417   if ((GDB_MULTI_ARCH >= 1)
 418       && (gdbarch->int_bit == 0))
 419     internal_error ("gdbarch: verify_gdbarch: int_bit invalid");
 420   if ((GDB_MULTI_ARCH >= 1)
 421       && (gdbarch->long_bit == 0))
 422     internal_error ("gdbarch: verify_gdbarch: long_bit invalid");
 423   if ((GDB_MULTI_ARCH >= 1)
 424       && (gdbarch->long_long_bit == 0))
 425     internal_error ("gdbarch: verify_gdbarch: long_long_bit invalid");
 426   if ((GDB_MULTI_ARCH >= 1)
 427       && (gdbarch->float_bit == 0))
 428     internal_error ("gdbarch: verify_gdbarch: float_bit invalid");
 429   if ((GDB_MULTI_ARCH >= 1)
 430       && (gdbarch->double_bit == 0))
 431     internal_error ("gdbarch: verify_gdbarch: double_bit invalid");
 432   if ((GDB_MULTI_ARCH >= 1)
 433       && (gdbarch->long_double_bit == 0))
 434     internal_error ("gdbarch: verify_gdbarch: long_double_bit invalid");
 435   /* Skip verify of ieee_float, invalid_p == 0 */
 436   if ((GDB_MULTI_ARCH >= 1)
 437       && (gdbarch->read_pc == 0))
 438     internal_error ("gdbarch: verify_gdbarch: read_pc invalid");
 439   if ((GDB_MULTI_ARCH >= 1)
 440       && (gdbarch->write_pc == 0))
 441     internal_error ("gdbarch: verify_gdbarch: write_pc invalid");
 442   if ((GDB_MULTI_ARCH >= 1)
 443       && (gdbarch->read_fp == 0))
 444     internal_error ("gdbarch: verify_gdbarch: read_fp invalid");
 445   if ((GDB_MULTI_ARCH >= 1)
 446       && (gdbarch->write_fp == 0))
 447     internal_error ("gdbarch: verify_gdbarch: write_fp invalid");
 448   if ((GDB_MULTI_ARCH >= 1)
 449       && (gdbarch->read_sp == 0))
 450     internal_error ("gdbarch: verify_gdbarch: read_sp invalid");
 451   if ((GDB_MULTI_ARCH >= 1)
 452       && (gdbarch->write_sp == 0))
 453     internal_error ("gdbarch: verify_gdbarch: write_sp invalid");
 454   if ((GDB_MULTI_ARCH >= 2)
 455       && (gdbarch->num_regs == -1))
 456     internal_error ("gdbarch: verify_gdbarch: num_regs invalid");
 457   if ((GDB_MULTI_ARCH >= 2)
 458       && (gdbarch->sp_regnum == -1))
 459     internal_error ("gdbarch: verify_gdbarch: sp_regnum invalid");
 460   if ((GDB_MULTI_ARCH >= 2)
 461       && (gdbarch->fp_regnum == -1))
 462     internal_error ("gdbarch: verify_gdbarch: fp_regnum invalid");
 463   if ((GDB_MULTI_ARCH >= 2)
 464       && (gdbarch->pc_regnum == -1))
 465     internal_error ("gdbarch: verify_gdbarch: pc_regnum invalid");
 466   /* Skip verify of register_name, invalid_p == 0 */
 467   if ((GDB_MULTI_ARCH >= 2)
 468       && (gdbarch->register_size == -1))
 469     internal_error ("gdbarch: verify_gdbarch: register_size invalid");
 470   if ((GDB_MULTI_ARCH >= 2)
 471       && (gdbarch->register_bytes == -1))
 472     internal_error ("gdbarch: verify_gdbarch: register_bytes invalid");
 473   if ((GDB_MULTI_ARCH >= 2)
 474       && (gdbarch->register_byte == 0))
 475     internal_error ("gdbarch: verify_gdbarch: register_byte invalid");
 476   if ((GDB_MULTI_ARCH >= 2)
 477       && (gdbarch->register_raw_size == 0))
 478     internal_error ("gdbarch: verify_gdbarch: register_raw_size invalid");
 479   if ((GDB_MULTI_ARCH >= 2)
 480       && (gdbarch->max_register_raw_size == -1))
 481     internal_error ("gdbarch: verify_gdbarch: max_register_raw_size invalid");
 482   if ((GDB_MULTI_ARCH >= 2)
 483       && (gdbarch->register_virtual_size == 0))
 484     internal_error ("gdbarch: verify_gdbarch: register_virtual_size invalid");
 485   if ((GDB_MULTI_ARCH >= 2)
 486       && (gdbarch->max_register_virtual_size == -1))
 487     internal_error ("gdbarch: verify_gdbarch: max_register_virtual_size invalid");
 488   if ((GDB_MULTI_ARCH >= 2)
 489       && (gdbarch->register_virtual_type == 0))
 490     internal_error ("gdbarch: verify_gdbarch: register_virtual_type invalid");
 491   if ((GDB_MULTI_ARCH >= 1)
 492       && (gdbarch->use_generic_dummy_frames == -1))
 493     internal_error ("gdbarch: verify_gdbarch: use_generic_dummy_frames invalid");
 494   if ((GDB_MULTI_ARCH >= 2)
 495       && (gdbarch->call_dummy_location == 0))
 496     internal_error ("gdbarch: verify_gdbarch: call_dummy_location invalid");
 497   if ((GDB_MULTI_ARCH >= 2)
 498       && (gdbarch->call_dummy_location == AT_ENTRY_POINT && gdbarch->call_dummy_address == 0))
 499     internal_error ("gdbarch: verify_gdbarch: call_dummy_address invalid");
 500   if ((GDB_MULTI_ARCH >= 2)
 501       && (gdbarch->call_dummy_start_offset == -1))
 502     internal_error ("gdbarch: verify_gdbarch: call_dummy_start_offset invalid");
 503   if ((GDB_MULTI_ARCH >= 2)
 504       && (gdbarch->call_dummy_breakpoint_offset == -1))
 505     internal_error ("gdbarch: verify_gdbarch: call_dummy_breakpoint_offset invalid");
 506   if ((GDB_MULTI_ARCH >= 1)
 507       && (gdbarch->call_dummy_breakpoint_offset_p == -1))
 508     internal_error ("gdbarch: verify_gdbarch: call_dummy_breakpoint_offset_p invalid");
 509   if ((GDB_MULTI_ARCH >= 2)
 510       && (gdbarch->call_dummy_length == -1))
 511     internal_error ("gdbarch: verify_gdbarch: call_dummy_length invalid");
 512   if ((GDB_MULTI_ARCH >= 2)
 513       && (gdbarch->pc_in_call_dummy == 0))
 514     internal_error ("gdbarch: verify_gdbarch: pc_in_call_dummy invalid");
 515   if ((GDB_MULTI_ARCH >= 1)
 516       && (gdbarch->call_dummy_p == -1))
 517     internal_error ("gdbarch: verify_gdbarch: call_dummy_p invalid");
 518   /* Skip verify of call_dummy_words, invalid_p == 0 */
 519   /* Skip verify of sizeof_call_dummy_words, invalid_p == 0 */
 520   if ((GDB_MULTI_ARCH >= 1)
 521       && (gdbarch->call_dummy_stack_adjust_p == -1))
 522     internal_error ("gdbarch: verify_gdbarch: call_dummy_stack_adjust_p invalid");
 523   if ((GDB_MULTI_ARCH >= 2)
 524       && (gdbarch->call_dummy_stack_adjust_p && gdbarch->call_dummy_stack_adjust == 0))
 525     internal_error ("gdbarch: verify_gdbarch: call_dummy_stack_adjust invalid");
 526   if ((GDB_MULTI_ARCH >= 2)
 527       && (gdbarch->fix_call_dummy == 0))
 528     internal_error ("gdbarch: verify_gdbarch: fix_call_dummy invalid");
 529   /* Skip verify of coerce_float_to_double, invalid_p == 0 */
 530   if ((GDB_MULTI_ARCH >= 1)
 531       && (gdbarch->get_saved_register == 0))
 532     internal_error ("gdbarch: verify_gdbarch: get_saved_register invalid");
 533   /* Skip verify of register_convertible, invalid_p == 0 */
 534   /* Skip verify of register_convert_to_virtual, invalid_p == 0 */
 535   /* Skip verify of register_convert_to_raw, invalid_p == 0 */
 536   /* Skip verify of pointer_to_address, invalid_p == 0 */
 537   /* Skip verify of address_to_pointer, invalid_p == 0 */
 538   /* Skip verify of return_value_on_stack, invalid_p == 0 */
 539   if ((GDB_MULTI_ARCH >= 2)
 540       && (gdbarch->extract_return_value == 0))
 541     internal_error ("gdbarch: verify_gdbarch: extract_return_value invalid");
 542   if ((GDB_MULTI_ARCH >= 1)
 543       && (gdbarch->push_arguments == 0))
 544     internal_error ("gdbarch: verify_gdbarch: push_arguments invalid");
 545   if ((GDB_MULTI_ARCH >= 2)
 546       && (gdbarch->push_dummy_frame == 0))
 547     internal_error ("gdbarch: verify_gdbarch: push_dummy_frame invalid");
 548   if ((GDB_MULTI_ARCH >= 1)
 549       && (gdbarch->push_return_address == 0))
 550     internal_error ("gdbarch: verify_gdbarch: push_return_address invalid");
 551   if ((GDB_MULTI_ARCH >= 2)
 552       && (gdbarch->pop_frame == 0))
 553     internal_error ("gdbarch: verify_gdbarch: pop_frame invalid");
 554   /* Skip verify of d10v_make_daddr, invalid_p == 0 */
 555   /* Skip verify of d10v_make_iaddr, invalid_p == 0 */
 556   if ((GDB_MULTI_ARCH >= 2)
 557       && (gdbarch->d10v_daddr_p == 0))
 558     internal_error ("gdbarch: verify_gdbarch: d10v_daddr_p invalid");
 559   if ((GDB_MULTI_ARCH >= 2)
 560       && (gdbarch->d10v_iaddr_p == 0))
 561     internal_error ("gdbarch: verify_gdbarch: d10v_iaddr_p invalid");
 562   if ((GDB_MULTI_ARCH >= 2)
 563       && (gdbarch->d10v_convert_daddr_to_raw == 0))
 564     internal_error ("gdbarch: verify_gdbarch: d10v_convert_daddr_to_raw invalid");
 565   if ((GDB_MULTI_ARCH >= 2)
 566       && (gdbarch->d10v_convert_iaddr_to_raw == 0))
 567     internal_error ("gdbarch: verify_gdbarch: d10v_convert_iaddr_to_raw invalid");
 568   if ((GDB_MULTI_ARCH >= 2)
 569       && (gdbarch->store_struct_return == 0))
 570     internal_error ("gdbarch: verify_gdbarch: store_struct_return invalid");
 571   if ((GDB_MULTI_ARCH >= 2)
 572       && (gdbarch->store_return_value == 0))
 573     internal_error ("gdbarch: verify_gdbarch: store_return_value invalid");
 574   if ((GDB_MULTI_ARCH >= 2)
 575       && (gdbarch->extract_struct_value_address == 0))
 576     internal_error ("gdbarch: verify_gdbarch: extract_struct_value_address invalid");
 577   if ((GDB_MULTI_ARCH >= 2)
 578       && (gdbarch->use_struct_convention == 0))
 579     internal_error ("gdbarch: verify_gdbarch: use_struct_convention invalid");
 580   if ((GDB_MULTI_ARCH >= 2)
 581       && (gdbarch->frame_init_saved_regs == 0))
 582     internal_error ("gdbarch: verify_gdbarch: frame_init_saved_regs invalid");
 583   if ((GDB_MULTI_ARCH >= 2)
 584       && (gdbarch->init_extra_frame_info == 0))
 585     internal_error ("gdbarch: verify_gdbarch: init_extra_frame_info invalid");
 586   if ((GDB_MULTI_ARCH >= 2)
 587       && (gdbarch->skip_prologue == 0))
 588     internal_error ("gdbarch: verify_gdbarch: skip_prologue invalid");
 589   if ((GDB_MULTI_ARCH >= 2)
 590       && (gdbarch->inner_than == 0))
 591     internal_error ("gdbarch: verify_gdbarch: inner_than invalid");
 592   /* Skip verify of breakpoint_from_pc, invalid_p == 0 */
 593   /* Skip verify of memory_insert_breakpoint, invalid_p == 0 */
 594   /* Skip verify of memory_remove_breakpoint, invalid_p == 0 */
 595   if ((GDB_MULTI_ARCH >= 2)
 596       && (gdbarch->decr_pc_after_break == -1))
 597     internal_error ("gdbarch: verify_gdbarch: decr_pc_after_break invalid");
 598   if ((GDB_MULTI_ARCH >= 2)
 599       && (gdbarch->function_start_offset == -1))
 600     internal_error ("gdbarch: verify_gdbarch: function_start_offset invalid");
 601   /* Skip verify of remote_translate_xfer_address, invalid_p == 0 */
 602   if ((GDB_MULTI_ARCH >= 2)
 603       && (gdbarch->frame_args_skip == -1))
 604     internal_error ("gdbarch: verify_gdbarch: frame_args_skip invalid");
 605   /* Skip verify of frameless_function_invocation, invalid_p == 0 */
 606   if ((GDB_MULTI_ARCH >= 2)
 607       && (gdbarch->frame_chain == 0))
 608     internal_error ("gdbarch: verify_gdbarch: frame_chain invalid");
 609   if ((GDB_MULTI_ARCH >= 1)
 610       && (gdbarch->frame_chain_valid == 0))
 611     internal_error ("gdbarch: verify_gdbarch: frame_chain_valid invalid");
 612   if ((GDB_MULTI_ARCH >= 2)
 613       && (gdbarch->frame_saved_pc == 0))
 614     internal_error ("gdbarch: verify_gdbarch: frame_saved_pc invalid");
 615   if ((GDB_MULTI_ARCH >= 2)
 616       && (gdbarch->frame_args_address == 0))
 617     internal_error ("gdbarch: verify_gdbarch: frame_args_address invalid");
 618   if ((GDB_MULTI_ARCH >= 2)
 619       && (gdbarch->frame_locals_address == 0))
 620     internal_error ("gdbarch: verify_gdbarch: frame_locals_address invalid");
 621   if ((GDB_MULTI_ARCH >= 2)
 622       && (gdbarch->saved_pc_after_call == 0))
 623     internal_error ("gdbarch: verify_gdbarch: saved_pc_after_call invalid");
 624   if ((GDB_MULTI_ARCH >= 2)
 625       && (gdbarch->frame_num_args == 0))
 626     internal_error ("gdbarch: verify_gdbarch: frame_num_args invalid");
 627   /* Skip verify of stack_align, has predicate */
 628   /* Skip verify of reg_struct_has_addr, has predicate */
 629 }
 630
 631
 632 /* Print out the details of the current architecture. */
 633
 634 void
 635 gdbarch_dump (void)
 636 {
 637   if (TARGET_ARCHITECTURE != NULL)
 638     fprintf_unfiltered (gdb_stdlog,
 639                         "gdbarch_update: TARGET_ARCHITECTURE = %s\n",
 640                         TARGET_ARCHITECTURE->printable_name);
 641   fprintf_unfiltered (gdb_stdlog,
 642                       "gdbarch_update: TARGET_BYTE_ORDER = %ld\n",
 643                       (long) TARGET_BYTE_ORDER);
 644   fprintf_unfiltered (gdb_stdlog,
 645                       "gdbarch_update: TARGET_BFD_VMA_BIT = %ld\n",
 646                       (long) TARGET_BFD_VMA_BIT);
 647   fprintf_unfiltered (gdb_stdlog,
 648                       "gdbarch_update: TARGET_PTR_BIT = %ld\n",
 649                       (long) TARGET_PTR_BIT);
 650   fprintf_unfiltered (gdb_stdlog,
 651                       "gdbarch_update: TARGET_SHORT_BIT = %ld\n",
 652                       (long) TARGET_SHORT_BIT);
 653   fprintf_unfiltered (gdb_stdlog,
 654                       "gdbarch_update: TARGET_INT_BIT = %ld\n",
 655                       (long) TARGET_INT_BIT);
 656   fprintf_unfiltered (gdb_stdlog,
 657                       "gdbarch_update: TARGET_LONG_BIT = %ld\n",
 658                       (long) TARGET_LONG_BIT);
 659   fprintf_unfiltered (gdb_stdlog,
 660                       "gdbarch_update: TARGET_LONG_LONG_BIT = %ld\n",
 661                       (long) TARGET_LONG_LONG_BIT);
 662   fprintf_unfiltered (gdb_stdlog,
 663                       "gdbarch_update: TARGET_FLOAT_BIT = %ld\n",
 664                       (long) TARGET_FLOAT_BIT);
 665   fprintf_unfiltered (gdb_stdlog,
 666                       "gdbarch_update: TARGET_DOUBLE_BIT = %ld\n",
 667                       (long) TARGET_DOUBLE_BIT);
 668   fprintf_unfiltered (gdb_stdlog,
 669                       "gdbarch_update: TARGET_LONG_DOUBLE_BIT = %ld\n",
 670                       (long) TARGET_LONG_DOUBLE_BIT);
 671   fprintf_unfiltered (gdb_stdlog,
 672                       "gdbarch_update: IEEE_FLOAT = %ld\n",
 673                       (long) IEEE_FLOAT);
 674   fprintf_unfiltered (gdb_stdlog,
 675                       "gdbarch_update: TARGET_READ_PC = 0x%08lx\n",
 676                       (long) current_gdbarch->read_pc
 677                       /*TARGET_READ_PC ()*/);
 678   fprintf_unfiltered (gdb_stdlog,
 679                       "gdbarch_update: TARGET_WRITE_PC = 0x%08lx\n",
 680                       (long) current_gdbarch->write_pc
 681                       /*TARGET_WRITE_PC ()*/);
 682   fprintf_unfiltered (gdb_stdlog,
 683                       "gdbarch_update: TARGET_READ_FP = 0x%08lx\n",
 684                       (long) current_gdbarch->read_fp
 685                       /*TARGET_READ_FP ()*/);
 686   fprintf_unfiltered (gdb_stdlog,
 687                       "gdbarch_update: TARGET_WRITE_FP = 0x%08lx\n",
 688                       (long) current_gdbarch->write_fp
 689                       /*TARGET_WRITE_FP ()*/);
 690   fprintf_unfiltered (gdb_stdlog,
 691                       "gdbarch_update: TARGET_READ_SP = 0x%08lx\n",
 692                       (long) current_gdbarch->read_sp
 693                       /*TARGET_READ_SP ()*/);
 694   fprintf_unfiltered (gdb_stdlog,
 695                       "gdbarch_update: TARGET_WRITE_SP = 0x%08lx\n",
 696                       (long) current_gdbarch->write_sp
 697                       /*TARGET_WRITE_SP ()*/);
 698   fprintf_unfiltered (gdb_stdlog,
 699                       "gdbarch_update: NUM_REGS = %ld\n",
 700                       (long) NUM_REGS);
 701   fprintf_unfiltered (gdb_stdlog,
 702                       "gdbarch_update: SP_REGNUM = %ld\n",
 703                       (long) SP_REGNUM);
 704   fprintf_unfiltered (gdb_stdlog,
 705                       "gdbarch_update: FP_REGNUM = %ld\n",
 706                       (long) FP_REGNUM);
 707   fprintf_unfiltered (gdb_stdlog,
 708                       "gdbarch_update: PC_REGNUM = %ld\n",
 709                       (long) PC_REGNUM);
 710   fprintf_unfiltered (gdb_stdlog,
 711                       "gdbarch_update: REGISTER_NAME = 0x%08lx\n",
 712                       (long) current_gdbarch->register_name
 713                       /*REGISTER_NAME ()*/);
 714   fprintf_unfiltered (gdb_stdlog,
 715                       "gdbarch_update: REGISTER_SIZE = %ld\n",
 716                       (long) REGISTER_SIZE);
 717   fprintf_unfiltered (gdb_stdlog,
 718                       "gdbarch_update: REGISTER_BYTES = %ld\n",
 719                       (long) REGISTER_BYTES);
 720   fprintf_unfiltered (gdb_stdlog,
 721                       "gdbarch_update: REGISTER_BYTE = 0x%08lx\n",
 722                       (long) current_gdbarch->register_byte
 723                       /*REGISTER_BYTE ()*/);
 724   fprintf_unfiltered (gdb_stdlog,
 725                       "gdbarch_update: REGISTER_RAW_SIZE = 0x%08lx\n",
 726                       (long) current_gdbarch->register_raw_size
 727                       /*REGISTER_RAW_SIZE ()*/);
 728   fprintf_unfiltered (gdb_stdlog,
 729                       "gdbarch_update: MAX_REGISTER_RAW_SIZE = %ld\n",
 730                       (long) MAX_REGISTER_RAW_SIZE);
 731   fprintf_unfiltered (gdb_stdlog,
 732                       "gdbarch_update: REGISTER_VIRTUAL_SIZE = 0x%08lx\n",
 733                       (long) current_gdbarch->register_virtual_size
 734                       /*REGISTER_VIRTUAL_SIZE ()*/);
 735   fprintf_unfiltered (gdb_stdlog,
 736                       "gdbarch_update: MAX_REGISTER_VIRTUAL_SIZE = %ld\n",
 737                       (long) MAX_REGISTER_VIRTUAL_SIZE);
 738   fprintf_unfiltered (gdb_stdlog,
 739                       "gdbarch_update: REGISTER_VIRTUAL_TYPE = 0x%08lx\n",
 740                       (long) current_gdbarch->register_virtual_type
 741                       /*REGISTER_VIRTUAL_TYPE ()*/);
 742   fprintf_unfiltered (gdb_stdlog,
 743                       "gdbarch_update: USE_GENERIC_DUMMY_FRAMES = %ld\n",
 744                       (long) USE_GENERIC_DUMMY_FRAMES);
 745   fprintf_unfiltered (gdb_stdlog,
 746                       "gdbarch_update: CALL_DUMMY_LOCATION = %ld\n",
 747                       (long) CALL_DUMMY_LOCATION);
 748   fprintf_unfiltered (gdb_stdlog,
 749                       "gdbarch_update: CALL_DUMMY_ADDRESS = 0x%08lx\n",
 750                       (long) current_gdbarch->call_dummy_address
 751                       /*CALL_DUMMY_ADDRESS ()*/);
 752   fprintf_unfiltered (gdb_stdlog,
 753                       "gdbarch_update: CALL_DUMMY_START_OFFSET = 0x%08lx\n",
 754                       (long) CALL_DUMMY_START_OFFSET);
 755   fprintf_unfiltered (gdb_stdlog,
 756                       "gdbarch_update: CALL_DUMMY_BREAKPOINT_OFFSET = 0x%08lx\n",
 757                       (long) CALL_DUMMY_BREAKPOINT_OFFSET);
 758   fprintf_unfiltered (gdb_stdlog,
 759                       "gdbarch_update: CALL_DUMMY_BREAKPOINT_OFFSET_P = %ld\n",
 760                       (long) CALL_DUMMY_BREAKPOINT_OFFSET_P);
 761   if (CALL_DUMMY_LOCATION == BEFORE_TEXT_END || CALL_DUMMY_LOCATION == AFTER_TEXT_END)
 762     fprintf_unfiltered (gdb_stdlog,
 763                         "gdbarch_update: CALL_DUMMY_LENGTH = %ld\n",
 764                         (long) CALL_DUMMY_LENGTH);
 765   fprintf_unfiltered (gdb_stdlog,
 766                       "gdbarch_update: PC_IN_CALL_DUMMY = 0x%08lx\n",
 767                       (long) current_gdbarch->pc_in_call_dummy
 768                       /*PC_IN_CALL_DUMMY ()*/);
 769   fprintf_unfiltered (gdb_stdlog,
 770                       "gdbarch_update: CALL_DUMMY_P = %ld\n",
 771                       (long) CALL_DUMMY_P);
 772   fprintf_unfiltered (gdb_stdlog,
 773                       "gdbarch_update: CALL_DUMMY_WORDS = 0x%08lx\n",
 774                       (long) CALL_DUMMY_WORDS);
 775   fprintf_unfiltered (gdb_stdlog,
 776                       "gdbarch_update: SIZEOF_CALL_DUMMY_WORDS = 0x%08lx\n",
 777                       (long) SIZEOF_CALL_DUMMY_WORDS);
 778   fprintf_unfiltered (gdb_stdlog,
 779                       "gdbarch_update: CALL_DUMMY_STACK_ADJUST_P = 0x%08lx\n",
 780                       (long) CALL_DUMMY_STACK_ADJUST_P);
 781   if (CALL_DUMMY_STACK_ADJUST_P)
 782     fprintf_unfiltered (gdb_stdlog,
 783                         "gdbarch_update: CALL_DUMMY_STACK_ADJUST = 0x%08lx\n",
 784                         (long) CALL_DUMMY_STACK_ADJUST);
 785   fprintf_unfiltered (gdb_stdlog,
 786                       "gdbarch_update: FIX_CALL_DUMMY = 0x%08lx\n",
 787                       (long) current_gdbarch->fix_call_dummy
 788                       /*FIX_CALL_DUMMY ()*/);
 789 #ifdef BELIEVE_PCC_PROMOTION
 790   fprintf_unfiltered (gdb_stdlog,
 791                       "gdbarch_update: BELIEVE_PCC_PROMOTION = %ld\n",
 792                       (long) BELIEVE_PCC_PROMOTION);
 793 #endif
 794 #ifdef BELIEVE_PCC_PROMOTION_TYPE
 795   fprintf_unfiltered (gdb_stdlog,
 796                       "gdbarch_update: BELIEVE_PCC_PROMOTION_TYPE = %ld\n",
 797                       (long) BELIEVE_PCC_PROMOTION_TYPE);
 798 #endif
 799   fprintf_unfiltered (gdb_stdlog,
 800                       "gdbarch_update: COERCE_FLOAT_TO_DOUBLE = 0x%08lx\n",
 801                       (long) current_gdbarch->coerce_float_to_double
 802                       /*COERCE_FLOAT_TO_DOUBLE ()*/);
 803   fprintf_unfiltered (gdb_stdlog,
 804                       "gdbarch_update: GET_SAVED_REGISTER = 0x%08lx\n",
 805                       (long) current_gdbarch->get_saved_register
 806                       /*GET_SAVED_REGISTER ()*/);
 807   fprintf_unfiltered (gdb_stdlog,
 808                       "gdbarch_update: REGISTER_CONVERTIBLE = 0x%08lx\n",
 809                       (long) current_gdbarch->register_convertible
 810                       /*REGISTER_CONVERTIBLE ()*/);
 811   fprintf_unfiltered (gdb_stdlog,
 812                       "gdbarch_update: REGISTER_CONVERT_TO_VIRTUAL = 0x%08lx\n",
 813                       (long) current_gdbarch->register_convert_to_virtual
 814                       /*REGISTER_CONVERT_TO_VIRTUAL ()*/);
 815   fprintf_unfiltered (gdb_stdlog,
 816                       "gdbarch_update: REGISTER_CONVERT_TO_RAW = 0x%08lx\n",
 817                       (long) current_gdbarch->register_convert_to_raw
 818                       /*REGISTER_CONVERT_TO_RAW ()*/);
 819   fprintf_unfiltered (gdb_stdlog,
 820                       "gdbarch_update: POINTER_TO_ADDRESS = 0x%08lx\n",
 821                       (long) current_gdbarch->pointer_to_address
 822                       /*POINTER_TO_ADDRESS ()*/);
 823   fprintf_unfiltered (gdb_stdlog,
 824                       "gdbarch_update: ADDRESS_TO_POINTER = 0x%08lx\n",
 825                       (long) current_gdbarch->address_to_pointer
 826                       /*ADDRESS_TO_POINTER ()*/);
 827   fprintf_unfiltered (gdb_stdlog,
 828                       "gdbarch_update: RETURN_VALUE_ON_STACK = 0x%08lx\n",
 829                       (long) current_gdbarch->return_value_on_stack
 830                       /*RETURN_VALUE_ON_STACK ()*/);
 831   fprintf_unfiltered (gdb_stdlog,
 832                       "gdbarch_update: EXTRACT_RETURN_VALUE = 0x%08lx\n",
 833                       (long) current_gdbarch->extract_return_value
 834                       /*EXTRACT_RETURN_VALUE ()*/);
 835   fprintf_unfiltered (gdb_stdlog,
 836                       "gdbarch_update: PUSH_ARGUMENTS = 0x%08lx\n",
 837                       (long) current_gdbarch->push_arguments
 838                       /*PUSH_ARGUMENTS ()*/);
 839   fprintf_unfiltered (gdb_stdlog,
 840                       "gdbarch_update: PUSH_DUMMY_FRAME = 0x%08lx\n",
 841                       (long) current_gdbarch->push_dummy_frame
 842                       /*PUSH_DUMMY_FRAME ()*/);
 843   fprintf_unfiltered (gdb_stdlog,
 844                       "gdbarch_update: PUSH_RETURN_ADDRESS = 0x%08lx\n",
 845                       (long) current_gdbarch->push_return_address
 846                       /*PUSH_RETURN_ADDRESS ()*/);
 847   fprintf_unfiltered (gdb_stdlog,
 848                       "gdbarch_update: POP_FRAME = 0x%08lx\n",
 849                       (long) current_gdbarch->pop_frame
 850                       /*POP_FRAME ()*/);
 851   fprintf_unfiltered (gdb_stdlog,
 852                       "gdbarch_update: D10V_MAKE_DADDR = 0x%08lx\n",
 853                       (long) current_gdbarch->d10v_make_daddr
 854                       /*D10V_MAKE_DADDR ()*/);
 855   fprintf_unfiltered (gdb_stdlog,
 856                       "gdbarch_update: D10V_MAKE_IADDR = 0x%08lx\n",
 857                       (long) current_gdbarch->d10v_make_iaddr
 858                       /*D10V_MAKE_IADDR ()*/);
 859   fprintf_unfiltered (gdb_stdlog,
 860                       "gdbarch_update: D10V_DADDR_P = 0x%08lx\n",
 861                       (long) current_gdbarch->d10v_daddr_p
 862                       /*D10V_DADDR_P ()*/);
 863   fprintf_unfiltered (gdb_stdlog,
 864                       "gdbarch_update: D10V_IADDR_P = 0x%08lx\n",
 865                       (long) current_gdbarch->d10v_iaddr_p
 866                       /*D10V_IADDR_P ()*/);
 867   fprintf_unfiltered (gdb_stdlog,
 868                       "gdbarch_update: D10V_CONVERT_DADDR_TO_RAW = 0x%08lx\n",
 869                       (long) current_gdbarch->d10v_convert_daddr_to_raw
 870                       /*D10V_CONVERT_DADDR_TO_RAW ()*/);
 871   fprintf_unfiltered (gdb_stdlog,
 872                       "gdbarch_update: D10V_CONVERT_IADDR_TO_RAW = 0x%08lx\n",
 873                       (long) current_gdbarch->d10v_convert_iaddr_to_raw
 874                       /*D10V_CONVERT_IADDR_TO_RAW ()*/);
 875   fprintf_unfiltered (gdb_stdlog,
 876                       "gdbarch_update: STORE_STRUCT_RETURN = 0x%08lx\n",
 877                       (long) current_gdbarch->store_struct_return
 878                       /*STORE_STRUCT_RETURN ()*/);
 879   fprintf_unfiltered (gdb_stdlog,
 880                       "gdbarch_update: STORE_RETURN_VALUE = 0x%08lx\n",
 881                       (long) current_gdbarch->store_return_value
 882                       /*STORE_RETURN_VALUE ()*/);
 883   fprintf_unfiltered (gdb_stdlog,
 884                       "gdbarch_update: EXTRACT_STRUCT_VALUE_ADDRESS = 0x%08lx\n",
 885                       (long) current_gdbarch->extract_struct_value_address
 886                       /*EXTRACT_STRUCT_VALUE_ADDRESS ()*/);
 887   fprintf_unfiltered (gdb_stdlog,
 888                       "gdbarch_update: USE_STRUCT_CONVENTION = 0x%08lx\n",
 889                       (long) current_gdbarch->use_struct_convention
 890                       /*USE_STRUCT_CONVENTION ()*/);
 891   fprintf_unfiltered (gdb_stdlog,
 892                       "gdbarch_update: FRAME_INIT_SAVED_REGS = 0x%08lx\n",
 893                       (long) current_gdbarch->frame_init_saved_regs
 894                       /*FRAME_INIT_SAVED_REGS ()*/);
 895   fprintf_unfiltered (gdb_stdlog,
 896                       "gdbarch_update: INIT_EXTRA_FRAME_INFO = 0x%08lx\n",
 897                       (long) current_gdbarch->init_extra_frame_info
 898                       /*INIT_EXTRA_FRAME_INFO ()*/);
 899   fprintf_unfiltered (gdb_stdlog,
 900                       "gdbarch_update: SKIP_PROLOGUE = 0x%08lx\n",
 901                       (long) current_gdbarch->skip_prologue
 902                       /*SKIP_PROLOGUE ()*/);
 903   fprintf_unfiltered (gdb_stdlog,
 904                       "gdbarch_update: INNER_THAN = 0x%08lx\n",
 905                       (long) current_gdbarch->inner_than
 906                       /*INNER_THAN ()*/);
 907   fprintf_unfiltered (gdb_stdlog,
 908                       "gdbarch_update: BREAKPOINT_FROM_PC = 0x%08lx\n",
 909                       (long) current_gdbarch->breakpoint_from_pc
 910                       /*BREAKPOINT_FROM_PC ()*/);
 911   fprintf_unfiltered (gdb_stdlog,
 912                       "gdbarch_update: MEMORY_INSERT_BREAKPOINT = 0x%08lx\n",
 913                       (long) current_gdbarch->memory_insert_breakpoint
 914                       /*MEMORY_INSERT_BREAKPOINT ()*/);
 915   fprintf_unfiltered (gdb_stdlog,
 916                       "gdbarch_update: MEMORY_REMOVE_BREAKPOINT = 0x%08lx\n",
 917                       (long) current_gdbarch->memory_remove_breakpoint
 918                       /*MEMORY_REMOVE_BREAKPOINT ()*/);
 919   fprintf_unfiltered (gdb_stdlog,
 920                       "gdbarch_update: DECR_PC_AFTER_BREAK = %ld\n",
 921                       (long) DECR_PC_AFTER_BREAK);
 922   fprintf_unfiltered (gdb_stdlog,
 923                       "gdbarch_update: FUNCTION_START_OFFSET = %ld\n",
 924                       (long) FUNCTION_START_OFFSET);
 925   fprintf_unfiltered (gdb_stdlog,
 926                       "gdbarch_update: REMOTE_TRANSLATE_XFER_ADDRESS = 0x%08lx\n",
 927                       (long) current_gdbarch->remote_translate_xfer_address
 928                       /*REMOTE_TRANSLATE_XFER_ADDRESS ()*/);
 929   fprintf_unfiltered (gdb_stdlog,
 930                       "gdbarch_update: FRAME_ARGS_SKIP = %ld\n",
 931                       (long) FRAME_ARGS_SKIP);
 932   fprintf_unfiltered (gdb_stdlog,
 933                       "gdbarch_update: FRAMELESS_FUNCTION_INVOCATION = 0x%08lx\n",
 934                       (long) current_gdbarch->frameless_function_invocation
 935                       /*FRAMELESS_FUNCTION_INVOCATION ()*/);
 936   fprintf_unfiltered (gdb_stdlog,
 937                       "gdbarch_update: FRAME_CHAIN = 0x%08lx\n",
 938                       (long) current_gdbarch->frame_chain
 939                       /*FRAME_CHAIN ()*/);
 940   fprintf_unfiltered (gdb_stdlog,
 941                       "gdbarch_update: FRAME_CHAIN_VALID = 0x%08lx\n",
 942                       (long) current_gdbarch->frame_chain_valid
 943                       /*FRAME_CHAIN_VALID ()*/);
 944   fprintf_unfiltered (gdb_stdlog,
 945                       "gdbarch_update: FRAME_SAVED_PC = 0x%08lx\n",
 946                       (long) current_gdbarch->frame_saved_pc
 947                       /*FRAME_SAVED_PC ()*/);
 948   fprintf_unfiltered (gdb_stdlog,
 949                       "gdbarch_update: FRAME_ARGS_ADDRESS = 0x%08lx\n",
 950                       (long) current_gdbarch->frame_args_address
 951                       /*FRAME_ARGS_ADDRESS ()*/);
 952   fprintf_unfiltered (gdb_stdlog,
 953                       "gdbarch_update: FRAME_LOCALS_ADDRESS = 0x%08lx\n",
 954                       (long) current_gdbarch->frame_locals_address
 955                       /*FRAME_LOCALS_ADDRESS ()*/);
 956   fprintf_unfiltered (gdb_stdlog,
 957                       "gdbarch_update: SAVED_PC_AFTER_CALL = 0x%08lx\n",
 958                       (long) current_gdbarch->saved_pc_after_call
 959                       /*SAVED_PC_AFTER_CALL ()*/);
 960   fprintf_unfiltered (gdb_stdlog,
 961                       "gdbarch_update: FRAME_NUM_ARGS = 0x%08lx\n",
 962                       (long) current_gdbarch->frame_num_args
 963                       /*FRAME_NUM_ARGS ()*/);
 964   fprintf_unfiltered (gdb_stdlog,
 965                       "gdbarch_update: STACK_ALIGN = 0x%08lx\n",
 966                       (long) current_gdbarch->stack_align
 967                       /*STACK_ALIGN ()*/);
 968   fprintf_unfiltered (gdb_stdlog,
 969                       "gdbarch_update: REG_STRUCT_HAS_ADDR = 0x%08lx\n",
 970                       (long) current_gdbarch->reg_struct_has_addr
 971                       /*REG_STRUCT_HAS_ADDR ()*/);
 972 }
 973
 974 struct gdbarch_tdep *
 975 gdbarch_tdep (struct gdbarch *gdbarch)
 976 {
 977   if (gdbarch_debug >= 2)
 978     fprintf_unfiltered (gdb_stdlog, "gdbarch_tdep called\n");
 979   return gdbarch->tdep;
 980 }
 981
 982
 983 const struct bfd_arch_info *
 984 gdbarch_bfd_arch_info (struct gdbarch *gdbarch)
 985 {
 986   if (gdbarch_debug >= 2)
 987     fprintf_unfiltered (gdb_stdlog, "gdbarch_bfd_arch_info called\n");
 988   return gdbarch->bfd_arch_info;
 989 }
 990
 991 int
 992 gdbarch_byte_order (struct gdbarch *gdbarch)
 993 {
 994   if (gdbarch_debug >= 2)
 995     fprintf_unfiltered (gdb_stdlog, "gdbarch_byte_order called\n");
 996   return gdbarch->byte_order;
 997 }
 998
 999 int
1000 gdbarch_bfd_vma_bit (struct gdbarch *gdbarch)
1001 {
1002   if (GDB_MULTI_ARCH == 0)
1003     return TARGET_ARCHITECTURE->bits_per_address;
1004   /* Skip verify of bfd_vma_bit, invalid_p == 0 */
1005   if (gdbarch_debug >= 2)
1006     fprintf_unfiltered (gdb_stdlog, "gdbarch_bfd_vma_bit called\n");
1007   return gdbarch->bfd_vma_bit;
1008 }
1009
1010 void
1011 set_gdbarch_bfd_vma_bit (struct gdbarch *gdbarch,
1012                          int bfd_vma_bit)
1013 {
1014   gdbarch->bfd_vma_bit = bfd_vma_bit;
1015 }
1016
1017 int
1018 gdbarch_ptr_bit (struct gdbarch *gdbarch)
1019 {
1020   if (gdbarch->ptr_bit == 0)
1021     internal_error ("gdbarch: gdbarch_ptr_bit invalid");
1022   if (gdbarch_debug >= 2)
1023     fprintf_unfiltered (gdb_stdlog, "gdbarch_ptr_bit called\n");
1024   return gdbarch->ptr_bit;
1025 }
1026
1027 void
1028 set_gdbarch_ptr_bit (struct gdbarch *gdbarch,
1029                      int ptr_bit)
1030 {
1031   gdbarch->ptr_bit = ptr_bit;
1032 }
1033
1034 int
1035 gdbarch_short_bit (struct gdbarch *gdbarch)
1036 {
1037   if (gdbarch->short_bit == 0)
1038     internal_error ("gdbarch: gdbarch_short_bit invalid");
1039   if (gdbarch_debug >= 2)
1040     fprintf_unfiltered (gdb_stdlog, "gdbarch_short_bit called\n");
1041   return gdbarch->short_bit;
1042 }
1043
1044 void
1045 set_gdbarch_short_bit (struct gdbarch *gdbarch,
1046                        int short_bit)
1047 {
1048   gdbarch->short_bit = short_bit;
1049 }
1050
1051 int
1052 gdbarch_int_bit (struct gdbarch *gdbarch)
1053 {
1054   if (gdbarch->int_bit == 0)
1055     internal_error ("gdbarch: gdbarch_int_bit invalid");
1056   if (gdbarch_debug >= 2)
1057     fprintf_unfiltered (gdb_stdlog, "gdbarch_int_bit called\n");
1058   return gdbarch->int_bit;
1059 }
1060
1061 void
1062 set_gdbarch_int_bit (struct gdbarch *gdbarch,
1063                      int int_bit)
1064 {
1065   gdbarch->int_bit = int_bit;
1066 }
1067
1068 int
1069 gdbarch_long_bit (struct gdbarch *gdbarch)
1070 {
1071   if (gdbarch->long_bit == 0)
1072     internal_error ("gdbarch: gdbarch_long_bit invalid");
1073   if (gdbarch_debug >= 2)
1074     fprintf_unfiltered (gdb_stdlog, "gdbarch_long_bit called\n");
1075   return gdbarch->long_bit;
1076 }
1077
1078 void
1079 set_gdbarch_long_bit (struct gdbarch *gdbarch,
1080                       int long_bit)
1081 {
1082   gdbarch->long_bit = long_bit;
1083 }
1084
1085 int
1086 gdbarch_long_long_bit (struct gdbarch *gdbarch)
1087 {
1088   if (gdbarch->long_long_bit == 0)
1089     internal_error ("gdbarch: gdbarch_long_long_bit invalid");
1090   if (gdbarch_debug >= 2)
1091     fprintf_unfiltered (gdb_stdlog, "gdbarch_long_long_bit called\n");
1092   return gdbarch->long_long_bit;
1093 }
1094
1095 void
1096 set_gdbarch_long_long_bit (struct gdbarch *gdbarch,
1097                            int long_long_bit)
1098 {
1099   gdbarch->long_long_bit = long_long_bit;
1100 }
1101
1102 int
1103 gdbarch_float_bit (struct gdbarch *gdbarch)
1104 {
1105   if (gdbarch->float_bit == 0)
1106     internal_error ("gdbarch: gdbarch_float_bit invalid");
1107   if (gdbarch_debug >= 2)
1108     fprintf_unfiltered (gdb_stdlog, "gdbarch_float_bit called\n");
1109   return gdbarch->float_bit;
1110 }
1111
1112 void
1113 set_gdbarch_float_bit (struct gdbarch *gdbarch,
1114                        int float_bit)
1115 {
1116   gdbarch->float_bit = float_bit;
1117 }
1118
1119 int
1120 gdbarch_double_bit (struct gdbarch *gdbarch)
1121 {
1122   if (gdbarch->double_bit == 0)
1123     internal_error ("gdbarch: gdbarch_double_bit invalid");
1124   if (gdbarch_debug >= 2)
1125     fprintf_unfiltered (gdb_stdlog, "gdbarch_double_bit called\n");
1126   return gdbarch->double_bit;
1127 }
1128
1129 void
1130 set_gdbarch_double_bit (struct gdbarch *gdbarch,
1131                         int double_bit)
1132 {
1133   gdbarch->double_bit = double_bit;
1134 }
1135
1136 int
1137 gdbarch_long_double_bit (struct gdbarch *gdbarch)
1138 {
1139   if (gdbarch->long_double_bit == 0)
1140     internal_error ("gdbarch: gdbarch_long_double_bit invalid");
1141   if (gdbarch_debug >= 2)
1142     fprintf_unfiltered (gdb_stdlog, "gdbarch_long_double_bit called\n");
1143   return gdbarch->long_double_bit;
1144 }
1145
1146 void
1147 set_gdbarch_long_double_bit (struct gdbarch *gdbarch,
1148                              int long_double_bit)
1149 {
1150   gdbarch->long_double_bit = long_double_bit;
1151 }
1152
1153 int
1154 gdbarch_ieee_float (struct gdbarch *gdbarch)
1155 {
1156   /* Skip verify of ieee_float, invalid_p == 0 */
1157   if (gdbarch_debug >= 2)
1158     fprintf_unfiltered (gdb_stdlog, "gdbarch_ieee_float called\n");
1159   return gdbarch->ieee_float;
1160 }
1161
1162 void
1163 set_gdbarch_ieee_float (struct gdbarch *gdbarch,
1164                         int ieee_float)
1165 {
1166   gdbarch->ieee_float = ieee_float;
1167 }
1168
1169 CORE_ADDR
1170 gdbarch_read_pc (struct gdbarch *gdbarch, int pid)
1171 {
1172   if (gdbarch->read_pc == 0)
1173     internal_error ("gdbarch: gdbarch_read_pc invalid");
1174   if (gdbarch_debug >= 2)
1175     fprintf_unfiltered (gdb_stdlog, "gdbarch_read_pc called\n");
1176   return gdbarch->read_pc (pid);
1177 }
1178
1179 void
1180 set_gdbarch_read_pc (struct gdbarch *gdbarch,
1181                      gdbarch_read_pc_ftype read_pc)
1182 {
1183   gdbarch->read_pc = read_pc;
1184 }
1185
1186 void
1187 gdbarch_write_pc (struct gdbarch *gdbarch, CORE_ADDR val, int pid)
1188 {
1189   if (gdbarch->write_pc == 0)
1190     internal_error ("gdbarch: gdbarch_write_pc invalid");
1191   if (gdbarch_debug >= 2)
1192     fprintf_unfiltered (gdb_stdlog, "gdbarch_write_pc called\n");
1193   gdbarch->write_pc (val, pid);
1194 }
1195
1196 void
1197 set_gdbarch_write_pc (struct gdbarch *gdbarch,
1198                       gdbarch_write_pc_ftype write_pc)
1199 {
1200   gdbarch->write_pc = write_pc;
1201 }
1202
1203 CORE_ADDR
1204 gdbarch_read_fp (struct gdbarch *gdbarch)
1205 {
1206   if (gdbarch->read_fp == 0)
1207     internal_error ("gdbarch: gdbarch_read_fp invalid");
1208   if (gdbarch_debug >= 2)
1209     fprintf_unfiltered (gdb_stdlog, "gdbarch_read_fp called\n");
1210   return gdbarch->read_fp ();
1211 }
1212
1213 void
1214 set_gdbarch_read_fp (struct gdbarch *gdbarch,
1215                      gdbarch_read_fp_ftype read_fp)
1216 {
1217   gdbarch->read_fp = read_fp;
1218 }
1219
1220 void
1221 gdbarch_write_fp (struct gdbarch *gdbarch, CORE_ADDR val)
1222 {
1223   if (gdbarch->write_fp == 0)
1224     internal_error ("gdbarch: gdbarch_write_fp invalid");
1225   if (gdbarch_debug >= 2)
1226     fprintf_unfiltered (gdb_stdlog, "gdbarch_write_fp called\n");
1227   gdbarch->write_fp (val);
1228 }
1229
1230 void
1231 set_gdbarch_write_fp (struct gdbarch *gdbarch,
1232                       gdbarch_write_fp_ftype write_fp)
1233 {
1234   gdbarch->write_fp = write_fp;
1235 }
1236
1237 CORE_ADDR
1238 gdbarch_read_sp (struct gdbarch *gdbarch)
1239 {
1240   if (gdbarch->read_sp == 0)
1241     internal_error ("gdbarch: gdbarch_read_sp invalid");
1242   if (gdbarch_debug >= 2)
1243     fprintf_unfiltered (gdb_stdlog, "gdbarch_read_sp called\n");
1244   return gdbarch->read_sp ();
1245 }
1246
1247 void
1248 set_gdbarch_read_sp (struct gdbarch *gdbarch,
1249                      gdbarch_read_sp_ftype read_sp)
1250 {
1251   gdbarch->read_sp = read_sp;
1252 }
1253
1254 void
1255 gdbarch_write_sp (struct gdbarch *gdbarch, CORE_ADDR val)
1256 {
1257   if (gdbarch->write_sp == 0)
1258     internal_error ("gdbarch: gdbarch_write_sp invalid");
1259   if (gdbarch_debug >= 2)
1260     fprintf_unfiltered (gdb_stdlog, "gdbarch_write_sp called\n");
1261   gdbarch->write_sp (val);
1262 }
1263
1264 void
1265 set_gdbarch_write_sp (struct gdbarch *gdbarch,
1266                       gdbarch_write_sp_ftype write_sp)
1267 {
1268   gdbarch->write_sp = write_sp;
1269 }
1270
1271 int
1272 gdbarch_num_regs (struct gdbarch *gdbarch)
1273 {
1274   if (gdbarch->num_regs == -1)
1275     internal_error ("gdbarch: gdbarch_num_regs invalid");
1276   if (gdbarch_debug >= 2)
1277     fprintf_unfiltered (gdb_stdlog, "gdbarch_num_regs called\n");
1278   return gdbarch->num_regs;
1279 }
1280
1281 void
1282 set_gdbarch_num_regs (struct gdbarch *gdbarch,
1283                       int num_regs)
1284 {
1285   gdbarch->num_regs = num_regs;
1286 }
1287
1288 int
1289 gdbarch_sp_regnum (struct gdbarch *gdbarch)
1290 {
1291   if (gdbarch->sp_regnum == -1)
1292     internal_error ("gdbarch: gdbarch_sp_regnum invalid");
1293   if (gdbarch_debug >= 2)
1294     fprintf_unfiltered (gdb_stdlog, "gdbarch_sp_regnum called\n");
1295   return gdbarch->sp_regnum;
1296 }
1297
1298 void
1299 set_gdbarch_sp_regnum (struct gdbarch *gdbarch,
1300                        int sp_regnum)
1301 {
1302   gdbarch->sp_regnum = sp_regnum;
1303 }
1304
1305 int
1306 gdbarch_fp_regnum (struct gdbarch *gdbarch)
1307 {
1308   if (gdbarch->fp_regnum == -1)
1309     internal_error ("gdbarch: gdbarch_fp_regnum invalid");
1310   if (gdbarch_debug >= 2)
1311     fprintf_unfiltered (gdb_stdlog, "gdbarch_fp_regnum called\n");
1312   return gdbarch->fp_regnum;
1313 }
1314
1315 void
1316 set_gdbarch_fp_regnum (struct gdbarch *gdbarch,
1317                        int fp_regnum)
1318 {
1319   gdbarch->fp_regnum = fp_regnum;
1320 }
1321
1322 int
1323 gdbarch_pc_regnum (struct gdbarch *gdbarch)
1324 {
1325   if (gdbarch->pc_regnum == -1)
1326     internal_error ("gdbarch: gdbarch_pc_regnum invalid");
1327   if (gdbarch_debug >= 2)
1328     fprintf_unfiltered (gdb_stdlog, "gdbarch_pc_regnum called\n");
1329   return gdbarch->pc_regnum;
1330 }
1331
1332 void
1333 set_gdbarch_pc_regnum (struct gdbarch *gdbarch,
1334                        int pc_regnum)
1335 {
1336   gdbarch->pc_regnum = pc_regnum;
1337 }
1338
1339 char *
1340 gdbarch_register_name (struct gdbarch *gdbarch, int regnr)
1341 {
1342   if (GDB_MULTI_ARCH == 0)
1343     return legacy_register_name (regnr);
1344   if (gdbarch->register_name == 0)
1345     internal_error ("gdbarch: gdbarch_register_name invalid");
1346   if (gdbarch_debug >= 2)
1347     fprintf_unfiltered (gdb_stdlog, "gdbarch_register_name called\n");
1348   return gdbarch->register_name (regnr);
1349 }
1350
1351 void
1352 set_gdbarch_register_name (struct gdbarch *gdbarch,
1353                            gdbarch_register_name_ftype register_name)
1354 {
1355   gdbarch->register_name = register_name;
1356 }
1357
1358 int
1359 gdbarch_register_size (struct gdbarch *gdbarch)
1360 {
1361   if (gdbarch->register_size == -1)
1362     internal_error ("gdbarch: gdbarch_register_size invalid");
1363   if (gdbarch_debug >= 2)
1364     fprintf_unfiltered (gdb_stdlog, "gdbarch_register_size called\n");
1365   return gdbarch->register_size;
1366 }
1367
1368 void
1369 set_gdbarch_register_size (struct gdbarch *gdbarch,
1370                            int register_size)
1371 {
1372   gdbarch->register_size = register_size;
1373 }
1374
1375 int
1376 gdbarch_register_bytes (struct gdbarch *gdbarch)
1377 {
1378   if (gdbarch->register_bytes == -1)
1379     internal_error ("gdbarch: gdbarch_register_bytes invalid");
1380   if (gdbarch_debug >= 2)
1381     fprintf_unfiltered (gdb_stdlog, "gdbarch_register_bytes called\n");
1382   return gdbarch->register_bytes;
1383 }
1384
1385 void
1386 set_gdbarch_register_bytes (struct gdbarch *gdbarch,
1387                             int register_bytes)
1388 {
1389   gdbarch->register_bytes = register_bytes;
1390 }
1391
1392 int
1393 gdbarch_register_byte (struct gdbarch *gdbarch, int reg_nr)
1394 {
1395   if (gdbarch->register_byte == 0)
1396     internal_error ("gdbarch: gdbarch_register_byte invalid");
1397   if (gdbarch_debug >= 2)
1398     fprintf_unfiltered (gdb_stdlog, "gdbarch_register_byte called\n");
1399   return gdbarch->register_byte (reg_nr);
1400 }
1401
1402 void
1403 set_gdbarch_register_byte (struct gdbarch *gdbarch,
1404                            gdbarch_register_byte_ftype register_byte)
1405 {
1406   gdbarch->register_byte = register_byte;
1407 }
1408
1409 int
1410 gdbarch_register_raw_size (struct gdbarch *gdbarch, int reg_nr)
1411 {
1412   if (gdbarch->register_raw_size == 0)
1413     internal_error ("gdbarch: gdbarch_register_raw_size invalid");
1414   if (gdbarch_debug >= 2)
1415     fprintf_unfiltered (gdb_stdlog, "gdbarch_register_raw_size called\n");
1416   return gdbarch->register_raw_size (reg_nr);
1417 }
1418
1419 void
1420 set_gdbarch_register_raw_size (struct gdbarch *gdbarch,
1421                                gdbarch_register_raw_size_ftype register_raw_size)
1422 {
1423   gdbarch->register_raw_size = register_raw_size;
1424 }
1425
1426 int
1427 gdbarch_max_register_raw_size (struct gdbarch *gdbarch)
1428 {
1429   if (gdbarch->max_register_raw_size == -1)
1430     internal_error ("gdbarch: gdbarch_max_register_raw_size invalid");
1431   if (gdbarch_debug >= 2)
1432     fprintf_unfiltered (gdb_stdlog, "gdbarch_max_register_raw_size called\n");
1433   return gdbarch->max_register_raw_size;
1434 }
1435
1436 void
1437 set_gdbarch_max_register_raw_size (struct gdbarch *gdbarch,
1438                                    int max_register_raw_size)
1439 {
1440   gdbarch->max_register_raw_size = max_register_raw_size;
1441 }
1442
1443 int
1444 gdbarch_register_virtual_size (struct gdbarch *gdbarch, int reg_nr)
1445 {
1446   if (gdbarch->register_virtual_size == 0)
1447     internal_error ("gdbarch: gdbarch_register_virtual_size invalid");
1448   if (gdbarch_debug >= 2)
1449     fprintf_unfiltered (gdb_stdlog, "gdbarch_register_virtual_size called\n");
1450   return gdbarch->register_virtual_size (reg_nr);
1451 }
1452
1453 void
1454 set_gdbarch_register_virtual_size (struct gdbarch *gdbarch,
1455                                    gdbarch_register_virtual_size_ftype register_virtual_size)
1456 {
1457   gdbarch->register_virtual_size = register_virtual_size;
1458 }
1459
1460 int
1461 gdbarch_max_register_virtual_size (struct gdbarch *gdbarch)
1462 {
1463   if (gdbarch->max_register_virtual_size == -1)
1464     internal_error ("gdbarch: gdbarch_max_register_virtual_size invalid");
1465   if (gdbarch_debug >= 2)
1466     fprintf_unfiltered (gdb_stdlog, "gdbarch_max_register_virtual_size called\n");
1467   return gdbarch->max_register_virtual_size;
1468 }
1469
1470 void
1471 set_gdbarch_max_register_virtual_size (struct gdbarch *gdbarch,
1472                                        int max_register_virtual_size)
1473 {
1474   gdbarch->max_register_virtual_size = max_register_virtual_size;
1475 }
1476
1477 struct type *
1478 gdbarch_register_virtual_type (struct gdbarch *gdbarch, int reg_nr)
1479 {
1480   if (gdbarch->register_virtual_type == 0)
1481     internal_error ("gdbarch: gdbarch_register_virtual_type invalid");
1482   if (gdbarch_debug >= 2)
1483     fprintf_unfiltered (gdb_stdlog, "gdbarch_register_virtual_type called\n");
1484   return gdbarch->register_virtual_type (reg_nr);
1485 }
1486
1487 void
1488 set_gdbarch_register_virtual_type (struct gdbarch *gdbarch,
1489                                    gdbarch_register_virtual_type_ftype register_virtual_type)
1490 {
1491   gdbarch->register_virtual_type = register_virtual_type;
1492 }
1493
1494 int
1495 gdbarch_use_generic_dummy_frames (struct gdbarch *gdbarch)
1496 {
1497   if (gdbarch->use_generic_dummy_frames == -1)
1498     internal_error ("gdbarch: gdbarch_use_generic_dummy_frames invalid");
1499   if (gdbarch_debug >= 2)
1500     fprintf_unfiltered (gdb_stdlog, "gdbarch_use_generic_dummy_frames called\n");
1501   return gdbarch->use_generic_dummy_frames;
1502 }
1503
1504 void
1505 set_gdbarch_use_generic_dummy_frames (struct gdbarch *gdbarch,
1506                                       int use_generic_dummy_frames)
1507 {
1508   gdbarch->use_generic_dummy_frames = use_generic_dummy_frames;
1509 }
1510
1511 int
1512 gdbarch_call_dummy_location (struct gdbarch *gdbarch)
1513 {
1514   if (gdbarch->call_dummy_location == 0)
1515     internal_error ("gdbarch: gdbarch_call_dummy_location invalid");
1516   if (gdbarch_debug >= 2)
1517     fprintf_unfiltered (gdb_stdlog, "gdbarch_call_dummy_location called\n");
1518   return gdbarch->call_dummy_location;
1519 }
1520
1521 void
1522 set_gdbarch_call_dummy_location (struct gdbarch *gdbarch,
1523                                  int call_dummy_location)
1524 {
1525   gdbarch->call_dummy_location = call_dummy_location;
1526 }
1527
1528 CORE_ADDR
1529 gdbarch_call_dummy_address (struct gdbarch *gdbarch)
1530 {
1531   if (gdbarch->call_dummy_address == 0)
1532     internal_error ("gdbarch: gdbarch_call_dummy_address invalid");
1533   if (gdbarch_debug >= 2)
1534     fprintf_unfiltered (gdb_stdlog, "gdbarch_call_dummy_address called\n");
1535   return gdbarch->call_dummy_address ();
1536 }
1537
1538 void
1539 set_gdbarch_call_dummy_address (struct gdbarch *gdbarch,
1540                                 gdbarch_call_dummy_address_ftype call_dummy_address)
1541 {
1542   gdbarch->call_dummy_address = call_dummy_address;
1543 }
1544
1545 CORE_ADDR
1546 gdbarch_call_dummy_start_offset (struct gdbarch *gdbarch)
1547 {
1548   if (gdbarch->call_dummy_start_offset == -1)
1549     internal_error ("gdbarch: gdbarch_call_dummy_start_offset invalid");
1550   if (gdbarch_debug >= 2)
1551     fprintf_unfiltered (gdb_stdlog, "gdbarch_call_dummy_start_offset called\n");
1552   return gdbarch->call_dummy_start_offset;
1553 }
1554
1555 void
1556 set_gdbarch_call_dummy_start_offset (struct gdbarch *gdbarch,
1557                                      CORE_ADDR call_dummy_start_offset)
1558 {
1559   gdbarch->call_dummy_start_offset = call_dummy_start_offset;
1560 }
1561
1562 CORE_ADDR
1563 gdbarch_call_dummy_breakpoint_offset (struct gdbarch *gdbarch)
1564 {
1565   if (gdbarch->call_dummy_breakpoint_offset == -1)
1566     internal_error ("gdbarch: gdbarch_call_dummy_breakpoint_offset invalid");
1567   if (gdbarch_debug >= 2)
1568     fprintf_unfiltered (gdb_stdlog, "gdbarch_call_dummy_breakpoint_offset called\n");
1569   return gdbarch->call_dummy_breakpoint_offset;
1570 }
1571
1572 void
1573 set_gdbarch_call_dummy_breakpoint_offset (struct gdbarch *gdbarch,
1574                                           CORE_ADDR call_dummy_breakpoint_offset)
1575 {
1576   gdbarch->call_dummy_breakpoint_offset = call_dummy_breakpoint_offset;
1577 }
1578
1579 int
1580 gdbarch_call_dummy_breakpoint_offset_p (struct gdbarch *gdbarch)
1581 {
1582   if (gdbarch->call_dummy_breakpoint_offset_p == -1)
1583     internal_error ("gdbarch: gdbarch_call_dummy_breakpoint_offset_p invalid");
1584   if (gdbarch_debug >= 2)
1585     fprintf_unfiltered (gdb_stdlog, "gdbarch_call_dummy_breakpoint_offset_p called\n");
1586   return gdbarch->call_dummy_breakpoint_offset_p;
1587 }
1588
1589 void
1590 set_gdbarch_call_dummy_breakpoint_offset_p (struct gdbarch *gdbarch,
1591                                             int call_dummy_breakpoint_offset_p)
1592 {
1593   gdbarch->call_dummy_breakpoint_offset_p = call_dummy_breakpoint_offset_p;
1594 }
1595
1596 int
1597 gdbarch_call_dummy_length (struct gdbarch *gdbarch)
1598 {
1599   if (gdbarch->call_dummy_length == -1)
1600     internal_error ("gdbarch: gdbarch_call_dummy_length invalid");
1601   if (gdbarch_debug >= 2)
1602     fprintf_unfiltered (gdb_stdlog, "gdbarch_call_dummy_length called\n");
1603   return gdbarch->call_dummy_length;
1604 }
1605
1606 void
1607 set_gdbarch_call_dummy_length (struct gdbarch *gdbarch,
1608                                int call_dummy_length)
1609 {
1610   gdbarch->call_dummy_length = call_dummy_length;
1611 }
1612
1613 int
1614 gdbarch_pc_in_call_dummy (struct gdbarch *gdbarch, CORE_ADDR pc, CORE_ADDR sp, CORE_ADDR frame_address)
1615 {
1616   if (gdbarch->pc_in_call_dummy == 0)
1617     internal_error ("gdbarch: gdbarch_pc_in_call_dummy invalid");
1618   if (gdbarch_debug >= 2)
1619     fprintf_unfiltered (gdb_stdlog, "gdbarch_pc_in_call_dummy called\n");
1620   return gdbarch->pc_in_call_dummy (pc, sp, frame_address);
1621 }
1622
1623 void
1624 set_gdbarch_pc_in_call_dummy (struct gdbarch *gdbarch,
1625                               gdbarch_pc_in_call_dummy_ftype pc_in_call_dummy)
1626 {
1627   gdbarch->pc_in_call_dummy = pc_in_call_dummy;
1628 }
1629
1630 int
1631 gdbarch_call_dummy_p (struct gdbarch *gdbarch)
1632 {
1633   if (gdbarch->call_dummy_p == -1)
1634     internal_error ("gdbarch: gdbarch_call_dummy_p invalid");
1635   if (gdbarch_debug >= 2)
1636     fprintf_unfiltered (gdb_stdlog, "gdbarch_call_dummy_p called\n");
1637   return gdbarch->call_dummy_p;
1638 }
1639
1640 void
1641 set_gdbarch_call_dummy_p (struct gdbarch *gdbarch,
1642                           int call_dummy_p)
1643 {
1644   gdbarch->call_dummy_p = call_dummy_p;
1645 }
1646
1647 LONGEST *
1648 gdbarch_call_dummy_words (struct gdbarch *gdbarch)
1649 {
1650   if (GDB_MULTI_ARCH == 0)
1651     return legacy_call_dummy_words;
1652   /* Skip verify of call_dummy_words, invalid_p == 0 */
1653   if (gdbarch_debug >= 2)
1654     fprintf_unfiltered (gdb_stdlog, "gdbarch_call_dummy_words called\n");
1655   return gdbarch->call_dummy_words;
1656 }
1657
1658 void
1659 set_gdbarch_call_dummy_words (struct gdbarch *gdbarch,
1660                               LONGEST * call_dummy_words)
1661 {
1662   gdbarch->call_dummy_words = call_dummy_words;
1663 }
1664
1665 int
1666 gdbarch_sizeof_call_dummy_words (struct gdbarch *gdbarch)
1667 {
1668   if (GDB_MULTI_ARCH == 0)
1669     return legacy_sizeof_call_dummy_words;
1670   /* Skip verify of sizeof_call_dummy_words, invalid_p == 0 */
1671   if (gdbarch_debug >= 2)
1672     fprintf_unfiltered (gdb_stdlog, "gdbarch_sizeof_call_dummy_words called\n");
1673   return gdbarch->sizeof_call_dummy_words;
1674 }
1675
1676 void
1677 set_gdbarch_sizeof_call_dummy_words (struct gdbarch *gdbarch,
1678                                      int sizeof_call_dummy_words)
1679 {
1680   gdbarch->sizeof_call_dummy_words = sizeof_call_dummy_words;
1681 }
1682
1683 int
1684 gdbarch_call_dummy_stack_adjust_p (struct gdbarch *gdbarch)
1685 {
1686   if (gdbarch->call_dummy_stack_adjust_p == -1)
1687     internal_error ("gdbarch: gdbarch_call_dummy_stack_adjust_p invalid");
1688   if (gdbarch_debug >= 2)
1689     fprintf_unfiltered (gdb_stdlog, "gdbarch_call_dummy_stack_adjust_p called\n");
1690   return gdbarch->call_dummy_stack_adjust_p;
1691 }
1692
1693 void
1694 set_gdbarch_call_dummy_stack_adjust_p (struct gdbarch *gdbarch,
1695                                        int call_dummy_stack_adjust_p)
1696 {
1697   gdbarch->call_dummy_stack_adjust_p = call_dummy_stack_adjust_p;
1698 }
1699
1700 int
1701 gdbarch_call_dummy_stack_adjust (struct gdbarch *gdbarch)
1702 {
1703   if (gdbarch->call_dummy_stack_adjust_p && gdbarch->call_dummy_stack_adjust == 0)
1704     internal_error ("gdbarch: gdbarch_call_dummy_stack_adjust invalid");
1705   if (gdbarch_debug >= 2)
1706     fprintf_unfiltered (gdb_stdlog, "gdbarch_call_dummy_stack_adjust called\n");
1707   return gdbarch->call_dummy_stack_adjust;
1708 }
1709
1710 void
1711 set_gdbarch_call_dummy_stack_adjust (struct gdbarch *gdbarch,
1712                                      int call_dummy_stack_adjust)
1713 {
1714   gdbarch->call_dummy_stack_adjust = call_dummy_stack_adjust;
1715 }
1716
1717 void
1718 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)
1719 {
1720   if (gdbarch->fix_call_dummy == 0)
1721     internal_error ("gdbarch: gdbarch_fix_call_dummy invalid");
1722   if (gdbarch_debug >= 2)
1723     fprintf_unfiltered (gdb_stdlog, "gdbarch_fix_call_dummy called\n");
1724   gdbarch->fix_call_dummy (dummy, pc, fun, nargs, args, type, gcc_p);
1725 }
1726
1727 void
1728 set_gdbarch_fix_call_dummy (struct gdbarch *gdbarch,
1729                             gdbarch_fix_call_dummy_ftype fix_call_dummy)
1730 {
1731   gdbarch->fix_call_dummy = fix_call_dummy;
1732 }
1733
1734 int
1735 gdbarch_believe_pcc_promotion (struct gdbarch *gdbarch)
1736 {
1737   if (gdbarch_debug >= 2)
1738     fprintf_unfiltered (gdb_stdlog, "gdbarch_believe_pcc_promotion called\n");
1739   return gdbarch->believe_pcc_promotion;
1740 }
1741
1742 void
1743 set_gdbarch_believe_pcc_promotion (struct gdbarch *gdbarch,
1744                                    int believe_pcc_promotion)
1745 {
1746   gdbarch->believe_pcc_promotion = believe_pcc_promotion;
1747 }
1748
1749 int
1750 gdbarch_believe_pcc_promotion_type (struct gdbarch *gdbarch)
1751 {
1752   if (gdbarch_debug >= 2)
1753     fprintf_unfiltered (gdb_stdlog, "gdbarch_believe_pcc_promotion_type called\n");
1754   return gdbarch->believe_pcc_promotion_type;
1755 }
1756
1757 void
1758 set_gdbarch_believe_pcc_promotion_type (struct gdbarch *gdbarch,
1759                                         int believe_pcc_promotion_type)
1760 {
1761   gdbarch->believe_pcc_promotion_type = believe_pcc_promotion_type;
1762 }
1763
1764 int
1765 gdbarch_coerce_float_to_double (struct gdbarch *gdbarch, struct type *formal, struct type *actual)
1766 {
1767   if (GDB_MULTI_ARCH == 0)
1768     return default_coerce_float_to_double (formal, actual);
1769   if (gdbarch->coerce_float_to_double == 0)
1770     internal_error ("gdbarch: gdbarch_coerce_float_to_double invalid");
1771   if (gdbarch_debug >= 2)
1772     fprintf_unfiltered (gdb_stdlog, "gdbarch_coerce_float_to_double called\n");
1773   return gdbarch->coerce_float_to_double (formal, actual);
1774 }
1775
1776 void
1777 set_gdbarch_coerce_float_to_double (struct gdbarch *gdbarch,
1778                                     gdbarch_coerce_float_to_double_ftype coerce_float_to_double)
1779 {
1780   gdbarch->coerce_float_to_double = coerce_float_to_double;
1781 }
1782
1783 void
1784 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)
1785 {
1786   if (gdbarch->get_saved_register == 0)
1787     internal_error ("gdbarch: gdbarch_get_saved_register invalid");
1788   if (gdbarch_debug >= 2)
1789     fprintf_unfiltered (gdb_stdlog, "gdbarch_get_saved_register called\n");
1790   gdbarch->get_saved_register (raw_buffer, optimized, addrp, frame, regnum, lval);
1791 }
1792
1793 void
1794 set_gdbarch_get_saved_register (struct gdbarch *gdbarch,
1795                                 gdbarch_get_saved_register_ftype get_saved_register)
1796 {
1797   gdbarch->get_saved_register = get_saved_register;
1798 }
1799
1800 int
1801 gdbarch_register_convertible (struct gdbarch *gdbarch, int nr)
1802 {
1803   if (GDB_MULTI_ARCH == 0)
1804     return generic_register_convertible_not (nr);
1805   if (gdbarch->register_convertible == 0)
1806     internal_error ("gdbarch: gdbarch_register_convertible invalid");
1807   if (gdbarch_debug >= 2)
1808     fprintf_unfiltered (gdb_stdlog, "gdbarch_register_convertible called\n");
1809   return gdbarch->register_convertible (nr);
1810 }
1811
1812 void
1813 set_gdbarch_register_convertible (struct gdbarch *gdbarch,
1814                                   gdbarch_register_convertible_ftype register_convertible)
1815 {
1816   gdbarch->register_convertible = register_convertible;
1817 }
1818
1819 void
1820 gdbarch_register_convert_to_virtual (struct gdbarch *gdbarch, int regnum, struct type *type, char *from, char *to)
1821 {
1822   if (gdbarch->register_convert_to_virtual == 0)
1823     internal_error ("gdbarch: gdbarch_register_convert_to_virtual invalid");
1824   if (gdbarch_debug >= 2)
1825     fprintf_unfiltered (gdb_stdlog, "gdbarch_register_convert_to_virtual called\n");
1826   gdbarch->register_convert_to_virtual (regnum, type, from, to);
1827 }
1828
1829 void
1830 set_gdbarch_register_convert_to_virtual (struct gdbarch *gdbarch,
1831                                          gdbarch_register_convert_to_virtual_ftype register_convert_to_virtual)
1832 {
1833   gdbarch->register_convert_to_virtual = register_convert_to_virtual;
1834 }
1835
1836 void
1837 gdbarch_register_convert_to_raw (struct gdbarch *gdbarch, struct type *type, int regnum, char *from, char *to)
1838 {
1839   if (gdbarch->register_convert_to_raw == 0)
1840     internal_error ("gdbarch: gdbarch_register_convert_to_raw invalid");
1841   if (gdbarch_debug >= 2)
1842     fprintf_unfiltered (gdb_stdlog, "gdbarch_register_convert_to_raw called\n");
1843   gdbarch->register_convert_to_raw (type, regnum, from, to);
1844 }
1845
1846 void
1847 set_gdbarch_register_convert_to_raw (struct gdbarch *gdbarch,
1848                                      gdbarch_register_convert_to_raw_ftype register_convert_to_raw)
1849 {
1850   gdbarch->register_convert_to_raw = register_convert_to_raw;
1851 }
1852
1853 CORE_ADDR
1854 gdbarch_pointer_to_address (struct gdbarch *gdbarch, struct type *type, char *buf)
1855 {
1856   if (GDB_MULTI_ARCH == 0)
1857     return generic_pointer_to_address (type, buf);
1858   if (gdbarch->pointer_to_address == 0)
1859     internal_error ("gdbarch: gdbarch_pointer_to_address invalid");
1860   if (gdbarch_debug >= 2)
1861     fprintf_unfiltered (gdb_stdlog, "gdbarch_pointer_to_address called\n");
1862   return gdbarch->pointer_to_address (type, buf);
1863 }
1864
1865 void
1866 set_gdbarch_pointer_to_address (struct gdbarch *gdbarch,
1867                                 gdbarch_pointer_to_address_ftype pointer_to_address)
1868 {
1869   gdbarch->pointer_to_address = pointer_to_address;
1870 }
1871
1872 void
1873 gdbarch_address_to_pointer (struct gdbarch *gdbarch, struct type *type, char *buf, CORE_ADDR addr)
1874 {
1875   if (GDB_MULTI_ARCH == 0)
1876     {
1877       generic_address_to_pointer (type, buf, addr);
1878       return;
1879     }
1880   if (gdbarch->address_to_pointer == 0)
1881     internal_error ("gdbarch: gdbarch_address_to_pointer invalid");
1882   if (gdbarch_debug >= 2)
1883     fprintf_unfiltered (gdb_stdlog, "gdbarch_address_to_pointer called\n");
1884   gdbarch->address_to_pointer (type, buf, addr);
1885 }
1886
1887 void
1888 set_gdbarch_address_to_pointer (struct gdbarch *gdbarch,
1889                                 gdbarch_address_to_pointer_ftype address_to_pointer)
1890 {
1891   gdbarch->address_to_pointer = address_to_pointer;
1892 }
1893
1894 int
1895 gdbarch_return_value_on_stack (struct gdbarch *gdbarch, struct type *type)
1896 {
1897   if (GDB_MULTI_ARCH == 0)
1898     return generic_return_value_on_stack_not (type);
1899   if (gdbarch->return_value_on_stack == 0)
1900     internal_error ("gdbarch: gdbarch_return_value_on_stack invalid");
1901   if (gdbarch_debug >= 2)
1902     fprintf_unfiltered (gdb_stdlog, "gdbarch_return_value_on_stack called\n");
1903   return gdbarch->return_value_on_stack (type);
1904 }
1905
1906 void
1907 set_gdbarch_return_value_on_stack (struct gdbarch *gdbarch,
1908                                    gdbarch_return_value_on_stack_ftype return_value_on_stack)
1909 {
1910   gdbarch->return_value_on_stack = return_value_on_stack;
1911 }
1912
1913 void
1914 gdbarch_extract_return_value (struct gdbarch *gdbarch, struct type *type, char *regbuf, char *valbuf)
1915 {
1916   if (gdbarch->extract_return_value == 0)
1917     internal_error ("gdbarch: gdbarch_extract_return_value invalid");
1918   if (gdbarch_debug >= 2)
1919     fprintf_unfiltered (gdb_stdlog, "gdbarch_extract_return_value called\n");
1920   gdbarch->extract_return_value (type, regbuf, valbuf);
1921 }
1922
1923 void
1924 set_gdbarch_extract_return_value (struct gdbarch *gdbarch,
1925                                   gdbarch_extract_return_value_ftype extract_return_value)
1926 {
1927   gdbarch->extract_return_value = extract_return_value;
1928 }
1929
1930 CORE_ADDR
1931 gdbarch_push_arguments (struct gdbarch *gdbarch, int nargs, struct value **args, CORE_ADDR sp, int struct_return, CORE_ADDR struct_addr)
1932 {
1933   if (gdbarch->push_arguments == 0)
1934     internal_error ("gdbarch: gdbarch_push_arguments invalid");
1935   if (gdbarch_debug >= 2)
1936     fprintf_unfiltered (gdb_stdlog, "gdbarch_push_arguments called\n");
1937   return gdbarch->push_arguments (nargs, args, sp, struct_return, struct_addr);
1938 }
1939
1940 void
1941 set_gdbarch_push_arguments (struct gdbarch *gdbarch,
1942                             gdbarch_push_arguments_ftype push_arguments)
1943 {
1944   gdbarch->push_arguments = push_arguments;
1945 }
1946
1947 void
1948 gdbarch_push_dummy_frame (struct gdbarch *gdbarch)
1949 {
1950   if (gdbarch->push_dummy_frame == 0)
1951     internal_error ("gdbarch: gdbarch_push_dummy_frame invalid");
1952   if (gdbarch_debug >= 2)
1953     fprintf_unfiltered (gdb_stdlog, "gdbarch_push_dummy_frame called\n");
1954   gdbarch->push_dummy_frame ();
1955 }
1956
1957 void
1958 set_gdbarch_push_dummy_frame (struct gdbarch *gdbarch,
1959                               gdbarch_push_dummy_frame_ftype push_dummy_frame)
1960 {
1961   gdbarch->push_dummy_frame = push_dummy_frame;
1962 }
1963
1964 CORE_ADDR
1965 gdbarch_push_return_address (struct gdbarch *gdbarch, CORE_ADDR pc, CORE_ADDR sp)
1966 {
1967   if (gdbarch->push_return_address == 0)
1968     internal_error ("gdbarch: gdbarch_push_return_address invalid");
1969   if (gdbarch_debug >= 2)
1970     fprintf_unfiltered (gdb_stdlog, "gdbarch_push_return_address called\n");
1971   return gdbarch->push_return_address (pc, sp);
1972 }
1973
1974 void
1975 set_gdbarch_push_return_address (struct gdbarch *gdbarch,
1976                                  gdbarch_push_return_address_ftype push_return_address)
1977 {
1978   gdbarch->push_return_address = push_return_address;
1979 }
1980
1981 void
1982 gdbarch_pop_frame (struct gdbarch *gdbarch)
1983 {
1984   if (gdbarch->pop_frame == 0)
1985     internal_error ("gdbarch: gdbarch_pop_frame invalid");
1986   if (gdbarch_debug >= 2)
1987     fprintf_unfiltered (gdb_stdlog, "gdbarch_pop_frame called\n");
1988   gdbarch->pop_frame ();
1989 }
1990
1991 void
1992 set_gdbarch_pop_frame (struct gdbarch *gdbarch,
1993                        gdbarch_pop_frame_ftype pop_frame)
1994 {
1995   gdbarch->pop_frame = pop_frame;
1996 }
1997
1998 CORE_ADDR
1999 gdbarch_d10v_make_daddr (struct gdbarch *gdbarch, CORE_ADDR x)
2000 {
2001   if (gdbarch->d10v_make_daddr == 0)
2002     internal_error ("gdbarch: gdbarch_d10v_make_daddr invalid");
2003   if (gdbarch_debug >= 2)
2004     fprintf_unfiltered (gdb_stdlog, "gdbarch_d10v_make_daddr called\n");
2005   return gdbarch->d10v_make_daddr (x);
2006 }
2007
2008 void
2009 set_gdbarch_d10v_make_daddr (struct gdbarch *gdbarch,
2010                              gdbarch_d10v_make_daddr_ftype d10v_make_daddr)
2011 {
2012   gdbarch->d10v_make_daddr = d10v_make_daddr;
2013 }
2014
2015 CORE_ADDR
2016 gdbarch_d10v_make_iaddr (struct gdbarch *gdbarch, CORE_ADDR x)
2017 {
2018   if (gdbarch->d10v_make_iaddr == 0)
2019     internal_error ("gdbarch: gdbarch_d10v_make_iaddr invalid");
2020   if (gdbarch_debug >= 2)
2021     fprintf_unfiltered (gdb_stdlog, "gdbarch_d10v_make_iaddr called\n");
2022   return gdbarch->d10v_make_iaddr (x);
2023 }
2024
2025 void
2026 set_gdbarch_d10v_make_iaddr (struct gdbarch *gdbarch,
2027                              gdbarch_d10v_make_iaddr_ftype d10v_make_iaddr)
2028 {
2029   gdbarch->d10v_make_iaddr = d10v_make_iaddr;
2030 }
2031
2032 int
2033 gdbarch_d10v_daddr_p (struct gdbarch *gdbarch, CORE_ADDR x)
2034 {
2035   if (gdbarch->d10v_daddr_p == 0)
2036     internal_error ("gdbarch: gdbarch_d10v_daddr_p invalid");
2037   if (gdbarch_debug >= 2)
2038     fprintf_unfiltered (gdb_stdlog, "gdbarch_d10v_daddr_p called\n");
2039   return gdbarch->d10v_daddr_p (x);
2040 }
2041
2042 void
2043 set_gdbarch_d10v_daddr_p (struct gdbarch *gdbarch,
2044                           gdbarch_d10v_daddr_p_ftype d10v_daddr_p)
2045 {
2046   gdbarch->d10v_daddr_p = d10v_daddr_p;
2047 }
2048
2049 int
2050 gdbarch_d10v_iaddr_p (struct gdbarch *gdbarch, CORE_ADDR x)
2051 {
2052   if (gdbarch->d10v_iaddr_p == 0)
2053     internal_error ("gdbarch: gdbarch_d10v_iaddr_p invalid");
2054   if (gdbarch_debug >= 2)
2055     fprintf_unfiltered (gdb_stdlog, "gdbarch_d10v_iaddr_p called\n");
2056   return gdbarch->d10v_iaddr_p (x);
2057 }
2058
2059 void
2060 set_gdbarch_d10v_iaddr_p (struct gdbarch *gdbarch,
2061                           gdbarch_d10v_iaddr_p_ftype d10v_iaddr_p)
2062 {
2063   gdbarch->d10v_iaddr_p = d10v_iaddr_p;
2064 }
2065
2066 CORE_ADDR
2067 gdbarch_d10v_convert_daddr_to_raw (struct gdbarch *gdbarch, CORE_ADDR x)
2068 {
2069   if (gdbarch->d10v_convert_daddr_to_raw == 0)
2070     internal_error ("gdbarch: gdbarch_d10v_convert_daddr_to_raw invalid");
2071   if (gdbarch_debug >= 2)
2072     fprintf_unfiltered (gdb_stdlog, "gdbarch_d10v_convert_daddr_to_raw called\n");
2073   return gdbarch->d10v_convert_daddr_to_raw (x);
2074 }
2075
2076 void
2077 set_gdbarch_d10v_convert_daddr_to_raw (struct gdbarch *gdbarch,
2078                                        gdbarch_d10v_convert_daddr_to_raw_ftype d10v_convert_daddr_to_raw)
2079 {
2080   gdbarch->d10v_convert_daddr_to_raw = d10v_convert_daddr_to_raw;
2081 }
2082
2083 CORE_ADDR
2084 gdbarch_d10v_convert_iaddr_to_raw (struct gdbarch *gdbarch, CORE_ADDR x)
2085 {
2086   if (gdbarch->d10v_convert_iaddr_to_raw == 0)
2087     internal_error ("gdbarch: gdbarch_d10v_convert_iaddr_to_raw invalid");
2088   if (gdbarch_debug >= 2)
2089     fprintf_unfiltered (gdb_stdlog, "gdbarch_d10v_convert_iaddr_to_raw called\n");
2090   return gdbarch->d10v_convert_iaddr_to_raw (x);
2091 }
2092
2093 void
2094 set_gdbarch_d10v_convert_iaddr_to_raw (struct gdbarch *gdbarch,
2095                                        gdbarch_d10v_convert_iaddr_to_raw_ftype d10v_convert_iaddr_to_raw)
2096 {
2097   gdbarch->d10v_convert_iaddr_to_raw = d10v_convert_iaddr_to_raw;
2098 }
2099
2100 void
2101 gdbarch_store_struct_return (struct gdbarch *gdbarch, CORE_ADDR addr, CORE_ADDR sp)
2102 {
2103   if (gdbarch->store_struct_return == 0)
2104     internal_error ("gdbarch: gdbarch_store_struct_return invalid");
2105   if (gdbarch_debug >= 2)
2106     fprintf_unfiltered (gdb_stdlog, "gdbarch_store_struct_return called\n");
2107   gdbarch->store_struct_return (addr, sp);
2108 }
2109
2110 void
2111 set_gdbarch_store_struct_return (struct gdbarch *gdbarch,
2112                                  gdbarch_store_struct_return_ftype store_struct_return)
2113 {
2114   gdbarch->store_struct_return = store_struct_return;
2115 }
2116
2117 void
2118 gdbarch_store_return_value (struct gdbarch *gdbarch, struct type *type, char *valbuf)
2119 {
2120   if (gdbarch->store_return_value == 0)
2121     internal_error ("gdbarch: gdbarch_store_return_value invalid");
2122   if (gdbarch_debug >= 2)
2123     fprintf_unfiltered (gdb_stdlog, "gdbarch_store_return_value called\n");
2124   gdbarch->store_return_value (type, valbuf);
2125 }
2126
2127 void
2128 set_gdbarch_store_return_value (struct gdbarch *gdbarch,
2129                                 gdbarch_store_return_value_ftype store_return_value)
2130 {
2131   gdbarch->store_return_value = store_return_value;
2132 }
2133
2134 CORE_ADDR
2135 gdbarch_extract_struct_value_address (struct gdbarch *gdbarch, char *regbuf)
2136 {
2137   if (gdbarch->extract_struct_value_address == 0)
2138     internal_error ("gdbarch: gdbarch_extract_struct_value_address invalid");
2139   if (gdbarch_debug >= 2)
2140     fprintf_unfiltered (gdb_stdlog, "gdbarch_extract_struct_value_address called\n");
2141   return gdbarch->extract_struct_value_address (regbuf);
2142 }
2143
2144 void
2145 set_gdbarch_extract_struct_value_address (struct gdbarch *gdbarch,
2146                                           gdbarch_extract_struct_value_address_ftype extract_struct_value_address)
2147 {
2148   gdbarch->extract_struct_value_address = extract_struct_value_address;
2149 }
2150
2151 int
2152 gdbarch_use_struct_convention (struct gdbarch *gdbarch, int gcc_p, struct type *value_type)
2153 {
2154   if (gdbarch->use_struct_convention == 0)
2155     internal_error ("gdbarch: gdbarch_use_struct_convention invalid");
2156   if (gdbarch_debug >= 2)
2157     fprintf_unfiltered (gdb_stdlog, "gdbarch_use_struct_convention called\n");
2158   return gdbarch->use_struct_convention (gcc_p, value_type);
2159 }
2160
2161 void
2162 set_gdbarch_use_struct_convention (struct gdbarch *gdbarch,
2163                                    gdbarch_use_struct_convention_ftype use_struct_convention)
2164 {
2165   gdbarch->use_struct_convention = use_struct_convention;
2166 }
2167
2168 void
2169 gdbarch_frame_init_saved_regs (struct gdbarch *gdbarch, struct frame_info *frame)
2170 {
2171   if (gdbarch->frame_init_saved_regs == 0)
2172     internal_error ("gdbarch: gdbarch_frame_init_saved_regs invalid");
2173   if (gdbarch_debug >= 2)
2174     fprintf_unfiltered (gdb_stdlog, "gdbarch_frame_init_saved_regs called\n");
2175   gdbarch->frame_init_saved_regs (frame);
2176 }
2177
2178 void
2179 set_gdbarch_frame_init_saved_regs (struct gdbarch *gdbarch,
2180                                    gdbarch_frame_init_saved_regs_ftype frame_init_saved_regs)
2181 {
2182   gdbarch->frame_init_saved_regs = frame_init_saved_regs;
2183 }
2184
2185 void
2186 gdbarch_init_extra_frame_info (struct gdbarch *gdbarch, int fromleaf, struct frame_info *frame)
2187 {
2188   if (gdbarch->init_extra_frame_info == 0)
2189     internal_error ("gdbarch: gdbarch_init_extra_frame_info invalid");
2190   if (gdbarch_debug >= 2)
2191     fprintf_unfiltered (gdb_stdlog, "gdbarch_init_extra_frame_info called\n");
2192   gdbarch->init_extra_frame_info (fromleaf, frame);
2193 }
2194
2195 void
2196 set_gdbarch_init_extra_frame_info (struct gdbarch *gdbarch,
2197                                    gdbarch_init_extra_frame_info_ftype init_extra_frame_info)
2198 {
2199   gdbarch->init_extra_frame_info = init_extra_frame_info;
2200 }
2201
2202 CORE_ADDR
2203 gdbarch_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR ip)
2204 {
2205   if (gdbarch->skip_prologue == 0)
2206     internal_error ("gdbarch: gdbarch_skip_prologue invalid");
2207   if (gdbarch_debug >= 2)
2208     fprintf_unfiltered (gdb_stdlog, "gdbarch_skip_prologue called\n");
2209   return gdbarch->skip_prologue (ip);
2210 }
2211
2212 void
2213 set_gdbarch_skip_prologue (struct gdbarch *gdbarch,
2214                            gdbarch_skip_prologue_ftype skip_prologue)
2215 {
2216   gdbarch->skip_prologue = skip_prologue;
2217 }
2218
2219 int
2220 gdbarch_inner_than (struct gdbarch *gdbarch, CORE_ADDR lhs, CORE_ADDR rhs)
2221 {
2222   if (gdbarch->inner_than == 0)
2223     internal_error ("gdbarch: gdbarch_inner_than invalid");
2224   if (gdbarch_debug >= 2)
2225     fprintf_unfiltered (gdb_stdlog, "gdbarch_inner_than called\n");
2226   return gdbarch->inner_than (lhs, rhs);
2227 }
2228
2229 void
2230 set_gdbarch_inner_than (struct gdbarch *gdbarch,
2231                         gdbarch_inner_than_ftype inner_than)
2232 {
2233   gdbarch->inner_than = inner_than;
2234 }
2235
2236 unsigned char *
2237 gdbarch_breakpoint_from_pc (struct gdbarch *gdbarch, CORE_ADDR *pcptr, int *lenptr)
2238 {
2239   if (GDB_MULTI_ARCH == 0)
2240     return legacy_breakpoint_from_pc (pcptr, lenptr);
2241   if (gdbarch->breakpoint_from_pc == 0)
2242     internal_error ("gdbarch: gdbarch_breakpoint_from_pc invalid");
2243   if (gdbarch_debug >= 2)
2244     fprintf_unfiltered (gdb_stdlog, "gdbarch_breakpoint_from_pc called\n");
2245   return gdbarch->breakpoint_from_pc (pcptr, lenptr);
2246 }
2247
2248 void
2249 set_gdbarch_breakpoint_from_pc (struct gdbarch *gdbarch,
2250                                 gdbarch_breakpoint_from_pc_ftype breakpoint_from_pc)
2251 {
2252   gdbarch->breakpoint_from_pc = breakpoint_from_pc;
2253 }
2254
2255 int
2256 gdbarch_memory_insert_breakpoint (struct gdbarch *gdbarch, CORE_ADDR addr, char *contents_cache)
2257 {
2258   if (GDB_MULTI_ARCH == 0)
2259     return default_memory_insert_breakpoint (addr, contents_cache);
2260   if (gdbarch->memory_insert_breakpoint == 0)
2261     internal_error ("gdbarch: gdbarch_memory_insert_breakpoint invalid");
2262   if (gdbarch_debug >= 2)
2263     fprintf_unfiltered (gdb_stdlog, "gdbarch_memory_insert_breakpoint called\n");
2264   return gdbarch->memory_insert_breakpoint (addr, contents_cache);
2265 }
2266
2267 void
2268 set_gdbarch_memory_insert_breakpoint (struct gdbarch *gdbarch,
2269                                       gdbarch_memory_insert_breakpoint_ftype memory_insert_breakpoint)
2270 {
2271   gdbarch->memory_insert_breakpoint = memory_insert_breakpoint;
2272 }
2273
2274 int
2275 gdbarch_memory_remove_breakpoint (struct gdbarch *gdbarch, CORE_ADDR addr, char *contents_cache)
2276 {
2277   if (GDB_MULTI_ARCH == 0)
2278     return default_memory_remove_breakpoint (addr, contents_cache);
2279   if (gdbarch->memory_remove_breakpoint == 0)
2280     internal_error ("gdbarch: gdbarch_memory_remove_breakpoint invalid");
2281   if (gdbarch_debug >= 2)
2282     fprintf_unfiltered (gdb_stdlog, "gdbarch_memory_remove_breakpoint called\n");
2283   return gdbarch->memory_remove_breakpoint (addr, contents_cache);
2284 }
2285
2286 void
2287 set_gdbarch_memory_remove_breakpoint (struct gdbarch *gdbarch,
2288                                       gdbarch_memory_remove_breakpoint_ftype memory_remove_breakpoint)
2289 {
2290   gdbarch->memory_remove_breakpoint = memory_remove_breakpoint;
2291 }
2292
2293 CORE_ADDR
2294 gdbarch_decr_pc_after_break (struct gdbarch *gdbarch)
2295 {
2296   if (gdbarch->decr_pc_after_break == -1)
2297     internal_error ("gdbarch: gdbarch_decr_pc_after_break invalid");
2298   if (gdbarch_debug >= 2)
2299     fprintf_unfiltered (gdb_stdlog, "gdbarch_decr_pc_after_break called\n");
2300   return gdbarch->decr_pc_after_break;
2301 }
2302
2303 void
2304 set_gdbarch_decr_pc_after_break (struct gdbarch *gdbarch,
2305                                  CORE_ADDR decr_pc_after_break)
2306 {
2307   gdbarch->decr_pc_after_break = decr_pc_after_break;
2308 }
2309
2310 CORE_ADDR
2311 gdbarch_function_start_offset (struct gdbarch *gdbarch)
2312 {
2313   if (gdbarch->function_start_offset == -1)
2314     internal_error ("gdbarch: gdbarch_function_start_offset invalid");
2315   if (gdbarch_debug >= 2)
2316     fprintf_unfiltered (gdb_stdlog, "gdbarch_function_start_offset called\n");
2317   return gdbarch->function_start_offset;
2318 }
2319
2320 void
2321 set_gdbarch_function_start_offset (struct gdbarch *gdbarch,
2322                                    CORE_ADDR function_start_offset)
2323 {
2324   gdbarch->function_start_offset = function_start_offset;
2325 }
2326
2327 void
2328 gdbarch_remote_translate_xfer_address (struct gdbarch *gdbarch, CORE_ADDR gdb_addr, int gdb_len, CORE_ADDR *rem_addr, int *rem_len)
2329 {
2330   if (GDB_MULTI_ARCH == 0)
2331     {
2332       generic_remote_translate_xfer_address (gdb_addr, gdb_len, rem_addr, rem_len);
2333       return;
2334     }
2335   if (gdbarch->remote_translate_xfer_address == 0)
2336     internal_error ("gdbarch: gdbarch_remote_translate_xfer_address invalid");
2337   if (gdbarch_debug >= 2)
2338     fprintf_unfiltered (gdb_stdlog, "gdbarch_remote_translate_xfer_address called\n");
2339   gdbarch->remote_translate_xfer_address (gdb_addr, gdb_len, rem_addr, rem_len);
2340 }
2341
2342 void
2343 set_gdbarch_remote_translate_xfer_address (struct gdbarch *gdbarch,
2344                                            gdbarch_remote_translate_xfer_address_ftype remote_translate_xfer_address)
2345 {
2346   gdbarch->remote_translate_xfer_address = remote_translate_xfer_address;
2347 }
2348
2349 CORE_ADDR
2350 gdbarch_frame_args_skip (struct gdbarch *gdbarch)
2351 {
2352   if (gdbarch->frame_args_skip == -1)
2353     internal_error ("gdbarch: gdbarch_frame_args_skip invalid");
2354   if (gdbarch_debug >= 2)
2355     fprintf_unfiltered (gdb_stdlog, "gdbarch_frame_args_skip called\n");
2356   return gdbarch->frame_args_skip;
2357 }
2358
2359 void
2360 set_gdbarch_frame_args_skip (struct gdbarch *gdbarch,
2361                              CORE_ADDR frame_args_skip)
2362 {
2363   gdbarch->frame_args_skip = frame_args_skip;
2364 }
2365
2366 int
2367 gdbarch_frameless_function_invocation (struct gdbarch *gdbarch, struct frame_info *fi)
2368 {
2369   if (GDB_MULTI_ARCH == 0)
2370     return generic_frameless_function_invocation_not (fi);
2371   if (gdbarch->frameless_function_invocation == 0)
2372     internal_error ("gdbarch: gdbarch_frameless_function_invocation invalid");
2373   if (gdbarch_debug >= 2)
2374     fprintf_unfiltered (gdb_stdlog, "gdbarch_frameless_function_invocation called\n");
2375   return gdbarch->frameless_function_invocation (fi);
2376 }
2377
2378 void
2379 set_gdbarch_frameless_function_invocation (struct gdbarch *gdbarch,
2380                                            gdbarch_frameless_function_invocation_ftype frameless_function_invocation)
2381 {
2382   gdbarch->frameless_function_invocation = frameless_function_invocation;
2383 }
2384
2385 CORE_ADDR
2386 gdbarch_frame_chain (struct gdbarch *gdbarch, struct frame_info *frame)
2387 {
2388   if (gdbarch->frame_chain == 0)
2389     internal_error ("gdbarch: gdbarch_frame_chain invalid");
2390   if (gdbarch_debug >= 2)
2391     fprintf_unfiltered (gdb_stdlog, "gdbarch_frame_chain called\n");
2392   return gdbarch->frame_chain (frame);
2393 }
2394
2395 void
2396 set_gdbarch_frame_chain (struct gdbarch *gdbarch,
2397                          gdbarch_frame_chain_ftype frame_chain)
2398 {
2399   gdbarch->frame_chain = frame_chain;
2400 }
2401
2402 int
2403 gdbarch_frame_chain_valid (struct gdbarch *gdbarch, CORE_ADDR chain, struct frame_info *thisframe)
2404 {
2405   if (gdbarch->frame_chain_valid == 0)
2406     internal_error ("gdbarch: gdbarch_frame_chain_valid invalid");
2407   if (gdbarch_debug >= 2)
2408     fprintf_unfiltered (gdb_stdlog, "gdbarch_frame_chain_valid called\n");
2409   return gdbarch->frame_chain_valid (chain, thisframe);
2410 }
2411
2412 void
2413 set_gdbarch_frame_chain_valid (struct gdbarch *gdbarch,
2414                                gdbarch_frame_chain_valid_ftype frame_chain_valid)
2415 {
2416   gdbarch->frame_chain_valid = frame_chain_valid;
2417 }
2418
2419 CORE_ADDR
2420 gdbarch_frame_saved_pc (struct gdbarch *gdbarch, struct frame_info *fi)
2421 {
2422   if (gdbarch->frame_saved_pc == 0)
2423     internal_error ("gdbarch: gdbarch_frame_saved_pc invalid");
2424   if (gdbarch_debug >= 2)
2425     fprintf_unfiltered (gdb_stdlog, "gdbarch_frame_saved_pc called\n");
2426   return gdbarch->frame_saved_pc (fi);
2427 }
2428
2429 void
2430 set_gdbarch_frame_saved_pc (struct gdbarch *gdbarch,
2431                             gdbarch_frame_saved_pc_ftype frame_saved_pc)
2432 {
2433   gdbarch->frame_saved_pc = frame_saved_pc;
2434 }
2435
2436 CORE_ADDR
2437 gdbarch_frame_args_address (struct gdbarch *gdbarch, struct frame_info *fi)
2438 {
2439   if (gdbarch->frame_args_address == 0)
2440     internal_error ("gdbarch: gdbarch_frame_args_address invalid");
2441   if (gdbarch_debug >= 2)
2442     fprintf_unfiltered (gdb_stdlog, "gdbarch_frame_args_address called\n");
2443   return gdbarch->frame_args_address (fi);
2444 }
2445
2446 void
2447 set_gdbarch_frame_args_address (struct gdbarch *gdbarch,
2448                                 gdbarch_frame_args_address_ftype frame_args_address)
2449 {
2450   gdbarch->frame_args_address = frame_args_address;
2451 }
2452
2453 CORE_ADDR
2454 gdbarch_frame_locals_address (struct gdbarch *gdbarch, struct frame_info *fi)
2455 {
2456   if (gdbarch->frame_locals_address == 0)
2457     internal_error ("gdbarch: gdbarch_frame_locals_address invalid");
2458   if (gdbarch_debug >= 2)
2459     fprintf_unfiltered (gdb_stdlog, "gdbarch_frame_locals_address called\n");
2460   return gdbarch->frame_locals_address (fi);
2461 }
2462
2463 void
2464 set_gdbarch_frame_locals_address (struct gdbarch *gdbarch,
2465                                   gdbarch_frame_locals_address_ftype frame_locals_address)
2466 {
2467   gdbarch->frame_locals_address = frame_locals_address;
2468 }
2469
2470 CORE_ADDR
2471 gdbarch_saved_pc_after_call (struct gdbarch *gdbarch, struct frame_info *frame)
2472 {
2473   if (gdbarch->saved_pc_after_call == 0)
2474     internal_error ("gdbarch: gdbarch_saved_pc_after_call invalid");
2475   if (gdbarch_debug >= 2)
2476     fprintf_unfiltered (gdb_stdlog, "gdbarch_saved_pc_after_call called\n");
2477   return gdbarch->saved_pc_after_call (frame);
2478 }
2479
2480 void
2481 set_gdbarch_saved_pc_after_call (struct gdbarch *gdbarch,
2482                                  gdbarch_saved_pc_after_call_ftype saved_pc_after_call)
2483 {
2484   gdbarch->saved_pc_after_call = saved_pc_after_call;
2485 }
2486
2487 int
2488 gdbarch_frame_num_args (struct gdbarch *gdbarch, struct frame_info *frame)
2489 {
2490   if (gdbarch->frame_num_args == 0)
2491     internal_error ("gdbarch: gdbarch_frame_num_args invalid");
2492   if (gdbarch_debug >= 2)
2493     fprintf_unfiltered (gdb_stdlog, "gdbarch_frame_num_args called\n");
2494   return gdbarch->frame_num_args (frame);
2495 }
2496
2497 void
2498 set_gdbarch_frame_num_args (struct gdbarch *gdbarch,
2499                             gdbarch_frame_num_args_ftype frame_num_args)
2500 {
2501   gdbarch->frame_num_args = frame_num_args;
2502 }
2503
2504 int
2505 gdbarch_stack_align_p (struct gdbarch *gdbarch)
2506 {
2507   return gdbarch->stack_align != 0;
2508 }
2509
2510 CORE_ADDR
2511 gdbarch_stack_align (struct gdbarch *gdbarch, CORE_ADDR sp)
2512 {
2513   if (gdbarch->stack_align == 0)
2514     internal_error ("gdbarch: gdbarch_stack_align invalid");
2515   if (gdbarch_debug >= 2)
2516     fprintf_unfiltered (gdb_stdlog, "gdbarch_stack_align called\n");
2517   return gdbarch->stack_align (sp);
2518 }
2519
2520 void
2521 set_gdbarch_stack_align (struct gdbarch *gdbarch,
2522                          gdbarch_stack_align_ftype stack_align)
2523 {
2524   gdbarch->stack_align = stack_align;
2525 }
2526
2527 int
2528 gdbarch_reg_struct_has_addr_p (struct gdbarch *gdbarch)
2529 {
2530   return gdbarch->reg_struct_has_addr != 0;
2531 }
2532
2533 int
2534 gdbarch_reg_struct_has_addr (struct gdbarch *gdbarch, int gcc_p, struct type *type)
2535 {
2536   if (gdbarch->reg_struct_has_addr == 0)
2537     internal_error ("gdbarch: gdbarch_reg_struct_has_addr invalid");
2538   if (gdbarch_debug >= 2)
2539     fprintf_unfiltered (gdb_stdlog, "gdbarch_reg_struct_has_addr called\n");
2540   return gdbarch->reg_struct_has_addr (gcc_p, type);
2541 }
2542
2543 void
2544 set_gdbarch_reg_struct_has_addr (struct gdbarch *gdbarch,
2545                                  gdbarch_reg_struct_has_addr_ftype reg_struct_has_addr)
2546 {
2547   gdbarch->reg_struct_has_addr = reg_struct_has_addr;
2548 }
2549
2550
2551 /* Keep a registrary of per-architecture data-pointers required by GDB
2552    modules. */
2553
2554 struct gdbarch_data
2555 {
2556   int index;
2557 };
2558
2559 struct gdbarch_data_registration
2560 {
2561   gdbarch_data_ftype *init;
2562   struct gdbarch_data *data;
2563   struct gdbarch_data_registration *next;
2564 };
2565
2566 struct gdbarch_data_registrary
2567 {
2568   int nr;
2569   struct gdbarch_data_registration *registrations;
2570 };
2571
2572 struct gdbarch_data_registrary gdbarch_data_registrary =
2573 {
2574   0, NULL,
2575 };
2576
2577 struct gdbarch_data *
2578 register_gdbarch_data (gdbarch_data_ftype *init)
2579 {
2580   struct gdbarch_data_registration **curr;
2581   for (curr = &gdbarch_data_registrary.registrations;
2582        (*curr) != NULL;
2583        curr = &(*curr)->next);
2584   (*curr) = XMALLOC (struct gdbarch_data_registration);
2585   (*curr)->next = NULL;
2586   (*curr)->init = init;
2587   (*curr)->data = XMALLOC (struct gdbarch_data);
2588   (*curr)->data->index = gdbarch_data_registrary.nr++;
2589   return (*curr)->data;
2590 }
2591
2592
2593 /* Walk through all the registered users initializing each in turn. */
2594
2595 static void
2596 init_gdbarch_data (struct gdbarch *gdbarch)
2597 {
2598   struct gdbarch_data_registration *rego;
2599   gdbarch->nr_data = gdbarch_data_registrary.nr + 1;
2600   gdbarch->data = xmalloc (sizeof (void*) * gdbarch->nr_data);
2601   for (rego = gdbarch_data_registrary.registrations;
2602        rego != NULL;
2603        rego = rego->next)
2604     {
2605       if (rego->data->index < gdbarch->nr_data)
2606         gdbarch->data[rego->data->index] = rego->init ();
2607     }
2608 }
2609
2610
2611 /* Return the current value of the specified per-architecture
2612    data-pointer. */
2613
2614 void *
2615 gdbarch_data (data)
2616      struct gdbarch_data *data;
2617 {
2618   if (data->index >= current_gdbarch->nr_data)
2619     internal_error ("gdbarch_data: request for non-existant data.");
2620   return current_gdbarch->data[data->index];
2621 }
2622
2623
2624
2625 /* Keep a registrary of swaped data required by GDB modules. */
2626
2627 struct gdbarch_swap
2628 {
2629   void *swap;
2630   struct gdbarch_swap_registration *source;
2631   struct gdbarch_swap *next;
2632 };
2633
2634 struct gdbarch_swap_registration
2635 {
2636   void *data;
2637   unsigned long sizeof_data;
2638   gdbarch_swap_ftype *init;
2639   struct gdbarch_swap_registration *next;
2640 };
2641
2642 struct gdbarch_swap_registrary
2643 {
2644   int nr;
2645   struct gdbarch_swap_registration *registrations;
2646 };
2647
2648 struct gdbarch_swap_registrary gdbarch_swap_registrary =
2649 {
2650   0, NULL,
2651 };
2652
2653 void
2654 register_gdbarch_swap (void *data,
2655                        unsigned long sizeof_data,
2656                        gdbarch_swap_ftype *init)
2657 {
2658   struct gdbarch_swap_registration **rego;
2659   for (rego = &gdbarch_swap_registrary.registrations;
2660        (*rego) != NULL;
2661        rego = &(*rego)->next);
2662   (*rego) = XMALLOC (struct gdbarch_swap_registration);
2663   (*rego)->next = NULL;
2664   (*rego)->init = init;
2665   (*rego)->data = data;
2666   (*rego)->sizeof_data = sizeof_data;
2667 }
2668
2669
2670 static void
2671 init_gdbarch_swap (struct gdbarch *gdbarch)
2672 {
2673   struct gdbarch_swap_registration *rego;
2674   struct gdbarch_swap **curr = &gdbarch->swap;
2675   for (rego = gdbarch_swap_registrary.registrations;
2676        rego != NULL;
2677        rego = rego->next)
2678     {
2679       if (rego->data != NULL)
2680         {
2681           (*curr) = XMALLOC (struct gdbarch_swap);
2682           (*curr)->source = rego;
2683           (*curr)->swap = xmalloc (rego->sizeof_data);
2684           (*curr)->next = NULL;
2685           memset (rego->data, 0, rego->sizeof_data);
2686           curr = &(*curr)->next;
2687         }
2688       if (rego->init != NULL)
2689         rego->init ();
2690     }
2691 }
2692
2693 static void
2694 swapout_gdbarch_swap (struct gdbarch *gdbarch)
2695 {
2696   struct gdbarch_swap *curr;
2697   for (curr = gdbarch->swap;
2698        curr != NULL;
2699        curr = curr->next)
2700     memcpy (curr->swap, curr->source->data, curr->source->sizeof_data);
2701 }
2702
2703 static void
2704 swapin_gdbarch_swap (struct gdbarch *gdbarch)
2705 {
2706   struct gdbarch_swap *curr;
2707   for (curr = gdbarch->swap;
2708        curr != NULL;
2709        curr = curr->next)
2710     memcpy (curr->source->data, curr->swap, curr->source->sizeof_data);
2711 }
2712
2713
2714 /* Keep a registrary of the architectures known by GDB. */
2715
2716 struct gdbarch_init_registration
2717 {
2718   enum bfd_architecture bfd_architecture;
2719   gdbarch_init_ftype *init;
2720   struct gdbarch_list *arches;
2721   struct gdbarch_init_registration *next;
2722 };
2723
2724 static struct gdbarch_init_registration *gdbarch_init_registrary = NULL;
2725
2726 void
2727 register_gdbarch_init (enum bfd_architecture bfd_architecture,
2728                        gdbarch_init_ftype *init)
2729 {
2730   struct gdbarch_init_registration **curr;
2731   const struct bfd_arch_info *bfd_arch_info;
2732   /* Check that BFD reconizes this architecture */
2733   bfd_arch_info = bfd_lookup_arch (bfd_architecture, 0);
2734   if (bfd_arch_info == NULL)
2735     {
2736       internal_error ("gdbarch: Attempt to register unknown architecture (%d)", bfd_architecture);
2737     }
2738   /* Check that we haven't seen this architecture before */
2739   for (curr = &gdbarch_init_registrary;
2740        (*curr) != NULL;
2741        curr = &(*curr)->next)
2742     {
2743       if (bfd_architecture == (*curr)->bfd_architecture)
2744         internal_error ("gdbarch: Duplicate registraration of architecture (%s)",
2745                bfd_arch_info->printable_name);
2746     }
2747   /* log it */
2748   if (gdbarch_debug)
2749     fprintf_unfiltered (gdb_stdlog, "register_gdbarch_init (%s, 0x%08lx)\n",
2750                         bfd_arch_info->printable_name,
2751                         (long) init);
2752   /* Append it */
2753   (*curr) = XMALLOC (struct gdbarch_init_registration);
2754   (*curr)->bfd_architecture = bfd_architecture;
2755   (*curr)->init = init;
2756   (*curr)->arches = NULL;
2757   (*curr)->next = NULL;
2758 }
2759
2760
2761
2762 /* Look for an architecture using gdbarch_info.  Base search on only
2763    BFD_ARCH_INFO and BYTE_ORDER. */
2764
2765 struct gdbarch_list *
2766 gdbarch_list_lookup_by_info (struct gdbarch_list *arches,
2767                              const struct gdbarch_info *info)
2768 {
2769   for (; arches != NULL; arches = arches->next)
2770     {
2771       if (info->bfd_arch_info != arches->gdbarch->bfd_arch_info)
2772         continue;
2773       if (info->byte_order != arches->gdbarch->byte_order)
2774         continue;
2775       return arches;
2776     }
2777   return NULL;
2778 }
2779
2780
2781 /* Update the current architecture. Return ZERO if the update request
2782    failed. */
2783
2784 int
2785 gdbarch_update (struct gdbarch_info info)
2786 {
2787   struct gdbarch *new_gdbarch;
2788   struct gdbarch_list **list;
2789   struct gdbarch_init_registration *rego;
2790
2791   /* Fill in any missing bits. Most important is the bfd_architecture
2792      which is used to select the target architecture. */
2793   if (info.bfd_architecture == bfd_arch_unknown)
2794     {
2795       if (info.bfd_arch_info != NULL)
2796         info.bfd_architecture = info.bfd_arch_info->arch;
2797       else if (info.abfd != NULL)
2798         info.bfd_architecture = bfd_get_arch (info.abfd);
2799       /* FIXME - should query BFD for its default architecture. */
2800       else
2801         info.bfd_architecture = current_gdbarch->bfd_arch_info->arch;
2802     }
2803   if (info.bfd_arch_info == NULL)
2804     {
2805       if (target_architecture_auto && info.abfd != NULL)
2806         info.bfd_arch_info = bfd_get_arch_info (info.abfd);
2807       else
2808         info.bfd_arch_info = current_gdbarch->bfd_arch_info;
2809     }
2810   if (info.byte_order == 0)
2811     {
2812       if (target_byte_order_auto && info.abfd != NULL)
2813         info.byte_order = (bfd_big_endian (info.abfd) ? BIG_ENDIAN
2814                            : bfd_little_endian (info.abfd) ? LITTLE_ENDIAN
2815                            : 0);
2816       else
2817         info.byte_order = current_gdbarch->byte_order;
2818       /* FIXME - should query BFD for its default byte-order. */
2819     }
2820   /* A default for abfd? */
2821
2822   /* Find the target that knows about this architecture. */
2823   for (rego = gdbarch_init_registrary;
2824        rego != NULL && rego->bfd_architecture != info.bfd_architecture;
2825        rego = rego->next);
2826   if (rego == NULL)
2827     {
2828       if (gdbarch_debug)
2829         fprintf_unfiltered (gdb_stdlog, "gdbarch_update: No matching architecture\n");
2830       return 0;
2831     }
2832
2833   if (gdbarch_debug)
2834     {
2835       fprintf_unfiltered (gdb_stdlog,
2836                           "gdbarch_update: info.bfd_architecture %d (%s)\n",
2837                           info.bfd_architecture,
2838                           bfd_lookup_arch (info.bfd_architecture, 0)->printable_name);
2839       fprintf_unfiltered (gdb_stdlog,
2840                           "gdbarch_update: info.bfd_arch_info %s\n",
2841                           (info.bfd_arch_info != NULL
2842                            ? info.bfd_arch_info->printable_name
2843                            : "(null)"));
2844       fprintf_unfiltered (gdb_stdlog,
2845                           "gdbarch_update: info.byte_order %d (%s)\n",
2846                           info.byte_order,
2847                           (info.byte_order == BIG_ENDIAN ? "big"
2848                            : info.byte_order == LITTLE_ENDIAN ? "little"
2849                            : "default"));
2850       fprintf_unfiltered (gdb_stdlog,
2851                           "gdbarch_update: info.abfd 0x%lx\n",
2852                           (long) info.abfd);
2853       fprintf_unfiltered (gdb_stdlog,
2854                           "gdbarch_update: info.tdep_info 0x%lx\n",
2855                           (long) info.tdep_info);
2856     }
2857
2858   /* Ask the target for a replacement architecture. */
2859   new_gdbarch = rego->init (info, rego->arches);
2860
2861   /* Did the target like it?  No. Reject the change. */
2862   if (new_gdbarch == NULL)
2863     {
2864       if (gdbarch_debug)
2865         fprintf_unfiltered (gdb_stdlog, "gdbarch_update: Target rejected architecture\n");
2866       return 0;
2867     }
2868
2869   /* Did the architecture change?  No. Do nothing. */
2870   if (current_gdbarch == new_gdbarch)
2871     {
2872       if (gdbarch_debug)
2873         fprintf_unfiltered (gdb_stdlog, "gdbarch_update: Architecture 0x%08lx (%s) unchanged\n",
2874                             (long) new_gdbarch,
2875                             new_gdbarch->bfd_arch_info->printable_name);
2876       return 1;
2877     }
2878
2879   /* Swap all data belonging to the old target out */
2880   swapout_gdbarch_swap (current_gdbarch);
2881
2882   /* Is this a pre-existing architecture?  Yes. Swap it in.  */
2883   for (list = &rego->arches;
2884        (*list) != NULL;
2885        list = &(*list)->next)
2886     {
2887       if ((*list)->gdbarch == new_gdbarch)
2888         {
2889           if (gdbarch_debug)
2890             fprintf_unfiltered (gdb_stdlog, "gdbarch_update: Previous architecture 0x%08lx (%s) selected\n",
2891                                 (long) new_gdbarch,
2892                                 new_gdbarch->bfd_arch_info->printable_name);
2893           current_gdbarch = new_gdbarch;
2894           swapin_gdbarch_swap (new_gdbarch);
2895           return 1;
2896         }
2897     }
2898
2899   /* Append this new architecture to this targets list. */
2900   (*list) = XMALLOC (struct gdbarch_list);
2901   (*list)->next = NULL;
2902   (*list)->gdbarch = new_gdbarch;
2903
2904   /* Switch to this new architecture.  Dump it out. */
2905   current_gdbarch = new_gdbarch;
2906   if (gdbarch_debug)
2907     {
2908       fprintf_unfiltered (gdb_stdlog,
2909                           "gdbarch_update: New architecture 0x%08lx (%s) selected\n",
2910                           (long) new_gdbarch,
2911                           new_gdbarch->bfd_arch_info->printable_name);
2912       gdbarch_dump ();
2913     }
2914
2915   /* Check that the newly installed architecture is valid.  */
2916   verify_gdbarch (new_gdbarch);
2917
2918   /* Initialize the per-architecture memory (swap) areas.
2919      CURRENT_GDBARCH must be update before these modules are
2920      called. */
2921   init_gdbarch_swap (new_gdbarch);
2922
2923   /* Initialize the per-architecture data-pointer of all parties that
2924      registered an interest in this architecture.  CURRENT_GDBARCH
2925      must be updated before these modules are called. */
2926   init_gdbarch_data (new_gdbarch);
2927
2928   return 1;
2929 }
2930
2931
2932
2933 /* Functions to manipulate the endianness of the target.  */
2934
2935 #ifdef TARGET_BYTE_ORDER_SELECTABLE
2936 /* compat - Catch old targets that expect a selectable byte-order to
2937    default to BIG_ENDIAN */
2938 #ifndef TARGET_BYTE_ORDER_DEFAULT
2939 #define TARGET_BYTE_ORDER_DEFAULT BIG_ENDIAN
2940 #endif
2941 #endif
2942 #if !TARGET_BYTE_ORDER_SELECTABLE_P
2943 #ifndef TARGET_BYTE_ORDER_DEFAULT
2944 /* compat - Catch old non byte-order selectable targets that do not
2945    define TARGET_BYTE_ORDER_DEFAULT and instead expect
2946    TARGET_BYTE_ORDER to be used as the default.  For targets that
2947    defined neither TARGET_BYTE_ORDER nor TARGET_BYTE_ORDER_DEFAULT the
2948    below will get a strange compiler warning. */
2949 #define TARGET_BYTE_ORDER_DEFAULT TARGET_BYTE_ORDER
2950 #endif
2951 #endif
2952 #ifndef TARGET_BYTE_ORDER_DEFAULT
2953 #define TARGET_BYTE_ORDER_DEFAULT BIG_ENDIAN /* arbitrary */
2954 #endif
2955 int target_byte_order = TARGET_BYTE_ORDER_DEFAULT;
2956 int target_byte_order_auto = 1;
2957
2958 /* Chain containing the \"set endian\" commands.  */
2959 static struct cmd_list_element *endianlist = NULL;
2960
2961 /* Called by ``show endian''.  */
2962 static void
2963 show_endian (char *args, int from_tty)
2964 {
2965   char *msg =
2966     (TARGET_BYTE_ORDER_AUTO
2967      ? "The target endianness is set automatically (currently %s endian)\n"
2968      : "The target is assumed to be %s endian\n");
2969   printf_unfiltered (msg, (TARGET_BYTE_ORDER == BIG_ENDIAN ? "big" : "little"));
2970 }
2971
2972 /* Called if the user enters ``set endian'' without an argument.  */
2973 static void
2974 set_endian (char *args, int from_tty)
2975 {
2976   printf_unfiltered ("\"set endian\" must be followed by \"auto\", \"big\" or \"little\".\n");
2977   show_endian (args, from_tty);
2978 }
2979
2980 /* Called by ``set endian big''.  */
2981 static void
2982 set_endian_big (char *args, int from_tty)
2983 {
2984   if (TARGET_BYTE_ORDER_SELECTABLE_P)
2985     {
2986       target_byte_order = BIG_ENDIAN;
2987       target_byte_order_auto = 0;
2988       if (GDB_MULTI_ARCH)
2989         {
2990           struct gdbarch_info info;
2991           memset (&info, 0, sizeof info);
2992           info.byte_order = BIG_ENDIAN;
2993           gdbarch_update (info);
2994         }
2995     }
2996   else
2997     {
2998       printf_unfiltered ("Byte order is not selectable.");
2999       show_endian (args, from_tty);
3000     }
3001 }
3002
3003 /* Called by ``set endian little''.  */
3004 static void
3005 set_endian_little (char *args, int from_tty)
3006 {
3007   if (TARGET_BYTE_ORDER_SELECTABLE_P)
3008     {
3009       target_byte_order = LITTLE_ENDIAN;
3010       target_byte_order_auto = 0;
3011       if (GDB_MULTI_ARCH)
3012         {
3013           struct gdbarch_info info;
3014           memset (&info, 0, sizeof info);
3015           info.byte_order = LITTLE_ENDIAN;
3016           gdbarch_update (info);
3017         }
3018     }
3019   else
3020     {
3021       printf_unfiltered ("Byte order is not selectable.");
3022       show_endian (args, from_tty);
3023     }
3024 }
3025
3026 /* Called by ``set endian auto''.  */
3027 static void
3028 set_endian_auto (char *args, int from_tty)
3029 {
3030   if (TARGET_BYTE_ORDER_SELECTABLE_P)
3031     {
3032       target_byte_order_auto = 1;
3033     }
3034   else
3035     {
3036       printf_unfiltered ("Byte order is not selectable.");
3037       show_endian (args, from_tty);
3038     }
3039 }
3040
3041 /* Set the endianness from a BFD.  */
3042 static void
3043 set_endian_from_file (bfd *abfd)
3044 {
3045   if (TARGET_BYTE_ORDER_SELECTABLE_P)
3046     {
3047       int want;
3048
3049       if (bfd_big_endian (abfd))
3050         want = BIG_ENDIAN;
3051       else
3052         want = LITTLE_ENDIAN;
3053       if (TARGET_BYTE_ORDER_AUTO)
3054         target_byte_order = want;
3055       else if (TARGET_BYTE_ORDER != want)
3056         warning ("%s endian file does not match %s endian target.",
3057                  want == BIG_ENDIAN ? "big" : "little",
3058                  TARGET_BYTE_ORDER == BIG_ENDIAN ? "big" : "little");
3059     }
3060   else
3061     {
3062       if (bfd_big_endian (abfd)
3063           ? TARGET_BYTE_ORDER != BIG_ENDIAN
3064           : TARGET_BYTE_ORDER == BIG_ENDIAN)
3065         warning ("%s endian file does not match %s endian target.",
3066                  bfd_big_endian (abfd) ? "big" : "little",
3067                  TARGET_BYTE_ORDER == BIG_ENDIAN ? "big" : "little");
3068     }
3069 }
3070
3071
3072
3073 /* Functions to manipulate the architecture of the target */
3074
3075 enum set_arch { set_arch_auto, set_arch_manual };
3076
3077 int target_architecture_auto = 1;
3078 extern const struct bfd_arch_info bfd_default_arch_struct;
3079 const struct bfd_arch_info *target_architecture = &bfd_default_arch_struct;
3080 int (*target_architecture_hook) (const struct bfd_arch_info *ap);
3081
3082 static void show_endian (char *, int);
3083 static void set_endian (char *, int);
3084 static void set_endian_big (char *, int);
3085 static void set_endian_little (char *, int);
3086 static void set_endian_auto (char *, int);
3087 static void set_endian_from_file (bfd *);
3088 static int arch_ok (const struct bfd_arch_info *arch);
3089 static void set_arch (const struct bfd_arch_info *arch, enum set_arch type);
3090 static void show_architecture (char *, int);
3091 static void set_architecture (char *, int);
3092 static void info_architecture (char *, int);
3093 static void set_architecture_from_file (bfd *);
3094
3095 /* Do the real work of changing the current architecture */
3096
3097 static int
3098 arch_ok (const struct bfd_arch_info *arch)
3099 {
3100   /* Should be performing the more basic check that the binary is
3101      compatible with GDB. */
3102   /* Check with the target that the architecture is valid. */
3103   return (target_architecture_hook == NULL
3104           || target_architecture_hook (arch));
3105 }
3106
3107 static void
3108 set_arch (const struct bfd_arch_info *arch,
3109           enum set_arch type)
3110 {
3111   switch (type)
3112     {
3113     case set_arch_auto:
3114       if (!arch_ok (arch))
3115         warning ("Target may not support %s architecture",
3116                  arch->printable_name);
3117       target_architecture = arch;
3118       break;
3119     case set_arch_manual:
3120       if (!arch_ok (arch))
3121         {
3122           printf_unfiltered ("Target does not support `%s' architecture.\n",
3123                              arch->printable_name);
3124         }
3125       else
3126         {
3127           target_architecture_auto = 0;
3128           target_architecture = arch;
3129         }
3130       break;
3131     }
3132   if (gdbarch_debug)
3133     gdbarch_dump ();
3134 }
3135
3136 /* Called if the user enters ``show architecture'' without an argument. */
3137 static void
3138 show_architecture (char *args, int from_tty)
3139 {
3140   const char *arch;
3141   arch = TARGET_ARCHITECTURE->printable_name;
3142   if (target_architecture_auto)
3143     printf_filtered ("The target architecture is set automatically (currently %s)\n", arch);
3144   else
3145     printf_filtered ("The target architecture is assumed to be %s\n", arch);
3146 }
3147
3148 /* Called if the user enters ``set architecture'' with or without an
3149    argument. */
3150 static void
3151 set_architecture (char *args, int from_tty)
3152 {
3153   if (args == NULL)
3154     {
3155       printf_unfiltered ("\"set architecture\" must be followed by \"auto\" or an architecture name.\n");
3156     }
3157   else if (strcmp (args, "auto") == 0)
3158     {
3159       target_architecture_auto = 1;
3160     }
3161   else if (GDB_MULTI_ARCH)
3162     {
3163       const struct bfd_arch_info *arch = bfd_scan_arch (args);
3164       if (arch == NULL)
3165         printf_unfiltered ("Architecture `%s' not reconized.\n", args);
3166       else
3167         {
3168           struct gdbarch_info info;
3169           memset (&info, 0, sizeof info);
3170           info.bfd_arch_info = arch;
3171           if (gdbarch_update (info))
3172             target_architecture_auto = 0;
3173           else
3174             printf_unfiltered ("Architecture `%s' not reconized.\n", args);
3175         }
3176     }
3177   else
3178     {
3179       const struct bfd_arch_info *arch = bfd_scan_arch (args);
3180       if (arch != NULL)
3181         set_arch (arch, set_arch_manual);
3182       else
3183         printf_unfiltered ("Architecture `%s' not reconized.\n", args);
3184     }
3185 }
3186
3187 /* Called if the user enters ``info architecture'' without an argument. */
3188 static void
3189 info_architecture (char *args, int from_tty)
3190 {
3191   enum bfd_architecture a;
3192   if (GDB_MULTI_ARCH)
3193     {
3194       if (gdbarch_init_registrary != NULL)
3195         {
3196           struct gdbarch_init_registration *rego;
3197           printf_filtered ("Available architectures are:\n");
3198           for (rego = gdbarch_init_registrary;
3199                rego != NULL;
3200                rego = rego->next)
3201             {
3202               const struct bfd_arch_info *ap;
3203               ap = bfd_lookup_arch (rego->bfd_architecture, 0);
3204               if (ap != NULL)
3205                 {
3206                   do
3207                     {
3208                       printf_filtered (" %s", ap->printable_name);
3209                       ap = ap->next;
3210                     }
3211                   while (ap != NULL);
3212                   printf_filtered ("\n");
3213                 }
3214             }
3215         }
3216       else
3217         {
3218           printf_filtered ("There are no available architectures.\n");
3219         }
3220       return;
3221     }
3222   printf_filtered ("Available architectures are:\n");
3223   for (a = bfd_arch_obscure + 1; a < bfd_arch_last; a++)
3224     {
3225       const struct bfd_arch_info *ap = bfd_lookup_arch (a, 0);
3226       if (ap != NULL)
3227         {
3228           do
3229             {
3230               printf_filtered (" %s", ap->printable_name);
3231               ap = ap->next;
3232             }
3233           while (ap != NULL);
3234           printf_filtered ("\n");
3235         }
3236     }
3237 }
3238
3239 /* Set the architecture from arch/machine */
3240 void
3241 set_architecture_from_arch_mach (arch, mach)
3242      enum bfd_architecture arch;
3243      unsigned long mach;
3244 {
3245   const struct bfd_arch_info *wanted = bfd_lookup_arch (arch, mach);
3246   if (wanted != NULL)
3247     set_arch (wanted, set_arch_manual);
3248   else
3249     internal_error ("gdbarch: hardwired architecture/machine not reconized");
3250 }
3251
3252 /* Set the architecture from a BFD */
3253 static void
3254 set_architecture_from_file (bfd *abfd)
3255 {
3256   const struct bfd_arch_info *wanted = bfd_get_arch_info (abfd);
3257   if (target_architecture_auto)
3258     {
3259       set_arch (wanted, set_arch_auto);
3260     }
3261   else if (wanted != target_architecture)
3262     {
3263       warning ("%s architecture file may be incompatible with %s target.",
3264                wanted->printable_name,
3265                target_architecture->printable_name);
3266     }
3267 }
3268
3269
3270 /* Misc helper functions for targets. */
3271
3272 int
3273 frame_num_args_unknown (fi)
3274      struct frame_info *fi;
3275 {
3276   return -1;
3277 }
3278
3279
3280 int
3281 generic_register_convertible_not (num)
3282      int num;
3283 {
3284   return 0;
3285 }
3286
3287
3288 /* Disassembler */
3289
3290 /* Pointer to the target-dependent disassembly function.  */
3291 int (*tm_print_insn) (bfd_vma, disassemble_info *);
3292 disassemble_info tm_print_insn_info;
3293
3294
3295
3296 /* Set the dynamic target-system-dependant parameters (architecture,
3297    byte-order) using information found in the BFD */
3298
3299 void
3300 set_gdbarch_from_file (abfd)
3301      bfd *abfd;
3302 {
3303   if (GDB_MULTI_ARCH)
3304     {
3305       struct gdbarch_info info;
3306       memset (&info, 0, sizeof info);
3307       info.abfd = abfd;
3308       gdbarch_update (info);
3309       return;
3310     }
3311   set_architecture_from_file (abfd);
3312   set_endian_from_file (abfd);
3313 }
3314
3315
3316 /* Initialize the current architecture.  */
3317 void
3318 initialize_current_architecture ()
3319 {
3320   if (GDB_MULTI_ARCH)
3321     {
3322       struct gdbarch_init_registration *rego;
3323       const struct bfd_arch_info *chosen = NULL;
3324       for (rego = gdbarch_init_registrary; rego != NULL; rego = rego->next)
3325         {
3326           const struct bfd_arch_info *ap
3327             = bfd_lookup_arch (rego->bfd_architecture, 0);
3328
3329           /* Choose the first architecture alphabetically.  */
3330           if (chosen == NULL
3331               || strcmp (ap->printable_name, chosen->printable_name) < 0)
3332             chosen = ap;
3333         }
3334
3335       if (chosen != NULL)
3336         {
3337           struct gdbarch_info info;
3338           memset (&info, 0, sizeof info);
3339           info.bfd_arch_info = chosen;
3340           gdbarch_update (info);
3341         }
3342     }
3343 }
3344
3345 extern void _initialize_gdbarch (void);
3346 void
3347 _initialize_gdbarch ()
3348 {
3349   struct cmd_list_element *c;
3350
3351   add_prefix_cmd ("endian", class_support, set_endian,
3352                   "Set endianness of target.",
3353                   &endianlist, "set endian ", 0, &setlist);
3354   add_cmd ("big", class_support, set_endian_big,
3355            "Set target as being big endian.", &endianlist);
3356   add_cmd ("little", class_support, set_endian_little,
3357            "Set target as being little endian.", &endianlist);
3358   add_cmd ("auto", class_support, set_endian_auto,
3359            "Select target endianness automatically.", &endianlist);
3360   add_cmd ("endian", class_support, show_endian,
3361            "Show endianness of target.", &showlist);
3362
3363   add_cmd ("architecture", class_support, set_architecture,
3364            "Set architecture of target.", &setlist);
3365   add_alias_cmd ("processor", "architecture", class_support, 1, &setlist);
3366   add_cmd ("architecture", class_support, show_architecture,
3367            "Show architecture of target.", &showlist);
3368   add_cmd ("architecture", class_support, info_architecture,
3369            "List supported target architectures", &infolist);
3370
3371   INIT_DISASSEMBLE_INFO_NO_ARCH (tm_print_insn_info, gdb_stdout, (fprintf_ftype)fprintf_filtered);
3372   tm_print_insn_info.flavour = bfd_target_unknown_flavour;
3373   tm_print_insn_info.read_memory_func = dis_asm_read_memory;
3374   tm_print_insn_info.memory_error_func = dis_asm_memory_error;
3375   tm_print_insn_info.print_address_func = dis_asm_print_address;
3376
3377   add_show_from_set (add_set_cmd ("arch",
3378                                   class_maintenance,
3379                                   var_zinteger,
3380                                   (char *)&gdbarch_debug,
3381                                   "Set architecture debugging.\n\
3382 When non-zero, architecture debugging is enabled.", &setdebuglist),
3383                      &showdebuglist);
3384   c = add_set_cmd ("archdebug",
3385                    class_maintenance,
3386                    var_zinteger,
3387                    (char *)&gdbarch_debug,
3388                    "Set architecture debugging.\n\
3389 When non-zero, architecture debugging is enabled.", &setlist);
3390
3391   deprecate_cmd (c, "set debug arch");
3392   deprecate_cmd (add_show_from_set (c, &showlist), "show debug arch");
3393 }