gdb/gdbarch.sh

   1 #!/bin/sh -u
   2
   3 # Architecture commands for GDB, the GNU debugger.
   4 #
   5 # Copyright 1998, 1999, 2000, 2001, 2002, 2003, 2004 Free Software
   6 # Foundation, Inc.
   7 #
   8 #
   9 # This file is part of GDB.
  10 #
  11 # This program is free software; you can redistribute it and/or modify
  12 # it under the terms of the GNU General Public License as published by
  13 # the Free Software Foundation; either version 2 of the License, or
  14 # (at your option) any later version.
  15 #
  16 # This program is distributed in the hope that it will be useful,
  17 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  18 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19 # GNU General Public License for more details.
  20 #
  21 # You should have received a copy of the GNU General Public License
  22 # along with this program; if not, write to the Free Software
  23 # Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  24
  25 # Make certain that the script is running in an internationalized
  26 # environment.
  27 LANG=c ; export LANG
  28 LC_ALL=c ; export LC_ALL
  29
  30
  31 compare_new ()
  32 {
  33     file=$1
  34     if test ! -r ${file}
  35     then
  36         echo "${file} missing? cp new-${file} ${file}" 1>&2
  37     elif diff -u ${file} new-${file}
  38     then
  39         echo "${file} unchanged" 1>&2
  40     else
  41         echo "${file} has changed? cp new-${file} ${file}" 1>&2
  42     fi
  43 }
  44
  45
  46 # Format of the input table
  47 read="class level macro returntype function formal actual attrib staticdefault predefault postdefault invalid_p fmt print print_p description"
  48
  49 do_read ()
  50 {
  51     comment=""
  52     class=""
  53     while read line
  54     do
  55         if test "${line}" = ""
  56         then
  57             continue
  58         elif test "${line}" = "#" -a "${comment}" = ""
  59         then
  60             continue
  61         elif expr "${line}" : "#" > /dev/null
  62         then
  63             comment="${comment}
  64 ${line}"
  65         else
  66
  67             # The semantics of IFS varies between different SH's.  Some
  68             # treat ``::' as three fields while some treat it as just too.
  69             # Work around this by eliminating ``::'' ....
  70             line="`echo "${line}" | sed -e 's/::/: :/g' -e 's/::/: :/g'`"
  71
  72             OFS="${IFS}" ; IFS="[:]"
  73             eval read ${read} <<EOF
  74 ${line}
  75 EOF
  76             IFS="${OFS}"
  77
  78             # .... and then going back through each field and strip out those
  79             # that ended up with just that space character.
  80             for r in ${read}
  81             do
  82                 if eval test \"\${${r}}\" = \"\ \"
  83                 then
  84                     eval ${r}=""
  85                 fi
  86             done
  87
  88             case "${level}" in
  89                 1 ) gt_level=">= GDB_MULTI_ARCH_PARTIAL" ;;
  90                 2 ) gt_level="> GDB_MULTI_ARCH_PARTIAL" ;;
  91                 "" ) gt_level="> GDB_MULTI_ARCH_PARTIAL" ;;
  92                 * ) error "Error: bad level for ${function}" 1>&2 ; kill $$ ; exit 1 ;;
  93             esac
  94
  95             case "${class}" in
  96                 m ) staticdefault="${predefault}" ;;
  97                 M ) staticdefault="0" ;;
  98                 * ) test "${staticdefault}" || staticdefault=0 ;;
  99             esac
 100
 101             # come up with a format, use a few guesses for variables
 102             case ":${class}:${fmt}:${print}:" in
 103                 :[vV]::: )
 104                     if [ "${returntype}" = int ]
 105                     then
 106                         fmt="%d"
 107                         print="${macro}"
 108                     elif [ "${returntype}" = long ]
 109                     then
 110                         fmt="%ld"
 111                         print="${macro}"
 112                     fi
 113                     ;;
 114             esac
 115             test "${fmt}" || fmt="%ld"
 116             test "${print}" || print="(long) ${macro}"
 117
 118             case "${class}" in
 119             F | V | M )
 120                 case "${invalid_p}" in
 121                 "" )
 122                     if test -n "${predefault}"
 123                     then
 124                         #invalid_p="gdbarch->${function} == ${predefault}"
 125                         predicate="gdbarch->${function} != ${predefault}"
 126                     elif class_is_variable_p
 127                     then
 128                         predicate="gdbarch->${function} != 0"
 129                     elif class_is_function_p
 130                     then
 131                         predicate="gdbarch->${function} != NULL"
 132                     fi
 133                     ;;
 134                 * )
 135                     echo "Predicate function ${function} with invalid_p." 1>&2
 136                     kill $$
 137                     exit 1
 138                     ;;
 139                 esac
 140             esac
 141
 142             # PREDEFAULT is a valid fallback definition of MEMBER when
 143             # multi-arch is not enabled.  This ensures that the
 144             # default value, when multi-arch is the same as the
 145             # default value when not multi-arch.  POSTDEFAULT is
 146             # always a valid definition of MEMBER as this again
 147             # ensures consistency.
 148
 149             if [ -n "${postdefault}" ]
 150             then
 151                 fallbackdefault="${postdefault}"
 152             elif [ -n "${predefault}" ]
 153             then
 154                 fallbackdefault="${predefault}"
 155             else
 156                 fallbackdefault="0"
 157             fi
 158
 159             #NOT YET: See gdbarch.log for basic verification of
 160             # database
 161
 162             break
 163         fi
 164     done
 165     if [ -n "${class}" ]
 166     then
 167         true
 168     else
 169         false
 170     fi
 171 }
 172
 173
 174 fallback_default_p ()
 175 {
 176     [ -n "${postdefault}" -a "x${invalid_p}" != "x0" ] \
 177         || [ -n "${predefault}" -a "x${invalid_p}" = "x0" ]
 178 }
 179
 180 class_is_variable_p ()
 181 {
 182     case "${class}" in
 183         *v* | *V* ) true ;;
 184         * ) false ;;
 185     esac
 186 }
 187
 188 class_is_function_p ()
 189 {
 190     case "${class}" in
 191         *f* | *F* | *m* | *M* ) true ;;
 192         * ) false ;;
 193     esac
 194 }
 195
 196 class_is_multiarch_p ()
 197 {
 198     case "${class}" in
 199         *m* | *M* ) true ;;
 200         * ) false ;;
 201     esac
 202 }
 203
 204 class_is_predicate_p ()
 205 {
 206     case "${class}" in
 207         *F* | *V* | *M* ) true ;;
 208         * ) false ;;
 209     esac
 210 }
 211
 212 class_is_info_p ()
 213 {
 214     case "${class}" in
 215         *i* ) true ;;
 216         * ) false ;;
 217     esac
 218 }
 219
 220
 221 # dump out/verify the doco
 222 for field in ${read}
 223 do
 224   case ${field} in
 225
 226     class ) : ;;
 227
 228         # # -> line disable
 229         # f -> function
 230         #   hiding a function
 231         # F -> function + predicate
 232         #   hiding a function + predicate to test function validity
 233         # v -> variable
 234         #   hiding a variable
 235         # V -> variable + predicate
 236         #   hiding a variable + predicate to test variables validity
 237         # i -> set from info
 238         #   hiding something from the ``struct info'' object
 239         # m -> multi-arch function
 240         #   hiding a multi-arch function (parameterised with the architecture)
 241         # M -> multi-arch function + predicate
 242         #   hiding a multi-arch function + predicate to test function validity
 243
 244     level ) : ;;
 245
 246         # See GDB_MULTI_ARCH description.  Having GDB_MULTI_ARCH >=
 247         # LEVEL is a predicate on checking that a given method is
 248         # initialized (using INVALID_P).
 249
 250     macro ) : ;;
 251
 252         # The name of the MACRO that this method is to be accessed by.
 253
 254     returntype ) : ;;
 255
 256         # For functions, the return type; for variables, the data type
 257
 258     function ) : ;;
 259
 260         # For functions, the member function name; for variables, the
 261         # variable name.  Member function names are always prefixed with
 262         # ``gdbarch_'' for name-space purity.
 263
 264     formal ) : ;;
 265
 266         # The formal argument list.  It is assumed that the formal
 267         # argument list includes the actual name of each list element.
 268         # A function with no arguments shall have ``void'' as the
 269         # formal argument list.
 270
 271     actual ) : ;;
 272
 273         # The list of actual arguments.  The arguments specified shall
 274         # match the FORMAL list given above.  Functions with out
 275         # arguments leave this blank.
 276
 277     attrib ) : ;;
 278
 279         # Any GCC attributes that should be attached to the function
 280         # declaration.  At present this field is unused.
 281
 282     staticdefault ) : ;;
 283
 284         # To help with the GDB startup a static gdbarch object is
 285         # created.  STATICDEFAULT is the value to insert into that
 286         # static gdbarch object.  Since this a static object only
 287         # simple expressions can be used.
 288
 289         # If STATICDEFAULT is empty, zero is used.
 290
 291     predefault ) : ;;
 292
 293         # An initial value to assign to MEMBER of the freshly
 294         # malloc()ed gdbarch object.  After initialization, the
 295         # freshly malloc()ed object is passed to the target
 296         # architecture code for further updates.
 297
 298         # If PREDEFAULT is empty, zero is used.
 299
 300         # A non-empty PREDEFAULT, an empty POSTDEFAULT and a zero
 301         # INVALID_P are specified, PREDEFAULT will be used as the
 302         # default for the non- multi-arch target.
 303
 304         # A zero PREDEFAULT function will force the fallback to call
 305         # internal_error().
 306
 307         # Variable declarations can refer to ``gdbarch'' which will
 308         # contain the current architecture.  Care should be taken.
 309
 310     postdefault ) : ;;
 311
 312         # A value to assign to MEMBER of the new gdbarch object should
 313         # the target architecture code fail to change the PREDEFAULT
 314         # value.
 315
 316         # If POSTDEFAULT is empty, no post update is performed.
 317
 318         # If both INVALID_P and POSTDEFAULT are non-empty then
 319         # INVALID_P will be used to determine if MEMBER should be
 320         # changed to POSTDEFAULT.
 321
 322         # If a non-empty POSTDEFAULT and a zero INVALID_P are
 323         # specified, POSTDEFAULT will be used as the default for the
 324         # non- multi-arch target (regardless of the value of
 325         # PREDEFAULT).
 326
 327         # You cannot specify both a zero INVALID_P and a POSTDEFAULT.
 328
 329         # Variable declarations can refer to ``current_gdbarch'' which
 330         # will contain the current architecture.  Care should be
 331         # taken.
 332
 333     invalid_p ) : ;;
 334
 335         # A predicate equation that validates MEMBER.  Non-zero is
 336         # returned if the code creating the new architecture failed to
 337         # initialize MEMBER or the initialized the member is invalid.
 338         # If POSTDEFAULT is non-empty then MEMBER will be updated to
 339         # that value.  If POSTDEFAULT is empty then internal_error()
 340         # is called.
 341
 342         # If INVALID_P is empty, a check that MEMBER is no longer
 343         # equal to PREDEFAULT is used.
 344
 345         # The expression ``0'' disables the INVALID_P check making
 346         # PREDEFAULT a legitimate value.
 347
 348         # See also PREDEFAULT and POSTDEFAULT.
 349
 350     fmt ) : ;;
 351
 352         # printf style format string that can be used to print out the
 353         # MEMBER.  Sometimes "%s" is useful.  For functions, this is
 354         # ignored and the function address is printed.
 355
 356         # If FMT is empty, ``%ld'' is used.
 357
 358     print ) : ;;
 359
 360         # An optional equation that casts MEMBER to a value suitable
 361         # for formatting by FMT.
 362
 363         # If PRINT is empty, ``(long)'' is used.
 364
 365     print_p ) : ;;
 366
 367         # An optional indicator for any predicte to wrap around the
 368         # print member code.
 369
 370         #   () -> Call a custom function to do the dump.
 371         #   exp -> Wrap print up in ``if (${print_p}) ...
 372         #   ``'' -> No predicate
 373
 374         # If PRINT_P is empty, ``1'' is always used.
 375
 376     description ) : ;;
 377
 378         # Currently unused.
 379
 380     *)
 381         echo "Bad field ${field}"
 382         exit 1;;
 383   esac
 384 done
 385
 386
 387 function_list ()
 388 {
 389   # See below (DOCO) for description of each field
 390   cat <<EOF
 391 i:2:TARGET_ARCHITECTURE:const struct bfd_arch_info *:bfd_arch_info::::&bfd_default_arch_struct::::%s:TARGET_ARCHITECTURE->printable_name:TARGET_ARCHITECTURE != NULL
 392 #
 393 i:2:TARGET_BYTE_ORDER:int:byte_order::::BFD_ENDIAN_BIG
 394 #
 395 i:2:TARGET_OSABI:enum gdb_osabi:osabi::::GDB_OSABI_UNKNOWN
 396 # Number of bits in a char or unsigned char for the target machine.
 397 # Just like CHAR_BIT in <limits.h> but describes the target machine.
 398 # v:2:TARGET_CHAR_BIT:int:char_bit::::8 * sizeof (char):8::0:
 399 #
 400 # Number of bits in a short or unsigned short for the target machine.
 401 v:2:TARGET_SHORT_BIT:int:short_bit::::8 * sizeof (short):2*TARGET_CHAR_BIT::0
 402 # Number of bits in an int or unsigned int for the target machine.
 403 v:2:TARGET_INT_BIT:int:int_bit::::8 * sizeof (int):4*TARGET_CHAR_BIT::0
 404 # Number of bits in a long or unsigned long for the target machine.
 405 v:2:TARGET_LONG_BIT:int:long_bit::::8 * sizeof (long):4*TARGET_CHAR_BIT::0
 406 # Number of bits in a long long or unsigned long long for the target
 407 # machine.
 408 v:2:TARGET_LONG_LONG_BIT:int:long_long_bit::::8 * sizeof (LONGEST):2*TARGET_LONG_BIT::0
 409 # Number of bits in a float for the target machine.
 410 v:2:TARGET_FLOAT_BIT:int:float_bit::::8 * sizeof (float):4*TARGET_CHAR_BIT::0
 411 # Number of bits in a double for the target machine.
 412 v:2:TARGET_DOUBLE_BIT:int:double_bit::::8 * sizeof (double):8*TARGET_CHAR_BIT::0
 413 # Number of bits in a long double for the target machine.
 414 v:2:TARGET_LONG_DOUBLE_BIT:int:long_double_bit::::8 * sizeof (long double):8*TARGET_CHAR_BIT::0
 415 # For most targets, a pointer on the target and its representation as an
 416 # address in GDB have the same size and "look the same".  For such a
 417 # target, you need only set TARGET_PTR_BIT / ptr_bit and TARGET_ADDR_BIT
 418 # / addr_bit will be set from it.
 419 #
 420 # If TARGET_PTR_BIT and TARGET_ADDR_BIT are different, you'll probably
 421 # also need to set POINTER_TO_ADDRESS and ADDRESS_TO_POINTER as well.
 422 #
 423 # ptr_bit is the size of a pointer on the target
 424 v:2:TARGET_PTR_BIT:int:ptr_bit::::8 * sizeof (void*):TARGET_INT_BIT::0
 425 # addr_bit is the size of a target address as represented in gdb
 426 v:2:TARGET_ADDR_BIT:int:addr_bit::::8 * sizeof (void*):0:TARGET_PTR_BIT:
 427 # Number of bits in a BFD_VMA for the target object file format.
 428 v:2:TARGET_BFD_VMA_BIT:int:bfd_vma_bit::::8 * sizeof (void*):TARGET_ARCHITECTURE->bits_per_address::0
 429 #
 430 # One if \`char' acts like \`signed char', zero if \`unsigned char'.
 431 v:2:TARGET_CHAR_SIGNED:int:char_signed::::1:-1:1::::
 432 #
 433 F:2:TARGET_READ_PC:CORE_ADDR:read_pc:ptid_t ptid:ptid
 434 f:2:TARGET_WRITE_PC:void:write_pc:CORE_ADDR val, ptid_t ptid:val, ptid::0:generic_target_write_pc::0
 435 # UNWIND_SP is a direct replacement for TARGET_READ_SP.
 436 F:2:TARGET_READ_SP:CORE_ADDR:read_sp:void
 437 # Function for getting target's idea of a frame pointer.  FIXME: GDB's
 438 # whole scheme for dealing with "frames" and "frame pointers" needs a
 439 # serious shakedown.
 440 f:2:TARGET_VIRTUAL_FRAME_POINTER:void:virtual_frame_pointer:CORE_ADDR pc, int *frame_regnum, LONGEST *frame_offset:pc, frame_regnum, frame_offset::0:legacy_virtual_frame_pointer::0
 441 #
 442 M:::void:pseudo_register_read:struct regcache *regcache, int cookednum, void *buf:regcache, cookednum, buf
 443 M:::void:pseudo_register_write:struct regcache *regcache, int cookednum, const void *buf:regcache, cookednum, buf
 444 #
 445 v:2:NUM_REGS:int:num_regs::::0:-1
 446 # This macro gives the number of pseudo-registers that live in the
 447 # register namespace but do not get fetched or stored on the target.
 448 # These pseudo-registers may be aliases for other registers,
 449 # combinations of other registers, or they may be computed by GDB.
 450 v:2:NUM_PSEUDO_REGS:int:num_pseudo_regs::::0:0::0:::
 451
 452 # GDB's standard (or well known) register numbers.  These can map onto
 453 # a real register or a pseudo (computed) register or not be defined at
 454 # all (-1).
 455 # SP_REGNUM will hopefully be replaced by UNWIND_SP.
 456 v:2:SP_REGNUM:int:sp_regnum::::-1:-1::0
 457 v:2:PC_REGNUM:int:pc_regnum::::-1:-1::0
 458 v:2:PS_REGNUM:int:ps_regnum::::-1:-1::0
 459 v:2:FP0_REGNUM:int:fp0_regnum::::0:-1::0
 460 # Convert stab register number (from \`r\' declaration) to a gdb REGNUM.
 461 f:2:STAB_REG_TO_REGNUM:int:stab_reg_to_regnum:int stab_regnr:stab_regnr:::no_op_reg_to_regnum::0
 462 # Provide a default mapping from a ecoff register number to a gdb REGNUM.
 463 f:2:ECOFF_REG_TO_REGNUM:int:ecoff_reg_to_regnum:int ecoff_regnr:ecoff_regnr:::no_op_reg_to_regnum::0
 464 # Provide a default mapping from a DWARF register number to a gdb REGNUM.
 465 f:2:DWARF_REG_TO_REGNUM:int:dwarf_reg_to_regnum:int dwarf_regnr:dwarf_regnr:::no_op_reg_to_regnum::0
 466 # Convert from an sdb register number to an internal gdb register number.
 467 f:2:SDB_REG_TO_REGNUM:int:sdb_reg_to_regnum:int sdb_regnr:sdb_regnr:::no_op_reg_to_regnum::0
 468 f:2:DWARF2_REG_TO_REGNUM:int:dwarf2_reg_to_regnum:int dwarf2_regnr:dwarf2_regnr:::no_op_reg_to_regnum::0
 469 f::REGISTER_NAME:const char *:register_name:int regnr:regnr
 470
 471 # REGISTER_TYPE is a direct replacement for DEPRECATED_REGISTER_VIRTUAL_TYPE.
 472 M:2:REGISTER_TYPE:struct type *:register_type:int reg_nr:reg_nr
 473 # REGISTER_TYPE is a direct replacement for DEPRECATED_REGISTER_VIRTUAL_TYPE.
 474 F:2:DEPRECATED_REGISTER_VIRTUAL_TYPE:struct type *:deprecated_register_virtual_type:int reg_nr:reg_nr
 475 # DEPRECATED_REGISTER_BYTES can be deleted.  The value is computed
 476 # from REGISTER_TYPE.
 477 v::DEPRECATED_REGISTER_BYTES:int:deprecated_register_bytes
 478 # If the value returned by DEPRECATED_REGISTER_BYTE agrees with the
 479 # register offsets computed using just REGISTER_TYPE, this can be
 480 # deleted.  See: maint print registers.  NOTE: cagney/2002-05-02: This
 481 # function with predicate has a valid (callable) initial value.  As a
 482 # consequence, even when the predicate is false, the corresponding
 483 # function works.  This simplifies the migration process - old code,
 484 # calling DEPRECATED_REGISTER_BYTE, doesn't need to be modified.
 485 F::DEPRECATED_REGISTER_BYTE:int:deprecated_register_byte:int reg_nr:reg_nr::generic_register_byte:generic_register_byte
 486 # If all registers have identical raw and virtual sizes and those
 487 # sizes agree with the value computed from REGISTER_TYPE,
 488 # DEPRECATED_REGISTER_RAW_SIZE can be deleted.  See: maint print
 489 # registers.
 490 F:2:DEPRECATED_REGISTER_RAW_SIZE:int:deprecated_register_raw_size:int reg_nr:reg_nr::generic_register_size:generic_register_size
 491 # If all registers have identical raw and virtual sizes and those
 492 # sizes agree with the value computed from REGISTER_TYPE,
 493 # DEPRECATED_REGISTER_VIRTUAL_SIZE can be deleted.  See: maint print
 494 # registers.
 495 F:2:DEPRECATED_REGISTER_VIRTUAL_SIZE:int:deprecated_register_virtual_size:int reg_nr:reg_nr::generic_register_size:generic_register_size
 496 # DEPRECATED_MAX_REGISTER_RAW_SIZE can be deleted.  It has been
 497 # replaced by the constant MAX_REGISTER_SIZE.
 498 V:2:DEPRECATED_MAX_REGISTER_RAW_SIZE:int:deprecated_max_register_raw_size
 499 # DEPRECATED_MAX_REGISTER_VIRTUAL_SIZE can be deleted.  It has been
 500 # replaced by the constant MAX_REGISTER_SIZE.
 501 V:2:DEPRECATED_MAX_REGISTER_VIRTUAL_SIZE:int:deprecated_max_register_virtual_size
 502
 503 # See gdbint.texinfo, and PUSH_DUMMY_CALL.
 504 M::UNWIND_DUMMY_ID:struct frame_id:unwind_dummy_id:struct frame_info *info:info
 505 # Implement UNWIND_DUMMY_ID and PUSH_DUMMY_CALL, then delete
 506 # SAVE_DUMMY_FRAME_TOS.
 507 F:2:DEPRECATED_SAVE_DUMMY_FRAME_TOS:void:deprecated_save_dummy_frame_tos:CORE_ADDR sp:sp
 508 # Implement UNWIND_DUMMY_ID and PUSH_DUMMY_CALL, then delete
 509 # DEPRECATED_FP_REGNUM.
 510 v:2:DEPRECATED_FP_REGNUM:int:deprecated_fp_regnum::::-1:-1::0
 511 # Implement UNWIND_DUMMY_ID and PUSH_DUMMY_CALL, then delete
 512 # DEPRECATED_TARGET_READ_FP.
 513 F::DEPRECATED_TARGET_READ_FP:CORE_ADDR:deprecated_target_read_fp:void
 514
 515 # See gdbint.texinfo.  See infcall.c.  New, all singing all dancing,
 516 # replacement for DEPRECATED_PUSH_ARGUMENTS.
 517 M::PUSH_DUMMY_CALL:CORE_ADDR:push_dummy_call:CORE_ADDR func_addr, struct regcache *regcache, CORE_ADDR bp_addr, int nargs, struct value **args, CORE_ADDR sp, int struct_return, CORE_ADDR struct_addr:func_addr, regcache, bp_addr, nargs, args, sp, struct_return, struct_addr
 518 # PUSH_DUMMY_CALL is a direct replacement for DEPRECATED_PUSH_ARGUMENTS.
 519 F:2:DEPRECATED_PUSH_ARGUMENTS:CORE_ADDR:deprecated_push_arguments:int nargs, struct value **args, CORE_ADDR sp, int struct_return, CORE_ADDR struct_addr:nargs, args, sp, struct_return, struct_addr
 520 # DEPRECATED_USE_GENERIC_DUMMY_FRAMES can be deleted.  Always true.
 521 v::DEPRECATED_USE_GENERIC_DUMMY_FRAMES:int:deprecated_use_generic_dummy_frames:::::1::0
 522 # Implement PUSH_RETURN_ADDRESS, and then merge in
 523 # DEPRECATED_PUSH_RETURN_ADDRESS.
 524 F:2:DEPRECATED_PUSH_RETURN_ADDRESS:CORE_ADDR:deprecated_push_return_address:CORE_ADDR pc, CORE_ADDR sp:pc, sp
 525 # Implement PUSH_DUMMY_CALL, then merge in DEPRECATED_DUMMY_WRITE_SP.
 526 F:2:DEPRECATED_DUMMY_WRITE_SP:void:deprecated_dummy_write_sp:CORE_ADDR val:val
 527 # DEPRECATED_REGISTER_SIZE can be deleted.
 528 v::DEPRECATED_REGISTER_SIZE:int:deprecated_register_size
 529 v::CALL_DUMMY_LOCATION:int:call_dummy_location:::::AT_ENTRY_POINT::0
 530 # DEPRECATED_CALL_DUMMY_START_OFFSET can be deleted.
 531 v::DEPRECATED_CALL_DUMMY_START_OFFSET:CORE_ADDR:deprecated_call_dummy_start_offset
 532 # DEPRECATED_CALL_DUMMY_BREAKPOINT_OFFSET can be deleted.
 533 v::DEPRECATED_CALL_DUMMY_BREAKPOINT_OFFSET:CORE_ADDR:deprecated_call_dummy_breakpoint_offset
 534 # DEPRECATED_CALL_DUMMY_WORDS can be deleted.
 535 v::DEPRECATED_CALL_DUMMY_WORDS:LONGEST *:deprecated_call_dummy_words::::0:legacy_call_dummy_words::0:0x%08lx
 536 # Implement PUSH_DUMMY_CALL, then delete DEPRECATED_SIZEOF_CALL_DUMMY_WORDS.
 537 v::DEPRECATED_SIZEOF_CALL_DUMMY_WORDS:int:deprecated_sizeof_call_dummy_words::::0:legacy_sizeof_call_dummy_words::0
 538 # DEPRECATED_FIX_CALL_DUMMY can be deleted.  For the SPARC, implement
 539 # PUSH_DUMMY_CODE and set CALL_DUMMY_LOCATION to ON_STACK.
 540 F::DEPRECATED_FIX_CALL_DUMMY:void:deprecated_fix_call_dummy:char *dummy, CORE_ADDR pc, CORE_ADDR fun, int nargs, struct value **args, struct type *type, int gcc_p:dummy, pc, fun, nargs, args, type, gcc_p
 541 # This is a replacement for DEPRECATED_FIX_CALL_DUMMY et.al.
 542 M::PUSH_DUMMY_CODE:CORE_ADDR:push_dummy_code:CORE_ADDR sp, CORE_ADDR funaddr, int using_gcc, struct value **args, int nargs, struct type *value_type, CORE_ADDR *real_pc, CORE_ADDR *bp_addr:sp, funaddr, using_gcc, args, nargs, value_type, real_pc, bp_addr
 543 # Implement PUSH_DUMMY_CALL, then delete DEPRECATED_PUSH_DUMMY_FRAME.
 544 F:2:DEPRECATED_PUSH_DUMMY_FRAME:void:deprecated_push_dummy_frame:void:-
 545
 546 F:2:DEPRECATED_DO_REGISTERS_INFO:void:deprecated_do_registers_info:int reg_nr, int fpregs:reg_nr, fpregs
 547 m:2:PRINT_REGISTERS_INFO:void:print_registers_info:struct ui_file *file, struct frame_info *frame, int regnum, int all:file, frame, regnum, all:::default_print_registers_info::0
 548 M:2:PRINT_FLOAT_INFO:void:print_float_info:struct ui_file *file, struct frame_info *frame, const char *args:file, frame, args
 549 M:2:PRINT_VECTOR_INFO:void:print_vector_info:struct ui_file *file, struct frame_info *frame, const char *args:file, frame, args
 550 # MAP a GDB RAW register number onto a simulator register number.  See
 551 # also include/...-sim.h.
 552 f:2:REGISTER_SIM_REGNO:int:register_sim_regno:int reg_nr:reg_nr:::legacy_register_sim_regno::0
 553 F:2:REGISTER_BYTES_OK:int:register_bytes_ok:long nr_bytes:nr_bytes
 554 f:2:CANNOT_FETCH_REGISTER:int:cannot_fetch_register:int regnum:regnum:::cannot_register_not::0
 555 f:2:CANNOT_STORE_REGISTER:int:cannot_store_register:int regnum:regnum:::cannot_register_not::0
 556 # setjmp/longjmp support.
 557 F:2:GET_LONGJMP_TARGET:int:get_longjmp_target:CORE_ADDR *pc:pc
 558 # NOTE: cagney/2002-11-24: This function with predicate has a valid
 559 # (callable) initial value.  As a consequence, even when the predicate
 560 # is false, the corresponding function works.  This simplifies the
 561 # migration process - old code, calling DEPRECATED_PC_IN_CALL_DUMMY(),
 562 # doesn't need to be modified.
 563 F::DEPRECATED_PC_IN_CALL_DUMMY:int:deprecated_pc_in_call_dummy:CORE_ADDR pc, CORE_ADDR sp, CORE_ADDR frame_address:pc, sp, frame_address::deprecated_pc_in_call_dummy:deprecated_pc_in_call_dummy
 564 F:2:DEPRECATED_INIT_FRAME_PC:CORE_ADDR:deprecated_init_frame_pc:int fromleaf, struct frame_info *prev:fromleaf, prev
 565 #
 566 v:2:BELIEVE_PCC_PROMOTION:int:believe_pcc_promotion:::::::
 567 F:2:DEPRECATED_GET_SAVED_REGISTER:void:deprecated_get_saved_register:char *raw_buffer, int *optimized, CORE_ADDR *addrp, struct frame_info *frame, int regnum, enum lval_type *lval:raw_buffer, optimized, addrp, frame, regnum, lval
 568 #
 569 # For register <-> value conversions, replaced by CONVERT_REGISTER_P et.al.
 570 # For raw <-> cooked register conversions, replaced by pseudo registers.
 571 F::DEPRECATED_REGISTER_CONVERTIBLE:int:deprecated_register_convertible:int nr:nr
 572 # For register <-> value conversions, replaced by CONVERT_REGISTER_P et.al.
 573 # For raw <-> cooked register conversions, replaced by pseudo registers.
 574 f:2:DEPRECATED_REGISTER_CONVERT_TO_VIRTUAL:void:deprecated_register_convert_to_virtual:int regnum, struct type *type, char *from, char *to:regnum, type, from, to:::0::0
 575 # For register <-> value conversions, replaced by CONVERT_REGISTER_P et.al.
 576 # For raw <-> cooked register conversions, replaced by pseudo registers.
 577 f:2:DEPRECATED_REGISTER_CONVERT_TO_RAW:void:deprecated_register_convert_to_raw:struct type *type, int regnum, const char *from, char *to:type, regnum, from, to:::0::0
 578 #
 579 f:1:CONVERT_REGISTER_P:int:convert_register_p:int regnum, struct type *type:regnum, type::0:legacy_convert_register_p::0
 580 f:1:REGISTER_TO_VALUE:void:register_to_value:struct frame_info *frame, int regnum, struct type *type, void *buf:frame, regnum, type, buf::0:legacy_register_to_value::0
 581 f:1:VALUE_TO_REGISTER:void:value_to_register:struct frame_info *frame, int regnum, struct type *type, const void *buf:frame, regnum, type, buf::0:legacy_value_to_register::0
 582 #
 583 f:2:POINTER_TO_ADDRESS:CORE_ADDR:pointer_to_address:struct type *type, const void *buf:type, buf:::unsigned_pointer_to_address::0
 584 f:2:ADDRESS_TO_POINTER:void:address_to_pointer:struct type *type, void *buf, CORE_ADDR addr:type, buf, addr:::unsigned_address_to_pointer::0
 585 F:2:INTEGER_TO_ADDRESS:CORE_ADDR:integer_to_address:struct type *type, void *buf:type, buf
 586 #
 587 F:2:DEPRECATED_POP_FRAME:void:deprecated_pop_frame:void:-
 588 # NOTE: cagney/2003-03-24: Replaced by PUSH_ARGUMENTS.
 589 F:2:DEPRECATED_STORE_STRUCT_RETURN:void:deprecated_store_struct_return:CORE_ADDR addr, CORE_ADDR sp:addr, sp
 590
 591 # It has been suggested that this, well actually its predecessor,
 592 # should take the type/value of the function to be called and not the
 593 # return type.  This is left as an exercise for the reader.
 594
 595 M:::enum return_value_convention:return_value:struct type *valtype, struct regcache *regcache, void *readbuf, const void *writebuf:valtype, regcache, readbuf, writebuf
 596
 597 # The deprecated methods RETURN_VALUE_ON_STACK, EXTRACT_RETURN_VALUE,
 598 # STORE_RETURN_VALUE and USE_STRUCT_CONVENTION have all been folded
 599 # into RETURN_VALUE.
 600
 601 f:2:RETURN_VALUE_ON_STACK:int:return_value_on_stack:struct type *type:type:::generic_return_value_on_stack_not::0
 602 f:2:EXTRACT_RETURN_VALUE:void:extract_return_value:struct type *type, struct regcache *regcache, void *valbuf:type, regcache, valbuf:::legacy_extract_return_value::0
 603 f:2:STORE_RETURN_VALUE:void:store_return_value:struct type *type, struct regcache *regcache, const void *valbuf:type, regcache, valbuf:::legacy_store_return_value::0
 604 f:2:DEPRECATED_EXTRACT_RETURN_VALUE:void:deprecated_extract_return_value:struct type *type, char *regbuf, char *valbuf:type, regbuf, valbuf
 605 f:2:DEPRECATED_STORE_RETURN_VALUE:void:deprecated_store_return_value:struct type *type, char *valbuf:type, valbuf
 606 f:2:USE_STRUCT_CONVENTION:int:use_struct_convention:int gcc_p, struct type *value_type:gcc_p, value_type:::generic_use_struct_convention::0
 607
 608 # As of 2004-01-17 only the 32-bit SPARC ABI has been identified as an
 609 # ABI suitable for the implementation of a robust extract
 610 # struct-convention return-value address method (the sparc saves the
 611 # address in the callers frame).  All the other cases so far examined,
 612 # the DEPRECATED_EXTRACT_STRUCT_VALUE implementation has been
 613 # erreneous - the code was incorrectly assuming that the return-value
 614 # address, stored in a register, was preserved across the entire
 615 # function call.
 616
 617 # For the moment retain DEPRECATED_EXTRACT_STRUCT_VALUE as a marker of
 618 # the ABIs that are still to be analyzed - perhaps this should simply
 619 # be deleted.  The commented out extract_returned_value_address method
 620 # is provided as a starting point for the 32-bit SPARC.  It, or
 621 # something like it, along with changes to both infcmd.c and stack.c
 622 # will be needed for that case to work.  NB: It is passed the callers
 623 # frame since it is only after the callee has returned that this
 624 # function is used.
 625
 626 #M:::CORE_ADDR:extract_returned_value_address:struct frame_info *caller_frame:caller_frame
 627 F:2:DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS:CORE_ADDR:deprecated_extract_struct_value_address:struct regcache *regcache:regcache
 628
 629 F:2:DEPRECATED_FRAME_INIT_SAVED_REGS:void:deprecated_frame_init_saved_regs:struct frame_info *frame:frame
 630 F:2:DEPRECATED_INIT_EXTRA_FRAME_INFO:void:deprecated_init_extra_frame_info:int fromleaf, struct frame_info *frame:fromleaf, frame
 631 #
 632 f:2:SKIP_PROLOGUE:CORE_ADDR:skip_prologue:CORE_ADDR ip:ip::0:0
 633 f:2:INNER_THAN:int:inner_than:CORE_ADDR lhs, CORE_ADDR rhs:lhs, rhs::0:0
 634 f::BREAKPOINT_FROM_PC:const unsigned char *:breakpoint_from_pc:CORE_ADDR *pcptr, int *lenptr:pcptr, lenptr:::0:
 635 M:2:ADJUST_BREAKPOINT_ADDRESS:CORE_ADDR:adjust_breakpoint_address:CORE_ADDR bpaddr:bpaddr
 636 f:2:MEMORY_INSERT_BREAKPOINT:int:memory_insert_breakpoint:CORE_ADDR addr, char *contents_cache:addr, contents_cache::0:default_memory_insert_breakpoint::0
 637 f:2:MEMORY_REMOVE_BREAKPOINT:int:memory_remove_breakpoint:CORE_ADDR addr, char *contents_cache:addr, contents_cache::0:default_memory_remove_breakpoint::0
 638 v:2:DECR_PC_AFTER_BREAK:CORE_ADDR:decr_pc_after_break::::0:::0
 639 v:2:FUNCTION_START_OFFSET:CORE_ADDR:function_start_offset::::0:::0
 640 #
 641 m::REMOTE_TRANSLATE_XFER_ADDRESS:void:remote_translate_xfer_address:struct regcache *regcache, CORE_ADDR gdb_addr, int gdb_len, CORE_ADDR *rem_addr, int *rem_len:regcache, gdb_addr, gdb_len, rem_addr, rem_len:::generic_remote_translate_xfer_address::0
 642 #
 643 v::FRAME_ARGS_SKIP:CORE_ADDR:frame_args_skip::::0:::0
 644 # DEPRECATED_FRAMELESS_FUNCTION_INVOCATION is not needed.  The new
 645 # frame code works regardless of the type of frame - frameless,
 646 # stackless, or normal.
 647 F::DEPRECATED_FRAMELESS_FUNCTION_INVOCATION:int:deprecated_frameless_function_invocation:struct frame_info *fi:fi
 648 F:2:DEPRECATED_FRAME_CHAIN:CORE_ADDR:deprecated_frame_chain:struct frame_info *frame:frame
 649 F:2:DEPRECATED_FRAME_CHAIN_VALID:int:deprecated_frame_chain_valid:CORE_ADDR chain, struct frame_info *thisframe:chain, thisframe
 650 # DEPRECATED_FRAME_SAVED_PC has been replaced by UNWIND_PC.  Please
 651 # note, per UNWIND_PC's doco, that while the two have similar
 652 # interfaces they have very different underlying implementations.
 653 F:2:DEPRECATED_FRAME_SAVED_PC:CORE_ADDR:deprecated_frame_saved_pc:struct frame_info *fi:fi
 654 M::UNWIND_PC:CORE_ADDR:unwind_pc:struct frame_info *next_frame:next_frame
 655 M::UNWIND_SP:CORE_ADDR:unwind_sp:struct frame_info *next_frame:next_frame
 656 # DEPRECATED_FRAME_ARGS_ADDRESS as been replaced by the per-frame
 657 # frame-base.  Enable frame-base before frame-unwind.
 658 F::DEPRECATED_FRAME_ARGS_ADDRESS:CORE_ADDR:deprecated_frame_args_address:struct frame_info *fi:fi::get_frame_base:get_frame_base
 659 # DEPRECATED_FRAME_LOCALS_ADDRESS as been replaced by the per-frame
 660 # frame-base.  Enable frame-base before frame-unwind.
 661 F::DEPRECATED_FRAME_LOCALS_ADDRESS:CORE_ADDR:deprecated_frame_locals_address:struct frame_info *fi:fi::get_frame_base:get_frame_base
 662 F::DEPRECATED_SAVED_PC_AFTER_CALL:CORE_ADDR:deprecated_saved_pc_after_call:struct frame_info *frame:frame
 663 F:2:FRAME_NUM_ARGS:int:frame_num_args:struct frame_info *frame:frame
 664 #
 665 # DEPRECATED_STACK_ALIGN has been replaced by an initial aligning call
 666 # to frame_align and the requirement that methods such as
 667 # push_dummy_call and frame_red_zone_size maintain correct stack/frame
 668 # alignment.
 669 F:2:DEPRECATED_STACK_ALIGN:CORE_ADDR:deprecated_stack_align:CORE_ADDR sp:sp
 670 M:::CORE_ADDR:frame_align:CORE_ADDR address:address
 671 # DEPRECATED_REG_STRUCT_HAS_ADDR has been replaced by
 672 # stabs_argument_has_addr.
 673 F:2:DEPRECATED_REG_STRUCT_HAS_ADDR:int:deprecated_reg_struct_has_addr:int gcc_p, struct type *type:gcc_p, type
 674 m:::int:stabs_argument_has_addr:struct type *type:type:::default_stabs_argument_has_addr::0
 675 v::FRAME_RED_ZONE_SIZE:int:frame_red_zone_size
 676 v:2:PARM_BOUNDARY:int:parm_boundary
 677 #
 678 v:2:TARGET_FLOAT_FORMAT:const struct floatformat *:float_format::::::default_float_format (current_gdbarch)::%s:(TARGET_FLOAT_FORMAT)->name
 679 v:2:TARGET_DOUBLE_FORMAT:const struct floatformat *:double_format::::::default_double_format (current_gdbarch)::%s:(TARGET_DOUBLE_FORMAT)->name
 680 v:2:TARGET_LONG_DOUBLE_FORMAT:const struct floatformat *:long_double_format::::::default_double_format (current_gdbarch)::%s:(TARGET_LONG_DOUBLE_FORMAT)->name
 681 m:::CORE_ADDR:convert_from_func_ptr_addr:CORE_ADDR addr, struct target_ops *targ:addr, targ:::convert_from_func_ptr_addr_identity::0
 682 # On some machines there are bits in addresses which are not really
 683 # part of the address, but are used by the kernel, the hardware, etc.
 684 # for special purposes.  ADDR_BITS_REMOVE takes out any such bits so
 685 # we get a "real" address such as one would find in a symbol table.
 686 # This is used only for addresses of instructions, and even then I'm
 687 # not sure it's used in all contexts.  It exists to deal with there
 688 # being a few stray bits in the PC which would mislead us, not as some
 689 # sort of generic thing to handle alignment or segmentation (it's
 690 # possible it should be in TARGET_READ_PC instead).
 691 f:2:ADDR_BITS_REMOVE:CORE_ADDR:addr_bits_remove:CORE_ADDR addr:addr:::core_addr_identity::0
 692 # It is not at all clear why SMASH_TEXT_ADDRESS is not folded into
 693 # ADDR_BITS_REMOVE.
 694 f:2:SMASH_TEXT_ADDRESS:CORE_ADDR:smash_text_address:CORE_ADDR addr:addr:::core_addr_identity::0
 695 # FIXME/cagney/2001-01-18: This should be split in two.  A target method that indicates if
 696 # the target needs software single step.  An ISA method to implement it.
 697 #
 698 # FIXME/cagney/2001-01-18: This should be replaced with something that inserts breakpoints
 699 # using the breakpoint system instead of blatting memory directly (as with rs6000).
 700 #
 701 # FIXME/cagney/2001-01-18: The logic is backwards.  It should be asking if the target can
 702 # single step.  If not, then implement single step using breakpoints.
 703 F:2:SOFTWARE_SINGLE_STEP:void:software_single_step:enum target_signal sig, int insert_breakpoints_p:sig, insert_breakpoints_p
 704 # FIXME: cagney/2003-08-28: Need to find a better way of selecting the
 705 # disassembler.  Perhaphs objdump can handle it?
 706 f::TARGET_PRINT_INSN:int:print_insn:bfd_vma vma, struct disassemble_info *info:vma, info:::0:
 707 f:2:SKIP_TRAMPOLINE_CODE:CORE_ADDR:skip_trampoline_code:CORE_ADDR pc:pc:::generic_skip_trampoline_code::0
 708
 709
 710 # If IN_SOLIB_DYNSYM_RESOLVE_CODE returns true, and SKIP_SOLIB_RESOLVER
 711 # evaluates non-zero, this is the address where the debugger will place
 712 # a step-resume breakpoint to get us past the dynamic linker.
 713 m:2:SKIP_SOLIB_RESOLVER:CORE_ADDR:skip_solib_resolver:CORE_ADDR pc:pc:::generic_skip_solib_resolver::0
 714 # For SVR4 shared libraries, each call goes through a small piece of
 715 # trampoline code in the ".plt" section.  IN_SOLIB_CALL_TRAMPOLINE evaluates
 716 # to nonzero if we are currently stopped in one of these.
 717 f:2:IN_SOLIB_CALL_TRAMPOLINE:int:in_solib_call_trampoline:CORE_ADDR pc, char *name:pc, name:::generic_in_solib_call_trampoline::0
 718
 719 # Some systems also have trampoline code for returning from shared libs.
 720 f:2:IN_SOLIB_RETURN_TRAMPOLINE:int:in_solib_return_trampoline:CORE_ADDR pc, char *name:pc, name:::generic_in_solib_return_trampoline::0
 721
 722 # A target might have problems with watchpoints as soon as the stack
 723 # frame of the current function has been destroyed.  This mostly happens
 724 # as the first action in a funtion's epilogue.  in_function_epilogue_p()
 725 # is defined to return a non-zero value if either the given addr is one
 726 # instruction after the stack destroying instruction up to the trailing
 727 # return instruction or if we can figure out that the stack frame has
 728 # already been invalidated regardless of the value of addr.  Targets
 729 # which don't suffer from that problem could just let this functionality
 730 # untouched.
 731 m:::int:in_function_epilogue_p:CORE_ADDR addr:addr::0:generic_in_function_epilogue_p::0
 732 # Given a vector of command-line arguments, return a newly allocated
 733 # string which, when passed to the create_inferior function, will be
 734 # parsed (on Unix systems, by the shell) to yield the same vector.
 735 # This function should call error() if the argument vector is not
 736 # representable for this target or if this target does not support
 737 # command-line arguments.
 738 # ARGC is the number of elements in the vector.
 739 # ARGV is an array of strings, one per argument.
 740 m::CONSTRUCT_INFERIOR_ARGUMENTS:char *:construct_inferior_arguments:int argc, char **argv:argc, argv:::construct_inferior_arguments::0
 741 f:2:ELF_MAKE_MSYMBOL_SPECIAL:void:elf_make_msymbol_special:asymbol *sym, struct minimal_symbol *msym:sym, msym:::default_elf_make_msymbol_special::0
 742 f:2:COFF_MAKE_MSYMBOL_SPECIAL:void:coff_make_msymbol_special:int val, struct minimal_symbol *msym:val, msym:::default_coff_make_msymbol_special::0
 743 v:2:NAME_OF_MALLOC:const char *:name_of_malloc::::"malloc":"malloc"::0:%s:NAME_OF_MALLOC
 744 v:2:CANNOT_STEP_BREAKPOINT:int:cannot_step_breakpoint::::0:0::0
 745 v:2:HAVE_NONSTEPPABLE_WATCHPOINT:int:have_nonsteppable_watchpoint::::0:0::0
 746 F:2:ADDRESS_CLASS_TYPE_FLAGS:int:address_class_type_flags:int byte_size, int dwarf2_addr_class:byte_size, dwarf2_addr_class
 747 M:2:ADDRESS_CLASS_TYPE_FLAGS_TO_NAME:const char *:address_class_type_flags_to_name:int type_flags:type_flags
 748 M:2:ADDRESS_CLASS_NAME_TO_TYPE_FLAGS:int:address_class_name_to_type_flags:const char *name, int *type_flags_ptr:name, type_flags_ptr
 749 # Is a register in a group
 750 m:::int:register_reggroup_p:int regnum, struct reggroup *reggroup:regnum, reggroup:::default_register_reggroup_p::0
 751 # Fetch the pointer to the ith function argument.
 752 F::FETCH_POINTER_ARGUMENT:CORE_ADDR:fetch_pointer_argument:struct frame_info *frame, int argi, struct type *type:frame, argi, type
 753
 754 # Return the appropriate register set for a core file section with
 755 # name SECT_NAME and size SECT_SIZE.
 756 M:::const struct regset *:regset_from_core_section:const char *sect_name, size_t sect_size:sect_name, sect_size
 757 EOF
 758 }
 759
 760 #
 761 # The .log file
 762 #
 763 exec > new-gdbarch.log
 764 function_list | while do_read
 765 do
 766     cat <<EOF
 767 ${class} ${macro}(${actual})
 768   ${returntype} ${function} ($formal)${attrib}
 769 EOF
 770     for r in ${read}
 771     do
 772         eval echo \"\ \ \ \ ${r}=\${${r}}\"
 773     done
 774     if class_is_predicate_p && fallback_default_p
 775     then
 776         echo "Error: predicate function ${macro} can not have a non- multi-arch default" 1>&2
 777         kill $$
 778         exit 1
 779     fi
 780     if [ "x${invalid_p}" = "x0" -a -n "${postdefault}" ]
 781     then
 782         echo "Error: postdefault is useless when invalid_p=0" 1>&2
 783         kill $$
 784         exit 1
 785     fi
 786     if class_is_multiarch_p
 787     then
 788         if class_is_predicate_p ; then :
 789         elif test "x${predefault}" = "x"
 790         then
 791             echo "Error: pure multi-arch function must have a predefault" 1>&2
 792             kill $$
 793             exit 1
 794         fi
 795     fi
 796     echo ""
 797 done
 798
 799 exec 1>&2
 800 compare_new gdbarch.log
 801
 802
 803 copyright ()
 804 {
 805 cat <<EOF
 806 /* *INDENT-OFF* */ /* THIS FILE IS GENERATED */
 807
 808 /* Dynamic architecture support for GDB, the GNU debugger.
 809
 810    Copyright 1998, 1999, 2000, 2001, 2002, 2003, 2004 Free
 811    Software Foundation, Inc.
 812
 813    This file is part of GDB.
 814
 815    This program is free software; you can redistribute it and/or modify
 816    it under the terms of the GNU General Public License as published by
 817    the Free Software Foundation; either version 2 of the License, or
 818    (at your option) any later version.
 819
 820    This program is distributed in the hope that it will be useful,
 821    but WITHOUT ANY WARRANTY; without even the implied warranty of
 822    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 823    GNU General Public License for more details.
 824
 825    You should have received a copy of the GNU General Public License
 826    along with this program; if not, write to the Free Software
 827    Foundation, Inc., 59 Temple Place - Suite 330,
 828    Boston, MA 02111-1307, USA.  */
 829
 830 /* This file was created with the aid of \`\`gdbarch.sh''.
 831
 832    The Bourne shell script \`\`gdbarch.sh'' creates the files
 833    \`\`new-gdbarch.c'' and \`\`new-gdbarch.h and then compares them
 834    against the existing \`\`gdbarch.[hc]''.  Any differences found
 835    being reported.
 836
 837    If editing this file, please also run gdbarch.sh and merge any
 838    changes into that script. Conversely, when making sweeping changes
 839    to this file, modifying gdbarch.sh and using its output may prove
 840    easier. */
 841
 842 EOF
 843 }
 844
 845 #
 846 # The .h file
 847 #
 848
 849 exec > new-gdbarch.h
 850 copyright
 851 cat <<EOF
 852 #ifndef GDBARCH_H
 853 #define GDBARCH_H
 854
 855 struct floatformat;
 856 struct ui_file;
 857 struct frame_info;
 858 struct value;
 859 struct objfile;
 860 struct minimal_symbol;
 861 struct regcache;
 862 struct reggroup;
 863 struct regset;
 864 struct disassemble_info;
 865 struct target_ops;
 866 struct obstack;
 867
 868 extern struct gdbarch *current_gdbarch;
 869
 870
 871 /* If any of the following are defined, the target wasn't correctly
 872    converted. */
 873
 874 #if (GDB_MULTI_ARCH >= GDB_MULTI_ARCH_PURE) && defined (GDB_TM_FILE)
 875 #error "GDB_TM_FILE: Pure multi-arch targets do not have a tm.h file."
 876 #endif
 877 EOF
 878
 879 # function typedef's
 880 printf "\n"
 881 printf "\n"
 882 printf "/* The following are pre-initialized by GDBARCH. */\n"
 883 function_list | while do_read
 884 do
 885     if class_is_info_p
 886     then
 887         printf "\n"
 888         printf "extern ${returntype} gdbarch_${function} (struct gdbarch *gdbarch);\n"
 889         printf "/* set_gdbarch_${function}() - not applicable - pre-initialized. */\n"
 890         printf "#if (GDB_MULTI_ARCH ${gt_level}) && defined (${macro})\n"
 891         printf "#error \"Non multi-arch definition of ${macro}\"\n"
 892         printf "#endif\n"
 893         printf "#if !defined (${macro})\n"
 894         printf "#define ${macro} (gdbarch_${function} (current_gdbarch))\n"
 895         printf "#endif\n"
 896     fi
 897 done
 898
 899 # function typedef's
 900 printf "\n"
 901 printf "\n"
 902 printf "/* The following are initialized by the target dependent code. */\n"
 903 function_list | while do_read
 904 do
 905     if [ -n "${comment}" ]
 906     then
 907         echo "${comment}" | sed \
 908             -e '2 s,#,/*,' \
 909             -e '3,$ s,#,  ,' \
 910             -e '$ s,$, */,'
 911     fi
 912     if class_is_multiarch_p
 913     then
 914         if class_is_predicate_p
 915         then
 916             printf "\n"
 917             printf "extern int gdbarch_${function}_p (struct gdbarch *gdbarch);\n"
 918         fi
 919     else
 920         if class_is_predicate_p
 921         then
 922             printf "\n"
 923             printf "#if defined (${macro})\n"
 924             printf "/* Legacy for systems yet to multi-arch ${macro} */\n"
 925             #printf "#if (GDB_MULTI_ARCH <= GDB_MULTI_ARCH_PARTIAL) && defined (${macro})\n"
 926             printf "#if !defined (${macro}_P)\n"
 927             printf "#define ${macro}_P() (1)\n"
 928             printf "#endif\n"
 929             printf "#endif\n"
 930             printf "\n"
 931             printf "extern int gdbarch_${function}_p (struct gdbarch *gdbarch);\n"
 932             printf "#if (GDB_MULTI_ARCH ${gt_level}) && defined (${macro}_P)\n"
 933             printf "#error \"Non multi-arch definition of ${macro}\"\n"
 934             printf "#endif\n"
 935             printf "#if (GDB_MULTI_ARCH ${gt_level}) || !defined (${macro}_P)\n"
 936             printf "#define ${macro}_P() (gdbarch_${function}_p (current_gdbarch))\n"
 937             printf "#endif\n"
 938         fi
 939     fi
 940     if class_is_variable_p
 941     then
 942         printf "\n"
 943         printf "extern ${returntype} gdbarch_${function} (struct gdbarch *gdbarch);\n"
 944         printf "extern void set_gdbarch_${function} (struct gdbarch *gdbarch, ${returntype} ${function});\n"
 945         printf "#if (GDB_MULTI_ARCH ${gt_level}) && defined (${macro})\n"
 946         printf "#error \"Non multi-arch definition of ${macro}\"\n"
 947         printf "#endif\n"
 948         printf "#if !defined (${macro})\n"
 949         printf "#define ${macro} (gdbarch_${function} (current_gdbarch))\n"
 950         printf "#endif\n"
 951     fi
 952     if class_is_function_p
 953     then
 954         printf "\n"
 955         if [ "x${formal}" = "xvoid" ] && class_is_multiarch_p
 956         then
 957             printf "typedef ${returntype} (gdbarch_${function}_ftype) (struct gdbarch *gdbarch);\n"
 958         elif class_is_multiarch_p
 959         then
 960             printf "typedef ${returntype} (gdbarch_${function}_ftype) (struct gdbarch *gdbarch, ${formal});\n"
 961         else
 962             printf "typedef ${returntype} (gdbarch_${function}_ftype) (${formal});\n"
 963         fi
 964         if [ "x${formal}" = "xvoid" ]
 965         then
 966           printf "extern ${returntype} gdbarch_${function} (struct gdbarch *gdbarch);\n"
 967         else
 968           printf "extern ${returntype} gdbarch_${function} (struct gdbarch *gdbarch, ${formal});\n"
 969         fi
 970         printf "extern void set_gdbarch_${function} (struct gdbarch *gdbarch, gdbarch_${function}_ftype *${function});\n"
 971         if class_is_multiarch_p ; then :
 972         else
 973             printf "#if (GDB_MULTI_ARCH ${gt_level}) && defined (${macro})\n"
 974             printf "#error \"Non multi-arch definition of ${macro}\"\n"
 975             printf "#endif\n"
 976             if [ "x${actual}" = "x" ]
 977             then
 978                 d="#define ${macro}() (gdbarch_${function} (current_gdbarch))"
 979             elif [ "x${actual}" = "x-" ]
 980             then
 981                 d="#define ${macro} (gdbarch_${function} (current_gdbarch))"
 982             else
 983                 d="#define ${macro}(${actual}) (gdbarch_${function} (current_gdbarch, ${actual}))"
 984             fi
 985             printf "#if !defined (${macro})\n"
 986             if [ "x${actual}" = "x" ]
 987             then
 988                 printf "#define ${macro}() (gdbarch_${function} (current_gdbarch))\n"
 989             elif [ "x${actual}" = "x-" ]
 990             then
 991                 printf "#define ${macro} (gdbarch_${function} (current_gdbarch))\n"
 992             else
 993                 printf "#define ${macro}(${actual}) (gdbarch_${function} (current_gdbarch, ${actual}))\n"
 994             fi
 995             printf "#endif\n"
 996         fi
 997     fi
 998 done
 999
1000 # close it off
1001 cat <<EOF
1002
1003 extern struct gdbarch_tdep *gdbarch_tdep (struct gdbarch *gdbarch);
1004
1005
1006 /* Mechanism for co-ordinating the selection of a specific
1007    architecture.
1008
1009    GDB targets (*-tdep.c) can register an interest in a specific
1010    architecture.  Other GDB components can register a need to maintain
1011    per-architecture data.
1012
1013    The mechanisms below ensures that there is only a loose connection
1014    between the set-architecture command and the various GDB
1015    components.  Each component can independently register their need
1016    to maintain architecture specific data with gdbarch.
1017
1018    Pragmatics:
1019
1020    Previously, a single TARGET_ARCHITECTURE_HOOK was provided.  It
1021    didn't scale.
1022
1023    The more traditional mega-struct containing architecture specific
1024    data for all the various GDB components was also considered.  Since
1025    GDB is built from a variable number of (fairly independent)
1026    components it was determined that the global aproach was not
1027    applicable. */
1028
1029
1030 /* Register a new architectural family with GDB.
1031
1032    Register support for the specified ARCHITECTURE with GDB.  When
1033    gdbarch determines that the specified architecture has been
1034    selected, the corresponding INIT function is called.
1035
1036    --
1037
1038    The INIT function takes two parameters: INFO which contains the
1039    information available to gdbarch about the (possibly new)
1040    architecture; ARCHES which is a list of the previously created
1041    \`\`struct gdbarch'' for this architecture.
1042
1043    The INFO parameter is, as far as possible, be pre-initialized with
1044    information obtained from INFO.ABFD or the previously selected
1045    architecture.
1046
1047    The ARCHES parameter is a linked list (sorted most recently used)
1048    of all the previously created architures for this architecture
1049    family.  The (possibly NULL) ARCHES->gdbarch can used to access
1050    values from the previously selected architecture for this
1051    architecture family.  The global \`\`current_gdbarch'' shall not be
1052    used.
1053
1054    The INIT function shall return any of: NULL - indicating that it
1055    doesn't recognize the selected architecture; an existing \`\`struct
1056    gdbarch'' from the ARCHES list - indicating that the new
1057    architecture is just a synonym for an earlier architecture (see
1058    gdbarch_list_lookup_by_info()); a newly created \`\`struct gdbarch''
1059    - that describes the selected architecture (see gdbarch_alloc()).
1060
1061    The DUMP_TDEP function shall print out all target specific values.
1062    Care should be taken to ensure that the function works in both the
1063    multi-arch and non- multi-arch cases. */
1064
1065 struct gdbarch_list
1066 {
1067   struct gdbarch *gdbarch;
1068   struct gdbarch_list *next;
1069 };
1070
1071 struct gdbarch_info
1072 {
1073   /* Use default: NULL (ZERO). */
1074   const struct bfd_arch_info *bfd_arch_info;
1075
1076   /* Use default: BFD_ENDIAN_UNKNOWN (NB: is not ZERO).  */
1077   int byte_order;
1078
1079   /* Use default: NULL (ZERO). */
1080   bfd *abfd;
1081
1082   /* Use default: NULL (ZERO). */
1083   struct gdbarch_tdep_info *tdep_info;
1084
1085   /* Use default: GDB_OSABI_UNINITIALIZED (-1).  */
1086   enum gdb_osabi osabi;
1087 };
1088
1089 typedef struct gdbarch *(gdbarch_init_ftype) (struct gdbarch_info info, struct gdbarch_list *arches);
1090 typedef void (gdbarch_dump_tdep_ftype) (struct gdbarch *gdbarch, struct ui_file *file);
1091
1092 /* DEPRECATED - use gdbarch_register() */
1093 extern void register_gdbarch_init (enum bfd_architecture architecture, gdbarch_init_ftype *);
1094
1095 extern void gdbarch_register (enum bfd_architecture architecture,
1096                               gdbarch_init_ftype *,
1097                               gdbarch_dump_tdep_ftype *);
1098
1099
1100 /* Return a freshly allocated, NULL terminated, array of the valid
1101    architecture names.  Since architectures are registered during the
1102    _initialize phase this function only returns useful information
1103    once initialization has been completed. */
1104
1105 extern const char **gdbarch_printable_names (void);
1106
1107
1108 /* Helper function.  Search the list of ARCHES for a GDBARCH that
1109    matches the information provided by INFO. */
1110
1111 extern struct gdbarch_list *gdbarch_list_lookup_by_info (struct gdbarch_list *arches,  const struct gdbarch_info *info);
1112
1113
1114 /* Helper function.  Create a preliminary \`\`struct gdbarch''.  Perform
1115    basic initialization using values obtained from the INFO andTDEP
1116    parameters.  set_gdbarch_*() functions are called to complete the
1117    initialization of the object. */
1118
1119 extern struct gdbarch *gdbarch_alloc (const struct gdbarch_info *info, struct gdbarch_tdep *tdep);
1120
1121
1122 /* Helper function.  Free a partially-constructed \`\`struct gdbarch''.
1123    It is assumed that the caller freeds the \`\`struct
1124    gdbarch_tdep''. */
1125
1126 extern void gdbarch_free (struct gdbarch *);
1127
1128
1129 /* Helper function.  Allocate memory from the \`\`struct gdbarch''
1130    obstack.  The memory is freed when the corresponding architecture
1131    is also freed.  */
1132
1133 extern void *gdbarch_obstack_zalloc (struct gdbarch *gdbarch, long size);
1134 #define GDBARCH_OBSTACK_CALLOC(GDBARCH, NR, TYPE) ((TYPE *) gdbarch_obstack_zalloc ((GDBARCH), (NR) * sizeof (TYPE)))
1135 #define GDBARCH_OBSTACK_ZALLOC(GDBARCH, TYPE) ((TYPE *) gdbarch_obstack_zalloc ((GDBARCH), sizeof (TYPE)))
1136
1137
1138 /* Helper function. Force an update of the current architecture.
1139
1140    The actual architecture selected is determined by INFO, \`\`(gdb) set
1141    architecture'' et.al., the existing architecture and BFD's default
1142    architecture.  INFO should be initialized to zero and then selected
1143    fields should be updated.
1144
1145    Returns non-zero if the update succeeds */
1146
1147 extern int gdbarch_update_p (struct gdbarch_info info);
1148
1149
1150 /* Helper function.  Find an architecture matching info.
1151
1152    INFO should be initialized using gdbarch_info_init, relevant fields
1153    set, and then finished using gdbarch_info_fill.
1154
1155    Returns the corresponding architecture, or NULL if no matching
1156    architecture was found.  "current_gdbarch" is not updated.  */
1157
1158 extern struct gdbarch *gdbarch_find_by_info (struct gdbarch_info info);
1159
1160
1161 /* Helper function.  Set the global "current_gdbarch" to "gdbarch".
1162
1163    FIXME: kettenis/20031124: Of the functions that follow, only
1164    gdbarch_from_bfd is supposed to survive.  The others will
1165    dissappear since in the future GDB will (hopefully) be truly
1166    multi-arch.  However, for now we're still stuck with the concept of
1167    a single active architecture.  */
1168
1169 extern void deprecated_current_gdbarch_select_hack (struct gdbarch *gdbarch);
1170
1171
1172 /* Register per-architecture data-pointer.
1173
1174    Reserve space for a per-architecture data-pointer.  An identifier
1175    for the reserved data-pointer is returned.  That identifer should
1176    be saved in a local static variable.
1177
1178    Memory for the per-architecture data shall be allocated using
1179    gdbarch_obstack_zalloc.  That memory will be deleted when the
1180    corresponding architecture object is deleted.
1181
1182    When a previously created architecture is re-selected, the
1183    per-architecture data-pointer for that previous architecture is
1184    restored.  INIT() is not re-called.
1185
1186    Multiple registrarants for any architecture are allowed (and
1187    strongly encouraged).  */
1188
1189 struct gdbarch_data;
1190
1191 typedef void *(gdbarch_data_pre_init_ftype) (struct obstack *obstack);
1192 extern struct gdbarch_data *gdbarch_data_register_pre_init (gdbarch_data_pre_init_ftype *init);
1193 typedef void *(gdbarch_data_post_init_ftype) (struct gdbarch *gdbarch);
1194 extern struct gdbarch_data *gdbarch_data_register_post_init (gdbarch_data_post_init_ftype *init);
1195 extern void deprecated_set_gdbarch_data (struct gdbarch *gdbarch,
1196                                          struct gdbarch_data *data,
1197                                          void *pointer);
1198
1199 extern void *gdbarch_data (struct gdbarch *gdbarch, struct gdbarch_data *);
1200
1201
1202
1203 /* Register per-architecture memory region.
1204
1205    Provide a memory-region swap mechanism.  Per-architecture memory
1206    region are created.  These memory regions are swapped whenever the
1207    architecture is changed.  For a new architecture, the memory region
1208    is initialized with zero (0) and the INIT function is called.
1209
1210    Memory regions are swapped / initialized in the order that they are
1211    registered.  NULL DATA and/or INIT values can be specified.
1212
1213    New code should use gdbarch_data_register_*(). */
1214
1215 typedef void (gdbarch_swap_ftype) (void);
1216 extern void deprecated_register_gdbarch_swap (void *data, unsigned long size, gdbarch_swap_ftype *init);
1217 #define DEPRECATED_REGISTER_GDBARCH_SWAP(VAR) deprecated_register_gdbarch_swap (&(VAR), sizeof ((VAR)), NULL)
1218
1219
1220
1221 /* Set the dynamic target-system-dependent parameters (architecture,
1222    byte-order, ...) using information found in the BFD */
1223
1224 extern void set_gdbarch_from_file (bfd *);
1225
1226
1227 /* Initialize the current architecture to the "first" one we find on
1228    our list.  */
1229
1230 extern void initialize_current_architecture (void);
1231
1232 /* gdbarch trace variable */
1233 extern int gdbarch_debug;
1234
1235 extern void gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file);
1236
1237 #endif
1238 EOF
1239 exec 1>&2
1240 #../move-if-change new-gdbarch.h gdbarch.h
1241 compare_new gdbarch.h
1242
1243
1244 #
1245 # C file
1246 #
1247
1248 exec > new-gdbarch.c
1249 copyright
1250 cat <<EOF
1251
1252 #include "defs.h"
1253 #include "arch-utils.h"
1254
1255 #include "gdbcmd.h"
1256 #include "inferior.h" /* enum CALL_DUMMY_LOCATION et.al. */
1257 #include "symcat.h"
1258
1259 #include "floatformat.h"
1260
1261 #include "gdb_assert.h"
1262 #include "gdb_string.h"
1263 #include "gdb-events.h"
1264 #include "reggroups.h"
1265 #include "osabi.h"
1266 #include "gdb_obstack.h"
1267
1268 /* Static function declarations */
1269
1270 static void alloc_gdbarch_data (struct gdbarch *);
1271
1272 /* Non-zero if we want to trace architecture code.  */
1273
1274 #ifndef GDBARCH_DEBUG
1275 #define GDBARCH_DEBUG 0
1276 #endif
1277 int gdbarch_debug = GDBARCH_DEBUG;
1278
1279 EOF
1280
1281 # gdbarch open the gdbarch object
1282 printf "\n"
1283 printf "/* Maintain the struct gdbarch object */\n"
1284 printf "\n"
1285 printf "struct gdbarch\n"
1286 printf "{\n"
1287 printf "  /* Has this architecture been fully initialized?  */\n"
1288 printf "  int initialized_p;\n"
1289 printf "\n"
1290 printf "  /* An obstack bound to the lifetime of the architecture.  */\n"
1291 printf "  struct obstack *obstack;\n"
1292 printf "\n"
1293 printf "  /* basic architectural information */\n"
1294 function_list | while do_read
1295 do
1296     if class_is_info_p
1297     then
1298         printf "  ${returntype} ${function};\n"
1299     fi
1300 done
1301 printf "\n"
1302 printf "  /* target specific vector. */\n"
1303 printf "  struct gdbarch_tdep *tdep;\n"
1304 printf "  gdbarch_dump_tdep_ftype *dump_tdep;\n"
1305 printf "\n"
1306 printf "  /* per-architecture data-pointers */\n"
1307 printf "  unsigned nr_data;\n"
1308 printf "  void **data;\n"
1309 printf "\n"
1310 printf "  /* per-architecture swap-regions */\n"
1311 printf "  struct gdbarch_swap *swap;\n"
1312 printf "\n"
1313 cat <<EOF
1314   /* Multi-arch values.
1315
1316      When extending this structure you must:
1317
1318      Add the field below.
1319
1320      Declare set/get functions and define the corresponding
1321      macro in gdbarch.h.
1322
1323      gdbarch_alloc(): If zero/NULL is not a suitable default,
1324      initialize the new field.
1325
1326      verify_gdbarch(): Confirm that the target updated the field
1327      correctly.
1328
1329      gdbarch_dump(): Add a fprintf_unfiltered call so that the new
1330      field is dumped out
1331
1332      \`\`startup_gdbarch()'': Append an initial value to the static
1333      variable (base values on the host's c-type system).
1334
1335      get_gdbarch(): Implement the set/get functions (probably using
1336      the macro's as shortcuts).
1337
1338      */
1339
1340 EOF
1341 function_list | while do_read
1342 do
1343     if class_is_variable_p
1344     then
1345         printf "  ${returntype} ${function};\n"
1346     elif class_is_function_p
1347     then
1348         printf "  gdbarch_${function}_ftype *${function}${attrib};\n"
1349     fi
1350 done
1351 printf "};\n"
1352
1353 # A pre-initialized vector
1354 printf "\n"
1355 printf "\n"
1356 cat <<EOF
1357 /* The default architecture uses host values (for want of a better
1358    choice). */
1359 EOF
1360 printf "\n"
1361 printf "extern const struct bfd_arch_info bfd_default_arch_struct;\n"
1362 printf "\n"
1363 printf "struct gdbarch startup_gdbarch =\n"
1364 printf "{\n"
1365 printf "  1, /* Always initialized.  */\n"
1366 printf "  NULL, /* The obstack.  */\n"
1367 printf "  /* basic architecture information */\n"
1368 function_list | while do_read
1369 do
1370     if class_is_info_p
1371     then
1372         printf "  ${staticdefault},  /* ${function} */\n"
1373     fi
1374 done
1375 cat <<EOF
1376   /* target specific vector and its dump routine */
1377   NULL, NULL,
1378   /*per-architecture data-pointers and swap regions */
1379   0, NULL, NULL,
1380   /* Multi-arch values */
1381 EOF
1382 function_list | while do_read
1383 do
1384     if class_is_function_p || class_is_variable_p
1385     then
1386         printf "  ${staticdefault},  /* ${function} */\n"
1387     fi
1388 done
1389 cat <<EOF
1390   /* startup_gdbarch() */
1391 };
1392
1393 struct gdbarch *current_gdbarch = &startup_gdbarch;
1394 EOF
1395
1396 # Create a new gdbarch struct
1397 cat <<EOF
1398
1399 /* Create a new \`\`struct gdbarch'' based on information provided by
1400    \`\`struct gdbarch_info''. */
1401 EOF
1402 printf "\n"
1403 cat <<EOF
1404 struct gdbarch *
1405 gdbarch_alloc (const struct gdbarch_info *info,
1406                struct gdbarch_tdep *tdep)
1407 {
1408   /* NOTE: The new architecture variable is named \`\`current_gdbarch''
1409      so that macros such as TARGET_DOUBLE_BIT, when expanded, refer to
1410      the current local architecture and not the previous global
1411      architecture.  This ensures that the new architectures initial
1412      values are not influenced by the previous architecture.  Once
1413      everything is parameterised with gdbarch, this will go away.  */
1414   struct gdbarch *current_gdbarch;
1415
1416   /* Create an obstack for allocating all the per-architecture memory,
1417      then use that to allocate the architecture vector.  */
1418   struct obstack *obstack = XMALLOC (struct obstack);
1419   obstack_init (obstack);
1420   current_gdbarch = obstack_alloc (obstack, sizeof (*current_gdbarch));
1421   memset (current_gdbarch, 0, sizeof (*current_gdbarch));
1422   current_gdbarch->obstack = obstack;
1423
1424   alloc_gdbarch_data (current_gdbarch);
1425
1426   current_gdbarch->tdep = tdep;
1427 EOF
1428 printf "\n"
1429 function_list | while do_read
1430 do
1431     if class_is_info_p
1432     then
1433         printf "  current_gdbarch->${function} = info->${function};\n"
1434     fi
1435 done
1436 printf "\n"
1437 printf "  /* Force the explicit initialization of these. */\n"
1438 function_list | while do_read
1439 do
1440     if class_is_function_p || class_is_variable_p
1441     then
1442         if [ -n "${predefault}" -a "x${predefault}" != "x0" ]
1443         then
1444           printf "  current_gdbarch->${function} = ${predefault};\n"
1445         fi
1446     fi
1447 done
1448 cat <<EOF
1449   /* gdbarch_alloc() */
1450
1451   return current_gdbarch;
1452 }
1453 EOF
1454
1455 # Free a gdbarch struct.
1456 printf "\n"
1457 printf "\n"
1458 cat <<EOF
1459 /* Allocate extra space using the per-architecture obstack.  */
1460
1461 void *
1462 gdbarch_obstack_zalloc (struct gdbarch *arch, long size)
1463 {
1464   void *data = obstack_alloc (arch->obstack, size);
1465   memset (data, 0, size);
1466   return data;
1467 }
1468
1469
1470 /* Free a gdbarch struct.  This should never happen in normal
1471    operation --- once you've created a gdbarch, you keep it around.
1472    However, if an architecture's init function encounters an error
1473    building the structure, it may need to clean up a partially
1474    constructed gdbarch.  */
1475
1476 void
1477 gdbarch_free (struct gdbarch *arch)
1478 {
1479   struct obstack *obstack;
1480   gdb_assert (arch != NULL);
1481   gdb_assert (!arch->initialized_p);
1482   obstack = arch->obstack;
1483   obstack_free (obstack, 0); /* Includes the ARCH.  */
1484   xfree (obstack);
1485 }
1486 EOF
1487
1488 # verify a new architecture
1489 cat <<EOF
1490
1491
1492 /* Ensure that all values in a GDBARCH are reasonable.  */
1493
1494 /* NOTE/WARNING: The parameter is called \`\`current_gdbarch'' so that it
1495    just happens to match the global variable \`\`current_gdbarch''.  That
1496    way macros refering to that variable get the local and not the global
1497    version - ulgh.  Once everything is parameterised with gdbarch, this
1498    will go away. */
1499
1500 static void
1501 verify_gdbarch (struct gdbarch *current_gdbarch)
1502 {
1503   struct ui_file *log;
1504   struct cleanup *cleanups;
1505   long dummy;
1506   char *buf;
1507   log = mem_fileopen ();
1508   cleanups = make_cleanup_ui_file_delete (log);
1509   /* fundamental */
1510   if (current_gdbarch->byte_order == BFD_ENDIAN_UNKNOWN)
1511     fprintf_unfiltered (log, "\n\tbyte-order");
1512   if (current_gdbarch->bfd_arch_info == NULL)
1513     fprintf_unfiltered (log, "\n\tbfd_arch_info");
1514   /* Check those that need to be defined for the given multi-arch level. */
1515 EOF
1516 function_list | while do_read
1517 do
1518     if class_is_function_p || class_is_variable_p
1519     then
1520         if [ "x${invalid_p}" = "x0" ]
1521         then
1522             printf "  /* Skip verify of ${function}, invalid_p == 0 */\n"
1523         elif class_is_predicate_p
1524         then
1525             printf "  /* Skip verify of ${function}, has predicate */\n"
1526         # FIXME: See do_read for potential simplification
1527         elif [ -n "${invalid_p}" -a -n "${postdefault}" ]
1528         then
1529             printf "  if (${invalid_p})\n"
1530             printf "    current_gdbarch->${function} = ${postdefault};\n"
1531         elif [ -n "${predefault}" -a -n "${postdefault}" ]
1532         then
1533             printf "  if (current_gdbarch->${function} == ${predefault})\n"
1534             printf "    current_gdbarch->${function} = ${postdefault};\n"
1535         elif [ -n "${postdefault}" ]
1536         then
1537             printf "  if (current_gdbarch->${function} == 0)\n"
1538             printf "    current_gdbarch->${function} = ${postdefault};\n"
1539         elif [ -n "${invalid_p}" ]
1540         then
1541             printf "  if ((GDB_MULTI_ARCH ${gt_level})\n"
1542             printf "      && (${invalid_p}))\n"
1543             printf "    fprintf_unfiltered (log, \"\\\\n\\\\t${function}\");\n"
1544         elif [ -n "${predefault}" ]
1545         then
1546             printf "  if ((GDB_MULTI_ARCH ${gt_level})\n"
1547             printf "      && (current_gdbarch->${function} == ${predefault}))\n"
1548             printf "    fprintf_unfiltered (log, \"\\\\n\\\\t${function}\");\n"
1549         fi
1550     fi
1551 done
1552 cat <<EOF
1553   buf = ui_file_xstrdup (log, &dummy);
1554   make_cleanup (xfree, buf);
1555   if (strlen (buf) > 0)
1556     internal_error (__FILE__, __LINE__,
1557                     "verify_gdbarch: the following are invalid ...%s",
1558                     buf);
1559   do_cleanups (cleanups);
1560 }
1561 EOF
1562
1563 # dump the structure
1564 printf "\n"
1565 printf "\n"
1566 cat <<EOF
1567 /* Print out the details of the current architecture. */
1568
1569 /* NOTE/WARNING: The parameter is called \`\`current_gdbarch'' so that it
1570    just happens to match the global variable \`\`current_gdbarch''.  That
1571    way macros refering to that variable get the local and not the global
1572    version - ulgh.  Once everything is parameterised with gdbarch, this
1573    will go away. */
1574
1575 void
1576 gdbarch_dump (struct gdbarch *current_gdbarch, struct ui_file *file)
1577 {
1578   fprintf_unfiltered (file,
1579                       "gdbarch_dump: GDB_MULTI_ARCH = %d\\n",
1580                       GDB_MULTI_ARCH);
1581 EOF
1582 function_list | sort -t: -k 3 | while do_read
1583 do
1584     # First the predicate
1585     if class_is_predicate_p
1586     then
1587         if class_is_multiarch_p
1588         then
1589             printf "  fprintf_unfiltered (file,\n"
1590             printf "                      \"gdbarch_dump: gdbarch_${function}_p() = %%d\\\\n\",\n"
1591             printf "                      gdbarch_${function}_p (current_gdbarch));\n"
1592         else
1593             printf "#ifdef ${macro}_P\n"
1594             printf "  fprintf_unfiltered (file,\n"
1595             printf "                      \"gdbarch_dump: %%s # %%s\\\\n\",\n"
1596             printf "                      \"${macro}_P()\",\n"
1597             printf "                      XSTRING (${macro}_P ()));\n"
1598             printf "  fprintf_unfiltered (file,\n"
1599             printf "                      \"gdbarch_dump: ${macro}_P() = %%d\\\\n\",\n"
1600             printf "                      ${macro}_P ());\n"
1601             printf "#endif\n"
1602         fi
1603     fi
1604     # multiarch functions don't have macros.
1605     if class_is_multiarch_p
1606     then
1607         printf "  fprintf_unfiltered (file,\n"
1608         printf "                      \"gdbarch_dump: ${function} = 0x%%08lx\\\\n\",\n"
1609         printf "                      (long) current_gdbarch->${function});\n"
1610         continue
1611     fi
1612     # Print the macro definition.
1613     printf "#ifdef ${macro}\n"
1614     if class_is_function_p
1615     then
1616         printf "  fprintf_unfiltered (file,\n"
1617         printf "                      \"gdbarch_dump: %%s # %%s\\\\n\",\n"
1618         printf "                      \"${macro}(${actual})\",\n"
1619         printf "                      XSTRING (${macro} (${actual})));\n"
1620     else
1621         printf "  fprintf_unfiltered (file,\n"
1622         printf "                      \"gdbarch_dump: ${macro} # %%s\\\\n\",\n"
1623         printf "                      XSTRING (${macro}));\n"
1624     fi
1625     if [ "x${print_p}" = "x()" ]
1626     then
1627         printf "  gdbarch_dump_${function} (current_gdbarch);\n"
1628     elif [ "x${print_p}" = "x0" ]
1629     then
1630         printf "  /* skip print of ${macro}, print_p == 0. */\n"
1631     elif [ -n "${print_p}" ]
1632     then
1633         printf "  if (${print_p})\n"
1634         printf "    fprintf_unfiltered (file,\n"
1635         printf "                        \"gdbarch_dump: ${macro} = %s\\\\n\",\n" "${fmt}"
1636         printf "                        ${print});\n"
1637     elif class_is_function_p
1638     then
1639         printf "  fprintf_unfiltered (file,\n"
1640         printf "                      \"gdbarch_dump: ${macro} = <0x%%08lx>\\\\n\",\n"
1641         printf "                      (long) current_gdbarch->${function}\n"
1642         printf "                      /*${macro} ()*/);\n"
1643     else
1644         printf "  fprintf_unfiltered (file,\n"
1645         printf "                      \"gdbarch_dump: ${macro} = %s\\\\n\",\n" "${fmt}"
1646         printf "                      ${print});\n"
1647     fi
1648     printf "#endif\n"
1649 done
1650 cat <<EOF
1651   if (current_gdbarch->dump_tdep != NULL)
1652     current_gdbarch->dump_tdep (current_gdbarch, file);
1653 }
1654 EOF
1655
1656
1657 # GET/SET
1658 printf "\n"
1659 cat <<EOF
1660 struct gdbarch_tdep *
1661 gdbarch_tdep (struct gdbarch *gdbarch)
1662 {
1663   if (gdbarch_debug >= 2)
1664     fprintf_unfiltered (gdb_stdlog, "gdbarch_tdep called\\n");
1665   return gdbarch->tdep;
1666 }
1667 EOF
1668 printf "\n"
1669 function_list | while do_read
1670 do
1671     if class_is_predicate_p
1672     then
1673         printf "\n"
1674         printf "int\n"
1675         printf "gdbarch_${function}_p (struct gdbarch *gdbarch)\n"
1676         printf "{\n"
1677         printf "  gdb_assert (gdbarch != NULL);\n"
1678         printf "  return ${predicate};\n"
1679         printf "}\n"
1680     fi
1681     if class_is_function_p
1682     then
1683         printf "\n"
1684         printf "${returntype}\n"
1685         if [ "x${formal}" = "xvoid" ]
1686         then
1687           printf "gdbarch_${function} (struct gdbarch *gdbarch)\n"
1688         else
1689           printf "gdbarch_${function} (struct gdbarch *gdbarch, ${formal})\n"
1690         fi
1691         printf "{\n"
1692         printf "  gdb_assert (gdbarch != NULL);\n"
1693         printf "  gdb_assert (gdbarch->${function} != NULL);\n"
1694         if class_is_predicate_p && test -n "${predefault}"
1695         then
1696             # Allow a call to a function with a predicate.
1697             printf "  /* Do not check predicate: ${predicate}, allow call.  */\n"
1698         fi
1699         printf "  if (gdbarch_debug >= 2)\n"
1700         printf "    fprintf_unfiltered (gdb_stdlog, \"gdbarch_${function} called\\\\n\");\n"
1701         if [ "x${actual}" = "x-" -o "x${actual}" = "x" ]
1702         then
1703             if class_is_multiarch_p
1704             then
1705                 params="gdbarch"
1706             else
1707                 params=""
1708             fi
1709         else
1710             if class_is_multiarch_p
1711             then
1712                 params="gdbarch, ${actual}"
1713             else
1714                 params="${actual}"
1715             fi
1716         fi
1717         if [ "x${returntype}" = "xvoid" ]
1718         then
1719           printf "  gdbarch->${function} (${params});\n"
1720         else
1721           printf "  return gdbarch->${function} (${params});\n"
1722         fi
1723         printf "}\n"
1724         printf "\n"
1725         printf "void\n"
1726         printf "set_gdbarch_${function} (struct gdbarch *gdbarch,\n"
1727         printf "            `echo ${function} | sed -e 's/./ /g'`  gdbarch_${function}_ftype ${function})\n"
1728         printf "{\n"
1729         printf "  gdbarch->${function} = ${function};\n"
1730         printf "}\n"
1731     elif class_is_variable_p
1732     then
1733         printf "\n"
1734         printf "${returntype}\n"
1735         printf "gdbarch_${function} (struct gdbarch *gdbarch)\n"
1736         printf "{\n"
1737         printf "  gdb_assert (gdbarch != NULL);\n"
1738         if [ "x${invalid_p}" = "x0" ]
1739         then
1740             printf "  /* Skip verify of ${function}, invalid_p == 0 */\n"
1741         elif [ -n "${invalid_p}" ]
1742         then
1743             printf "  /* Check variable is valid.  */\n"
1744             printf "  gdb_assert (!(${invalid_p}));\n"
1745         elif [ -n "${predefault}" ]
1746         then
1747             printf "  /* Check variable changed from pre-default.  */\n"
1748             printf "  gdb_assert (gdbarch->${function} != ${predefault});\n"
1749         fi
1750         printf "  if (gdbarch_debug >= 2)\n"
1751         printf "    fprintf_unfiltered (gdb_stdlog, \"gdbarch_${function} called\\\\n\");\n"
1752         printf "  return gdbarch->${function};\n"
1753         printf "}\n"
1754         printf "\n"
1755         printf "void\n"
1756         printf "set_gdbarch_${function} (struct gdbarch *gdbarch,\n"
1757         printf "            `echo ${function} | sed -e 's/./ /g'`  ${returntype} ${function})\n"
1758         printf "{\n"
1759         printf "  gdbarch->${function} = ${function};\n"
1760         printf "}\n"
1761     elif class_is_info_p
1762     then
1763         printf "\n"
1764         printf "${returntype}\n"
1765         printf "gdbarch_${function} (struct gdbarch *gdbarch)\n"
1766         printf "{\n"
1767         printf "  gdb_assert (gdbarch != NULL);\n"
1768         printf "  if (gdbarch_debug >= 2)\n"
1769         printf "    fprintf_unfiltered (gdb_stdlog, \"gdbarch_${function} called\\\\n\");\n"
1770         printf "  return gdbarch->${function};\n"
1771         printf "}\n"
1772     fi
1773 done
1774
1775 # All the trailing guff
1776 cat <<EOF
1777
1778
1779 /* Keep a registry of per-architecture data-pointers required by GDB
1780    modules. */
1781
1782 struct gdbarch_data
1783 {
1784   unsigned index;
1785   int init_p;
1786   gdbarch_data_pre_init_ftype *pre_init;
1787   gdbarch_data_post_init_ftype *post_init;
1788 };
1789
1790 struct gdbarch_data_registration
1791 {
1792   struct gdbarch_data *data;
1793   struct gdbarch_data_registration *next;
1794 };
1795
1796 struct gdbarch_data_registry
1797 {
1798   unsigned nr;
1799   struct gdbarch_data_registration *registrations;
1800 };
1801
1802 struct gdbarch_data_registry gdbarch_data_registry =
1803 {
1804   0, NULL,
1805 };
1806
1807 static struct gdbarch_data *
1808 gdbarch_data_register (gdbarch_data_pre_init_ftype *pre_init,
1809                        gdbarch_data_post_init_ftype *post_init)
1810 {
1811   struct gdbarch_data_registration **curr;
1812   /* Append the new registraration.  */
1813   for (curr = &gdbarch_data_registry.registrations;
1814        (*curr) != NULL;
1815        curr = &(*curr)->next);
1816   (*curr) = XMALLOC (struct gdbarch_data_registration);
1817   (*curr)->next = NULL;
1818   (*curr)->data = XMALLOC (struct gdbarch_data);
1819   (*curr)->data->index = gdbarch_data_registry.nr++;
1820   (*curr)->data->pre_init = pre_init;
1821   (*curr)->data->post_init = post_init;
1822   (*curr)->data->init_p = 1;
1823   return (*curr)->data;
1824 }
1825
1826 struct gdbarch_data *
1827 gdbarch_data_register_pre_init (gdbarch_data_pre_init_ftype *pre_init)
1828 {
1829   return gdbarch_data_register (pre_init, NULL);
1830 }
1831
1832 struct gdbarch_data *
1833 gdbarch_data_register_post_init (gdbarch_data_post_init_ftype *post_init)
1834 {
1835   return gdbarch_data_register (NULL, post_init);
1836 }
1837
1838 /* Create/delete the gdbarch data vector. */
1839
1840 static void
1841 alloc_gdbarch_data (struct gdbarch *gdbarch)
1842 {
1843   gdb_assert (gdbarch->data == NULL);
1844   gdbarch->nr_data = gdbarch_data_registry.nr;
1845   gdbarch->data = GDBARCH_OBSTACK_CALLOC (gdbarch, gdbarch->nr_data, void *);
1846 }
1847
1848 /* Initialize the current value of the specified per-architecture
1849    data-pointer. */
1850
1851 void
1852 deprecated_set_gdbarch_data (struct gdbarch *gdbarch,
1853                              struct gdbarch_data *data,
1854                              void *pointer)
1855 {
1856   gdb_assert (data->index < gdbarch->nr_data);
1857   gdb_assert (gdbarch->data[data->index] == NULL);
1858   gdb_assert (data->pre_init == NULL);
1859   gdbarch->data[data->index] = pointer;
1860 }
1861
1862 /* Return the current value of the specified per-architecture
1863    data-pointer. */
1864
1865 void *
1866 gdbarch_data (struct gdbarch *gdbarch, struct gdbarch_data *data)
1867 {
1868   gdb_assert (data->index < gdbarch->nr_data);
1869   if (gdbarch->data[data->index] == NULL)
1870     {
1871       /* The data-pointer isn't initialized, call init() to get a
1872          value.  */
1873       if (data->pre_init != NULL)
1874         /* Mid architecture creation: pass just the obstack, and not
1875            the entire architecture, as that way it isn't possible for
1876            pre-init code to refer to undefined architecture
1877            fields.  */
1878         gdbarch->data[data->index] = data->pre_init (gdbarch->obstack);
1879       else if (gdbarch->initialized_p
1880                && data->post_init != NULL)
1881         /* Post architecture creation: pass the entire architecture
1882            (as all fields are valid), but be careful to also detect
1883            recursive references.  */
1884         {
1885           gdb_assert (data->init_p);
1886           data->init_p = 0;
1887           gdbarch->data[data->index] = data->post_init (gdbarch);
1888           data->init_p = 1;
1889         }
1890       else
1891         /* The architecture initialization hasn't completed - punt -
1892          hope that the caller knows what they are doing.  Once
1893          deprecated_set_gdbarch_data has been initialized, this can be
1894          changed to an internal error.  */
1895         return NULL;
1896       gdb_assert (gdbarch->data[data->index] != NULL);
1897     }
1898   return gdbarch->data[data->index];
1899 }
1900
1901
1902
1903 /* Keep a registry of swapped data required by GDB modules. */
1904
1905 struct gdbarch_swap
1906 {
1907   void *swap;
1908   struct gdbarch_swap_registration *source;
1909   struct gdbarch_swap *next;
1910 };
1911
1912 struct gdbarch_swap_registration
1913 {
1914   void *data;
1915   unsigned long sizeof_data;
1916   gdbarch_swap_ftype *init;
1917   struct gdbarch_swap_registration *next;
1918 };
1919
1920 struct gdbarch_swap_registry
1921 {
1922   int nr;
1923   struct gdbarch_swap_registration *registrations;
1924 };
1925
1926 struct gdbarch_swap_registry gdbarch_swap_registry =
1927 {
1928   0, NULL,
1929 };
1930
1931 void
1932 deprecated_register_gdbarch_swap (void *data,
1933                                   unsigned long sizeof_data,
1934                                   gdbarch_swap_ftype *init)
1935 {
1936   struct gdbarch_swap_registration **rego;
1937   for (rego = &gdbarch_swap_registry.registrations;
1938        (*rego) != NULL;
1939        rego = &(*rego)->next);
1940   (*rego) = XMALLOC (struct gdbarch_swap_registration);
1941   (*rego)->next = NULL;
1942   (*rego)->init = init;
1943   (*rego)->data = data;
1944   (*rego)->sizeof_data = sizeof_data;
1945 }
1946
1947 static void
1948 current_gdbarch_swap_init_hack (void)
1949 {
1950   struct gdbarch_swap_registration *rego;
1951   struct gdbarch_swap **curr = &current_gdbarch->swap;
1952   for (rego = gdbarch_swap_registry.registrations;
1953        rego != NULL;
1954        rego = rego->next)
1955     {
1956       if (rego->data != NULL)
1957         {
1958           (*curr) = GDBARCH_OBSTACK_ZALLOC (current_gdbarch,
1959                                             struct gdbarch_swap);
1960           (*curr)->source = rego;
1961           (*curr)->swap = gdbarch_obstack_zalloc (current_gdbarch,
1962                                                   rego->sizeof_data);
1963           (*curr)->next = NULL;
1964           curr = &(*curr)->next;
1965         }
1966       if (rego->init != NULL)
1967         rego->init ();
1968     }
1969 }
1970
1971 static struct gdbarch *
1972 current_gdbarch_swap_out_hack (void)
1973 {
1974   struct gdbarch *old_gdbarch = current_gdbarch;
1975   struct gdbarch_swap *curr;
1976
1977   gdb_assert (old_gdbarch != NULL);
1978   for (curr = old_gdbarch->swap;
1979        curr != NULL;
1980        curr = curr->next)
1981     {
1982       memcpy (curr->swap, curr->source->data, curr->source->sizeof_data);
1983       memset (curr->source->data, 0, curr->source->sizeof_data);
1984     }
1985   current_gdbarch = NULL;
1986   return old_gdbarch;
1987 }
1988
1989 static void
1990 current_gdbarch_swap_in_hack (struct gdbarch *new_gdbarch)
1991 {
1992   struct gdbarch_swap *curr;
1993
1994   gdb_assert (current_gdbarch == NULL);
1995   for (curr = new_gdbarch->swap;
1996        curr != NULL;
1997        curr = curr->next)
1998     memcpy (curr->source->data, curr->swap, curr->source->sizeof_data);
1999   current_gdbarch = new_gdbarch;
2000 }
2001
2002
2003 /* Keep a registry of the architectures known by GDB. */
2004
2005 struct gdbarch_registration
2006 {
2007   enum bfd_architecture bfd_architecture;
2008   gdbarch_init_ftype *init;
2009   gdbarch_dump_tdep_ftype *dump_tdep;
2010   struct gdbarch_list *arches;
2011   struct gdbarch_registration *next;
2012 };
2013
2014 static struct gdbarch_registration *gdbarch_registry = NULL;
2015
2016 static void
2017 append_name (const char ***buf, int *nr, const char *name)
2018 {
2019   *buf = xrealloc (*buf, sizeof (char**) * (*nr + 1));
2020   (*buf)[*nr] = name;
2021   *nr += 1;
2022 }
2023
2024 const char **
2025 gdbarch_printable_names (void)
2026 {
2027   /* Accumulate a list of names based on the registed list of
2028      architectures. */
2029   enum bfd_architecture a;
2030   int nr_arches = 0;
2031   const char **arches = NULL;
2032   struct gdbarch_registration *rego;
2033   for (rego = gdbarch_registry;
2034        rego != NULL;
2035        rego = rego->next)
2036     {
2037       const struct bfd_arch_info *ap;
2038       ap = bfd_lookup_arch (rego->bfd_architecture, 0);
2039       if (ap == NULL)
2040         internal_error (__FILE__, __LINE__,
2041                         "gdbarch_architecture_names: multi-arch unknown");
2042       do
2043         {
2044           append_name (&arches, &nr_arches, ap->printable_name);
2045           ap = ap->next;
2046         }
2047       while (ap != NULL);
2048     }
2049   append_name (&arches, &nr_arches, NULL);
2050   return arches;
2051 }
2052
2053
2054 void
2055 gdbarch_register (enum bfd_architecture bfd_architecture,
2056                   gdbarch_init_ftype *init,
2057                   gdbarch_dump_tdep_ftype *dump_tdep)
2058 {
2059   struct gdbarch_registration **curr;
2060   const struct bfd_arch_info *bfd_arch_info;
2061   /* Check that BFD recognizes this architecture */
2062   bfd_arch_info = bfd_lookup_arch (bfd_architecture, 0);
2063   if (bfd_arch_info == NULL)
2064     {
2065       internal_error (__FILE__, __LINE__,
2066                       "gdbarch: Attempt to register unknown architecture (%d)",
2067                       bfd_architecture);
2068     }
2069   /* Check that we haven't seen this architecture before */
2070   for (curr = &gdbarch_registry;
2071        (*curr) != NULL;
2072        curr = &(*curr)->next)
2073     {
2074       if (bfd_architecture == (*curr)->bfd_architecture)
2075         internal_error (__FILE__, __LINE__,
2076                         "gdbarch: Duplicate registraration of architecture (%s)",
2077                         bfd_arch_info->printable_name);
2078     }
2079   /* log it */
2080   if (gdbarch_debug)
2081     fprintf_unfiltered (gdb_stdlog, "register_gdbarch_init (%s, 0x%08lx)\n",
2082                         bfd_arch_info->printable_name,
2083                         (long) init);
2084   /* Append it */
2085   (*curr) = XMALLOC (struct gdbarch_registration);
2086   (*curr)->bfd_architecture = bfd_architecture;
2087   (*curr)->init = init;
2088   (*curr)->dump_tdep = dump_tdep;
2089   (*curr)->arches = NULL;
2090   (*curr)->next = NULL;
2091 }
2092
2093 void
2094 register_gdbarch_init (enum bfd_architecture bfd_architecture,
2095                        gdbarch_init_ftype *init)
2096 {
2097   gdbarch_register (bfd_architecture, init, NULL);
2098 }
2099
2100
2101 /* Look for an architecture using gdbarch_info.  Base search on only
2102    BFD_ARCH_INFO and BYTE_ORDER. */
2103
2104 struct gdbarch_list *
2105 gdbarch_list_lookup_by_info (struct gdbarch_list *arches,
2106                              const struct gdbarch_info *info)
2107 {
2108   for (; arches != NULL; arches = arches->next)
2109     {
2110       if (info->bfd_arch_info != arches->gdbarch->bfd_arch_info)
2111         continue;
2112       if (info->byte_order != arches->gdbarch->byte_order)
2113         continue;
2114       if (info->osabi != arches->gdbarch->osabi)
2115         continue;
2116       return arches;
2117     }
2118   return NULL;
2119 }
2120
2121
2122 /* Find an architecture that matches the specified INFO.  Create a new
2123    architecture if needed.  Return that new architecture.  Assumes
2124    that there is no current architecture.  */
2125
2126 static struct gdbarch *
2127 find_arch_by_info (struct gdbarch *old_gdbarch, struct gdbarch_info info)
2128 {
2129   struct gdbarch *new_gdbarch;
2130   struct gdbarch_registration *rego;
2131
2132   /* The existing architecture has been swapped out - all this code
2133      works from a clean slate.  */
2134   gdb_assert (current_gdbarch == NULL);
2135
2136   /* Fill in missing parts of the INFO struct using a number of
2137      sources: "set ..."; INFOabfd supplied; and the existing
2138      architecture.  */
2139   gdbarch_info_fill (old_gdbarch, &info);
2140
2141   /* Must have found some sort of architecture. */
2142   gdb_assert (info.bfd_arch_info != NULL);
2143
2144   if (gdbarch_debug)
2145     {
2146       fprintf_unfiltered (gdb_stdlog,
2147                           "find_arch_by_info: info.bfd_arch_info %s\n",
2148                           (info.bfd_arch_info != NULL
2149                            ? info.bfd_arch_info->printable_name
2150                            : "(null)"));
2151       fprintf_unfiltered (gdb_stdlog,
2152                           "find_arch_by_info: info.byte_order %d (%s)\n",
2153                           info.byte_order,
2154                           (info.byte_order == BFD_ENDIAN_BIG ? "big"
2155                            : info.byte_order == BFD_ENDIAN_LITTLE ? "little"
2156                            : "default"));
2157       fprintf_unfiltered (gdb_stdlog,
2158                           "find_arch_by_info: info.osabi %d (%s)\n",
2159                           info.osabi, gdbarch_osabi_name (info.osabi));
2160       fprintf_unfiltered (gdb_stdlog,
2161                           "find_arch_by_info: info.abfd 0x%lx\n",
2162                           (long) info.abfd);
2163       fprintf_unfiltered (gdb_stdlog,
2164                           "find_arch_by_info: info.tdep_info 0x%lx\n",
2165                           (long) info.tdep_info);
2166     }
2167
2168   /* Find the tdep code that knows about this architecture.  */
2169   for (rego = gdbarch_registry;
2170        rego != NULL;
2171        rego = rego->next)
2172     if (rego->bfd_architecture == info.bfd_arch_info->arch)
2173       break;
2174   if (rego == NULL)
2175     {
2176       if (gdbarch_debug)
2177         fprintf_unfiltered (gdb_stdlog, "find_arch_by_info: "
2178                             "No matching architecture\n");
2179       return 0;
2180     }
2181
2182   /* Ask the tdep code for an architecture that matches "info".  */
2183   new_gdbarch = rego->init (info, rego->arches);
2184
2185   /* Did the tdep code like it?  No.  Reject the change and revert to
2186      the old architecture.  */
2187   if (new_gdbarch == NULL)
2188     {
2189       if (gdbarch_debug)
2190         fprintf_unfiltered (gdb_stdlog, "find_arch_by_info: "
2191                             "Target rejected architecture\n");
2192       return NULL;
2193     }
2194
2195   /* Is this a pre-existing architecture (as determined by already
2196      being initialized)?  Move it to the front of the architecture
2197      list (keeping the list sorted Most Recently Used).  */
2198   if (new_gdbarch->initialized_p)
2199     {
2200       struct gdbarch_list **list;
2201       struct gdbarch_list *this;
2202       if (gdbarch_debug)
2203         fprintf_unfiltered (gdb_stdlog, "find_arch_by_info: "
2204                             "Previous architecture 0x%08lx (%s) selected\n",
2205                             (long) new_gdbarch,
2206                             new_gdbarch->bfd_arch_info->printable_name);
2207       /* Find the existing arch in the list.  */
2208       for (list = &rego->arches;
2209            (*list) != NULL && (*list)->gdbarch != new_gdbarch;
2210            list = &(*list)->next);
2211       /* It had better be in the list of architectures.  */
2212       gdb_assert ((*list) != NULL && (*list)->gdbarch == new_gdbarch);
2213       /* Unlink THIS.  */
2214       this = (*list);
2215       (*list) = this->next;
2216       /* Insert THIS at the front.  */
2217       this->next = rego->arches;
2218       rego->arches = this;
2219       /* Return it.  */
2220       return new_gdbarch;
2221     }
2222
2223   /* It's a new architecture.  */
2224   if (gdbarch_debug)
2225     fprintf_unfiltered (gdb_stdlog, "find_arch_by_info: "
2226                         "New architecture 0x%08lx (%s) selected\n",
2227                         (long) new_gdbarch,
2228                         new_gdbarch->bfd_arch_info->printable_name);
2229
2230   /* Insert the new architecture into the front of the architecture
2231      list (keep the list sorted Most Recently Used).  */
2232   {
2233     struct gdbarch_list *this = XMALLOC (struct gdbarch_list);
2234     this->next = rego->arches;
2235     this->gdbarch = new_gdbarch;
2236     rego->arches = this;
2237   }
2238
2239   /* Check that the newly installed architecture is valid.  Plug in
2240      any post init values.  */
2241   new_gdbarch->dump_tdep = rego->dump_tdep;
2242   verify_gdbarch (new_gdbarch);
2243   new_gdbarch->initialized_p = 1;
2244
2245   /* Initialize any per-architecture swap areas.  This phase requires
2246      a valid global CURRENT_GDBARCH.  Set it momentarially, and then
2247      swap the entire architecture out.  */
2248   current_gdbarch = new_gdbarch;
2249   current_gdbarch_swap_init_hack ();
2250   current_gdbarch_swap_out_hack ();
2251
2252   if (gdbarch_debug)
2253     gdbarch_dump (new_gdbarch, gdb_stdlog);
2254
2255   return new_gdbarch;
2256 }
2257
2258 struct gdbarch *
2259 gdbarch_find_by_info (struct gdbarch_info info)
2260 {
2261   /* Save the previously selected architecture, setting the global to
2262      NULL.  This stops things like gdbarch->init() trying to use the
2263      previous architecture's configuration.  The previous architecture
2264      may not even be of the same architecture family.  The most recent
2265      architecture of the same family is found at the head of the
2266      rego->arches list.  */
2267   struct gdbarch *old_gdbarch = current_gdbarch_swap_out_hack ();
2268
2269   /* Find the specified architecture.  */
2270   struct gdbarch *new_gdbarch = find_arch_by_info (old_gdbarch, info);
2271
2272   /* Restore the existing architecture.  */
2273   gdb_assert (current_gdbarch == NULL);
2274   current_gdbarch_swap_in_hack (old_gdbarch);
2275
2276   return new_gdbarch;
2277 }
2278
2279 /* Make the specified architecture current, swapping the existing one
2280    out.  */
2281
2282 void
2283 deprecated_current_gdbarch_select_hack (struct gdbarch *new_gdbarch)
2284 {
2285   gdb_assert (new_gdbarch != NULL);
2286   gdb_assert (current_gdbarch != NULL);
2287   gdb_assert (new_gdbarch->initialized_p);
2288   current_gdbarch_swap_out_hack ();
2289   current_gdbarch_swap_in_hack (new_gdbarch);
2290   architecture_changed_event ();
2291 }
2292
2293 extern void _initialize_gdbarch (void);
2294
2295 void
2296 _initialize_gdbarch (void)
2297 {
2298   struct cmd_list_element *c;
2299
2300   add_show_from_set (add_set_cmd ("arch",
2301                                   class_maintenance,
2302                                   var_zinteger,
2303                                   (char *)&gdbarch_debug,
2304                                   "Set architecture debugging.\\n\\
2305 When non-zero, architecture debugging is enabled.", &setdebuglist),
2306                      &showdebuglist);
2307   c = add_set_cmd ("archdebug",
2308                    class_maintenance,
2309                    var_zinteger,
2310                    (char *)&gdbarch_debug,
2311                    "Set architecture debugging.\\n\\
2312 When non-zero, architecture debugging is enabled.", &setlist);
2313
2314   deprecate_cmd (c, "set debug arch");
2315   deprecate_cmd (add_show_from_set (c, &showlist), "show debug arch");
2316 }
2317 EOF
2318
2319 # close things off
2320 exec 1>&2
2321 #../move-if-change new-gdbarch.c gdbarch.c
2322 compare_new gdbarch.c