gdb/gdbarch.sh

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