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