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     # On some SH's, 'read' trims leading and trailing whitespace by
  51     # default (e.g., bash), while on others (e.g., dash), it doesn't.
  52     # Set IFS to empty to disable the trimming everywhere.
  53     while IFS='' read line
  54     do
  55         if test "${line}" = ""
  56         then
  57             continue
  58         elif test "${line}" = "#" -a "${comment}" = ""
  59         then
  60             continue
  61         elif expr "${line}" : "#" > /dev/null
  62         then
  63             comment="${comment}
  64 ${line}"
  65         else
  66
  67             # The semantics of IFS varies between different SH's.  Some
  68             # treat ``::' as three fields while some treat it as just too.
  69             # Work around this by eliminating ``::'' ....
  70             line="`echo "${line}" | sed -e 's/::/: :/g' -e 's/::/: :/g'`"
  71
  72             OFS="${IFS}" ; IFS="[:]"
  73             eval read ${read} <<EOF
  74 ${line}
  75 EOF
  76             IFS="${OFS}"
  77
  78             if test -n "${garbage_at_eol}"
  79             then
  80                 echo "Garbage at end-of-line in ${line}" 1>&2
  81                 kill $$
  82                 exit 1
  83             fi
  84
  85             # .... and then going back through each field and strip out those
  86             # that ended up with just that space character.
  87             for r in ${read}
  88             do
  89                 if eval test \"\${${r}}\" = \"\ \"
  90                 then
  91                     eval ${r}=""
  92                 fi
  93             done
  94
  95             case "${class}" in
  96                 m ) staticdefault="${predefault}" ;;
  97                 M ) staticdefault="0" ;;
  98                 * ) test "${staticdefault}" || staticdefault=0 ;;
  99             esac
 100
 101             case "${class}" in
 102             F | V | M )
 103                 case "${invalid_p}" in
 104                 "" )
 105                     if test -n "${predefault}"
 106                     then
 107                         #invalid_p="gdbarch->${function} == ${predefault}"
 108                         predicate="gdbarch->${function} != ${predefault}"
 109                     elif class_is_variable_p
 110                     then
 111                         predicate="gdbarch->${function} != 0"
 112                     elif class_is_function_p
 113                     then
 114                         predicate="gdbarch->${function} != NULL"
 115                     fi
 116                     ;;
 117                 * )
 118                     echo "Predicate function ${function} with invalid_p." 1>&2
 119                     kill $$
 120                     exit 1
 121                     ;;
 122                 esac
 123             esac
 124
 125             # PREDEFAULT is a valid fallback definition of MEMBER when
 126             # multi-arch is not enabled.  This ensures that the
 127             # default value, when multi-arch is the same as the
 128             # default value when not multi-arch.  POSTDEFAULT is
 129             # always a valid definition of MEMBER as this again
 130             # ensures consistency.
 131
 132             if [ -n "${postdefault}" ]
 133             then
 134                 fallbackdefault="${postdefault}"
 135             elif [ -n "${predefault}" ]
 136             then
 137                 fallbackdefault="${predefault}"
 138             else
 139                 fallbackdefault="0"
 140             fi
 141
 142             #NOT YET: See gdbarch.log for basic verification of
 143             # database
 144
 145             break
 146         fi
 147     done
 148     if [ -n "${class}" ]
 149     then
 150         true
 151     else
 152         false
 153     fi
 154 }
 155
 156
 157 fallback_default_p ()
 158 {
 159     [ -n "${postdefault}" -a "x${invalid_p}" != "x0" ] \
 160         || [ -n "${predefault}" -a "x${invalid_p}" = "x0" ]
 161 }
 162
 163 class_is_variable_p ()
 164 {
 165     case "${class}" in
 166         *v* | *V* ) true ;;
 167         * ) false ;;
 168     esac
 169 }
 170
 171 class_is_function_p ()
 172 {
 173     case "${class}" in
 174         *f* | *F* | *m* | *M* ) true ;;
 175         * ) false ;;
 176     esac
 177 }
 178
 179 class_is_multiarch_p ()
 180 {
 181     case "${class}" in
 182         *m* | *M* ) true ;;
 183         * ) false ;;
 184     esac
 185 }
 186
 187 class_is_predicate_p ()
 188 {
 189     case "${class}" in
 190         *F* | *V* | *M* ) true ;;
 191         * ) false ;;
 192     esac
 193 }
 194
 195 class_is_info_p ()
 196 {
 197     case "${class}" in
 198         *i* ) true ;;
 199         * ) false ;;
 200     esac
 201 }
 202
 203
 204 # dump out/verify the doco
 205 for field in ${read}
 206 do
 207   case ${field} in
 208
 209     class ) : ;;
 210
 211         # # -> line disable
 212         # f -> function
 213         #   hiding a function
 214         # F -> function + predicate
 215         #   hiding a function + predicate to test function validity
 216         # v -> variable
 217         #   hiding a variable
 218         # V -> variable + predicate
 219         #   hiding a variable + predicate to test variables validity
 220         # i -> set from info
 221         #   hiding something from the ``struct info'' object
 222         # m -> multi-arch function
 223         #   hiding a multi-arch function (parameterised with the architecture)
 224         # M -> multi-arch function + predicate
 225         #   hiding a multi-arch function + predicate to test function validity
 226
 227     returntype ) : ;;
 228
 229         # For functions, the return type; for variables, the data type
 230
 231     function ) : ;;
 232
 233         # For functions, the member function name; for variables, the
 234         # variable name.  Member function names are always prefixed with
 235         # ``gdbarch_'' for name-space purity.
 236
 237     formal ) : ;;
 238
 239         # The formal argument list.  It is assumed that the formal
 240         # argument list includes the actual name of each list element.
 241         # A function with no arguments shall have ``void'' as the
 242         # formal argument list.
 243
 244     actual ) : ;;
 245
 246         # The list of actual arguments.  The arguments specified shall
 247         # match the FORMAL list given above.  Functions with out
 248         # arguments leave this blank.
 249
 250     staticdefault ) : ;;
 251
 252         # To help with the GDB startup a static gdbarch object is
 253         # created.  STATICDEFAULT is the value to insert into that
 254         # static gdbarch object.  Since this a static object only
 255         # simple expressions can be used.
 256
 257         # If STATICDEFAULT is empty, zero is used.
 258
 259     predefault ) : ;;
 260
 261         # An initial value to assign to MEMBER of the freshly
 262         # malloc()ed gdbarch object.  After initialization, the
 263         # freshly malloc()ed object is passed to the target
 264         # architecture code for further updates.
 265
 266         # If PREDEFAULT is empty, zero is used.
 267
 268         # A non-empty PREDEFAULT, an empty POSTDEFAULT and a zero
 269         # INVALID_P are specified, PREDEFAULT will be used as the
 270         # default for the non- multi-arch target.
 271
 272         # A zero PREDEFAULT function will force the fallback to call
 273         # internal_error().
 274
 275         # Variable declarations can refer to ``gdbarch'' which will
 276         # contain the current architecture.  Care should be taken.
 277
 278     postdefault ) : ;;
 279
 280         # A value to assign to MEMBER of the new gdbarch object should
 281         # the target architecture code fail to change the PREDEFAULT
 282         # value.
 283
 284         # If POSTDEFAULT is empty, no post update is performed.
 285
 286         # If both INVALID_P and POSTDEFAULT are non-empty then
 287         # INVALID_P will be used to determine if MEMBER should be
 288         # changed to POSTDEFAULT.
 289
 290         # If a non-empty POSTDEFAULT and a zero INVALID_P are
 291         # specified, POSTDEFAULT will be used as the default for the
 292         # non- multi-arch target (regardless of the value of
 293         # PREDEFAULT).
 294
 295         # You cannot specify both a zero INVALID_P and a POSTDEFAULT.
 296
 297         # Variable declarations can refer to ``gdbarch'' which
 298         # will contain the current architecture.  Care should be
 299         # taken.
 300
 301     invalid_p ) : ;;
 302
 303         # A predicate equation that validates MEMBER.  Non-zero is
 304         # returned if the code creating the new architecture failed to
 305         # initialize MEMBER or the initialized the member is invalid.
 306         # If POSTDEFAULT is non-empty then MEMBER will be updated to
 307         # that value.  If POSTDEFAULT is empty then internal_error()
 308         # is called.
 309
 310         # If INVALID_P is empty, a check that MEMBER is no longer
 311         # equal to PREDEFAULT is used.
 312
 313         # The expression ``0'' disables the INVALID_P check making
 314         # PREDEFAULT a legitimate value.
 315
 316         # See also PREDEFAULT and POSTDEFAULT.
 317
 318     print ) : ;;
 319
 320         # An optional expression that convers MEMBER to a value
 321         # suitable for formatting using %s.
 322
 323         # If PRINT is empty, core_addr_to_string_nz (for CORE_ADDR)
 324         # or plongest (anything else) is used.
 325
 326     garbage_at_eol ) : ;;
 327
 328         # Catches stray fields.
 329
 330     *)
 331         echo "Bad field ${field}"
 332         exit 1;;
 333   esac
 334 done
 335
 336
 337 function_list ()
 338 {
 339   # See below (DOCO) for description of each field
 340   cat <<EOF
 341 i:const struct bfd_arch_info *:bfd_arch_info:::&bfd_default_arch_struct::::gdbarch_bfd_arch_info (gdbarch)->printable_name
 342 #
 343 i:int:byte_order:::BFD_ENDIAN_BIG
 344 i:int:byte_order_for_code:::BFD_ENDIAN_BIG
 345 #
 346 i:enum gdb_osabi:osabi:::GDB_OSABI_UNKNOWN
 347 #
 348 i:const struct target_desc *:target_desc:::::::host_address_to_string (gdbarch->target_desc)
 349
 350 # The bit byte-order has to do just with numbering of bits in debugging symbols
 351 # and such.  Conceptually, it's quite separate from byte/word byte order.
 352 v:int:bits_big_endian:::1:(gdbarch->byte_order == BFD_ENDIAN_BIG)::0
 353
 354 # Number of bits in a char or unsigned char for the target machine.
 355 # Just like CHAR_BIT in <limits.h> but describes the target machine.
 356 # v:TARGET_CHAR_BIT:int:char_bit::::8 * sizeof (char):8::0:
 357 #
 358 # Number of bits in a short or unsigned short for the target machine.
 359 v:int:short_bit:::8 * sizeof (short):2*TARGET_CHAR_BIT::0
 360 # Number of bits in an int or unsigned int for the target machine.
 361 v:int:int_bit:::8 * sizeof (int):4*TARGET_CHAR_BIT::0
 362 # Number of bits in a long or unsigned long for the target machine.
 363 v:int:long_bit:::8 * sizeof (long):4*TARGET_CHAR_BIT::0
 364 # Number of bits in a long long or unsigned long long for the target
 365 # machine.
 366 v:int:long_long_bit:::8 * sizeof (LONGEST):2*gdbarch->long_bit::0
 367 # Alignment of a long long or unsigned long long for the target
 368 # machine.
 369 v:int:long_long_align_bit:::8 * sizeof (LONGEST):2*gdbarch->long_bit::0
 370
 371 # The ABI default bit-size and format for "half", "float", "double", and
 372 # "long double".  These bit/format pairs should eventually be combined
 373 # into a single object.  For the moment, just initialize them as a pair.
 374 # Each format describes both the big and little endian layouts (if
 375 # useful).
 376
 377 v:int:half_bit:::16:2*TARGET_CHAR_BIT::0
 378 v:const struct floatformat **:half_format:::::floatformats_ieee_half::pformat (gdbarch->half_format)
 379 v:int:float_bit:::8 * sizeof (float):4*TARGET_CHAR_BIT::0
 380 v:const struct floatformat **:float_format:::::floatformats_ieee_single::pformat (gdbarch->float_format)
 381 v:int:double_bit:::8 * sizeof (double):8*TARGET_CHAR_BIT::0
 382 v:const struct floatformat **:double_format:::::floatformats_ieee_double::pformat (gdbarch->double_format)
 383 v:int:long_double_bit:::8 * sizeof (long double):8*TARGET_CHAR_BIT::0
 384 v:const struct floatformat **:long_double_format:::::floatformats_ieee_double::pformat (gdbarch->long_double_format)
 385
 386 # For most targets, a pointer on the target and its representation as an
 387 # address in GDB have the same size and "look the same".  For such a
 388 # target, you need only set gdbarch_ptr_bit and gdbarch_addr_bit
 389 # / addr_bit will be set from it.
 390 #
 391 # If gdbarch_ptr_bit and gdbarch_addr_bit are different, you'll probably
 392 # also need to set gdbarch_dwarf2_addr_size, gdbarch_pointer_to_address and
 393 # gdbarch_address_to_pointer as well.
 394 #
 395 # ptr_bit is the size of a pointer on the target
 396 v:int:ptr_bit:::8 * sizeof (void*):gdbarch->int_bit::0
 397 # addr_bit is the size of a target address as represented in gdb
 398 v:int:addr_bit:::8 * sizeof (void*):0:gdbarch_ptr_bit (gdbarch):
 399 #
 400 # dwarf2_addr_size is the target address size as used in the Dwarf debug
 401 # info.  For .debug_frame FDEs, this is supposed to be the target address
 402 # size from the associated CU header, and which is equivalent to the
 403 # DWARF2_ADDR_SIZE as defined by the target specific GCC back-end.
 404 # Unfortunately there is no good way to determine this value.  Therefore
 405 # dwarf2_addr_size simply defaults to the target pointer size.
 406 #
 407 # dwarf2_addr_size is not used for .eh_frame FDEs, which are generally
 408 # defined using the target's pointer size so far.
 409 #
 410 # Note that dwarf2_addr_size only needs to be redefined by a target if the
 411 # GCC back-end defines a DWARF2_ADDR_SIZE other than the target pointer size,
 412 # and if Dwarf versions < 4 need to be supported.
 413 v:int:dwarf2_addr_size:::sizeof (void*):0:gdbarch_ptr_bit (gdbarch) / TARGET_CHAR_BIT:
 414 #
 415 # One if \`char' acts like \`signed char', zero if \`unsigned char'.
 416 v:int:char_signed:::1:-1:1
 417 #
 418 F:CORE_ADDR:read_pc:struct regcache *regcache:regcache
 419 F:void:write_pc:struct regcache *regcache, CORE_ADDR val:regcache, val
 420 # Function for getting target's idea of a frame pointer.  FIXME: GDB's
 421 # whole scheme for dealing with "frames" and "frame pointers" needs a
 422 # serious shakedown.
 423 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
 424 #
 425 M:enum register_status:pseudo_register_read:struct regcache *regcache, int cookednum, gdb_byte *buf:regcache, cookednum, buf
 426 # Read a register into a new struct value.  If the register is wholly
 427 # or partly unavailable, this should call mark_value_bytes_unavailable
 428 # as appropriate.  If this is defined, then pseudo_register_read will
 429 # never be called.
 430 M:struct value *:pseudo_register_read_value:struct regcache *regcache, int cookednum:regcache, cookednum
 431 M:void:pseudo_register_write:struct regcache *regcache, int cookednum, const gdb_byte *buf:regcache, cookednum, buf
 432 #
 433 v:int:num_regs:::0:-1
 434 # This macro gives the number of pseudo-registers that live in the
 435 # register namespace but do not get fetched or stored on the target.
 436 # These pseudo-registers may be aliases for other registers,
 437 # combinations of other registers, or they may be computed by GDB.
 438 v:int:num_pseudo_regs:::0:0::0
 439
 440 # Assemble agent expression bytecode to collect pseudo-register REG.
 441 # Return -1 if something goes wrong, 0 otherwise.
 442 M:int:ax_pseudo_register_collect:struct agent_expr *ax, int reg:ax, reg
 443
 444 # Assemble agent expression bytecode to push the value of pseudo-register
 445 # REG on the interpreter stack.
 446 # Return -1 if something goes wrong, 0 otherwise.
 447 M:int:ax_pseudo_register_push_stack:struct agent_expr *ax, int reg:ax, reg
 448
 449 # GDB's standard (or well known) register numbers.  These can map onto
 450 # a real register or a pseudo (computed) register or not be defined at
 451 # all (-1).
 452 # gdbarch_sp_regnum will hopefully be replaced by UNWIND_SP.
 453 v:int:sp_regnum:::-1:-1::0
 454 v:int:pc_regnum:::-1:-1::0
 455 v:int:ps_regnum:::-1:-1::0
 456 v:int:fp0_regnum:::0:-1::0
 457 # Convert stab register number (from \`r\' declaration) to a gdb REGNUM.
 458 m:int:stab_reg_to_regnum:int stab_regnr:stab_regnr::no_op_reg_to_regnum::0
 459 # Provide a default mapping from a ecoff register number to a gdb REGNUM.
 460 m:int:ecoff_reg_to_regnum:int ecoff_regnr:ecoff_regnr::no_op_reg_to_regnum::0
 461 # Convert from an sdb register number to an internal gdb register number.
 462 m:int:sdb_reg_to_regnum:int sdb_regnr:sdb_regnr::no_op_reg_to_regnum::0
 463 # Provide a default mapping from a DWARF2 register number to a gdb REGNUM.
 464 m:int:dwarf2_reg_to_regnum:int dwarf2_regnr:dwarf2_regnr::no_op_reg_to_regnum::0
 465 m:const char *:register_name:int regnr:regnr::0
 466
 467 # Return the type of a register specified by the architecture.  Only
 468 # the register cache should call this function directly; others should
 469 # use "register_type".
 470 M:struct type *:register_type:int reg_nr:reg_nr
 471
 472 # See gdbint.texinfo, and PUSH_DUMMY_CALL.
 473 M:struct frame_id:dummy_id:struct frame_info *this_frame:this_frame
 474 # Implement DUMMY_ID and PUSH_DUMMY_CALL, then delete
 475 # deprecated_fp_regnum.
 476 v:int:deprecated_fp_regnum:::-1:-1::0
 477
 478 # See gdbint.texinfo.  See infcall.c.
 479 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
 480 v:int:call_dummy_location::::AT_ENTRY_POINT::0
 481 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
 482
 483 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
 484 M:void:print_float_info:struct ui_file *file, struct frame_info *frame, const char *args:file, frame, args
 485 M:void:print_vector_info:struct ui_file *file, struct frame_info *frame, const char *args:file, frame, args
 486 # MAP a GDB RAW register number onto a simulator register number.  See
 487 # also include/...-sim.h.
 488 m:int:register_sim_regno:int reg_nr:reg_nr::legacy_register_sim_regno::0
 489 m:int:cannot_fetch_register:int regnum:regnum::cannot_register_not::0
 490 m:int:cannot_store_register:int regnum:regnum::cannot_register_not::0
 491 # setjmp/longjmp support.
 492 F:int:get_longjmp_target:struct frame_info *frame, CORE_ADDR *pc:frame, pc
 493 #
 494 v:int:believe_pcc_promotion:::::::
 495 #
 496 m:int:convert_register_p:int regnum, struct type *type:regnum, type:0:generic_convert_register_p::0
 497 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
 498 f:void:value_to_register:struct frame_info *frame, int regnum, struct type *type, const gdb_byte *buf:frame, regnum, type, buf:0
 499 # Construct a value representing the contents of register REGNUM in
 500 # frame FRAME, interpreted as type TYPE.  The routine needs to
 501 # allocate and return a struct value with all value attributes
 502 # (but not the value contents) filled in.
 503 f:struct value *:value_from_register:struct type *type, int regnum, struct frame_info *frame:type, regnum, frame::default_value_from_register::0
 504 #
 505 m:CORE_ADDR:pointer_to_address:struct type *type, const gdb_byte *buf:type, buf::unsigned_pointer_to_address::0
 506 m:void:address_to_pointer:struct type *type, gdb_byte *buf, CORE_ADDR addr:type, buf, addr::unsigned_address_to_pointer::0
 507 M:CORE_ADDR:integer_to_address:struct type *type, const gdb_byte *buf:type, buf
 508
 509 # Return the return-value convention that will be used by FUNCTION
 510 # to return a value of type VALTYPE.  FUNCTION may be NULL in which
 511 # case the return convention is computed based only on VALTYPE.
 512 #
 513 # If READBUF is not NULL, extract the return value and save it in this buffer.
 514 #
 515 # If WRITEBUF is not NULL, it contains a return value which will be
 516 # stored into the appropriate register.  This can be used when we want
 517 # to force the value returned by a function (see the "return" command
 518 # for instance).
 519 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
 520
 521 # Return true if the return value of function is stored in the first hidden
 522 # parameter.  In theory, this feature should be language-dependent, specified
 523 # by language and its ABI, such as C++.  Unfortunately, compiler may
 524 # implement it to a target-dependent feature.  So that we need such hook here
 525 # to be aware of this in GDB.
 526 m:int:return_in_first_hidden_param_p:struct type *type:type::default_return_in_first_hidden_param_p::0
 527
 528 m:CORE_ADDR:skip_prologue:CORE_ADDR ip:ip:0:0
 529 M:CORE_ADDR:skip_main_prologue:CORE_ADDR ip:ip
 530 f:int:inner_than:CORE_ADDR lhs, CORE_ADDR rhs:lhs, rhs:0:0
 531 m:const gdb_byte *:breakpoint_from_pc:CORE_ADDR *pcptr, int *lenptr:pcptr, lenptr::0:
 532 # Return the adjusted address and kind to use for Z0/Z1 packets.
 533 # KIND is usually the memory length of the breakpoint, but may have a
 534 # different target-specific meaning.
 535 m:void:remote_breakpoint_from_pc:CORE_ADDR *pcptr, int *kindptr:pcptr, kindptr:0:default_remote_breakpoint_from_pc::0
 536 M:CORE_ADDR:adjust_breakpoint_address:CORE_ADDR bpaddr:bpaddr
 537 m:int:memory_insert_breakpoint:struct bp_target_info *bp_tgt:bp_tgt:0:default_memory_insert_breakpoint::0
 538 m:int:memory_remove_breakpoint:struct bp_target_info *bp_tgt:bp_tgt:0:default_memory_remove_breakpoint::0
 539 v:CORE_ADDR:decr_pc_after_break:::0:::0
 540
 541 # A function can be addressed by either it's "pointer" (possibly a
 542 # descriptor address) or "entry point" (first executable instruction).
 543 # The method "convert_from_func_ptr_addr" converting the former to the
 544 # latter.  gdbarch_deprecated_function_start_offset is being used to implement
 545 # a simplified subset of that functionality - the function's address
 546 # corresponds to the "function pointer" and the function's start
 547 # corresponds to the "function entry point" - and hence is redundant.
 548
 549 v:CORE_ADDR:deprecated_function_start_offset:::0:::0
 550
 551 # Return the remote protocol register number associated with this
 552 # register.  Normally the identity mapping.
 553 m:int:remote_register_number:int regno:regno::default_remote_register_number::0
 554
 555 # Fetch the target specific address used to represent a load module.
 556 F:CORE_ADDR:fetch_tls_load_module_address:struct objfile *objfile:objfile
 557 #
 558 v:CORE_ADDR:frame_args_skip:::0:::0
 559 M:CORE_ADDR:unwind_pc:struct frame_info *next_frame:next_frame
 560 M:CORE_ADDR:unwind_sp:struct frame_info *next_frame:next_frame
 561 # DEPRECATED_FRAME_LOCALS_ADDRESS as been replaced by the per-frame
 562 # frame-base.  Enable frame-base before frame-unwind.
 563 F:int:frame_num_args:struct frame_info *frame:frame
 564 #
 565 M:CORE_ADDR:frame_align:CORE_ADDR address:address
 566 m:int:stabs_argument_has_addr:struct type *type:type::default_stabs_argument_has_addr::0
 567 v:int:frame_red_zone_size
 568 #
 569 m:CORE_ADDR:convert_from_func_ptr_addr:CORE_ADDR addr, struct target_ops *targ:addr, targ::convert_from_func_ptr_addr_identity::0
 570 # On some machines there are bits in addresses which are not really
 571 # part of the address, but are used by the kernel, the hardware, etc.
 572 # for special purposes.  gdbarch_addr_bits_remove takes out any such bits so
 573 # we get a "real" address such as one would find in a symbol table.
 574 # This is used only for addresses of instructions, and even then I'm
 575 # not sure it's used in all contexts.  It exists to deal with there
 576 # being a few stray bits in the PC which would mislead us, not as some
 577 # sort of generic thing to handle alignment or segmentation (it's
 578 # possible it should be in TARGET_READ_PC instead).
 579 m:CORE_ADDR:addr_bits_remove: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 # Implement the "info proc" command for core files.  Noe that there
 947 # are two "info_proc"-like methods on gdbarch -- one for core files,
 948 # one for live targets.
 949 M:void:core_info_proc:char *args, enum info_proc_what what:args, what
 950
 951 # Iterate over all objfiles in the order that makes the most sense
 952 # for the architecture to make global symbol searches.
 953 #
 954 # CB is a callback function where OBJFILE is the objfile to be searched,
 955 # and CB_DATA a pointer to user-defined data (the same data that is passed
 956 # when calling this gdbarch method).  The iteration stops if this function
 957 # returns nonzero.
 958 #
 959 # CB_DATA is a pointer to some user-defined data to be passed to
 960 # the callback.
 961 #
 962 # If not NULL, CURRENT_OBJFILE corresponds to the objfile being
 963 # inspected when the symbol search was requested.
 964 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
 965
 966 # Ravenscar arch-dependent ops.
 967 v:struct ravenscar_arch_ops *:ravenscar_ops:::NULL:NULL::0:host_address_to_string (gdbarch->ravenscar_ops)
 968 EOF
 969 }
 970
 971 #
 972 # The .log file
 973 #
 974 exec > new-gdbarch.log
 975 function_list | while do_read
 976 do
 977     cat <<EOF
 978 ${class} ${returntype} ${function} ($formal)
 979 EOF
 980     for r in ${read}
 981     do
 982         eval echo \"\ \ \ \ ${r}=\${${r}}\"
 983     done
 984     if class_is_predicate_p && fallback_default_p
 985     then
 986         echo "Error: predicate function ${function} can not have a non- multi-arch default" 1>&2
 987         kill $$
 988         exit 1
 989     fi
 990     if [ "x${invalid_p}" = "x0" -a -n "${postdefault}" ]
 991     then
 992         echo "Error: postdefault is useless when invalid_p=0" 1>&2
 993         kill $$
 994         exit 1
 995     fi
 996     if class_is_multiarch_p
 997     then
 998         if class_is_predicate_p ; then :
 999         elif test "x${predefault}" = "x"
1000         then
1001             echo "Error: pure multi-arch function ${function} must have a predefault" 1>&2
1002             kill $$
1003             exit 1
1004         fi
1005     fi
1006     echo ""
1007 done
1008
1009 exec 1>&2
1010 compare_new gdbarch.log
1011
1012
1013 copyright ()
1014 {
1015 cat <<EOF
1016 /* *INDENT-OFF* */ /* THIS FILE IS GENERATED -*- buffer-read-only: t -*- */
1017 /* vi:set ro: */
1018
1019 /* Dynamic architecture support for GDB, the GNU debugger.
1020
1021    Copyright (C) 1998-2012 Free Software Foundation, Inc.
1022
1023    This file is part of GDB.
1024
1025    This program is free software; you can redistribute it and/or modify
1026    it under the terms of the GNU General Public License as published by
1027    the Free Software Foundation; either version 3 of the License, or
1028    (at your option) any later version.
1029
1030    This program is distributed in the hope that it will be useful,
1031    but WITHOUT ANY WARRANTY; without even the implied warranty of
1032    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
1033    GNU General Public License for more details.
1034
1035    You should have received a copy of the GNU General Public License
1036    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
1037
1038 /* This file was created with the aid of \`\`gdbarch.sh''.
1039
1040    The Bourne shell script \`\`gdbarch.sh'' creates the files
1041    \`\`new-gdbarch.c'' and \`\`new-gdbarch.h and then compares them
1042    against the existing \`\`gdbarch.[hc]''.  Any differences found
1043    being reported.
1044
1045    If editing this file, please also run gdbarch.sh and merge any
1046    changes into that script. Conversely, when making sweeping changes
1047    to this file, modifying gdbarch.sh and using its output may prove
1048    easier.  */
1049
1050 EOF
1051 }
1052
1053 #
1054 # The .h file
1055 #
1056
1057 exec > new-gdbarch.h
1058 copyright
1059 cat <<EOF
1060 #ifndef GDBARCH_H
1061 #define GDBARCH_H
1062
1063 struct floatformat;
1064 struct ui_file;
1065 struct frame_info;
1066 struct value;
1067 struct objfile;
1068 struct obj_section;
1069 struct minimal_symbol;
1070 struct regcache;
1071 struct reggroup;
1072 struct regset;
1073 struct disassemble_info;
1074 struct target_ops;
1075 struct obstack;
1076 struct bp_target_info;
1077 struct target_desc;
1078 struct displaced_step_closure;
1079 struct core_regset_section;
1080 struct syscall;
1081 struct agent_expr;
1082 struct axs_value;
1083 struct stap_parse_info;
1084 struct ravenscar_arch_ops;
1085
1086 /* The architecture associated with the inferior through the
1087    connection to the target.
1088
1089    The architecture vector provides some information that is really a
1090    property of the inferior, accessed through a particular target:
1091    ptrace operations; the layout of certain RSP packets; the solib_ops
1092    vector; etc.  To differentiate architecture accesses to
1093    per-inferior/target properties from
1094    per-thread/per-frame/per-objfile properties, accesses to
1095    per-inferior/target properties should be made through this
1096    gdbarch.  */
1097
1098 /* This is a convenience wrapper for 'current_inferior ()->gdbarch'.  */
1099 extern struct gdbarch *target_gdbarch (void);
1100
1101 /* The initial, default architecture.  It uses host values (for want of a better
1102    choice).  */
1103 extern struct gdbarch startup_gdbarch;
1104
1105
1106 /* Callback type for the 'iterate_over_objfiles_in_search_order'
1107    gdbarch  method.  */
1108
1109 typedef int (iterate_over_objfiles_in_search_order_cb_ftype)
1110   (struct objfile *objfile, void *cb_data);
1111 EOF
1112
1113 # function typedef's
1114 printf "\n"
1115 printf "\n"
1116 printf "/* The following are pre-initialized by GDBARCH.  */\n"
1117 function_list | while do_read
1118 do
1119     if class_is_info_p
1120     then
1121         printf "\n"
1122         printf "extern ${returntype} gdbarch_${function} (struct gdbarch *gdbarch);\n"
1123         printf "/* set_gdbarch_${function}() - not applicable - pre-initialized.  */\n"
1124     fi
1125 done
1126
1127 # function typedef's
1128 printf "\n"
1129 printf "\n"
1130 printf "/* The following are initialized by the target dependent code.  */\n"
1131 function_list | while do_read
1132 do
1133     if [ -n "${comment}" ]
1134     then
1135         echo "${comment}" | sed \
1136             -e '2 s,#,/*,' \
1137             -e '3,$ s,#,  ,' \
1138             -e '$ s,$, */,'
1139     fi
1140
1141     if class_is_predicate_p
1142     then
1143         printf "\n"
1144         printf "extern int gdbarch_${function}_p (struct gdbarch *gdbarch);\n"
1145     fi
1146     if class_is_variable_p
1147     then
1148         printf "\n"
1149         printf "extern ${returntype} gdbarch_${function} (struct gdbarch *gdbarch);\n"
1150         printf "extern void set_gdbarch_${function} (struct gdbarch *gdbarch, ${returntype} ${function});\n"
1151     fi
1152     if class_is_function_p
1153     then
1154         printf "\n"
1155         if [ "x${formal}" = "xvoid" ] && class_is_multiarch_p
1156         then
1157             printf "typedef ${returntype} (gdbarch_${function}_ftype) (struct gdbarch *gdbarch);\n"
1158         elif class_is_multiarch_p
1159         then
1160             printf "typedef ${returntype} (gdbarch_${function}_ftype) (struct gdbarch *gdbarch, ${formal});\n"
1161         else
1162             printf "typedef ${returntype} (gdbarch_${function}_ftype) (${formal});\n"
1163         fi
1164         if [ "x${formal}" = "xvoid" ]
1165         then
1166           printf "extern ${returntype} gdbarch_${function} (struct gdbarch *gdbarch);\n"
1167         else
1168           printf "extern ${returntype} gdbarch_${function} (struct gdbarch *gdbarch, ${formal});\n"
1169         fi
1170         printf "extern void set_gdbarch_${function} (struct gdbarch *gdbarch, gdbarch_${function}_ftype *${function});\n"
1171     fi
1172 done
1173
1174 # close it off
1175 cat <<EOF
1176
1177 /* Definition for an unknown syscall, used basically in error-cases.  */
1178 #define UNKNOWN_SYSCALL (-1)
1179
1180 extern struct gdbarch_tdep *gdbarch_tdep (struct gdbarch *gdbarch);
1181
1182
1183 /* Mechanism for co-ordinating the selection of a specific
1184    architecture.
1185
1186    GDB targets (*-tdep.c) can register an interest in a specific
1187    architecture.  Other GDB components can register a need to maintain
1188    per-architecture data.
1189
1190    The mechanisms below ensures that there is only a loose connection
1191    between the set-architecture command and the various GDB
1192    components.  Each component can independently register their need
1193    to maintain architecture specific data with gdbarch.
1194
1195    Pragmatics:
1196
1197    Previously, a single TARGET_ARCHITECTURE_HOOK was provided.  It
1198    didn't scale.
1199
1200    The more traditional mega-struct containing architecture specific
1201    data for all the various GDB components was also considered.  Since
1202    GDB is built from a variable number of (fairly independent)
1203    components it was determined that the global aproach was not
1204    applicable.  */
1205
1206
1207 /* Register a new architectural family with GDB.
1208
1209    Register support for the specified ARCHITECTURE with GDB.  When
1210    gdbarch determines that the specified architecture has been
1211    selected, the corresponding INIT function is called.
1212
1213    --
1214
1215    The INIT function takes two parameters: INFO which contains the
1216    information available to gdbarch about the (possibly new)
1217    architecture; ARCHES which is a list of the previously created
1218    \`\`struct gdbarch'' for this architecture.
1219
1220    The INFO parameter is, as far as possible, be pre-initialized with
1221    information obtained from INFO.ABFD or the global defaults.
1222
1223    The ARCHES parameter is a linked list (sorted most recently used)
1224    of all the previously created architures for this architecture
1225    family.  The (possibly NULL) ARCHES->gdbarch can used to access
1226    values from the previously selected architecture for this
1227    architecture family.
1228
1229    The INIT function shall return any of: NULL - indicating that it
1230    doesn't recognize the selected architecture; an existing \`\`struct
1231    gdbarch'' from the ARCHES list - indicating that the new
1232    architecture is just a synonym for an earlier architecture (see
1233    gdbarch_list_lookup_by_info()); a newly created \`\`struct gdbarch''
1234    - that describes the selected architecture (see gdbarch_alloc()).
1235
1236    The DUMP_TDEP function shall print out all target specific values.
1237    Care should be taken to ensure that the function works in both the
1238    multi-arch and non- multi-arch cases.  */
1239
1240 struct gdbarch_list
1241 {
1242   struct gdbarch *gdbarch;
1243   struct gdbarch_list *next;
1244 };
1245
1246 struct gdbarch_info
1247 {
1248   /* Use default: NULL (ZERO).  */
1249   const struct bfd_arch_info *bfd_arch_info;
1250
1251   /* Use default: BFD_ENDIAN_UNKNOWN (NB: is not ZERO).  */
1252   int byte_order;
1253
1254   int byte_order_for_code;
1255
1256   /* Use default: NULL (ZERO).  */
1257   bfd *abfd;
1258
1259   /* Use default: NULL (ZERO).  */
1260   struct gdbarch_tdep_info *tdep_info;
1261
1262   /* Use default: GDB_OSABI_UNINITIALIZED (-1).  */
1263   enum gdb_osabi osabi;
1264
1265   /* Use default: NULL (ZERO).  */
1266   const struct target_desc *target_desc;
1267 };
1268
1269 typedef struct gdbarch *(gdbarch_init_ftype) (struct gdbarch_info info, struct gdbarch_list *arches);
1270 typedef void (gdbarch_dump_tdep_ftype) (struct gdbarch *gdbarch, struct ui_file *file);
1271
1272 /* DEPRECATED - use gdbarch_register() */
1273 extern void register_gdbarch_init (enum bfd_architecture architecture, gdbarch_init_ftype *);
1274
1275 extern void gdbarch_register (enum bfd_architecture architecture,
1276                               gdbarch_init_ftype *,
1277                               gdbarch_dump_tdep_ftype *);
1278
1279
1280 /* Return a freshly allocated, NULL terminated, array of the valid
1281    architecture names.  Since architectures are registered during the
1282    _initialize phase this function only returns useful information
1283    once initialization has been completed.  */
1284
1285 extern const char **gdbarch_printable_names (void);
1286
1287
1288 /* Helper function.  Search the list of ARCHES for a GDBARCH that
1289    matches the information provided by INFO.  */
1290
1291 extern struct gdbarch_list *gdbarch_list_lookup_by_info (struct gdbarch_list *arches, const struct gdbarch_info *info);
1292
1293
1294 /* Helper function.  Create a preliminary \`\`struct gdbarch''.  Perform
1295    basic initialization using values obtained from the INFO and TDEP
1296    parameters.  set_gdbarch_*() functions are called to complete the
1297    initialization of the object.  */
1298
1299 extern struct gdbarch *gdbarch_alloc (const struct gdbarch_info *info, struct gdbarch_tdep *tdep);
1300
1301
1302 /* Helper function.  Free a partially-constructed \`\`struct gdbarch''.
1303    It is assumed that the caller freeds the \`\`struct
1304    gdbarch_tdep''.  */
1305
1306 extern void gdbarch_free (struct gdbarch *);
1307
1308
1309 /* Helper function.  Allocate memory from the \`\`struct gdbarch''
1310    obstack.  The memory is freed when the corresponding architecture
1311    is also freed.  */
1312
1313 extern void *gdbarch_obstack_zalloc (struct gdbarch *gdbarch, long size);
1314 #define GDBARCH_OBSTACK_CALLOC(GDBARCH, NR, TYPE) ((TYPE *) gdbarch_obstack_zalloc ((GDBARCH), (NR) * sizeof (TYPE)))
1315 #define GDBARCH_OBSTACK_ZALLOC(GDBARCH, TYPE) ((TYPE *) gdbarch_obstack_zalloc ((GDBARCH), sizeof (TYPE)))
1316
1317
1318 /* Helper function.  Force an update of the current architecture.
1319
1320    The actual architecture selected is determined by INFO, \`\`(gdb) set
1321    architecture'' et.al., the existing architecture and BFD's default
1322    architecture.  INFO should be initialized to zero and then selected
1323    fields should be updated.
1324
1325    Returns non-zero if the update succeeds.  */
1326
1327 extern int gdbarch_update_p (struct gdbarch_info info);
1328
1329
1330 /* Helper function.  Find an architecture matching info.
1331
1332    INFO should be initialized using gdbarch_info_init, relevant fields
1333    set, and then finished using gdbarch_info_fill.
1334
1335    Returns the corresponding architecture, or NULL if no matching
1336    architecture was found.  */
1337
1338 extern struct gdbarch *gdbarch_find_by_info (struct gdbarch_info info);
1339
1340
1341 /* Helper function.  Set the target gdbarch to "gdbarch".  */
1342
1343 extern void set_target_gdbarch (struct gdbarch *gdbarch);
1344
1345
1346 /* Register per-architecture data-pointer.
1347
1348    Reserve space for a per-architecture data-pointer.  An identifier
1349    for the reserved data-pointer is returned.  That identifer should
1350    be saved in a local static variable.
1351
1352    Memory for the per-architecture data shall be allocated using
1353    gdbarch_obstack_zalloc.  That memory will be deleted when the
1354    corresponding architecture object is deleted.
1355
1356    When a previously created architecture is re-selected, the
1357    per-architecture data-pointer for that previous architecture is
1358    restored.  INIT() is not re-called.
1359
1360    Multiple registrarants for any architecture are allowed (and
1361    strongly encouraged).  */
1362
1363 struct gdbarch_data;
1364
1365 typedef void *(gdbarch_data_pre_init_ftype) (struct obstack *obstack);
1366 extern struct gdbarch_data *gdbarch_data_register_pre_init (gdbarch_data_pre_init_ftype *init);
1367 typedef void *(gdbarch_data_post_init_ftype) (struct gdbarch *gdbarch);
1368 extern struct gdbarch_data *gdbarch_data_register_post_init (gdbarch_data_post_init_ftype *init);
1369 extern void deprecated_set_gdbarch_data (struct gdbarch *gdbarch,
1370                                          struct gdbarch_data *data,
1371                                          void *pointer);
1372
1373 extern void *gdbarch_data (struct gdbarch *gdbarch, struct gdbarch_data *);
1374
1375
1376 /* Set the dynamic target-system-dependent parameters (architecture,
1377    byte-order, ...) using information found in the BFD.  */
1378
1379 extern void set_gdbarch_from_file (bfd *);
1380
1381
1382 /* Initialize the current architecture to the "first" one we find on
1383    our list.  */
1384
1385 extern void initialize_current_architecture (void);
1386
1387 /* gdbarch trace variable */
1388 extern unsigned int gdbarch_debug;
1389
1390 extern void gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file);
1391
1392 #endif
1393 EOF
1394 exec 1>&2
1395 #../move-if-change new-gdbarch.h gdbarch.h
1396 compare_new gdbarch.h
1397
1398
1399 #
1400 # C file
1401 #
1402
1403 exec > new-gdbarch.c
1404 copyright
1405 cat <<EOF
1406
1407 #include "defs.h"
1408 #include "arch-utils.h"
1409
1410 #include "gdbcmd.h"
1411 #include "inferior.h"
1412 #include "symcat.h"
1413
1414 #include "floatformat.h"
1415
1416 #include "gdb_assert.h"
1417 #include "gdb_string.h"
1418 #include "reggroups.h"
1419 #include "osabi.h"
1420 #include "gdb_obstack.h"
1421 #include "observer.h"
1422 #include "regcache.h"
1423 #include "objfiles.h"
1424
1425 /* Static function declarations */
1426
1427 static void alloc_gdbarch_data (struct gdbarch *);
1428
1429 /* Non-zero if we want to trace architecture code.  */
1430
1431 #ifndef GDBARCH_DEBUG
1432 #define GDBARCH_DEBUG 0
1433 #endif
1434 unsigned int gdbarch_debug = GDBARCH_DEBUG;
1435 static void
1436 show_gdbarch_debug (struct ui_file *file, int from_tty,
1437                     struct cmd_list_element *c, const char *value)
1438 {
1439   fprintf_filtered (file, _("Architecture debugging is %s.\\n"), value);
1440 }
1441
1442 static const char *
1443 pformat (const struct floatformat **format)
1444 {
1445   if (format == NULL)
1446     return "(null)";
1447   else
1448     /* Just print out one of them - this is only for diagnostics.  */
1449     return format[0]->name;
1450 }
1451
1452 static const char *
1453 pstring (const char *string)
1454 {
1455   if (string == NULL)
1456     return "(null)";
1457   return string;
1458 }
1459
1460 EOF
1461
1462 # gdbarch open the gdbarch object
1463 printf "\n"
1464 printf "/* Maintain the struct gdbarch object.  */\n"
1465 printf "\n"
1466 printf "struct gdbarch\n"
1467 printf "{\n"
1468 printf "  /* Has this architecture been fully initialized?  */\n"
1469 printf "  int initialized_p;\n"
1470 printf "\n"
1471 printf "  /* An obstack bound to the lifetime of the architecture.  */\n"
1472 printf "  struct obstack *obstack;\n"
1473 printf "\n"
1474 printf "  /* basic architectural information.  */\n"
1475 function_list | while do_read
1476 do
1477     if class_is_info_p
1478     then
1479         printf "  ${returntype} ${function};\n"
1480     fi
1481 done
1482 printf "\n"
1483 printf "  /* target specific vector.  */\n"
1484 printf "  struct gdbarch_tdep *tdep;\n"
1485 printf "  gdbarch_dump_tdep_ftype *dump_tdep;\n"
1486 printf "\n"
1487 printf "  /* per-architecture data-pointers.  */\n"
1488 printf "  unsigned nr_data;\n"
1489 printf "  void **data;\n"
1490 printf "\n"
1491 cat <<EOF
1492   /* Multi-arch values.
1493
1494      When extending this structure you must:
1495
1496      Add the field below.
1497
1498      Declare set/get functions and define the corresponding
1499      macro in gdbarch.h.
1500
1501      gdbarch_alloc(): If zero/NULL is not a suitable default,
1502      initialize the new field.
1503
1504      verify_gdbarch(): Confirm that the target updated the field
1505      correctly.
1506
1507      gdbarch_dump(): Add a fprintf_unfiltered call so that the new
1508      field is dumped out
1509
1510      \`\`startup_gdbarch()'': Append an initial value to the static
1511      variable (base values on the host's c-type system).
1512
1513      get_gdbarch(): Implement the set/get functions (probably using
1514      the macro's as shortcuts).
1515
1516      */
1517
1518 EOF
1519 function_list | while do_read
1520 do
1521     if class_is_variable_p
1522     then
1523         printf "  ${returntype} ${function};\n"
1524     elif class_is_function_p
1525     then
1526         printf "  gdbarch_${function}_ftype *${function};\n"
1527     fi
1528 done
1529 printf "};\n"
1530
1531 # A pre-initialized vector
1532 printf "\n"
1533 printf "\n"
1534 cat <<EOF
1535 /* The default architecture uses host values (for want of a better
1536    choice).  */
1537 EOF
1538 printf "\n"
1539 printf "extern const struct bfd_arch_info bfd_default_arch_struct;\n"
1540 printf "\n"
1541 printf "struct gdbarch startup_gdbarch =\n"
1542 printf "{\n"
1543 printf "  1, /* Always initialized.  */\n"
1544 printf "  NULL, /* The obstack.  */\n"
1545 printf "  /* basic architecture information.  */\n"
1546 function_list | while do_read
1547 do
1548     if class_is_info_p
1549     then
1550         printf "  ${staticdefault},  /* ${function} */\n"
1551     fi
1552 done
1553 cat <<EOF
1554   /* target specific vector and its dump routine.  */
1555   NULL, NULL,
1556   /*per-architecture data-pointers.  */
1557   0, NULL,
1558   /* Multi-arch values */
1559 EOF
1560 function_list | while do_read
1561 do
1562     if class_is_function_p || class_is_variable_p
1563     then
1564         printf "  ${staticdefault},  /* ${function} */\n"
1565     fi
1566 done
1567 cat <<EOF
1568   /* startup_gdbarch() */
1569 };
1570
1571 EOF
1572
1573 # Create a new gdbarch struct
1574 cat <<EOF
1575
1576 /* Create a new \`\`struct gdbarch'' based on information provided by
1577    \`\`struct gdbarch_info''.  */
1578 EOF
1579 printf "\n"
1580 cat <<EOF
1581 struct gdbarch *
1582 gdbarch_alloc (const struct gdbarch_info *info,
1583                struct gdbarch_tdep *tdep)
1584 {
1585   struct gdbarch *gdbarch;
1586
1587   /* Create an obstack for allocating all the per-architecture memory,
1588      then use that to allocate the architecture vector.  */
1589   struct obstack *obstack = XMALLOC (struct obstack);
1590   obstack_init (obstack);
1591   gdbarch = obstack_alloc (obstack, sizeof (*gdbarch));
1592   memset (gdbarch, 0, sizeof (*gdbarch));
1593   gdbarch->obstack = obstack;
1594
1595   alloc_gdbarch_data (gdbarch);
1596
1597   gdbarch->tdep = tdep;
1598 EOF
1599 printf "\n"
1600 function_list | while do_read
1601 do
1602     if class_is_info_p
1603     then
1604         printf "  gdbarch->${function} = info->${function};\n"
1605     fi
1606 done
1607 printf "\n"
1608 printf "  /* Force the explicit initialization of these.  */\n"
1609 function_list | while do_read
1610 do
1611     if class_is_function_p || class_is_variable_p
1612     then
1613         if [ -n "${predefault}" -a "x${predefault}" != "x0" ]
1614         then
1615           printf "  gdbarch->${function} = ${predefault};\n"
1616         fi
1617     fi
1618 done
1619 cat <<EOF
1620   /* gdbarch_alloc() */
1621
1622   return gdbarch;
1623 }
1624 EOF
1625
1626 # Free a gdbarch struct.
1627 printf "\n"
1628 printf "\n"
1629 cat <<EOF
1630 /* Allocate extra space using the per-architecture obstack.  */
1631
1632 void *
1633 gdbarch_obstack_zalloc (struct gdbarch *arch, long size)
1634 {
1635   void *data = obstack_alloc (arch->obstack, size);
1636
1637   memset (data, 0, size);
1638   return data;
1639 }
1640
1641
1642 /* Free a gdbarch struct.  This should never happen in normal
1643    operation --- once you've created a gdbarch, you keep it around.
1644    However, if an architecture's init function encounters an error
1645    building the structure, it may need to clean up a partially
1646    constructed gdbarch.  */
1647
1648 void
1649 gdbarch_free (struct gdbarch *arch)
1650 {
1651   struct obstack *obstack;
1652
1653   gdb_assert (arch != NULL);
1654   gdb_assert (!arch->initialized_p);
1655   obstack = arch->obstack;
1656   obstack_free (obstack, 0); /* Includes the ARCH.  */
1657   xfree (obstack);
1658 }
1659 EOF
1660
1661 # verify a new architecture
1662 cat <<EOF
1663
1664
1665 /* Ensure that all values in a GDBARCH are reasonable.  */
1666
1667 static void
1668 verify_gdbarch (struct gdbarch *gdbarch)
1669 {
1670   struct ui_file *log;
1671   struct cleanup *cleanups;
1672   long length;
1673   char *buf;
1674
1675   log = mem_fileopen ();
1676   cleanups = make_cleanup_ui_file_delete (log);
1677   /* fundamental */
1678   if (gdbarch->byte_order == BFD_ENDIAN_UNKNOWN)
1679     fprintf_unfiltered (log, "\n\tbyte-order");
1680   if (gdbarch->bfd_arch_info == NULL)
1681     fprintf_unfiltered (log, "\n\tbfd_arch_info");
1682   /* Check those that need to be defined for the given multi-arch level.  */
1683 EOF
1684 function_list | while do_read
1685 do
1686     if class_is_function_p || class_is_variable_p
1687     then
1688         if [ "x${invalid_p}" = "x0" ]
1689         then
1690             printf "  /* Skip verify of ${function}, invalid_p == 0 */\n"
1691         elif class_is_predicate_p
1692         then
1693             printf "  /* Skip verify of ${function}, has predicate.  */\n"
1694         # FIXME: See do_read for potential simplification
1695         elif [ -n "${invalid_p}" -a -n "${postdefault}" ]
1696         then
1697             printf "  if (${invalid_p})\n"
1698             printf "    gdbarch->${function} = ${postdefault};\n"
1699         elif [ -n "${predefault}" -a -n "${postdefault}" ]
1700         then
1701             printf "  if (gdbarch->${function} == ${predefault})\n"
1702             printf "    gdbarch->${function} = ${postdefault};\n"
1703         elif [ -n "${postdefault}" ]
1704         then
1705             printf "  if (gdbarch->${function} == 0)\n"
1706             printf "    gdbarch->${function} = ${postdefault};\n"
1707         elif [ -n "${invalid_p}" ]
1708         then
1709             printf "  if (${invalid_p})\n"
1710             printf "    fprintf_unfiltered (log, \"\\\\n\\\\t${function}\");\n"
1711         elif [ -n "${predefault}" ]
1712         then
1713             printf "  if (gdbarch->${function} == ${predefault})\n"
1714             printf "    fprintf_unfiltered (log, \"\\\\n\\\\t${function}\");\n"
1715         fi
1716     fi
1717 done
1718 cat <<EOF
1719   buf = ui_file_xstrdup (log, &length);
1720   make_cleanup (xfree, buf);
1721   if (length > 0)
1722     internal_error (__FILE__, __LINE__,
1723                     _("verify_gdbarch: the following are invalid ...%s"),
1724                     buf);
1725   do_cleanups (cleanups);
1726 }
1727 EOF
1728
1729 # dump the structure
1730 printf "\n"
1731 printf "\n"
1732 cat <<EOF
1733 /* Print out the details of the current architecture.  */
1734
1735 void
1736 gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file)
1737 {
1738   const char *gdb_nm_file = "<not-defined>";
1739
1740 #if defined (GDB_NM_FILE)
1741   gdb_nm_file = GDB_NM_FILE;
1742 #endif
1743   fprintf_unfiltered (file,
1744                       "gdbarch_dump: GDB_NM_FILE = %s\\n",
1745                       gdb_nm_file);
1746 EOF
1747 function_list | sort -t: -k 3 | while do_read
1748 do
1749     # First the predicate
1750     if class_is_predicate_p
1751     then
1752         printf "  fprintf_unfiltered (file,\n"
1753         printf "                      \"gdbarch_dump: gdbarch_${function}_p() = %%d\\\\n\",\n"
1754         printf "                      gdbarch_${function}_p (gdbarch));\n"
1755     fi
1756     # Print the corresponding value.
1757     if class_is_function_p
1758     then
1759         printf "  fprintf_unfiltered (file,\n"
1760         printf "                      \"gdbarch_dump: ${function} = <%%s>\\\\n\",\n"
1761         printf "                      host_address_to_string (gdbarch->${function}));\n"
1762     else
1763         # It is a variable
1764         case "${print}:${returntype}" in
1765             :CORE_ADDR )
1766                 fmt="%s"
1767                 print="core_addr_to_string_nz (gdbarch->${function})"
1768                 ;;
1769             :* )
1770                 fmt="%s"
1771                 print="plongest (gdbarch->${function})"
1772                 ;;
1773             * )
1774                 fmt="%s"
1775                 ;;
1776         esac
1777         printf "  fprintf_unfiltered (file,\n"
1778         printf "                      \"gdbarch_dump: ${function} = %s\\\\n\",\n" "${fmt}"
1779         printf "                      ${print});\n"
1780     fi
1781 done
1782 cat <<EOF
1783   if (gdbarch->dump_tdep != NULL)
1784     gdbarch->dump_tdep (gdbarch, file);
1785 }
1786 EOF
1787
1788
1789 # GET/SET
1790 printf "\n"
1791 cat <<EOF
1792 struct gdbarch_tdep *
1793 gdbarch_tdep (struct gdbarch *gdbarch)
1794 {
1795   if (gdbarch_debug >= 2)
1796     fprintf_unfiltered (gdb_stdlog, "gdbarch_tdep called\\n");
1797   return gdbarch->tdep;
1798 }
1799 EOF
1800 printf "\n"
1801 function_list | while do_read
1802 do
1803     if class_is_predicate_p
1804     then
1805         printf "\n"
1806         printf "int\n"
1807         printf "gdbarch_${function}_p (struct gdbarch *gdbarch)\n"
1808         printf "{\n"
1809         printf "  gdb_assert (gdbarch != NULL);\n"
1810         printf "  return ${predicate};\n"
1811         printf "}\n"
1812     fi
1813     if class_is_function_p
1814     then
1815         printf "\n"
1816         printf "${returntype}\n"
1817         if [ "x${formal}" = "xvoid" ]
1818         then
1819           printf "gdbarch_${function} (struct gdbarch *gdbarch)\n"
1820         else
1821           printf "gdbarch_${function} (struct gdbarch *gdbarch, ${formal})\n"
1822         fi
1823         printf "{\n"
1824         printf "  gdb_assert (gdbarch != NULL);\n"
1825         printf "  gdb_assert (gdbarch->${function} != NULL);\n"
1826         if class_is_predicate_p && test -n "${predefault}"
1827         then
1828             # Allow a call to a function with a predicate.
1829             printf "  /* Do not check predicate: ${predicate}, allow call.  */\n"
1830         fi
1831         printf "  if (gdbarch_debug >= 2)\n"
1832         printf "    fprintf_unfiltered (gdb_stdlog, \"gdbarch_${function} called\\\\n\");\n"
1833         if [ "x${actual}" = "x-" -o "x${actual}" = "x" ]
1834         then
1835             if class_is_multiarch_p
1836             then
1837                 params="gdbarch"
1838             else
1839                 params=""
1840             fi
1841         else
1842             if class_is_multiarch_p
1843             then
1844                 params="gdbarch, ${actual}"
1845             else
1846                 params="${actual}"
1847             fi
1848         fi
1849         if [ "x${returntype}" = "xvoid" ]
1850         then
1851           printf "  gdbarch->${function} (${params});\n"
1852         else
1853           printf "  return gdbarch->${function} (${params});\n"
1854         fi
1855         printf "}\n"
1856         printf "\n"
1857         printf "void\n"
1858         printf "set_gdbarch_${function} (struct gdbarch *gdbarch,\n"
1859         printf "            `echo ${function} | sed -e 's/./ /g'`  gdbarch_${function}_ftype ${function})\n"
1860         printf "{\n"
1861         printf "  gdbarch->${function} = ${function};\n"
1862         printf "}\n"
1863     elif class_is_variable_p
1864     then
1865         printf "\n"
1866         printf "${returntype}\n"
1867         printf "gdbarch_${function} (struct gdbarch *gdbarch)\n"
1868         printf "{\n"
1869         printf "  gdb_assert (gdbarch != NULL);\n"
1870         if [ "x${invalid_p}" = "x0" ]
1871         then
1872             printf "  /* Skip verify of ${function}, invalid_p == 0 */\n"
1873         elif [ -n "${invalid_p}" ]
1874         then
1875             printf "  /* Check variable is valid.  */\n"
1876             printf "  gdb_assert (!(${invalid_p}));\n"
1877         elif [ -n "${predefault}" ]
1878         then
1879             printf "  /* Check variable changed from pre-default.  */\n"
1880             printf "  gdb_assert (gdbarch->${function} != ${predefault});\n"
1881         fi
1882         printf "  if (gdbarch_debug >= 2)\n"
1883         printf "    fprintf_unfiltered (gdb_stdlog, \"gdbarch_${function} called\\\\n\");\n"
1884         printf "  return gdbarch->${function};\n"
1885         printf "}\n"
1886         printf "\n"
1887         printf "void\n"
1888         printf "set_gdbarch_${function} (struct gdbarch *gdbarch,\n"
1889         printf "            `echo ${function} | sed -e 's/./ /g'`  ${returntype} ${function})\n"
1890         printf "{\n"
1891         printf "  gdbarch->${function} = ${function};\n"
1892         printf "}\n"
1893     elif class_is_info_p
1894     then
1895         printf "\n"
1896         printf "${returntype}\n"
1897         printf "gdbarch_${function} (struct gdbarch *gdbarch)\n"
1898         printf "{\n"
1899         printf "  gdb_assert (gdbarch != NULL);\n"
1900         printf "  if (gdbarch_debug >= 2)\n"
1901         printf "    fprintf_unfiltered (gdb_stdlog, \"gdbarch_${function} called\\\\n\");\n"
1902         printf "  return gdbarch->${function};\n"
1903         printf "}\n"
1904     fi
1905 done
1906
1907 # All the trailing guff
1908 cat <<EOF
1909
1910
1911 /* Keep a registry of per-architecture data-pointers required by GDB
1912    modules.  */
1913
1914 struct gdbarch_data
1915 {
1916   unsigned index;
1917   int init_p;
1918   gdbarch_data_pre_init_ftype *pre_init;
1919   gdbarch_data_post_init_ftype *post_init;
1920 };
1921
1922 struct gdbarch_data_registration
1923 {
1924   struct gdbarch_data *data;
1925   struct gdbarch_data_registration *next;
1926 };
1927
1928 struct gdbarch_data_registry
1929 {
1930   unsigned nr;
1931   struct gdbarch_data_registration *registrations;
1932 };
1933
1934 struct gdbarch_data_registry gdbarch_data_registry =
1935 {
1936   0, NULL,
1937 };
1938
1939 static struct gdbarch_data *
1940 gdbarch_data_register (gdbarch_data_pre_init_ftype *pre_init,
1941                        gdbarch_data_post_init_ftype *post_init)
1942 {
1943   struct gdbarch_data_registration **curr;
1944
1945   /* Append the new registration.  */
1946   for (curr = &gdbarch_data_registry.registrations;
1947        (*curr) != NULL;
1948        curr = &(*curr)->next);
1949   (*curr) = XMALLOC (struct gdbarch_data_registration);
1950   (*curr)->next = NULL;
1951   (*curr)->data = XMALLOC (struct gdbarch_data);
1952   (*curr)->data->index = gdbarch_data_registry.nr++;
1953   (*curr)->data->pre_init = pre_init;
1954   (*curr)->data->post_init = post_init;
1955   (*curr)->data->init_p = 1;
1956   return (*curr)->data;
1957 }
1958
1959 struct gdbarch_data *
1960 gdbarch_data_register_pre_init (gdbarch_data_pre_init_ftype *pre_init)
1961 {
1962   return gdbarch_data_register (pre_init, NULL);
1963 }
1964
1965 struct gdbarch_data *
1966 gdbarch_data_register_post_init (gdbarch_data_post_init_ftype *post_init)
1967 {
1968   return gdbarch_data_register (NULL, post_init);
1969 }
1970
1971 /* Create/delete the gdbarch data vector.  */
1972
1973 static void
1974 alloc_gdbarch_data (struct gdbarch *gdbarch)
1975 {
1976   gdb_assert (gdbarch->data == NULL);
1977   gdbarch->nr_data = gdbarch_data_registry.nr;
1978   gdbarch->data = GDBARCH_OBSTACK_CALLOC (gdbarch, gdbarch->nr_data, void *);
1979 }
1980
1981 /* Initialize the current value of the specified per-architecture
1982    data-pointer.  */
1983
1984 void
1985 deprecated_set_gdbarch_data (struct gdbarch *gdbarch,
1986                              struct gdbarch_data *data,
1987                              void *pointer)
1988 {
1989   gdb_assert (data->index < gdbarch->nr_data);
1990   gdb_assert (gdbarch->data[data->index] == NULL);
1991   gdb_assert (data->pre_init == NULL);
1992   gdbarch->data[data->index] = pointer;
1993 }
1994
1995 /* Return the current value of the specified per-architecture
1996    data-pointer.  */
1997
1998 void *
1999 gdbarch_data (struct gdbarch *gdbarch, struct gdbarch_data *data)
2000 {
2001   gdb_assert (data->index < gdbarch->nr_data);
2002   if (gdbarch->data[data->index] == NULL)
2003     {
2004       /* The data-pointer isn't initialized, call init() to get a
2005          value.  */
2006       if (data->pre_init != NULL)
2007         /* Mid architecture creation: pass just the obstack, and not
2008            the entire architecture, as that way it isn't possible for
2009            pre-init code to refer to undefined architecture
2010            fields.  */
2011         gdbarch->data[data->index] = data->pre_init (gdbarch->obstack);
2012       else if (gdbarch->initialized_p
2013                && data->post_init != NULL)
2014         /* Post architecture creation: pass the entire architecture
2015            (as all fields are valid), but be careful to also detect
2016            recursive references.  */
2017         {
2018           gdb_assert (data->init_p);
2019           data->init_p = 0;
2020           gdbarch->data[data->index] = data->post_init (gdbarch);
2021           data->init_p = 1;
2022         }
2023       else
2024         /* The architecture initialization hasn't completed - punt -
2025          hope that the caller knows what they are doing.  Once
2026          deprecated_set_gdbarch_data has been initialized, this can be
2027          changed to an internal error.  */
2028         return NULL;
2029       gdb_assert (gdbarch->data[data->index] != NULL);
2030     }
2031   return gdbarch->data[data->index];
2032 }
2033
2034
2035 /* Keep a registry of the architectures known by GDB.  */
2036
2037 struct gdbarch_registration
2038 {
2039   enum bfd_architecture bfd_architecture;
2040   gdbarch_init_ftype *init;
2041   gdbarch_dump_tdep_ftype *dump_tdep;
2042   struct gdbarch_list *arches;
2043   struct gdbarch_registration *next;
2044 };
2045
2046 static struct gdbarch_registration *gdbarch_registry = NULL;
2047
2048 static void
2049 append_name (const char ***buf, int *nr, const char *name)
2050 {
2051   *buf = xrealloc (*buf, sizeof (char**) * (*nr + 1));
2052   (*buf)[*nr] = name;
2053   *nr += 1;
2054 }
2055
2056 const char **
2057 gdbarch_printable_names (void)
2058 {
2059   /* Accumulate a list of names based on the registed list of
2060      architectures.  */
2061   int nr_arches = 0;
2062   const char **arches = NULL;
2063   struct gdbarch_registration *rego;
2064
2065   for (rego = gdbarch_registry;
2066        rego != NULL;
2067        rego = rego->next)
2068     {
2069       const struct bfd_arch_info *ap;
2070       ap = bfd_lookup_arch (rego->bfd_architecture, 0);
2071       if (ap == NULL)
2072         internal_error (__FILE__, __LINE__,
2073                         _("gdbarch_architecture_names: multi-arch unknown"));
2074       do
2075         {
2076           append_name (&arches, &nr_arches, ap->printable_name);
2077           ap = ap->next;
2078         }
2079       while (ap != NULL);
2080     }
2081   append_name (&arches, &nr_arches, NULL);
2082   return arches;
2083 }
2084
2085
2086 void
2087 gdbarch_register (enum bfd_architecture bfd_architecture,
2088                   gdbarch_init_ftype *init,
2089                   gdbarch_dump_tdep_ftype *dump_tdep)
2090 {
2091   struct gdbarch_registration **curr;
2092   const struct bfd_arch_info *bfd_arch_info;
2093
2094   /* Check that BFD recognizes this architecture */
2095   bfd_arch_info = bfd_lookup_arch (bfd_architecture, 0);
2096   if (bfd_arch_info == NULL)
2097     {
2098       internal_error (__FILE__, __LINE__,
2099                       _("gdbarch: Attempt to register "
2100                         "unknown architecture (%d)"),
2101                       bfd_architecture);
2102     }
2103   /* Check that we haven't seen this architecture before.  */
2104   for (curr = &gdbarch_registry;
2105        (*curr) != NULL;
2106        curr = &(*curr)->next)
2107     {
2108       if (bfd_architecture == (*curr)->bfd_architecture)
2109         internal_error (__FILE__, __LINE__,
2110                         _("gdbarch: Duplicate registration "
2111                           "of architecture (%s)"),
2112                         bfd_arch_info->printable_name);
2113     }
2114   /* log it */
2115   if (gdbarch_debug)
2116     fprintf_unfiltered (gdb_stdlog, "register_gdbarch_init (%s, %s)\n",
2117                         bfd_arch_info->printable_name,
2118                         host_address_to_string (init));
2119   /* Append it */
2120   (*curr) = XMALLOC (struct gdbarch_registration);
2121   (*curr)->bfd_architecture = bfd_architecture;
2122   (*curr)->init = init;
2123   (*curr)->dump_tdep = dump_tdep;
2124   (*curr)->arches = NULL;
2125   (*curr)->next = NULL;
2126 }
2127
2128 void
2129 register_gdbarch_init (enum bfd_architecture bfd_architecture,
2130                        gdbarch_init_ftype *init)
2131 {
2132   gdbarch_register (bfd_architecture, init, NULL);
2133 }
2134
2135
2136 /* Look for an architecture using gdbarch_info.  */
2137
2138 struct gdbarch_list *
2139 gdbarch_list_lookup_by_info (struct gdbarch_list *arches,
2140                              const struct gdbarch_info *info)
2141 {
2142   for (; arches != NULL; arches = arches->next)
2143     {
2144       if (info->bfd_arch_info != arches->gdbarch->bfd_arch_info)
2145         continue;
2146       if (info->byte_order != arches->gdbarch->byte_order)
2147         continue;
2148       if (info->osabi != arches->gdbarch->osabi)
2149         continue;
2150       if (info->target_desc != arches->gdbarch->target_desc)
2151         continue;
2152       return arches;
2153     }
2154   return NULL;
2155 }
2156
2157
2158 /* Find an architecture that matches the specified INFO.  Create a new
2159    architecture if needed.  Return that new architecture.  */
2160
2161 struct gdbarch *
2162 gdbarch_find_by_info (struct gdbarch_info info)
2163 {
2164   struct gdbarch *new_gdbarch;
2165   struct gdbarch_registration *rego;
2166
2167   /* Fill in missing parts of the INFO struct using a number of
2168      sources: "set ..."; INFOabfd supplied; and the global
2169      defaults.  */
2170   gdbarch_info_fill (&info);
2171
2172   /* Must have found some sort of architecture.  */
2173   gdb_assert (info.bfd_arch_info != NULL);
2174
2175   if (gdbarch_debug)
2176     {
2177       fprintf_unfiltered (gdb_stdlog,
2178                           "gdbarch_find_by_info: info.bfd_arch_info %s\n",
2179                           (info.bfd_arch_info != NULL
2180                            ? info.bfd_arch_info->printable_name
2181                            : "(null)"));
2182       fprintf_unfiltered (gdb_stdlog,
2183                           "gdbarch_find_by_info: info.byte_order %d (%s)\n",
2184                           info.byte_order,
2185                           (info.byte_order == BFD_ENDIAN_BIG ? "big"
2186                            : info.byte_order == BFD_ENDIAN_LITTLE ? "little"
2187                            : "default"));
2188       fprintf_unfiltered (gdb_stdlog,
2189                           "gdbarch_find_by_info: info.osabi %d (%s)\n",
2190                           info.osabi, gdbarch_osabi_name (info.osabi));
2191       fprintf_unfiltered (gdb_stdlog,
2192                           "gdbarch_find_by_info: info.abfd %s\n",
2193                           host_address_to_string (info.abfd));
2194       fprintf_unfiltered (gdb_stdlog,
2195                           "gdbarch_find_by_info: info.tdep_info %s\n",
2196                           host_address_to_string (info.tdep_info));
2197     }
2198
2199   /* Find the tdep code that knows about this architecture.  */
2200   for (rego = gdbarch_registry;
2201        rego != NULL;
2202        rego = rego->next)
2203     if (rego->bfd_architecture == info.bfd_arch_info->arch)
2204       break;
2205   if (rego == NULL)
2206     {
2207       if (gdbarch_debug)
2208         fprintf_unfiltered (gdb_stdlog, "gdbarch_find_by_info: "
2209                             "No matching architecture\n");
2210       return 0;
2211     }
2212
2213   /* Ask the tdep code for an architecture that matches "info".  */
2214   new_gdbarch = rego->init (info, rego->arches);
2215
2216   /* Did the tdep code like it?  No.  Reject the change and revert to
2217      the old architecture.  */
2218   if (new_gdbarch == NULL)
2219     {
2220       if (gdbarch_debug)
2221         fprintf_unfiltered (gdb_stdlog, "gdbarch_find_by_info: "
2222                             "Target rejected architecture\n");
2223       return NULL;
2224     }
2225
2226   /* Is this a pre-existing architecture (as determined by already
2227      being initialized)?  Move it to the front of the architecture
2228      list (keeping the list sorted Most Recently Used).  */
2229   if (new_gdbarch->initialized_p)
2230     {
2231       struct gdbarch_list **list;
2232       struct gdbarch_list *this;
2233       if (gdbarch_debug)
2234         fprintf_unfiltered (gdb_stdlog, "gdbarch_find_by_info: "
2235                             "Previous architecture %s (%s) selected\n",
2236                             host_address_to_string (new_gdbarch),
2237                             new_gdbarch->bfd_arch_info->printable_name);
2238       /* Find the existing arch in the list.  */
2239       for (list = &rego->arches;
2240            (*list) != NULL && (*list)->gdbarch != new_gdbarch;
2241            list = &(*list)->next);
2242       /* It had better be in the list of architectures.  */
2243       gdb_assert ((*list) != NULL && (*list)->gdbarch == new_gdbarch);
2244       /* Unlink THIS.  */
2245       this = (*list);
2246       (*list) = this->next;
2247       /* Insert THIS at the front.  */
2248       this->next = rego->arches;
2249       rego->arches = this;
2250       /* Return it.  */
2251       return new_gdbarch;
2252     }
2253
2254   /* It's a new architecture.  */
2255   if (gdbarch_debug)
2256     fprintf_unfiltered (gdb_stdlog, "gdbarch_find_by_info: "
2257                         "New architecture %s (%s) selected\n",
2258                         host_address_to_string (new_gdbarch),
2259                         new_gdbarch->bfd_arch_info->printable_name);
2260
2261   /* Insert the new architecture into the front of the architecture
2262      list (keep the list sorted Most Recently Used).  */
2263   {
2264     struct gdbarch_list *this = XMALLOC (struct gdbarch_list);
2265     this->next = rego->arches;
2266     this->gdbarch = new_gdbarch;
2267     rego->arches = this;
2268   }
2269
2270   /* Check that the newly installed architecture is valid.  Plug in
2271      any post init values.  */
2272   new_gdbarch->dump_tdep = rego->dump_tdep;
2273   verify_gdbarch (new_gdbarch);
2274   new_gdbarch->initialized_p = 1;
2275
2276   if (gdbarch_debug)
2277     gdbarch_dump (new_gdbarch, gdb_stdlog);
2278
2279   return new_gdbarch;
2280 }
2281
2282 /* Make the specified architecture current.  */
2283
2284 void
2285 set_target_gdbarch (struct gdbarch *new_gdbarch)
2286 {
2287   gdb_assert (new_gdbarch != NULL);
2288   gdb_assert (new_gdbarch->initialized_p);
2289   current_inferior ()->gdbarch = new_gdbarch;
2290   observer_notify_architecture_changed (new_gdbarch);
2291   registers_changed ();
2292 }
2293
2294 /* Return the current inferior's arch.  */
2295
2296 struct gdbarch *
2297 target_gdbarch (void)
2298 {
2299   return current_inferior ()->gdbarch;
2300 }
2301
2302 extern void _initialize_gdbarch (void);
2303
2304 void
2305 _initialize_gdbarch (void)
2306 {
2307   add_setshow_zuinteger_cmd ("arch", class_maintenance, &gdbarch_debug, _("\\
2308 Set architecture debugging."), _("\\
2309 Show architecture debugging."), _("\\
2310 When non-zero, architecture debugging is enabled."),
2311                             NULL,
2312                             show_gdbarch_debug,
2313                             &setdebuglist, &showdebuglist);
2314 }
2315 EOF
2316
2317 # close things off
2318 exec 1>&2
2319 #../move-if-change new-gdbarch.c gdbarch.c
2320 compare_new gdbarch.c