gdb/gdbarch.sh

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