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