gdb/gdbarch.sh

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