gdb/gdbarch.sh

   1 #!/bin/sh -u
   2
   3 # Architecture commands for GDB, the GNU debugger.
   4 #
   5 # Copyright (C) 1998-2019 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 two.
  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;enum bfd_endian;byte_order;;;BFD_ENDIAN_BIG
 344 i;enum bfd_endian;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 short or unsigned short for the target machine.
 355 v;int;short_bit;;;8 * sizeof (short);2*TARGET_CHAR_BIT;;0
 356 # Number of bits in an int or unsigned int for the target machine.
 357 v;int;int_bit;;;8 * sizeof (int);4*TARGET_CHAR_BIT;;0
 358 # Number of bits in a long or unsigned long for the target machine.
 359 v;int;long_bit;;;8 * sizeof (long);4*TARGET_CHAR_BIT;;0
 360 # Number of bits in a long long or unsigned long long for the target
 361 # machine.
 362 v;int;long_long_bit;;;8 * sizeof (LONGEST);2*gdbarch->long_bit;;0
 363
 364 # The ABI default bit-size and format for "half", "float", "double", and
 365 # "long double".  These bit/format pairs should eventually be combined
 366 # into a single object.  For the moment, just initialize them as a pair.
 367 # Each format describes both the big and little endian layouts (if
 368 # useful).
 369
 370 v;int;half_bit;;;16;2*TARGET_CHAR_BIT;;0
 371 v;const struct floatformat **;half_format;;;;;floatformats_ieee_half;;pformat (gdbarch->half_format)
 372 v;int;float_bit;;;8 * sizeof (float);4*TARGET_CHAR_BIT;;0
 373 v;const struct floatformat **;float_format;;;;;floatformats_ieee_single;;pformat (gdbarch->float_format)
 374 v;int;double_bit;;;8 * sizeof (double);8*TARGET_CHAR_BIT;;0
 375 v;const struct floatformat **;double_format;;;;;floatformats_ieee_double;;pformat (gdbarch->double_format)
 376 v;int;long_double_bit;;;8 * sizeof (long double);8*TARGET_CHAR_BIT;;0
 377 v;const struct floatformat **;long_double_format;;;;;floatformats_ieee_double;;pformat (gdbarch->long_double_format)
 378
 379 # The ABI default bit-size for "wchar_t".  wchar_t is a built-in type
 380 # starting with C++11.
 381 v;int;wchar_bit;;;8 * sizeof (wchar_t);4*TARGET_CHAR_BIT;;0
 382 # One if \`wchar_t' is signed, zero if unsigned.
 383 v;int;wchar_signed;;;1;-1;1
 384
 385 # Returns the floating-point format to be used for values of length LENGTH.
 386 # NAME, if non-NULL, is the type name, which may be used to distinguish
 387 # different target formats of the same length.
 388 m;const struct floatformat **;floatformat_for_type;const char *name, int length;name, length;0;default_floatformat_for_type;;0
 389
 390 # For most targets, a pointer on the target and its representation as an
 391 # address in GDB have the same size and "look the same".  For such a
 392 # target, you need only set gdbarch_ptr_bit and gdbarch_addr_bit
 393 # / addr_bit will be set from it.
 394 #
 395 # If gdbarch_ptr_bit and gdbarch_addr_bit are different, you'll probably
 396 # also need to set gdbarch_dwarf2_addr_size, gdbarch_pointer_to_address and
 397 # gdbarch_address_to_pointer as well.
 398 #
 399 # ptr_bit is the size of a pointer on the target
 400 v;int;ptr_bit;;;8 * sizeof (void*);gdbarch->int_bit;;0
 401 # addr_bit is the size of a target address as represented in gdb
 402 v;int;addr_bit;;;8 * sizeof (void*);0;gdbarch_ptr_bit (gdbarch);
 403 #
 404 # dwarf2_addr_size is the target address size as used in the Dwarf debug
 405 # info.  For .debug_frame FDEs, this is supposed to be the target address
 406 # size from the associated CU header, and which is equivalent to the
 407 # DWARF2_ADDR_SIZE as defined by the target specific GCC back-end.
 408 # Unfortunately there is no good way to determine this value.  Therefore
 409 # dwarf2_addr_size simply defaults to the target pointer size.
 410 #
 411 # dwarf2_addr_size is not used for .eh_frame FDEs, which are generally
 412 # defined using the target's pointer size so far.
 413 #
 414 # Note that dwarf2_addr_size only needs to be redefined by a target if the
 415 # GCC back-end defines a DWARF2_ADDR_SIZE other than the target pointer size,
 416 # and if Dwarf versions < 4 need to be supported.
 417 v;int;dwarf2_addr_size;;;sizeof (void*);0;gdbarch_ptr_bit (gdbarch) / TARGET_CHAR_BIT;
 418 #
 419 # One if \`char' acts like \`signed char', zero if \`unsigned char'.
 420 v;int;char_signed;;;1;-1;1
 421 #
 422 F;CORE_ADDR;read_pc;readable_regcache *regcache;regcache
 423 F;void;write_pc;struct regcache *regcache, CORE_ADDR val;regcache, val
 424 # Function for getting target's idea of a frame pointer.  FIXME: GDB's
 425 # whole scheme for dealing with "frames" and "frame pointers" needs a
 426 # serious shakedown.
 427 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
 428 #
 429 M;enum register_status;pseudo_register_read;readable_regcache *regcache, int cookednum, gdb_byte *buf;regcache, cookednum, buf
 430 # Read a register into a new struct value.  If the register is wholly
 431 # or partly unavailable, this should call mark_value_bytes_unavailable
 432 # as appropriate.  If this is defined, then pseudo_register_read will
 433 # never be called.
 434 M;struct value *;pseudo_register_read_value;readable_regcache *regcache, int cookednum;regcache, cookednum
 435 M;void;pseudo_register_write;struct regcache *regcache, int cookednum, const gdb_byte *buf;regcache, cookednum, buf
 436 #
 437 v;int;num_regs;;;0;-1
 438 # This macro gives the number of pseudo-registers that live in the
 439 # register namespace but do not get fetched or stored on the target.
 440 # These pseudo-registers may be aliases for other registers,
 441 # combinations of other registers, or they may be computed by GDB.
 442 v;int;num_pseudo_regs;;;0;0;;0
 443
 444 # Assemble agent expression bytecode to collect pseudo-register REG.
 445 # Return -1 if something goes wrong, 0 otherwise.
 446 M;int;ax_pseudo_register_collect;struct agent_expr *ax, int reg;ax, reg
 447
 448 # Assemble agent expression bytecode to push the value of pseudo-register
 449 # REG on the interpreter stack.
 450 # Return -1 if something goes wrong, 0 otherwise.
 451 M;int;ax_pseudo_register_push_stack;struct agent_expr *ax, int reg;ax, reg
 452
 453 # Some targets/architectures can do extra processing/display of
 454 # segmentation faults.  E.g., Intel MPX boundary faults.
 455 # Call the architecture dependent function to handle the fault.
 456 # UIOUT is the output stream where the handler will place information.
 457 M;void;handle_segmentation_fault;struct ui_out *uiout;uiout
 458
 459 # GDB's standard (or well known) register numbers.  These can map onto
 460 # a real register or a pseudo (computed) register or not be defined at
 461 # all (-1).
 462 # gdbarch_sp_regnum will hopefully be replaced by UNWIND_SP.
 463 v;int;sp_regnum;;;-1;-1;;0
 464 v;int;pc_regnum;;;-1;-1;;0
 465 v;int;ps_regnum;;;-1;-1;;0
 466 v;int;fp0_regnum;;;0;-1;;0
 467 # Convert stab register number (from \`r\' declaration) to a gdb REGNUM.
 468 m;int;stab_reg_to_regnum;int stab_regnr;stab_regnr;;no_op_reg_to_regnum;;0
 469 # Provide a default mapping from a ecoff register number to a gdb REGNUM.
 470 m;int;ecoff_reg_to_regnum;int ecoff_regnr;ecoff_regnr;;no_op_reg_to_regnum;;0
 471 # Convert from an sdb register number to an internal gdb register number.
 472 m;int;sdb_reg_to_regnum;int sdb_regnr;sdb_regnr;;no_op_reg_to_regnum;;0
 473 # Provide a default mapping from a DWARF2 register number to a gdb REGNUM.
 474 # Return -1 for bad REGNUM.  Note: Several targets get this wrong.
 475 m;int;dwarf2_reg_to_regnum;int dwarf2_regnr;dwarf2_regnr;;no_op_reg_to_regnum;;0
 476 m;const char *;register_name;int regnr;regnr;;0
 477
 478 # Return the type of a register specified by the architecture.  Only
 479 # the register cache should call this function directly; others should
 480 # use "register_type".
 481 M;struct type *;register_type;int reg_nr;reg_nr
 482
 483 # Generate a dummy frame_id for THIS_FRAME assuming that the frame is
 484 # a dummy frame.  A dummy frame is created before an inferior call,
 485 # the frame_id returned here must match the frame_id that was built
 486 # for the inferior call.  Usually this means the returned frame_id's
 487 # stack address should match the address returned by
 488 # gdbarch_push_dummy_call, and the returned frame_id's code address
 489 # should match the address at which the breakpoint was set in the dummy
 490 # frame.
 491 m;struct frame_id;dummy_id;struct frame_info *this_frame;this_frame;;default_dummy_id;;0
 492 # Implement DUMMY_ID and PUSH_DUMMY_CALL, then delete
 493 # deprecated_fp_regnum.
 494 v;int;deprecated_fp_regnum;;;-1;-1;;0
 495
 496 M;CORE_ADDR;push_dummy_call;struct value *function, struct regcache *regcache, CORE_ADDR bp_addr, int nargs, struct value **args, CORE_ADDR sp, function_call_return_method return_method, CORE_ADDR struct_addr;function, regcache, bp_addr, nargs, args, sp, return_method, struct_addr
 497 v;int;call_dummy_location;;;;AT_ENTRY_POINT;;0
 498 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
 499
 500 # Return true if the code of FRAME is writable.
 501 m;int;code_of_frame_writable;struct frame_info *frame;frame;;default_code_of_frame_writable;;0
 502
 503 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
 504 m;void;print_float_info;struct ui_file *file, struct frame_info *frame, const char *args;file, frame, args;;default_print_float_info;;0
 505 M;void;print_vector_info;struct ui_file *file, struct frame_info *frame, const char *args;file, frame, args
 506 # MAP a GDB RAW register number onto a simulator register number.  See
 507 # also include/...-sim.h.
 508 m;int;register_sim_regno;int reg_nr;reg_nr;;legacy_register_sim_regno;;0
 509 m;int;cannot_fetch_register;int regnum;regnum;;cannot_register_not;;0
 510 m;int;cannot_store_register;int regnum;regnum;;cannot_register_not;;0
 511
 512 # Determine the address where a longjmp will land and save this address
 513 # in PC.  Return nonzero on success.
 514 #
 515 # FRAME corresponds to the longjmp frame.
 516 F;int;get_longjmp_target;struct frame_info *frame, CORE_ADDR *pc;frame, pc
 517
 518 #
 519 v;int;believe_pcc_promotion;;;;;;;
 520 #
 521 m;int;convert_register_p;int regnum, struct type *type;regnum, type;0;generic_convert_register_p;;0
 522 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
 523 f;void;value_to_register;struct frame_info *frame, int regnum, struct type *type, const gdb_byte *buf;frame, regnum, type, buf;0
 524 # Construct a value representing the contents of register REGNUM in
 525 # frame FRAME_ID, interpreted as type TYPE.  The routine needs to
 526 # allocate and return a struct value with all value attributes
 527 # (but not the value contents) filled in.
 528 m;struct value *;value_from_register;struct type *type, int regnum, struct frame_id frame_id;type, regnum, frame_id;;default_value_from_register;;0
 529 #
 530 m;CORE_ADDR;pointer_to_address;struct type *type, const gdb_byte *buf;type, buf;;unsigned_pointer_to_address;;0
 531 m;void;address_to_pointer;struct type *type, gdb_byte *buf, CORE_ADDR addr;type, buf, addr;;unsigned_address_to_pointer;;0
 532 M;CORE_ADDR;integer_to_address;struct type *type, const gdb_byte *buf;type, buf
 533
 534 # Return the return-value convention that will be used by FUNCTION
 535 # to return a value of type VALTYPE.  FUNCTION may be NULL in which
 536 # case the return convention is computed based only on VALTYPE.
 537 #
 538 # If READBUF is not NULL, extract the return value and save it in this buffer.
 539 #
 540 # If WRITEBUF is not NULL, it contains a return value which will be
 541 # stored into the appropriate register.  This can be used when we want
 542 # to force the value returned by a function (see the "return" command
 543 # for instance).
 544 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
 545
 546 # Return true if the return value of function is stored in the first hidden
 547 # parameter.  In theory, this feature should be language-dependent, specified
 548 # by language and its ABI, such as C++.  Unfortunately, compiler may
 549 # implement it to a target-dependent feature.  So that we need such hook here
 550 # to be aware of this in GDB.
 551 m;int;return_in_first_hidden_param_p;struct type *type;type;;default_return_in_first_hidden_param_p;;0
 552
 553 m;CORE_ADDR;skip_prologue;CORE_ADDR ip;ip;0;0
 554 M;CORE_ADDR;skip_main_prologue;CORE_ADDR ip;ip
 555 # On some platforms, a single function may provide multiple entry points,
 556 # e.g. one that is used for function-pointer calls and a different one
 557 # that is used for direct function calls.
 558 # In order to ensure that breakpoints set on the function will trigger
 559 # no matter via which entry point the function is entered, a platform
 560 # may provide the skip_entrypoint callback.  It is called with IP set
 561 # to the main entry point of a function (as determined by the symbol table),
 562 # and should return the address of the innermost entry point, where the
 563 # actual breakpoint needs to be set.  Note that skip_entrypoint is used
 564 # by GDB common code even when debugging optimized code, where skip_prologue
 565 # is not used.
 566 M;CORE_ADDR;skip_entrypoint;CORE_ADDR ip;ip
 567
 568 f;int;inner_than;CORE_ADDR lhs, CORE_ADDR rhs;lhs, rhs;0;0
 569 m;const gdb_byte *;breakpoint_from_pc;CORE_ADDR *pcptr, int *lenptr;pcptr, lenptr;0;default_breakpoint_from_pc;;0
 570
 571 # Return the breakpoint kind for this target based on *PCPTR.
 572 m;int;breakpoint_kind_from_pc;CORE_ADDR *pcptr;pcptr;;0;
 573
 574 # Return the software breakpoint from KIND.  KIND can have target
 575 # specific meaning like the Z0 kind parameter.
 576 # SIZE is set to the software breakpoint's length in memory.
 577 m;const gdb_byte *;sw_breakpoint_from_kind;int kind, int *size;kind, size;;NULL;;0
 578
 579 # Return the breakpoint kind for this target based on the current
 580 # processor state (e.g. the current instruction mode on ARM) and the
 581 # *PCPTR.  In default, it is gdbarch->breakpoint_kind_from_pc.
 582 m;int;breakpoint_kind_from_current_state;struct regcache *regcache, CORE_ADDR *pcptr;regcache, pcptr;0;default_breakpoint_kind_from_current_state;;0
 583
 584 M;CORE_ADDR;adjust_breakpoint_address;CORE_ADDR bpaddr;bpaddr
 585 m;int;memory_insert_breakpoint;struct bp_target_info *bp_tgt;bp_tgt;0;default_memory_insert_breakpoint;;0
 586 m;int;memory_remove_breakpoint;struct bp_target_info *bp_tgt;bp_tgt;0;default_memory_remove_breakpoint;;0
 587 v;CORE_ADDR;decr_pc_after_break;;;0;;;0
 588
 589 # A function can be addressed by either it's "pointer" (possibly a
 590 # descriptor address) or "entry point" (first executable instruction).
 591 # The method "convert_from_func_ptr_addr" converting the former to the
 592 # latter.  gdbarch_deprecated_function_start_offset is being used to implement
 593 # a simplified subset of that functionality - the function's address
 594 # corresponds to the "function pointer" and the function's start
 595 # corresponds to the "function entry point" - and hence is redundant.
 596
 597 v;CORE_ADDR;deprecated_function_start_offset;;;0;;;0
 598
 599 # Return the remote protocol register number associated with this
 600 # register.  Normally the identity mapping.
 601 m;int;remote_register_number;int regno;regno;;default_remote_register_number;;0
 602
 603 # Fetch the target specific address used to represent a load module.
 604 F;CORE_ADDR;fetch_tls_load_module_address;struct objfile *objfile;objfile
 605
 606 # Return the thread-local address at OFFSET in the thread-local
 607 # storage for the thread PTID and the shared library or executable
 608 # file given by LM_ADDR.  If that block of thread-local storage hasn't
 609 # been allocated yet, this function may throw an error.  LM_ADDR may
 610 # be zero for statically linked multithreaded inferiors.
 611
 612 M;CORE_ADDR;get_thread_local_address;ptid_t ptid, CORE_ADDR lm_addr, CORE_ADDR offset;ptid, lm_addr, offset
 613 #
 614 v;CORE_ADDR;frame_args_skip;;;0;;;0
 615 m;CORE_ADDR;unwind_pc;struct frame_info *next_frame;next_frame;;default_unwind_pc;;0
 616 m;CORE_ADDR;unwind_sp;struct frame_info *next_frame;next_frame;;default_unwind_sp;;0
 617 # DEPRECATED_FRAME_LOCALS_ADDRESS as been replaced by the per-frame
 618 # frame-base.  Enable frame-base before frame-unwind.
 619 F;int;frame_num_args;struct frame_info *frame;frame
 620 #
 621 M;CORE_ADDR;frame_align;CORE_ADDR address;address
 622 m;int;stabs_argument_has_addr;struct type *type;type;;default_stabs_argument_has_addr;;0
 623 v;int;frame_red_zone_size
 624 #
 625 m;CORE_ADDR;convert_from_func_ptr_addr;CORE_ADDR addr, struct target_ops *targ;addr, targ;;convert_from_func_ptr_addr_identity;;0
 626 # On some machines there are bits in addresses which are not really
 627 # part of the address, but are used by the kernel, the hardware, etc.
 628 # for special purposes.  gdbarch_addr_bits_remove takes out any such bits so
 629 # we get a "real" address such as one would find in a symbol table.
 630 # This is used only for addresses of instructions, and even then I'm
 631 # not sure it's used in all contexts.  It exists to deal with there
 632 # being a few stray bits in the PC which would mislead us, not as some
 633 # sort of generic thing to handle alignment or segmentation (it's
 634 # possible it should be in TARGET_READ_PC instead).
 635 m;CORE_ADDR;addr_bits_remove;CORE_ADDR addr;addr;;core_addr_identity;;0
 636
 637 # On some machines, not all bits of an address word are significant.
 638 # For example, on AArch64, the top bits of an address known as the "tag"
 639 # are ignored by the kernel, the hardware, etc. and can be regarded as
 640 # additional data associated with the address.
 641 v;int;significant_addr_bit;;;;;;0
 642
 643 # FIXME/cagney/2001-01-18: This should be split in two.  A target method that
 644 # indicates if the target needs software single step.  An ISA method to
 645 # implement it.
 646 #
 647 # FIXME/cagney/2001-01-18: The logic is backwards.  It should be asking if the
 648 # target can single step.  If not, then implement single step using breakpoints.
 649 #
 650 # Return a vector of addresses on which the software single step
 651 # breakpoints should be inserted.  NULL means software single step is
 652 # not used.
 653 # Multiple breakpoints may be inserted for some instructions such as
 654 # conditional branch.  However, each implementation must always evaluate
 655 # the condition and only put the breakpoint at the branch destination if
 656 # the condition is true, so that we ensure forward progress when stepping
 657 # past a conditional branch to self.
 658 F;std::vector<CORE_ADDR>;software_single_step;struct regcache *regcache;regcache
 659
 660 # Return non-zero if the processor is executing a delay slot and a
 661 # further single-step is needed before the instruction finishes.
 662 M;int;single_step_through_delay;struct frame_info *frame;frame
 663 # FIXME: cagney/2003-08-28: Need to find a better way of selecting the
 664 # disassembler.  Perhaps objdump can handle it?
 665 f;int;print_insn;bfd_vma vma, struct disassemble_info *info;vma, info;;default_print_insn;;0
 666 f;CORE_ADDR;skip_trampoline_code;struct frame_info *frame, CORE_ADDR pc;frame, pc;;generic_skip_trampoline_code;;0
 667
 668
 669 # If in_solib_dynsym_resolve_code() returns true, and SKIP_SOLIB_RESOLVER
 670 # evaluates non-zero, this is the address where the debugger will place
 671 # a step-resume breakpoint to get us past the dynamic linker.
 672 m;CORE_ADDR;skip_solib_resolver;CORE_ADDR pc;pc;;generic_skip_solib_resolver;;0
 673 # Some systems also have trampoline code for returning from shared libs.
 674 m;int;in_solib_return_trampoline;CORE_ADDR pc, const char *name;pc, name;;generic_in_solib_return_trampoline;;0
 675
 676 # Return true if PC lies inside an indirect branch thunk.
 677 m;bool;in_indirect_branch_thunk;CORE_ADDR pc;pc;;default_in_indirect_branch_thunk;;0
 678
 679 # A target might have problems with watchpoints as soon as the stack
 680 # frame of the current function has been destroyed.  This mostly happens
 681 # as the first action in a function's epilogue.  stack_frame_destroyed_p()
 682 # is defined to return a non-zero value if either the given addr is one
 683 # instruction after the stack destroying instruction up to the trailing
 684 # return instruction or if we can figure out that the stack frame has
 685 # already been invalidated regardless of the value of addr.  Targets
 686 # which don't suffer from that problem could just let this functionality
 687 # untouched.
 688 m;int;stack_frame_destroyed_p;CORE_ADDR addr;addr;0;generic_stack_frame_destroyed_p;;0
 689 # Process an ELF symbol in the minimal symbol table in a backend-specific
 690 # way.  Normally this hook is supposed to do nothing, however if required,
 691 # then this hook can be used to apply tranformations to symbols that are
 692 # considered special in some way.  For example the MIPS backend uses it
 693 # to interpret \`st_other' information to mark compressed code symbols so
 694 # that they can be treated in the appropriate manner in the processing of
 695 # the main symbol table and DWARF-2 records.
 696 F;void;elf_make_msymbol_special;asymbol *sym, struct minimal_symbol *msym;sym, msym
 697 f;void;coff_make_msymbol_special;int val, struct minimal_symbol *msym;val, msym;;default_coff_make_msymbol_special;;0
 698 # Process a symbol in the main symbol table in a backend-specific way.
 699 # Normally this hook is supposed to do nothing, however if required,
 700 # then this hook can be used to apply tranformations to symbols that
 701 # are considered special in some way.  This is currently used by the
 702 # MIPS backend to make sure compressed code symbols have the ISA bit
 703 # set.  This in turn is needed for symbol values seen in GDB to match
 704 # the values used at the runtime by the program itself, for function
 705 # and label references.
 706 f;void;make_symbol_special;struct symbol *sym, struct objfile *objfile;sym, objfile;;default_make_symbol_special;;0
 707 # Adjust the address retrieved from a DWARF-2 record other than a line
 708 # entry in a backend-specific way.  Normally this hook is supposed to
 709 # return the address passed unchanged, however if that is incorrect for
 710 # any reason, then this hook can be used to fix the address up in the
 711 # required manner.  This is currently used by the MIPS backend to make
 712 # sure addresses in FDE, range records, etc. referring to compressed
 713 # code have the ISA bit set, matching line information and the symbol
 714 # table.
 715 f;CORE_ADDR;adjust_dwarf2_addr;CORE_ADDR pc;pc;;default_adjust_dwarf2_addr;;0
 716 # Adjust the address updated by a line entry in a backend-specific way.
 717 # Normally this hook is supposed to return the address passed unchanged,
 718 # however in the case of inconsistencies in these records, this hook can
 719 # be used to fix them up in the required manner.  This is currently used
 720 # by the MIPS backend to make sure all line addresses in compressed code
 721 # are presented with the ISA bit set, which is not always the case.  This
 722 # in turn ensures breakpoint addresses are correctly matched against the
 723 # stop PC.
 724 f;CORE_ADDR;adjust_dwarf2_line;CORE_ADDR addr, int rel;addr, rel;;default_adjust_dwarf2_line;;0
 725 v;int;cannot_step_breakpoint;;;0;0;;0
 726 # See comment in target.h about continuable, steppable and
 727 # non-steppable watchpoints.
 728 v;int;have_nonsteppable_watchpoint;;;0;0;;0
 729 F;int;address_class_type_flags;int byte_size, int dwarf2_addr_class;byte_size, dwarf2_addr_class
 730 M;const char *;address_class_type_flags_to_name;int type_flags;type_flags
 731 # Execute vendor-specific DWARF Call Frame Instruction.  OP is the instruction.
 732 # FS are passed from the generic execute_cfa_program function.
 733 m;bool;execute_dwarf_cfa_vendor_op;gdb_byte op, struct dwarf2_frame_state *fs;op, fs;;default_execute_dwarf_cfa_vendor_op;;0
 734
 735 # Return the appropriate type_flags for the supplied address class.
 736 # This function should return 1 if the address class was recognized and
 737 # type_flags was set, zero otherwise.
 738 M;int;address_class_name_to_type_flags;const char *name, int *type_flags_ptr;name, type_flags_ptr
 739 # Is a register in a group
 740 m;int;register_reggroup_p;int regnum, struct reggroup *reggroup;regnum, reggroup;;default_register_reggroup_p;;0
 741 # Fetch the pointer to the ith function argument.
 742 F;CORE_ADDR;fetch_pointer_argument;struct frame_info *frame, int argi, struct type *type;frame, argi, type
 743
 744 # Iterate over all supported register notes in a core file.  For each
 745 # supported register note section, the iterator must call CB and pass
 746 # CB_DATA unchanged.  If REGCACHE is not NULL, the iterator can limit
 747 # the supported register note sections based on the current register
 748 # values.  Otherwise it should enumerate all supported register note
 749 # sections.
 750 M;void;iterate_over_regset_sections;iterate_over_regset_sections_cb *cb, void *cb_data, const struct regcache *regcache;cb, cb_data, regcache
 751
 752 # Create core file notes
 753 M;char *;make_corefile_notes;bfd *obfd, int *note_size;obfd, note_size
 754
 755 # Find core file memory regions
 756 M;int;find_memory_regions;find_memory_region_ftype func, void *data;func, data
 757
 758 # Read offset OFFSET of TARGET_OBJECT_LIBRARIES formatted shared libraries list from
 759 # core file into buffer READBUF with length LEN.  Return the number of bytes read
 760 # (zero indicates failure).
 761 # failed, otherwise, return the red length of READBUF.
 762 M;ULONGEST;core_xfer_shared_libraries;gdb_byte *readbuf, ULONGEST offset, ULONGEST len;readbuf, offset, len
 763
 764 # Read offset OFFSET of TARGET_OBJECT_LIBRARIES_AIX formatted shared
 765 # libraries list from core file into buffer READBUF with length LEN.
 766 # Return the number of bytes read (zero indicates failure).
 767 M;ULONGEST;core_xfer_shared_libraries_aix;gdb_byte *readbuf, ULONGEST offset, ULONGEST len;readbuf, offset, len
 768
 769 # How the core target converts a PTID from a core file to a string.
 770 M;std::string;core_pid_to_str;ptid_t ptid;ptid
 771
 772 # How the core target extracts the name of a thread from a core file.
 773 M;const char *;core_thread_name;struct thread_info *thr;thr
 774
 775 # Read offset OFFSET of TARGET_OBJECT_SIGNAL_INFO signal information
 776 # from core file into buffer READBUF with length LEN.  Return the number
 777 # of bytes read (zero indicates EOF, a negative value indicates failure).
 778 M;LONGEST;core_xfer_siginfo;gdb_byte *readbuf, ULONGEST offset, ULONGEST len; readbuf, offset, len
 779
 780 # BFD target to use when generating a core file.
 781 V;const char *;gcore_bfd_target;;;0;0;;;pstring (gdbarch->gcore_bfd_target)
 782
 783 # If the elements of C++ vtables are in-place function descriptors rather
 784 # than normal function pointers (which may point to code or a descriptor),
 785 # set this to one.
 786 v;int;vtable_function_descriptors;;;0;0;;0
 787
 788 # Set if the least significant bit of the delta is used instead of the least
 789 # significant bit of the pfn for pointers to virtual member functions.
 790 v;int;vbit_in_delta;;;0;0;;0
 791
 792 # Advance PC to next instruction in order to skip a permanent breakpoint.
 793 f;void;skip_permanent_breakpoint;struct regcache *regcache;regcache;default_skip_permanent_breakpoint;default_skip_permanent_breakpoint;;0
 794
 795 # The maximum length of an instruction on this architecture in bytes.
 796 V;ULONGEST;max_insn_length;;;0;0
 797
 798 # Copy the instruction at FROM to TO, and make any adjustments
 799 # necessary to single-step it at that address.
 800 #
 801 # REGS holds the state the thread's registers will have before
 802 # executing the copied instruction; the PC in REGS will refer to FROM,
 803 # not the copy at TO.  The caller should update it to point at TO later.
 804 #
 805 # Return a pointer to data of the architecture's choice to be passed
 806 # to gdbarch_displaced_step_fixup.  Or, return NULL to indicate that
 807 # the instruction's effects have been completely simulated, with the
 808 # resulting state written back to REGS.
 809 #
 810 # For a general explanation of displaced stepping and how GDB uses it,
 811 # see the comments in infrun.c.
 812 #
 813 # The TO area is only guaranteed to have space for
 814 # gdbarch_max_insn_length (arch) bytes, so this function must not
 815 # write more bytes than that to that area.
 816 #
 817 # If you do not provide this function, GDB assumes that the
 818 # architecture does not support displaced stepping.
 819 #
 820 # If the instruction cannot execute out of line, return NULL.  The
 821 # core falls back to stepping past the instruction in-line instead in
 822 # that case.
 823 M;struct displaced_step_closure *;displaced_step_copy_insn;CORE_ADDR from, CORE_ADDR to, struct regcache *regs;from, to, regs
 824
 825 # Return true if GDB should use hardware single-stepping to execute
 826 # the displaced instruction identified by CLOSURE.  If false,
 827 # GDB will simply restart execution at the displaced instruction
 828 # location, and it is up to the target to ensure GDB will receive
 829 # control again (e.g. by placing a software breakpoint instruction
 830 # into the displaced instruction buffer).
 831 #
 832 # The default implementation returns false on all targets that
 833 # provide a gdbarch_software_single_step routine, and true otherwise.
 834 m;int;displaced_step_hw_singlestep;struct displaced_step_closure *closure;closure;;default_displaced_step_hw_singlestep;;0
 835
 836 # Fix up the state resulting from successfully single-stepping a
 837 # displaced instruction, to give the result we would have gotten from
 838 # stepping the instruction in its original location.
 839 #
 840 # REGS is the register state resulting from single-stepping the
 841 # displaced instruction.
 842 #
 843 # CLOSURE is the result from the matching call to
 844 # gdbarch_displaced_step_copy_insn.
 845 #
 846 # If you provide gdbarch_displaced_step_copy_insn.but not this
 847 # function, then GDB assumes that no fixup is needed after
 848 # single-stepping the instruction.
 849 #
 850 # For a general explanation of displaced stepping and how GDB uses it,
 851 # see the comments in infrun.c.
 852 M;void;displaced_step_fixup;struct displaced_step_closure *closure, CORE_ADDR from, CORE_ADDR to, struct regcache *regs;closure, from, to, regs;;NULL
 853
 854 # Return the address of an appropriate place to put displaced
 855 # instructions while we step over them.  There need only be one such
 856 # place, since we're only stepping one thread over a breakpoint at a
 857 # time.
 858 #
 859 # For a general explanation of displaced stepping and how GDB uses it,
 860 # see the comments in infrun.c.
 861 m;CORE_ADDR;displaced_step_location;void;;;NULL;;(! gdbarch->displaced_step_location) != (! gdbarch->displaced_step_copy_insn)
 862
 863 # Relocate an instruction to execute at a different address.  OLDLOC
 864 # is the address in the inferior memory where the instruction to
 865 # relocate is currently at.  On input, TO points to the destination
 866 # where we want the instruction to be copied (and possibly adjusted)
 867 # to.  On output, it points to one past the end of the resulting
 868 # instruction(s).  The effect of executing the instruction at TO shall
 869 # be the same as if executing it at FROM.  For example, call
 870 # instructions that implicitly push the return address on the stack
 871 # should be adjusted to return to the instruction after OLDLOC;
 872 # relative branches, and other PC-relative instructions need the
 873 # offset adjusted; etc.
 874 M;void;relocate_instruction;CORE_ADDR *to, CORE_ADDR from;to, from;;NULL
 875
 876 # Refresh overlay mapped state for section OSECT.
 877 F;void;overlay_update;struct obj_section *osect;osect
 878
 879 M;const struct target_desc *;core_read_description;struct target_ops *target, bfd *abfd;target, abfd
 880
 881 # Handle special encoding of static variables in stabs debug info.
 882 F;const char *;static_transform_name;const char *name;name
 883 # Set if the address in N_SO or N_FUN stabs may be zero.
 884 v;int;sofun_address_maybe_missing;;;0;0;;0
 885
 886 # Parse the instruction at ADDR storing in the record execution log
 887 # the registers REGCACHE and memory ranges that will be affected when
 888 # the instruction executes, along with their current values.
 889 # Return -1 if something goes wrong, 0 otherwise.
 890 M;int;process_record;struct regcache *regcache, CORE_ADDR addr;regcache, addr
 891
 892 # Save process state after a signal.
 893 # Return -1 if something goes wrong, 0 otherwise.
 894 M;int;process_record_signal;struct regcache *regcache, enum gdb_signal signal;regcache, signal
 895
 896 # Signal translation: translate inferior's signal (target's) number
 897 # into GDB's representation.  The implementation of this method must
 898 # be host independent.  IOW, don't rely on symbols of the NAT_FILE
 899 # header (the nm-*.h files), the host <signal.h> header, or similar
 900 # headers.  This is mainly used when cross-debugging core files ---
 901 # "Live" targets hide the translation behind the target interface
 902 # (target_wait, target_resume, etc.).
 903 M;enum gdb_signal;gdb_signal_from_target;int signo;signo
 904
 905 # Signal translation: translate the GDB's internal signal number into
 906 # the inferior's signal (target's) representation.  The implementation
 907 # of this method must be host independent.  IOW, don't rely on symbols
 908 # of the NAT_FILE header (the nm-*.h files), the host <signal.h>
 909 # header, or similar headers.
 910 # Return the target signal number if found, or -1 if the GDB internal
 911 # signal number is invalid.
 912 M;int;gdb_signal_to_target;enum gdb_signal signal;signal
 913
 914 # Extra signal info inspection.
 915 #
 916 # Return a type suitable to inspect extra signal information.
 917 M;struct type *;get_siginfo_type;void;
 918
 919 # Record architecture-specific information from the symbol table.
 920 M;void;record_special_symbol;struct objfile *objfile, asymbol *sym;objfile, sym
 921
 922 # Function for the 'catch syscall' feature.
 923
 924 # Get architecture-specific system calls information from registers.
 925 M;LONGEST;get_syscall_number;thread_info *thread;thread
 926
 927 # The filename of the XML syscall for this architecture.
 928 v;const char *;xml_syscall_file;;;0;0;;0;pstring (gdbarch->xml_syscall_file)
 929
 930 # Information about system calls from this architecture
 931 v;struct syscalls_info *;syscalls_info;;;0;0;;0;host_address_to_string (gdbarch->syscalls_info)
 932
 933 # SystemTap related fields and functions.
 934
 935 # A NULL-terminated array of prefixes used to mark an integer constant
 936 # on the architecture's assembly.
 937 # For example, on x86 integer constants are written as:
 938 #
 939 #  \$10 ;; integer constant 10
 940 #
 941 # in this case, this prefix would be the character \`\$\'.
 942 v;const char *const *;stap_integer_prefixes;;;0;0;;0;pstring_list (gdbarch->stap_integer_prefixes)
 943
 944 # A NULL-terminated array of suffixes used to mark an integer constant
 945 # on the architecture's assembly.
 946 v;const char *const *;stap_integer_suffixes;;;0;0;;0;pstring_list (gdbarch->stap_integer_suffixes)
 947
 948 # A NULL-terminated array of prefixes used to mark a register name on
 949 # the architecture's assembly.
 950 # For example, on x86 the register name is written as:
 951 #
 952 #  \%eax ;; register eax
 953 #
 954 # in this case, this prefix would be the character \`\%\'.
 955 v;const char *const *;stap_register_prefixes;;;0;0;;0;pstring_list (gdbarch->stap_register_prefixes)
 956
 957 # A NULL-terminated array of suffixes used to mark a register name on
 958 # the architecture's assembly.
 959 v;const char *const *;stap_register_suffixes;;;0;0;;0;pstring_list (gdbarch->stap_register_suffixes)
 960
 961 # A NULL-terminated array of prefixes used to mark a register
 962 # indirection on the architecture's assembly.
 963 # For example, on x86 the register indirection is written as:
 964 #
 965 #  \(\%eax\) ;; indirecting eax
 966 #
 967 # in this case, this prefix would be the charater \`\(\'.
 968 #
 969 # Please note that we use the indirection prefix also for register
 970 # displacement, e.g., \`4\(\%eax\)\' on x86.
 971 v;const char *const *;stap_register_indirection_prefixes;;;0;0;;0;pstring_list (gdbarch->stap_register_indirection_prefixes)
 972
 973 # A NULL-terminated array of suffixes used to mark a register
 974 # indirection on the architecture's assembly.
 975 # For example, on x86 the register indirection is written as:
 976 #
 977 #  \(\%eax\) ;; indirecting eax
 978 #
 979 # in this case, this prefix would be the charater \`\)\'.
 980 #
 981 # Please note that we use the indirection suffix also for register
 982 # displacement, e.g., \`4\(\%eax\)\' on x86.
 983 v;const char *const *;stap_register_indirection_suffixes;;;0;0;;0;pstring_list (gdbarch->stap_register_indirection_suffixes)
 984
 985 # Prefix(es) used to name a register using GDB's nomenclature.
 986 #
 987 # For example, on PPC a register is represented by a number in the assembly
 988 # language (e.g., \`10\' is the 10th general-purpose register).  However,
 989 # inside GDB this same register has an \`r\' appended to its name, so the 10th
 990 # register would be represented as \`r10\' internally.
 991 v;const char *;stap_gdb_register_prefix;;;0;0;;0;pstring (gdbarch->stap_gdb_register_prefix)
 992
 993 # Suffix used to name a register using GDB's nomenclature.
 994 v;const char *;stap_gdb_register_suffix;;;0;0;;0;pstring (gdbarch->stap_gdb_register_suffix)
 995
 996 # Check if S is a single operand.
 997 #
 998 # Single operands can be:
 999 #  \- Literal integers, e.g. \`\$10\' on x86
1000 #  \- Register access, e.g. \`\%eax\' on x86
1001 #  \- Register indirection, e.g. \`\(\%eax\)\' on x86
1002 #  \- Register displacement, e.g. \`4\(\%eax\)\' on x86
1003 #
1004 # This function should check for these patterns on the string
1005 # and return 1 if some were found, or zero otherwise.  Please try to match
1006 # as much info as you can from the string, i.e., if you have to match
1007 # something like \`\(\%\', do not match just the \`\(\'.
1008 M;int;stap_is_single_operand;const char *s;s
1009
1010 # Function used to handle a "special case" in the parser.
1011 #
1012 # A "special case" is considered to be an unknown token, i.e., a token
1013 # that the parser does not know how to parse.  A good example of special
1014 # case would be ARM's register displacement syntax:
1015 #
1016 #  [R0, #4]  ;; displacing R0 by 4
1017 #
1018 # Since the parser assumes that a register displacement is of the form:
1019 #
1020 #  <number> <indirection_prefix> <register_name> <indirection_suffix>
1021 #
1022 # it means that it will not be able to recognize and parse this odd syntax.
1023 # Therefore, we should add a special case function that will handle this token.
1024 #
1025 # This function should generate the proper expression form of the expression
1026 # using GDB\'s internal expression mechanism (e.g., \`write_exp_elt_opcode\'
1027 # and so on).  It should also return 1 if the parsing was successful, or zero
1028 # if the token was not recognized as a special token (in this case, returning
1029 # zero means that the special parser is deferring the parsing to the generic
1030 # parser), and should advance the buffer pointer (p->arg).
1031 M;int;stap_parse_special_token;struct stap_parse_info *p;p
1032
1033 # DTrace related functions.
1034
1035 # The expression to compute the NARTGth+1 argument to a DTrace USDT probe.
1036 # NARG must be >= 0.
1037 M;void;dtrace_parse_probe_argument;struct parser_state *pstate, int narg;pstate, narg
1038
1039 # True if the given ADDR does not contain the instruction sequence
1040 # corresponding to a disabled DTrace is-enabled probe.
1041 M;int;dtrace_probe_is_enabled;CORE_ADDR addr;addr
1042
1043 # Enable a DTrace is-enabled probe at ADDR.
1044 M;void;dtrace_enable_probe;CORE_ADDR addr;addr
1045
1046 # Disable a DTrace is-enabled probe at ADDR.
1047 M;void;dtrace_disable_probe;CORE_ADDR addr;addr
1048
1049 # True if the list of shared libraries is one and only for all
1050 # processes, as opposed to a list of shared libraries per inferior.
1051 # This usually means that all processes, although may or may not share
1052 # an address space, will see the same set of symbols at the same
1053 # addresses.
1054 v;int;has_global_solist;;;0;0;;0
1055
1056 # On some targets, even though each inferior has its own private
1057 # address space, the debug interface takes care of making breakpoints
1058 # visible to all address spaces automatically.  For such cases,
1059 # this property should be set to true.
1060 v;int;has_global_breakpoints;;;0;0;;0
1061
1062 # True if inferiors share an address space (e.g., uClinux).
1063 m;int;has_shared_address_space;void;;;default_has_shared_address_space;;0
1064
1065 # True if a fast tracepoint can be set at an address.
1066 m;int;fast_tracepoint_valid_at;CORE_ADDR addr, std::string *msg;addr, msg;;default_fast_tracepoint_valid_at;;0
1067
1068 # Guess register state based on tracepoint location.  Used for tracepoints
1069 # where no registers have been collected, but there's only one location,
1070 # allowing us to guess the PC value, and perhaps some other registers.
1071 # On entry, regcache has all registers marked as unavailable.
1072 m;void;guess_tracepoint_registers;struct regcache *regcache, CORE_ADDR addr;regcache, addr;;default_guess_tracepoint_registers;;0
1073
1074 # Return the "auto" target charset.
1075 f;const char *;auto_charset;void;;default_auto_charset;default_auto_charset;;0
1076 # Return the "auto" target wide charset.
1077 f;const char *;auto_wide_charset;void;;default_auto_wide_charset;default_auto_wide_charset;;0
1078
1079 # If non-empty, this is a file extension that will be opened in place
1080 # of the file extension reported by the shared library list.
1081 #
1082 # This is most useful for toolchains that use a post-linker tool,
1083 # where the names of the files run on the target differ in extension
1084 # compared to the names of the files GDB should load for debug info.
1085 v;const char *;solib_symbols_extension;;;;;;;pstring (gdbarch->solib_symbols_extension)
1086
1087 # If true, the target OS has DOS-based file system semantics.  That
1088 # is, absolute paths include a drive name, and the backslash is
1089 # considered a directory separator.
1090 v;int;has_dos_based_file_system;;;0;0;;0
1091
1092 # Generate bytecodes to collect the return address in a frame.
1093 # Since the bytecodes run on the target, possibly with GDB not even
1094 # connected, the full unwinding machinery is not available, and
1095 # typically this function will issue bytecodes for one or more likely
1096 # places that the return address may be found.
1097 m;void;gen_return_address;struct agent_expr *ax, struct axs_value *value, CORE_ADDR scope;ax, value, scope;;default_gen_return_address;;0
1098
1099 # Implement the "info proc" command.
1100 M;void;info_proc;const char *args, enum info_proc_what what;args, what
1101
1102 # Implement the "info proc" command for core files.  Noe that there
1103 # are two "info_proc"-like methods on gdbarch -- one for core files,
1104 # one for live targets.
1105 M;void;core_info_proc;const char *args, enum info_proc_what what;args, what
1106
1107 # Iterate over all objfiles in the order that makes the most sense
1108 # for the architecture to make global symbol searches.
1109 #
1110 # CB is a callback function where OBJFILE is the objfile to be searched,
1111 # and CB_DATA a pointer to user-defined data (the same data that is passed
1112 # when calling this gdbarch method).  The iteration stops if this function
1113 # returns nonzero.
1114 #
1115 # CB_DATA is a pointer to some user-defined data to be passed to
1116 # the callback.
1117 #
1118 # If not NULL, CURRENT_OBJFILE corresponds to the objfile being
1119 # inspected when the symbol search was requested.
1120 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
1121
1122 # Ravenscar arch-dependent ops.
1123 v;struct ravenscar_arch_ops *;ravenscar_ops;;;NULL;NULL;;0;host_address_to_string (gdbarch->ravenscar_ops)
1124
1125 # Return non-zero if the instruction at ADDR is a call; zero otherwise.
1126 m;int;insn_is_call;CORE_ADDR addr;addr;;default_insn_is_call;;0
1127
1128 # Return non-zero if the instruction at ADDR is a return; zero otherwise.
1129 m;int;insn_is_ret;CORE_ADDR addr;addr;;default_insn_is_ret;;0
1130
1131 # Return non-zero if the instruction at ADDR is a jump; zero otherwise.
1132 m;int;insn_is_jump;CORE_ADDR addr;addr;;default_insn_is_jump;;0
1133
1134 # Read one auxv entry from *READPTR, not reading locations >= ENDPTR.
1135 # Return 0 if *READPTR is already at the end of the buffer.
1136 # Return -1 if there is insufficient buffer for a whole entry.
1137 # Return 1 if an entry was read into *TYPEP and *VALP.
1138 M;int;auxv_parse;gdb_byte **readptr, gdb_byte *endptr, CORE_ADDR *typep, CORE_ADDR *valp;readptr, endptr, typep, valp
1139
1140 # Print the description of a single auxv entry described by TYPE and VAL
1141 # to FILE.
1142 m;void;print_auxv_entry;struct ui_file *file, CORE_ADDR type, CORE_ADDR val;file, type, val;;default_print_auxv_entry;;0
1143
1144 # Find the address range of the current inferior's vsyscall/vDSO, and
1145 # write it to *RANGE.  If the vsyscall's length can't be determined, a
1146 # range with zero length is returned.  Returns true if the vsyscall is
1147 # found, false otherwise.
1148 m;int;vsyscall_range;struct mem_range *range;range;;default_vsyscall_range;;0
1149
1150 # Allocate SIZE bytes of PROT protected page aligned memory in inferior.
1151 # PROT has GDB_MMAP_PROT_* bitmask format.
1152 # Throw an error if it is not possible.  Returned address is always valid.
1153 f;CORE_ADDR;infcall_mmap;CORE_ADDR size, unsigned prot;size, prot;;default_infcall_mmap;;0
1154
1155 # Deallocate SIZE bytes of memory at ADDR in inferior from gdbarch_infcall_mmap.
1156 # Print a warning if it is not possible.
1157 f;void;infcall_munmap;CORE_ADDR addr, CORE_ADDR size;addr, size;;default_infcall_munmap;;0
1158
1159 # Return string (caller has to use xfree for it) with options for GCC
1160 # to produce code for this target, typically "-m64", "-m32" or "-m31".
1161 # These options are put before CU's DW_AT_producer compilation options so that
1162 # they can override it.  Method may also return NULL.
1163 m;char *;gcc_target_options;void;;;default_gcc_target_options;;0
1164
1165 # Return a regular expression that matches names used by this
1166 # architecture in GNU configury triplets.  The result is statically
1167 # allocated and must not be freed.  The default implementation simply
1168 # returns the BFD architecture name, which is correct in nearly every
1169 # case.
1170 m;const char *;gnu_triplet_regexp;void;;;default_gnu_triplet_regexp;;0
1171
1172 # Return the size in 8-bit bytes of an addressable memory unit on this
1173 # architecture.  This corresponds to the number of 8-bit bytes associated to
1174 # each address in memory.
1175 m;int;addressable_memory_unit_size;void;;;default_addressable_memory_unit_size;;0
1176
1177 # Functions for allowing a target to modify its disassembler options.
1178 v;const char *;disassembler_options_implicit;;;0;0;;0;pstring (gdbarch->disassembler_options_implicit)
1179 v;char **;disassembler_options;;;0;0;;0;pstring_ptr (gdbarch->disassembler_options)
1180 v;const disasm_options_and_args_t *;valid_disassembler_options;;;0;0;;0;host_address_to_string (gdbarch->valid_disassembler_options)
1181
1182 # Type alignment override method.  Return the architecture specific
1183 # alignment required for TYPE.  If there is no special handling
1184 # required for TYPE then return the value 0, GDB will then apply the
1185 # default rules as laid out in gdbtypes.c:type_align.
1186 m;ULONGEST;type_align;struct type *type;type;;default_type_align;;0
1187
1188 EOF
1189 }
1190
1191 #
1192 # The .log file
1193 #
1194 exec > new-gdbarch.log
1195 function_list | while do_read
1196 do
1197     cat <<EOF
1198 ${class} ${returntype} ${function} ($formal)
1199 EOF
1200     for r in ${read}
1201     do
1202         eval echo \"\ \ \ \ ${r}=\${${r}}\"
1203     done
1204     if class_is_predicate_p && fallback_default_p
1205     then
1206         echo "Error: predicate function ${function} can not have a non- multi-arch default" 1>&2
1207         kill $$
1208         exit 1
1209     fi
1210     if [ "x${invalid_p}" = "x0" -a -n "${postdefault}" ]
1211     then
1212         echo "Error: postdefault is useless when invalid_p=0" 1>&2
1213         kill $$
1214         exit 1
1215     fi
1216     if class_is_multiarch_p
1217     then
1218         if class_is_predicate_p ; then :
1219         elif test "x${predefault}" = "x"
1220         then
1221             echo "Error: pure multi-arch function ${function} must have a predefault" 1>&2
1222             kill $$
1223             exit 1
1224         fi
1225     fi
1226     echo ""
1227 done
1228
1229 exec 1>&2
1230 compare_new gdbarch.log
1231
1232
1233 copyright ()
1234 {
1235 cat <<EOF
1236 /* *INDENT-OFF* */ /* THIS FILE IS GENERATED -*- buffer-read-only: t -*- */
1237 /* vi:set ro: */
1238
1239 /* Dynamic architecture support for GDB, the GNU debugger.
1240
1241    Copyright (C) 1998-2019 Free Software Foundation, Inc.
1242
1243    This file is part of GDB.
1244
1245    This program is free software; you can redistribute it and/or modify
1246    it under the terms of the GNU General Public License as published by
1247    the Free Software Foundation; either version 3 of the License, or
1248    (at your option) any later version.
1249
1250    This program is distributed in the hope that it will be useful,
1251    but WITHOUT ANY WARRANTY; without even the implied warranty of
1252    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
1253    GNU General Public License for more details.
1254
1255    You should have received a copy of the GNU General Public License
1256    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
1257
1258 /* This file was created with the aid of \`\`gdbarch.sh''.
1259
1260    The Bourne shell script \`\`gdbarch.sh'' creates the files
1261    \`\`new-gdbarch.c'' and \`\`new-gdbarch.h and then compares them
1262    against the existing \`\`gdbarch.[hc]''.  Any differences found
1263    being reported.
1264
1265    If editing this file, please also run gdbarch.sh and merge any
1266    changes into that script. Conversely, when making sweeping changes
1267    to this file, modifying gdbarch.sh and using its output may prove
1268    easier.  */
1269
1270 EOF
1271 }
1272
1273 #
1274 # The .h file
1275 #
1276
1277 exec > new-gdbarch.h
1278 copyright
1279 cat <<EOF
1280 #ifndef GDBARCH_H
1281 #define GDBARCH_H
1282
1283 #include <vector>
1284 #include "frame.h"
1285 #include "dis-asm.h"
1286 #include "gdb_obstack.h"
1287
1288 struct floatformat;
1289 struct ui_file;
1290 struct value;
1291 struct objfile;
1292 struct obj_section;
1293 struct minimal_symbol;
1294 struct regcache;
1295 struct reggroup;
1296 struct regset;
1297 struct disassemble_info;
1298 struct target_ops;
1299 struct obstack;
1300 struct bp_target_info;
1301 struct target_desc;
1302 struct symbol;
1303 struct displaced_step_closure;
1304 struct syscall;
1305 struct agent_expr;
1306 struct axs_value;
1307 struct stap_parse_info;
1308 struct parser_state;
1309 struct ravenscar_arch_ops;
1310 struct mem_range;
1311 struct syscalls_info;
1312 struct thread_info;
1313 struct ui_out;
1314
1315 #include "regcache.h"
1316
1317 /* The architecture associated with the inferior through the
1318    connection to the target.
1319
1320    The architecture vector provides some information that is really a
1321    property of the inferior, accessed through a particular target:
1322    ptrace operations; the layout of certain RSP packets; the solib_ops
1323    vector; etc.  To differentiate architecture accesses to
1324    per-inferior/target properties from
1325    per-thread/per-frame/per-objfile properties, accesses to
1326    per-inferior/target properties should be made through this
1327    gdbarch.  */
1328
1329 /* This is a convenience wrapper for 'current_inferior ()->gdbarch'.  */
1330 extern struct gdbarch *target_gdbarch (void);
1331
1332 /* Callback type for the 'iterate_over_objfiles_in_search_order'
1333    gdbarch  method.  */
1334
1335 typedef int (iterate_over_objfiles_in_search_order_cb_ftype)
1336   (struct objfile *objfile, void *cb_data);
1337
1338 /* Callback type for regset section iterators.  The callback usually
1339    invokes the REGSET's supply or collect method, to which it must
1340    pass a buffer - for collects this buffer will need to be created using
1341    COLLECT_SIZE, for supply the existing buffer being read from should
1342    be at least SUPPLY_SIZE.  SECT_NAME is a BFD section name, and HUMAN_NAME
1343    is used for diagnostic messages.  CB_DATA should have been passed
1344    unchanged through the iterator.  */
1345
1346 typedef void (iterate_over_regset_sections_cb)
1347   (const char *sect_name, int supply_size, int collect_size,
1348    const struct regset *regset, const char *human_name, void *cb_data);
1349
1350 /* For a function call, does the function return a value using a
1351    normal value return or a structure return - passing a hidden
1352    argument pointing to storage.  For the latter, there are two
1353    cases: language-mandated structure return and target ABI
1354    structure return.  */
1355
1356 enum function_call_return_method
1357 {
1358   /* Standard value return.  */
1359   return_method_normal = 0,
1360
1361   /* Language ABI structure return.  This is handled
1362      by passing the return location as the first parameter to
1363      the function, even preceding "this".  */
1364   return_method_hidden_param,
1365
1366   /* Target ABI struct return.  This is target-specific; for instance,
1367      on ia64 the first argument is passed in out0 but the hidden
1368      structure return pointer would normally be passed in r8.  */
1369   return_method_struct,
1370 };
1371
1372 EOF
1373
1374 # function typedef's
1375 printf "\n"
1376 printf "\n"
1377 printf "/* The following are pre-initialized by GDBARCH.  */\n"
1378 function_list | while do_read
1379 do
1380     if class_is_info_p
1381     then
1382         printf "\n"
1383         printf "extern ${returntype} gdbarch_${function} (struct gdbarch *gdbarch);\n"
1384         printf "/* set_gdbarch_${function}() - not applicable - pre-initialized.  */\n"
1385     fi
1386 done
1387
1388 # function typedef's
1389 printf "\n"
1390 printf "\n"
1391 printf "/* The following are initialized by the target dependent code.  */\n"
1392 function_list | while do_read
1393 do
1394     if [ -n "${comment}" ]
1395     then
1396         echo "${comment}" | sed \
1397             -e '2 s,#,/*,' \
1398             -e '3,$ s,#,  ,' \
1399             -e '$ s,$, */,'
1400     fi
1401
1402     if class_is_predicate_p
1403     then
1404         printf "\n"
1405         printf "extern int gdbarch_${function}_p (struct gdbarch *gdbarch);\n"
1406     fi
1407     if class_is_variable_p
1408     then
1409         printf "\n"
1410         printf "extern ${returntype} gdbarch_${function} (struct gdbarch *gdbarch);\n"
1411         printf "extern void set_gdbarch_${function} (struct gdbarch *gdbarch, ${returntype} ${function});\n"
1412     fi
1413     if class_is_function_p
1414     then
1415         printf "\n"
1416         if [ "x${formal}" = "xvoid" ] && class_is_multiarch_p
1417         then
1418             printf "typedef ${returntype} (gdbarch_${function}_ftype) (struct gdbarch *gdbarch);\n"
1419         elif class_is_multiarch_p
1420         then
1421             printf "typedef ${returntype} (gdbarch_${function}_ftype) (struct gdbarch *gdbarch, ${formal});\n"
1422         else
1423             printf "typedef ${returntype} (gdbarch_${function}_ftype) (${formal});\n"
1424         fi
1425         if [ "x${formal}" = "xvoid" ]
1426         then
1427           printf "extern ${returntype} gdbarch_${function} (struct gdbarch *gdbarch);\n"
1428         else
1429           printf "extern ${returntype} gdbarch_${function} (struct gdbarch *gdbarch, ${formal});\n"
1430         fi
1431         printf "extern void set_gdbarch_${function} (struct gdbarch *gdbarch, gdbarch_${function}_ftype *${function});\n"
1432     fi
1433 done
1434
1435 # close it off
1436 cat <<EOF
1437
1438 extern struct gdbarch_tdep *gdbarch_tdep (struct gdbarch *gdbarch);
1439
1440
1441 /* Mechanism for co-ordinating the selection of a specific
1442    architecture.
1443
1444    GDB targets (*-tdep.c) can register an interest in a specific
1445    architecture.  Other GDB components can register a need to maintain
1446    per-architecture data.
1447
1448    The mechanisms below ensures that there is only a loose connection
1449    between the set-architecture command and the various GDB
1450    components.  Each component can independently register their need
1451    to maintain architecture specific data with gdbarch.
1452
1453    Pragmatics:
1454
1455    Previously, a single TARGET_ARCHITECTURE_HOOK was provided.  It
1456    didn't scale.
1457
1458    The more traditional mega-struct containing architecture specific
1459    data for all the various GDB components was also considered.  Since
1460    GDB is built from a variable number of (fairly independent)
1461    components it was determined that the global aproach was not
1462    applicable.  */
1463
1464
1465 /* Register a new architectural family with GDB.
1466
1467    Register support for the specified ARCHITECTURE with GDB.  When
1468    gdbarch determines that the specified architecture has been
1469    selected, the corresponding INIT function is called.
1470
1471    --
1472
1473    The INIT function takes two parameters: INFO which contains the
1474    information available to gdbarch about the (possibly new)
1475    architecture; ARCHES which is a list of the previously created
1476    \`\`struct gdbarch'' for this architecture.
1477
1478    The INFO parameter is, as far as possible, be pre-initialized with
1479    information obtained from INFO.ABFD or the global defaults.
1480
1481    The ARCHES parameter is a linked list (sorted most recently used)
1482    of all the previously created architures for this architecture
1483    family.  The (possibly NULL) ARCHES->gdbarch can used to access
1484    values from the previously selected architecture for this
1485    architecture family.
1486
1487    The INIT function shall return any of: NULL - indicating that it
1488    doesn't recognize the selected architecture; an existing \`\`struct
1489    gdbarch'' from the ARCHES list - indicating that the new
1490    architecture is just a synonym for an earlier architecture (see
1491    gdbarch_list_lookup_by_info()); a newly created \`\`struct gdbarch''
1492    - that describes the selected architecture (see gdbarch_alloc()).
1493
1494    The DUMP_TDEP function shall print out all target specific values.
1495    Care should be taken to ensure that the function works in both the
1496    multi-arch and non- multi-arch cases.  */
1497
1498 struct gdbarch_list
1499 {
1500   struct gdbarch *gdbarch;
1501   struct gdbarch_list *next;
1502 };
1503
1504 struct gdbarch_info
1505 {
1506   /* Use default: NULL (ZERO).  */
1507   const struct bfd_arch_info *bfd_arch_info;
1508
1509   /* Use default: BFD_ENDIAN_UNKNOWN (NB: is not ZERO).  */
1510   enum bfd_endian byte_order;
1511
1512   enum bfd_endian byte_order_for_code;
1513
1514   /* Use default: NULL (ZERO).  */
1515   bfd *abfd;
1516
1517   /* Use default: NULL (ZERO).  */
1518   union
1519     {
1520       /* Architecture-specific information.  The generic form for targets
1521          that have extra requirements.  */
1522       struct gdbarch_tdep_info *tdep_info;
1523
1524       /* Architecture-specific target description data.  Numerous targets
1525          need only this, so give them an easy way to hold it.  */
1526       struct tdesc_arch_data *tdesc_data;
1527
1528       /* SPU file system ID.  This is a single integer, so using the
1529          generic form would only complicate code.  Other targets may
1530          reuse this member if suitable.  */
1531       int *id;
1532     };
1533
1534   /* Use default: GDB_OSABI_UNINITIALIZED (-1).  */
1535   enum gdb_osabi osabi;
1536
1537   /* Use default: NULL (ZERO).  */
1538   const struct target_desc *target_desc;
1539 };
1540
1541 typedef struct gdbarch *(gdbarch_init_ftype) (struct gdbarch_info info, struct gdbarch_list *arches);
1542 typedef void (gdbarch_dump_tdep_ftype) (struct gdbarch *gdbarch, struct ui_file *file);
1543
1544 /* DEPRECATED - use gdbarch_register() */
1545 extern void register_gdbarch_init (enum bfd_architecture architecture, gdbarch_init_ftype *);
1546
1547 extern void gdbarch_register (enum bfd_architecture architecture,
1548                               gdbarch_init_ftype *,
1549                               gdbarch_dump_tdep_ftype *);
1550
1551
1552 /* Return a freshly allocated, NULL terminated, array of the valid
1553    architecture names.  Since architectures are registered during the
1554    _initialize phase this function only returns useful information
1555    once initialization has been completed.  */
1556
1557 extern const char **gdbarch_printable_names (void);
1558
1559
1560 /* Helper function.  Search the list of ARCHES for a GDBARCH that
1561    matches the information provided by INFO.  */
1562
1563 extern struct gdbarch_list *gdbarch_list_lookup_by_info (struct gdbarch_list *arches, const struct gdbarch_info *info);
1564
1565
1566 /* Helper function.  Create a preliminary \`\`struct gdbarch''.  Perform
1567    basic initialization using values obtained from the INFO and TDEP
1568    parameters.  set_gdbarch_*() functions are called to complete the
1569    initialization of the object.  */
1570
1571 extern struct gdbarch *gdbarch_alloc (const struct gdbarch_info *info, struct gdbarch_tdep *tdep);
1572
1573
1574 /* Helper function.  Free a partially-constructed \`\`struct gdbarch''.
1575    It is assumed that the caller freeds the \`\`struct
1576    gdbarch_tdep''.  */
1577
1578 extern void gdbarch_free (struct gdbarch *);
1579
1580 /* Get the obstack owned by ARCH.  */
1581
1582 extern obstack *gdbarch_obstack (gdbarch *arch);
1583
1584 /* Helper function.  Allocate memory from the \`\`struct gdbarch''
1585    obstack.  The memory is freed when the corresponding architecture
1586    is also freed.  */
1587
1588 #define GDBARCH_OBSTACK_CALLOC(GDBARCH, NR, TYPE) \
1589   obstack_calloc<TYPE> (gdbarch_obstack ((GDBARCH)), (NR))
1590
1591 #define GDBARCH_OBSTACK_ZALLOC(GDBARCH, TYPE) \
1592   obstack_zalloc<TYPE> (gdbarch_obstack ((GDBARCH)))
1593
1594 /* Duplicate STRING, returning an equivalent string that's allocated on the
1595    obstack associated with GDBARCH.  The string is freed when the corresponding
1596    architecture is also freed.  */
1597
1598 extern char *gdbarch_obstack_strdup (struct gdbarch *arch, const char *string);
1599
1600 /* Helper function.  Force an update of the current architecture.
1601
1602    The actual architecture selected is determined by INFO, \`\`(gdb) set
1603    architecture'' et.al., the existing architecture and BFD's default
1604    architecture.  INFO should be initialized to zero and then selected
1605    fields should be updated.
1606
1607    Returns non-zero if the update succeeds.  */
1608
1609 extern int gdbarch_update_p (struct gdbarch_info info);
1610
1611
1612 /* Helper function.  Find an architecture matching info.
1613
1614    INFO should be initialized using gdbarch_info_init, relevant fields
1615    set, and then finished using gdbarch_info_fill.
1616
1617    Returns the corresponding architecture, or NULL if no matching
1618    architecture was found.  */
1619
1620 extern struct gdbarch *gdbarch_find_by_info (struct gdbarch_info info);
1621
1622
1623 /* Helper function.  Set the target gdbarch to "gdbarch".  */
1624
1625 extern void set_target_gdbarch (struct gdbarch *gdbarch);
1626
1627
1628 /* Register per-architecture data-pointer.
1629
1630    Reserve space for a per-architecture data-pointer.  An identifier
1631    for the reserved data-pointer is returned.  That identifer should
1632    be saved in a local static variable.
1633
1634    Memory for the per-architecture data shall be allocated using
1635    gdbarch_obstack_zalloc.  That memory will be deleted when the
1636    corresponding architecture object is deleted.
1637
1638    When a previously created architecture is re-selected, the
1639    per-architecture data-pointer for that previous architecture is
1640    restored.  INIT() is not re-called.
1641
1642    Multiple registrarants for any architecture are allowed (and
1643    strongly encouraged).  */
1644
1645 struct gdbarch_data;
1646
1647 typedef void *(gdbarch_data_pre_init_ftype) (struct obstack *obstack);
1648 extern struct gdbarch_data *gdbarch_data_register_pre_init (gdbarch_data_pre_init_ftype *init);
1649 typedef void *(gdbarch_data_post_init_ftype) (struct gdbarch *gdbarch);
1650 extern struct gdbarch_data *gdbarch_data_register_post_init (gdbarch_data_post_init_ftype *init);
1651 extern void deprecated_set_gdbarch_data (struct gdbarch *gdbarch,
1652                                          struct gdbarch_data *data,
1653                                          void *pointer);
1654
1655 extern void *gdbarch_data (struct gdbarch *gdbarch, struct gdbarch_data *);
1656
1657
1658 /* Set the dynamic target-system-dependent parameters (architecture,
1659    byte-order, ...) using information found in the BFD.  */
1660
1661 extern void set_gdbarch_from_file (bfd *);
1662
1663
1664 /* Initialize the current architecture to the "first" one we find on
1665    our list.  */
1666
1667 extern void initialize_current_architecture (void);
1668
1669 /* gdbarch trace variable */
1670 extern unsigned int gdbarch_debug;
1671
1672 extern void gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file);
1673
1674 /* Return the number of cooked registers (raw + pseudo) for ARCH.  */
1675
1676 static inline int
1677 gdbarch_num_cooked_regs (gdbarch *arch)
1678 {
1679   return gdbarch_num_regs (arch) + gdbarch_num_pseudo_regs (arch);
1680 }
1681
1682 #endif
1683 EOF
1684 exec 1>&2
1685 #../move-if-change new-gdbarch.h gdbarch.h
1686 compare_new gdbarch.h
1687
1688
1689 #
1690 # C file
1691 #
1692
1693 exec > new-gdbarch.c
1694 copyright
1695 cat <<EOF
1696
1697 #include "defs.h"
1698 #include "arch-utils.h"
1699
1700 #include "gdbcmd.h"
1701 #include "inferior.h"
1702 #include "symcat.h"
1703
1704 #include "floatformat.h"
1705 #include "reggroups.h"
1706 #include "osabi.h"
1707 #include "gdb_obstack.h"
1708 #include "observable.h"
1709 #include "regcache.h"
1710 #include "objfiles.h"
1711 #include "auxv.h"
1712 #include "frame-unwind.h"
1713 #include "dummy-frame.h"
1714
1715 /* Static function declarations */
1716
1717 static void alloc_gdbarch_data (struct gdbarch *);
1718
1719 /* Non-zero if we want to trace architecture code.  */
1720
1721 #ifndef GDBARCH_DEBUG
1722 #define GDBARCH_DEBUG 0
1723 #endif
1724 unsigned int gdbarch_debug = GDBARCH_DEBUG;
1725 static void
1726 show_gdbarch_debug (struct ui_file *file, int from_tty,
1727                     struct cmd_list_element *c, const char *value)
1728 {
1729   fprintf_filtered (file, _("Architecture debugging is %s.\\n"), value);
1730 }
1731
1732 static const char *
1733 pformat (const struct floatformat **format)
1734 {
1735   if (format == NULL)
1736     return "(null)";
1737   else
1738     /* Just print out one of them - this is only for diagnostics.  */
1739     return format[0]->name;
1740 }
1741
1742 static const char *
1743 pstring (const char *string)
1744 {
1745   if (string == NULL)
1746     return "(null)";
1747   return string;
1748 }
1749
1750 static const char *
1751 pstring_ptr (char **string)
1752 {
1753   if (string == NULL || *string == NULL)
1754     return "(null)";
1755   return *string;
1756 }
1757
1758 /* Helper function to print a list of strings, represented as "const
1759    char *const *".  The list is printed comma-separated.  */
1760
1761 static const char *
1762 pstring_list (const char *const *list)
1763 {
1764   static char ret[100];
1765   const char *const *p;
1766   size_t offset = 0;
1767
1768   if (list == NULL)
1769     return "(null)";
1770
1771   ret[0] = '\0';
1772   for (p = list; *p != NULL && offset < sizeof (ret); ++p)
1773     {
1774       size_t s = xsnprintf (ret + offset, sizeof (ret) - offset, "%s, ", *p);
1775       offset += 2 + s;
1776     }
1777
1778   if (offset > 0)
1779     {
1780       gdb_assert (offset - 2 < sizeof (ret));
1781       ret[offset - 2] = '\0';
1782     }
1783
1784   return ret;
1785 }
1786
1787 EOF
1788
1789 # gdbarch open the gdbarch object
1790 printf "\n"
1791 printf "/* Maintain the struct gdbarch object.  */\n"
1792 printf "\n"
1793 printf "struct gdbarch\n"
1794 printf "{\n"
1795 printf "  /* Has this architecture been fully initialized?  */\n"
1796 printf "  int initialized_p;\n"
1797 printf "\n"
1798 printf "  /* An obstack bound to the lifetime of the architecture.  */\n"
1799 printf "  struct obstack *obstack;\n"
1800 printf "\n"
1801 printf "  /* basic architectural information.  */\n"
1802 function_list | while do_read
1803 do
1804     if class_is_info_p
1805     then
1806         printf "  ${returntype} ${function};\n"
1807     fi
1808 done
1809 printf "\n"
1810 printf "  /* target specific vector.  */\n"
1811 printf "  struct gdbarch_tdep *tdep;\n"
1812 printf "  gdbarch_dump_tdep_ftype *dump_tdep;\n"
1813 printf "\n"
1814 printf "  /* per-architecture data-pointers.  */\n"
1815 printf "  unsigned nr_data;\n"
1816 printf "  void **data;\n"
1817 printf "\n"
1818 cat <<EOF
1819   /* Multi-arch values.
1820
1821      When extending this structure you must:
1822
1823      Add the field below.
1824
1825      Declare set/get functions and define the corresponding
1826      macro in gdbarch.h.
1827
1828      gdbarch_alloc(): If zero/NULL is not a suitable default,
1829      initialize the new field.
1830
1831      verify_gdbarch(): Confirm that the target updated the field
1832      correctly.
1833
1834      gdbarch_dump(): Add a fprintf_unfiltered call so that the new
1835      field is dumped out
1836
1837      get_gdbarch(): Implement the set/get functions (probably using
1838      the macro's as shortcuts).
1839
1840      */
1841
1842 EOF
1843 function_list | while do_read
1844 do
1845     if class_is_variable_p
1846     then
1847         printf "  ${returntype} ${function};\n"
1848     elif class_is_function_p
1849     then
1850         printf "  gdbarch_${function}_ftype *${function};\n"
1851     fi
1852 done
1853 printf "};\n"
1854
1855 # Create a new gdbarch struct
1856 cat <<EOF
1857
1858 /* Create a new \`\`struct gdbarch'' based on information provided by
1859    \`\`struct gdbarch_info''.  */
1860 EOF
1861 printf "\n"
1862 cat <<EOF
1863 struct gdbarch *
1864 gdbarch_alloc (const struct gdbarch_info *info,
1865                struct gdbarch_tdep *tdep)
1866 {
1867   struct gdbarch *gdbarch;
1868
1869   /* Create an obstack for allocating all the per-architecture memory,
1870      then use that to allocate the architecture vector.  */
1871   struct obstack *obstack = XNEW (struct obstack);
1872   obstack_init (obstack);
1873   gdbarch = XOBNEW (obstack, struct gdbarch);
1874   memset (gdbarch, 0, sizeof (*gdbarch));
1875   gdbarch->obstack = obstack;
1876
1877   alloc_gdbarch_data (gdbarch);
1878
1879   gdbarch->tdep = tdep;
1880 EOF
1881 printf "\n"
1882 function_list | while do_read
1883 do
1884     if class_is_info_p
1885     then
1886         printf "  gdbarch->${function} = info->${function};\n"
1887     fi
1888 done
1889 printf "\n"
1890 printf "  /* Force the explicit initialization of these.  */\n"
1891 function_list | while do_read
1892 do
1893     if class_is_function_p || class_is_variable_p
1894     then
1895         if [ -n "${predefault}" -a "x${predefault}" != "x0" ]
1896         then
1897           printf "  gdbarch->${function} = ${predefault};\n"
1898         fi
1899     fi
1900 done
1901 cat <<EOF
1902   /* gdbarch_alloc() */
1903
1904   return gdbarch;
1905 }
1906 EOF
1907
1908 # Free a gdbarch struct.
1909 printf "\n"
1910 printf "\n"
1911 cat <<EOF
1912
1913 obstack *gdbarch_obstack (gdbarch *arch)
1914 {
1915   return arch->obstack;
1916 }
1917
1918 /* See gdbarch.h.  */
1919
1920 char *
1921 gdbarch_obstack_strdup (struct gdbarch *arch, const char *string)
1922 {
1923   return obstack_strdup (arch->obstack, string);
1924 }
1925
1926
1927 /* Free a gdbarch struct.  This should never happen in normal
1928    operation --- once you've created a gdbarch, you keep it around.
1929    However, if an architecture's init function encounters an error
1930    building the structure, it may need to clean up a partially
1931    constructed gdbarch.  */
1932
1933 void
1934 gdbarch_free (struct gdbarch *arch)
1935 {
1936   struct obstack *obstack;
1937
1938   gdb_assert (arch != NULL);
1939   gdb_assert (!arch->initialized_p);
1940   obstack = arch->obstack;
1941   obstack_free (obstack, 0); /* Includes the ARCH.  */
1942   xfree (obstack);
1943 }
1944 EOF
1945
1946 # verify a new architecture
1947 cat <<EOF
1948
1949
1950 /* Ensure that all values in a GDBARCH are reasonable.  */
1951
1952 static void
1953 verify_gdbarch (struct gdbarch *gdbarch)
1954 {
1955   string_file log;
1956
1957   /* fundamental */
1958   if (gdbarch->byte_order == BFD_ENDIAN_UNKNOWN)
1959     log.puts ("\n\tbyte-order");
1960   if (gdbarch->bfd_arch_info == NULL)
1961     log.puts ("\n\tbfd_arch_info");
1962   /* Check those that need to be defined for the given multi-arch level.  */
1963 EOF
1964 function_list | while do_read
1965 do
1966     if class_is_function_p || class_is_variable_p
1967     then
1968         if [ "x${invalid_p}" = "x0" ]
1969         then
1970             printf "  /* Skip verify of ${function}, invalid_p == 0 */\n"
1971         elif class_is_predicate_p
1972         then
1973             printf "  /* Skip verify of ${function}, has predicate.  */\n"
1974         # FIXME: See do_read for potential simplification
1975         elif [ -n "${invalid_p}" -a -n "${postdefault}" ]
1976         then
1977             printf "  if (${invalid_p})\n"
1978             printf "    gdbarch->${function} = ${postdefault};\n"
1979         elif [ -n "${predefault}" -a -n "${postdefault}" ]
1980         then
1981             printf "  if (gdbarch->${function} == ${predefault})\n"
1982             printf "    gdbarch->${function} = ${postdefault};\n"
1983         elif [ -n "${postdefault}" ]
1984         then
1985             printf "  if (gdbarch->${function} == 0)\n"
1986             printf "    gdbarch->${function} = ${postdefault};\n"
1987         elif [ -n "${invalid_p}" ]
1988         then
1989             printf "  if (${invalid_p})\n"
1990             printf "    log.puts (\"\\\\n\\\\t${function}\");\n"
1991         elif [ -n "${predefault}" ]
1992         then
1993             printf "  if (gdbarch->${function} == ${predefault})\n"
1994             printf "    log.puts (\"\\\\n\\\\t${function}\");\n"
1995         fi
1996     fi
1997 done
1998 cat <<EOF
1999   if (!log.empty ())
2000     internal_error (__FILE__, __LINE__,
2001                     _("verify_gdbarch: the following are invalid ...%s"),
2002                     log.c_str ());
2003 }
2004 EOF
2005
2006 # dump the structure
2007 printf "\n"
2008 printf "\n"
2009 cat <<EOF
2010 /* Print out the details of the current architecture.  */
2011
2012 void
2013 gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file)
2014 {
2015   const char *gdb_nm_file = "<not-defined>";
2016
2017 #if defined (GDB_NM_FILE)
2018   gdb_nm_file = GDB_NM_FILE;
2019 #endif
2020   fprintf_unfiltered (file,
2021                       "gdbarch_dump: GDB_NM_FILE = %s\\n",
2022                       gdb_nm_file);
2023 EOF
2024 function_list | sort '-t;' -k 3 | while do_read
2025 do
2026     # First the predicate
2027     if class_is_predicate_p
2028     then
2029         printf "  fprintf_unfiltered (file,\n"
2030         printf "                      \"gdbarch_dump: gdbarch_${function}_p() = %%d\\\\n\",\n"
2031         printf "                      gdbarch_${function}_p (gdbarch));\n"
2032     fi
2033     # Print the corresponding value.
2034     if class_is_function_p
2035     then
2036         printf "  fprintf_unfiltered (file,\n"
2037         printf "                      \"gdbarch_dump: ${function} = <%%s>\\\\n\",\n"
2038         printf "                      host_address_to_string (gdbarch->${function}));\n"
2039     else
2040         # It is a variable
2041         case "${print}:${returntype}" in
2042             :CORE_ADDR )
2043                 fmt="%s"
2044                 print="core_addr_to_string_nz (gdbarch->${function})"
2045                 ;;
2046             :* )
2047                 fmt="%s"
2048                 print="plongest (gdbarch->${function})"
2049                 ;;
2050             * )
2051                 fmt="%s"
2052                 ;;
2053         esac
2054         printf "  fprintf_unfiltered (file,\n"
2055         printf "                      \"gdbarch_dump: ${function} = %s\\\\n\",\n" "${fmt}"
2056         printf "                      ${print});\n"
2057     fi
2058 done
2059 cat <<EOF
2060   if (gdbarch->dump_tdep != NULL)
2061     gdbarch->dump_tdep (gdbarch, file);
2062 }
2063 EOF
2064
2065
2066 # GET/SET
2067 printf "\n"
2068 cat <<EOF
2069 struct gdbarch_tdep *
2070 gdbarch_tdep (struct gdbarch *gdbarch)
2071 {
2072   if (gdbarch_debug >= 2)
2073     fprintf_unfiltered (gdb_stdlog, "gdbarch_tdep called\\n");
2074   return gdbarch->tdep;
2075 }
2076 EOF
2077 printf "\n"
2078 function_list | while do_read
2079 do
2080     if class_is_predicate_p
2081     then
2082         printf "\n"
2083         printf "int\n"
2084         printf "gdbarch_${function}_p (struct gdbarch *gdbarch)\n"
2085         printf "{\n"
2086         printf "  gdb_assert (gdbarch != NULL);\n"
2087         printf "  return ${predicate};\n"
2088         printf "}\n"
2089     fi
2090     if class_is_function_p
2091     then
2092         printf "\n"
2093         printf "${returntype}\n"
2094         if [ "x${formal}" = "xvoid" ]
2095         then
2096           printf "gdbarch_${function} (struct gdbarch *gdbarch)\n"
2097         else
2098           printf "gdbarch_${function} (struct gdbarch *gdbarch, ${formal})\n"
2099         fi
2100         printf "{\n"
2101         printf "  gdb_assert (gdbarch != NULL);\n"
2102         printf "  gdb_assert (gdbarch->${function} != NULL);\n"
2103         if class_is_predicate_p && test -n "${predefault}"
2104         then
2105             # Allow a call to a function with a predicate.
2106             printf "  /* Do not check predicate: ${predicate}, allow call.  */\n"
2107         fi
2108         printf "  if (gdbarch_debug >= 2)\n"
2109         printf "    fprintf_unfiltered (gdb_stdlog, \"gdbarch_${function} called\\\\n\");\n"
2110         if [ "x${actual}" = "x-" -o "x${actual}" = "x" ]
2111         then
2112             if class_is_multiarch_p
2113             then
2114                 params="gdbarch"
2115             else
2116                 params=""
2117             fi
2118         else
2119             if class_is_multiarch_p
2120             then
2121                 params="gdbarch, ${actual}"
2122             else
2123                 params="${actual}"
2124             fi
2125         fi
2126         if [ "x${returntype}" = "xvoid" ]
2127         then
2128           printf "  gdbarch->${function} (${params});\n"
2129         else
2130           printf "  return gdbarch->${function} (${params});\n"
2131         fi
2132         printf "}\n"
2133         printf "\n"
2134         printf "void\n"
2135         printf "set_gdbarch_${function} (struct gdbarch *gdbarch,\n"
2136         printf "            `echo ${function} | sed -e 's/./ /g'`  gdbarch_${function}_ftype ${function})\n"
2137         printf "{\n"
2138         printf "  gdbarch->${function} = ${function};\n"
2139         printf "}\n"
2140     elif class_is_variable_p
2141     then
2142         printf "\n"
2143         printf "${returntype}\n"
2144         printf "gdbarch_${function} (struct gdbarch *gdbarch)\n"
2145         printf "{\n"
2146         printf "  gdb_assert (gdbarch != NULL);\n"
2147         if [ "x${invalid_p}" = "x0" ]
2148         then
2149             printf "  /* Skip verify of ${function}, invalid_p == 0 */\n"
2150         elif [ -n "${invalid_p}" ]
2151         then
2152             printf "  /* Check variable is valid.  */\n"
2153             printf "  gdb_assert (!(${invalid_p}));\n"
2154         elif [ -n "${predefault}" ]
2155         then
2156             printf "  /* Check variable changed from pre-default.  */\n"
2157             printf "  gdb_assert (gdbarch->${function} != ${predefault});\n"
2158         fi
2159         printf "  if (gdbarch_debug >= 2)\n"
2160         printf "    fprintf_unfiltered (gdb_stdlog, \"gdbarch_${function} called\\\\n\");\n"
2161         printf "  return gdbarch->${function};\n"
2162         printf "}\n"
2163         printf "\n"
2164         printf "void\n"
2165         printf "set_gdbarch_${function} (struct gdbarch *gdbarch,\n"
2166         printf "            `echo ${function} | sed -e 's/./ /g'`  ${returntype} ${function})\n"
2167         printf "{\n"
2168         printf "  gdbarch->${function} = ${function};\n"
2169         printf "}\n"
2170     elif class_is_info_p
2171     then
2172         printf "\n"
2173         printf "${returntype}\n"
2174         printf "gdbarch_${function} (struct gdbarch *gdbarch)\n"
2175         printf "{\n"
2176         printf "  gdb_assert (gdbarch != NULL);\n"
2177         printf "  if (gdbarch_debug >= 2)\n"
2178         printf "    fprintf_unfiltered (gdb_stdlog, \"gdbarch_${function} called\\\\n\");\n"
2179         printf "  return gdbarch->${function};\n"
2180         printf "}\n"
2181     fi
2182 done
2183
2184 # All the trailing guff
2185 cat <<EOF
2186
2187
2188 /* Keep a registry of per-architecture data-pointers required by GDB
2189    modules.  */
2190
2191 struct gdbarch_data
2192 {
2193   unsigned index;
2194   int init_p;
2195   gdbarch_data_pre_init_ftype *pre_init;
2196   gdbarch_data_post_init_ftype *post_init;
2197 };
2198
2199 struct gdbarch_data_registration
2200 {
2201   struct gdbarch_data *data;
2202   struct gdbarch_data_registration *next;
2203 };
2204
2205 struct gdbarch_data_registry
2206 {
2207   unsigned nr;
2208   struct gdbarch_data_registration *registrations;
2209 };
2210
2211 struct gdbarch_data_registry gdbarch_data_registry =
2212 {
2213   0, NULL,
2214 };
2215
2216 static struct gdbarch_data *
2217 gdbarch_data_register (gdbarch_data_pre_init_ftype *pre_init,
2218                        gdbarch_data_post_init_ftype *post_init)
2219 {
2220   struct gdbarch_data_registration **curr;
2221
2222   /* Append the new registration.  */
2223   for (curr = &gdbarch_data_registry.registrations;
2224        (*curr) != NULL;
2225        curr = &(*curr)->next);
2226   (*curr) = XNEW (struct gdbarch_data_registration);
2227   (*curr)->next = NULL;
2228   (*curr)->data = XNEW (struct gdbarch_data);
2229   (*curr)->data->index = gdbarch_data_registry.nr++;
2230   (*curr)->data->pre_init = pre_init;
2231   (*curr)->data->post_init = post_init;
2232   (*curr)->data->init_p = 1;
2233   return (*curr)->data;
2234 }
2235
2236 struct gdbarch_data *
2237 gdbarch_data_register_pre_init (gdbarch_data_pre_init_ftype *pre_init)
2238 {
2239   return gdbarch_data_register (pre_init, NULL);
2240 }
2241
2242 struct gdbarch_data *
2243 gdbarch_data_register_post_init (gdbarch_data_post_init_ftype *post_init)
2244 {
2245   return gdbarch_data_register (NULL, post_init);
2246 }
2247
2248 /* Create/delete the gdbarch data vector.  */
2249
2250 static void
2251 alloc_gdbarch_data (struct gdbarch *gdbarch)
2252 {
2253   gdb_assert (gdbarch->data == NULL);
2254   gdbarch->nr_data = gdbarch_data_registry.nr;
2255   gdbarch->data = GDBARCH_OBSTACK_CALLOC (gdbarch, gdbarch->nr_data, void *);
2256 }
2257
2258 /* Initialize the current value of the specified per-architecture
2259    data-pointer.  */
2260
2261 void
2262 deprecated_set_gdbarch_data (struct gdbarch *gdbarch,
2263                              struct gdbarch_data *data,
2264                              void *pointer)
2265 {
2266   gdb_assert (data->index < gdbarch->nr_data);
2267   gdb_assert (gdbarch->data[data->index] == NULL);
2268   gdb_assert (data->pre_init == NULL);
2269   gdbarch->data[data->index] = pointer;
2270 }
2271
2272 /* Return the current value of the specified per-architecture
2273    data-pointer.  */
2274
2275 void *
2276 gdbarch_data (struct gdbarch *gdbarch, struct gdbarch_data *data)
2277 {
2278   gdb_assert (data->index < gdbarch->nr_data);
2279   if (gdbarch->data[data->index] == NULL)
2280     {
2281       /* The data-pointer isn't initialized, call init() to get a
2282          value.  */
2283       if (data->pre_init != NULL)
2284         /* Mid architecture creation: pass just the obstack, and not
2285            the entire architecture, as that way it isn't possible for
2286            pre-init code to refer to undefined architecture
2287            fields.  */
2288         gdbarch->data[data->index] = data->pre_init (gdbarch->obstack);
2289       else if (gdbarch->initialized_p
2290                && data->post_init != NULL)
2291         /* Post architecture creation: pass the entire architecture
2292            (as all fields are valid), but be careful to also detect
2293            recursive references.  */
2294         {
2295           gdb_assert (data->init_p);
2296           data->init_p = 0;
2297           gdbarch->data[data->index] = data->post_init (gdbarch);
2298           data->init_p = 1;
2299         }
2300       else
2301         /* The architecture initialization hasn't completed - punt -
2302          hope that the caller knows what they are doing.  Once
2303          deprecated_set_gdbarch_data has been initialized, this can be
2304          changed to an internal error.  */
2305         return NULL;
2306       gdb_assert (gdbarch->data[data->index] != NULL);
2307     }
2308   return gdbarch->data[data->index];
2309 }
2310
2311
2312 /* Keep a registry of the architectures known by GDB.  */
2313
2314 struct gdbarch_registration
2315 {
2316   enum bfd_architecture bfd_architecture;
2317   gdbarch_init_ftype *init;
2318   gdbarch_dump_tdep_ftype *dump_tdep;
2319   struct gdbarch_list *arches;
2320   struct gdbarch_registration *next;
2321 };
2322
2323 static struct gdbarch_registration *gdbarch_registry = NULL;
2324
2325 static void
2326 append_name (const char ***buf, int *nr, const char *name)
2327 {
2328   *buf = XRESIZEVEC (const char *, *buf, *nr + 1);
2329   (*buf)[*nr] = name;
2330   *nr += 1;
2331 }
2332
2333 const char **
2334 gdbarch_printable_names (void)
2335 {
2336   /* Accumulate a list of names based on the registed list of
2337      architectures.  */
2338   int nr_arches = 0;
2339   const char **arches = NULL;
2340   struct gdbarch_registration *rego;
2341
2342   for (rego = gdbarch_registry;
2343        rego != NULL;
2344        rego = rego->next)
2345     {
2346       const struct bfd_arch_info *ap;
2347       ap = bfd_lookup_arch (rego->bfd_architecture, 0);
2348       if (ap == NULL)
2349         internal_error (__FILE__, __LINE__,
2350                         _("gdbarch_architecture_names: multi-arch unknown"));
2351       do
2352         {
2353           append_name (&arches, &nr_arches, ap->printable_name);
2354           ap = ap->next;
2355         }
2356       while (ap != NULL);
2357     }
2358   append_name (&arches, &nr_arches, NULL);
2359   return arches;
2360 }
2361
2362
2363 void
2364 gdbarch_register (enum bfd_architecture bfd_architecture,
2365                   gdbarch_init_ftype *init,
2366                   gdbarch_dump_tdep_ftype *dump_tdep)
2367 {
2368   struct gdbarch_registration **curr;
2369   const struct bfd_arch_info *bfd_arch_info;
2370
2371   /* Check that BFD recognizes this architecture */
2372   bfd_arch_info = bfd_lookup_arch (bfd_architecture, 0);
2373   if (bfd_arch_info == NULL)
2374     {
2375       internal_error (__FILE__, __LINE__,
2376                       _("gdbarch: Attempt to register "
2377                         "unknown architecture (%d)"),
2378                       bfd_architecture);
2379     }
2380   /* Check that we haven't seen this architecture before.  */
2381   for (curr = &gdbarch_registry;
2382        (*curr) != NULL;
2383        curr = &(*curr)->next)
2384     {
2385       if (bfd_architecture == (*curr)->bfd_architecture)
2386         internal_error (__FILE__, __LINE__,
2387                         _("gdbarch: Duplicate registration "
2388                           "of architecture (%s)"),
2389                         bfd_arch_info->printable_name);
2390     }
2391   /* log it */
2392   if (gdbarch_debug)
2393     fprintf_unfiltered (gdb_stdlog, "register_gdbarch_init (%s, %s)\n",
2394                         bfd_arch_info->printable_name,
2395                         host_address_to_string (init));
2396   /* Append it */
2397   (*curr) = XNEW (struct gdbarch_registration);
2398   (*curr)->bfd_architecture = bfd_architecture;
2399   (*curr)->init = init;
2400   (*curr)->dump_tdep = dump_tdep;
2401   (*curr)->arches = NULL;
2402   (*curr)->next = NULL;
2403 }
2404
2405 void
2406 register_gdbarch_init (enum bfd_architecture bfd_architecture,
2407                        gdbarch_init_ftype *init)
2408 {
2409   gdbarch_register (bfd_architecture, init, NULL);
2410 }
2411
2412
2413 /* Look for an architecture using gdbarch_info.  */
2414
2415 struct gdbarch_list *
2416 gdbarch_list_lookup_by_info (struct gdbarch_list *arches,
2417                              const struct gdbarch_info *info)
2418 {
2419   for (; arches != NULL; arches = arches->next)
2420     {
2421       if (info->bfd_arch_info != arches->gdbarch->bfd_arch_info)
2422         continue;
2423       if (info->byte_order != arches->gdbarch->byte_order)
2424         continue;
2425       if (info->osabi != arches->gdbarch->osabi)
2426         continue;
2427       if (info->target_desc != arches->gdbarch->target_desc)
2428         continue;
2429       return arches;
2430     }
2431   return NULL;
2432 }
2433
2434
2435 /* Find an architecture that matches the specified INFO.  Create a new
2436    architecture if needed.  Return that new architecture.  */
2437
2438 struct gdbarch *
2439 gdbarch_find_by_info (struct gdbarch_info info)
2440 {
2441   struct gdbarch *new_gdbarch;
2442   struct gdbarch_registration *rego;
2443
2444   /* Fill in missing parts of the INFO struct using a number of
2445      sources: "set ..."; INFOabfd supplied; and the global
2446      defaults.  */
2447   gdbarch_info_fill (&info);
2448
2449   /* Must have found some sort of architecture.  */
2450   gdb_assert (info.bfd_arch_info != NULL);
2451
2452   if (gdbarch_debug)
2453     {
2454       fprintf_unfiltered (gdb_stdlog,
2455                           "gdbarch_find_by_info: info.bfd_arch_info %s\n",
2456                           (info.bfd_arch_info != NULL
2457                            ? info.bfd_arch_info->printable_name
2458                            : "(null)"));
2459       fprintf_unfiltered (gdb_stdlog,
2460                           "gdbarch_find_by_info: info.byte_order %d (%s)\n",
2461                           info.byte_order,
2462                           (info.byte_order == BFD_ENDIAN_BIG ? "big"
2463                            : info.byte_order == BFD_ENDIAN_LITTLE ? "little"
2464                            : "default"));
2465       fprintf_unfiltered (gdb_stdlog,
2466                           "gdbarch_find_by_info: info.osabi %d (%s)\n",
2467                           info.osabi, gdbarch_osabi_name (info.osabi));
2468       fprintf_unfiltered (gdb_stdlog,
2469                           "gdbarch_find_by_info: info.abfd %s\n",
2470                           host_address_to_string (info.abfd));
2471       fprintf_unfiltered (gdb_stdlog,
2472                           "gdbarch_find_by_info: info.tdep_info %s\n",
2473                           host_address_to_string (info.tdep_info));
2474     }
2475
2476   /* Find the tdep code that knows about this architecture.  */
2477   for (rego = gdbarch_registry;
2478        rego != NULL;
2479        rego = rego->next)
2480     if (rego->bfd_architecture == info.bfd_arch_info->arch)
2481       break;
2482   if (rego == NULL)
2483     {
2484       if (gdbarch_debug)
2485         fprintf_unfiltered (gdb_stdlog, "gdbarch_find_by_info: "
2486                             "No matching architecture\n");
2487       return 0;
2488     }
2489
2490   /* Ask the tdep code for an architecture that matches "info".  */
2491   new_gdbarch = rego->init (info, rego->arches);
2492
2493   /* Did the tdep code like it?  No.  Reject the change and revert to
2494      the old architecture.  */
2495   if (new_gdbarch == NULL)
2496     {
2497       if (gdbarch_debug)
2498         fprintf_unfiltered (gdb_stdlog, "gdbarch_find_by_info: "
2499                             "Target rejected architecture\n");
2500       return NULL;
2501     }
2502
2503   /* Is this a pre-existing architecture (as determined by already
2504      being initialized)?  Move it to the front of the architecture
2505      list (keeping the list sorted Most Recently Used).  */
2506   if (new_gdbarch->initialized_p)
2507     {
2508       struct gdbarch_list **list;
2509       struct gdbarch_list *self;
2510       if (gdbarch_debug)
2511         fprintf_unfiltered (gdb_stdlog, "gdbarch_find_by_info: "
2512                             "Previous architecture %s (%s) selected\n",
2513                             host_address_to_string (new_gdbarch),
2514                             new_gdbarch->bfd_arch_info->printable_name);
2515       /* Find the existing arch in the list.  */
2516       for (list = &rego->arches;
2517            (*list) != NULL && (*list)->gdbarch != new_gdbarch;
2518            list = &(*list)->next);
2519       /* It had better be in the list of architectures.  */
2520       gdb_assert ((*list) != NULL && (*list)->gdbarch == new_gdbarch);
2521       /* Unlink SELF.  */
2522       self = (*list);
2523       (*list) = self->next;
2524       /* Insert SELF at the front.  */
2525       self->next = rego->arches;
2526       rego->arches = self;
2527       /* Return it.  */
2528       return new_gdbarch;
2529     }
2530
2531   /* It's a new architecture.  */
2532   if (gdbarch_debug)
2533     fprintf_unfiltered (gdb_stdlog, "gdbarch_find_by_info: "
2534                         "New architecture %s (%s) selected\n",
2535                         host_address_to_string (new_gdbarch),
2536                         new_gdbarch->bfd_arch_info->printable_name);
2537
2538   /* Insert the new architecture into the front of the architecture
2539      list (keep the list sorted Most Recently Used).  */
2540   {
2541     struct gdbarch_list *self = XNEW (struct gdbarch_list);
2542     self->next = rego->arches;
2543     self->gdbarch = new_gdbarch;
2544     rego->arches = self;
2545   }
2546
2547   /* Check that the newly installed architecture is valid.  Plug in
2548      any post init values.  */
2549   new_gdbarch->dump_tdep = rego->dump_tdep;
2550   verify_gdbarch (new_gdbarch);
2551   new_gdbarch->initialized_p = 1;
2552
2553   if (gdbarch_debug)
2554     gdbarch_dump (new_gdbarch, gdb_stdlog);
2555
2556   return new_gdbarch;
2557 }
2558
2559 /* Make the specified architecture current.  */
2560
2561 void
2562 set_target_gdbarch (struct gdbarch *new_gdbarch)
2563 {
2564   gdb_assert (new_gdbarch != NULL);
2565   gdb_assert (new_gdbarch->initialized_p);
2566   current_inferior ()->gdbarch = new_gdbarch;
2567   gdb::observers::architecture_changed.notify (new_gdbarch);
2568   registers_changed ();
2569 }
2570
2571 /* Return the current inferior's arch.  */
2572
2573 struct gdbarch *
2574 target_gdbarch (void)
2575 {
2576   return current_inferior ()->gdbarch;
2577 }
2578
2579 void
2580 _initialize_gdbarch (void)
2581 {
2582   add_setshow_zuinteger_cmd ("arch", class_maintenance, &gdbarch_debug, _("\\
2583 Set architecture debugging."), _("\\
2584 Show architecture debugging."), _("\\
2585 When non-zero, architecture debugging is enabled."),
2586                             NULL,
2587                             show_gdbarch_debug,
2588                             &setdebuglist, &showdebuglist);
2589 }
2590 EOF
2591
2592 # close things off
2593 exec 1>&2
2594 #../move-if-change new-gdbarch.c gdbarch.c
2595 compare_new gdbarch.c