gdb/gdbarch.sh

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