gdb/gdbarch.sh

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