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