gdb/gdbarch.sh

   1 #!/bin/sh -u
   2
   3 # Architecture commands for GDB, the GNU debugger.
   4 # Copyright 1998, 1999, 2000, 2001, 2002, 2003 Free Software Foundation, Inc.
   5 #
   6 # This file is part of GDB.
   7 #
   8 # This program is free software; you can redistribute it and/or modify
   9 # it under the terms of the GNU General Public License as published by
  10 # the Free Software Foundation; either version 2 of the License, or
  11 # (at your option) any later version.
  12 #
  13 # This program is distributed in the hope that it will be useful,
  14 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 # GNU General Public License for more details.
  17 #
  18 # You should have received a copy of the GNU General Public License
  19 # along with this program; if not, write to the Free Software
  20 # Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  21
  22 # Make certain that the script is running in an internationalized
  23 # environment.
  24 LANG=c ; export LANG
  25 LC_ALL=c ; export LC_ALL
  26
  27
  28 compare_new ()
  29 {
  30     file=$1
  31     if test ! -r ${file}
  32     then
  33         echo "${file} missing? cp new-${file} ${file}" 1>&2
  34     elif diff -u ${file} new-${file}
  35     then
  36         echo "${file} unchanged" 1>&2
  37     else
  38         echo "${file} has changed? cp new-${file} ${file}" 1>&2
  39     fi
  40 }
  41
  42
  43 # Format of the input table
  44 read="class level macro returntype function formal actual attrib staticdefault predefault postdefault invalid_p fmt print print_p description"
  45
  46 do_read ()
  47 {
  48     comment=""
  49     class=""
  50     while read line
  51     do
  52         if test "${line}" = ""
  53         then
  54             continue
  55         elif test "${line}" = "#" -a "${comment}" = ""
  56         then
  57             continue
  58         elif expr "${line}" : "#" > /dev/null
  59         then
  60             comment="${comment}
  61 ${line}"
  62         else
  63
  64             # The semantics of IFS varies between different SH's.  Some
  65             # treat ``::' as three fields while some treat it as just too.
  66             # Work around this by eliminating ``::'' ....
  67             line="`echo "${line}" | sed -e 's/::/: :/g' -e 's/::/: :/g'`"
  68
  69             OFS="${IFS}" ; IFS="[:]"
  70             eval read ${read} <<EOF
  71 ${line}
  72 EOF
  73             IFS="${OFS}"
  74
  75             # .... and then going back through each field and strip out those
  76             # that ended up with just that space character.
  77             for r in ${read}
  78             do
  79                 if eval test \"\${${r}}\" = \"\ \"
  80                 then
  81                     eval ${r}=""
  82                 fi
  83             done
  84
  85             case "${level}" in
  86                 1 ) gt_level=">= GDB_MULTI_ARCH_PARTIAL" ;;
  87                 2 ) gt_level="> GDB_MULTI_ARCH_PARTIAL" ;;
  88                 "" ) gt_level="> GDB_MULTI_ARCH_PARTIAL" ;;
  89                 * ) error "Error: bad level for ${function}" 1>&2 ; kill $$ ; exit 1 ;;
  90             esac
  91
  92             case "${class}" in
  93                 m ) staticdefault="${predefault}" ;;
  94                 M ) staticdefault="0" ;;
  95                 * ) test "${staticdefault}" || staticdefault=0 ;;
  96             esac
  97             # NOT YET: Breaks BELIEVE_PCC_PROMOTION and confuses non-
  98             # multi-arch defaults.
  99             # test "${predefault}" || predefault=0
 100
 101             # come up with a format, use a few guesses for variables
 102             case ":${class}:${fmt}:${print}:" in
 103                 :[vV]::: )
 104                     if [ "${returntype}" = int ]
 105                     then
 106                         fmt="%d"
 107                         print="${macro}"
 108                     elif [ "${returntype}" = long ]
 109                     then
 110                         fmt="%ld"
 111                         print="${macro}"
 112                     fi
 113                     ;;
 114             esac
 115             test "${fmt}" || fmt="%ld"
 116             test "${print}" || print="(long) ${macro}"
 117
 118             case "${class}" in
 119             F | V | M )
 120                 case "${invalid_p}" in
 121                 "" )
 122                     if test -n "${predefault}" -a "${predefault}" != "0"
 123                     then
 124                         #invalid_p="gdbarch->${function} == ${predefault}"
 125                         predicate="gdbarch->${function} != ${predefault}"
 126                     else
 127                         # filled in later
 128                         predicate=""
 129                     fi
 130                     ;;
 131                 * )
 132                     echo "Predicate function ${function} with invalid_p." 1>&2
 133                     kill $$
 134                     exit 1
 135                     ;;
 136                 esac
 137             esac
 138
 139             # PREDEFAULT is a valid fallback definition of MEMBER when
 140             # multi-arch is not enabled.  This ensures that the
 141             # default value, when multi-arch is the same as the
 142             # default value when not multi-arch.  POSTDEFAULT is
 143             # always a valid definition of MEMBER as this again
 144             # ensures consistency.
 145
 146             if [ -n "${postdefault}" ]
 147             then
 148                 fallbackdefault="${postdefault}"
 149             elif [ -n "${predefault}" ]
 150             then
 151                 fallbackdefault="${predefault}"
 152             else
 153                 fallbackdefault="0"
 154             fi
 155
 156             #NOT YET: See gdbarch.log for basic verification of
 157             # database
 158
 159             break
 160         fi
 161     done
 162     if [ -n "${class}" ]
 163     then
 164         true
 165     else
 166         false
 167     fi
 168 }
 169
 170
 171 fallback_default_p ()
 172 {
 173     [ -n "${postdefault}" -a "x${invalid_p}" != "x0" ] \
 174         || [ -n "${predefault}" -a "x${invalid_p}" = "x0" ]
 175 }
 176
 177 class_is_variable_p ()
 178 {
 179     case "${class}" in
 180         *v* | *V* ) true ;;
 181         * ) false ;;
 182     esac
 183 }
 184
 185 class_is_function_p ()
 186 {
 187     case "${class}" in
 188         *f* | *F* | *m* | *M* ) true ;;
 189         * ) false ;;
 190     esac
 191 }
 192
 193 class_is_multiarch_p ()
 194 {
 195     case "${class}" in
 196         *m* | *M* ) true ;;
 197         * ) false ;;
 198     esac
 199 }
 200
 201 class_is_predicate_p ()
 202 {
 203     case "${class}" in
 204         *F* | *V* | *M* ) true ;;
 205         * ) false ;;
 206     esac
 207 }
 208
 209 class_is_info_p ()
 210 {
 211     case "${class}" in
 212         *i* ) true ;;
 213         * ) false ;;
 214     esac
 215 }
 216
 217
 218 # dump out/verify the doco
 219 for field in ${read}
 220 do
 221   case ${field} in
 222
 223     class ) : ;;
 224
 225         # # -> line disable
 226         # f -> function
 227         #   hiding a function
 228         # F -> function + predicate
 229         #   hiding a function + predicate to test function validity
 230         # v -> variable
 231         #   hiding a variable
 232         # V -> variable + predicate
 233         #   hiding a variable + predicate to test variables validity
 234         # i -> set from info
 235         #   hiding something from the ``struct info'' object
 236         # m -> multi-arch function
 237         #   hiding a multi-arch function (parameterised with the architecture)
 238         # M -> multi-arch function + predicate
 239         #   hiding a multi-arch function + predicate to test function validity
 240
 241     level ) : ;;
 242
 243         # See GDB_MULTI_ARCH description.  Having GDB_MULTI_ARCH >=
 244         # LEVEL is a predicate on checking that a given method is
 245         # initialized (using INVALID_P).
 246
 247     macro ) : ;;
 248
 249         # The name of the MACRO that this method is to be accessed by.
 250
 251     returntype ) : ;;
 252
 253         # For functions, the return type; for variables, the data type
 254
 255     function ) : ;;
 256
 257         # For functions, the member function name; for variables, the
 258         # variable name.  Member function names are always prefixed with
 259         # ``gdbarch_'' for name-space purity.
 260
 261     formal ) : ;;
 262
 263         # The formal argument list.  It is assumed that the formal
 264         # argument list includes the actual name of each list element.
 265         # A function with no arguments shall have ``void'' as the
 266         # formal argument list.
 267
 268     actual ) : ;;
 269
 270         # The list of actual arguments.  The arguments specified shall
 271         # match the FORMAL list given above.  Functions with out
 272         # arguments leave this blank.
 273
 274     attrib ) : ;;
 275
 276         # Any GCC attributes that should be attached to the function
 277         # declaration.  At present this field is unused.
 278
 279     staticdefault ) : ;;
 280
 281         # To help with the GDB startup a static gdbarch object is
 282         # created.  STATICDEFAULT is the value to insert into that
 283         # static gdbarch object.  Since this a static object only
 284         # simple expressions can be used.
 285
 286         # If STATICDEFAULT is empty, zero is used.
 287
 288     predefault ) : ;;
 289
 290         # An initial value to assign to MEMBER of the freshly
 291         # malloc()ed gdbarch object.  After initialization, the
 292         # freshly malloc()ed object is passed to the target
 293         # architecture code for further updates.
 294
 295         # If PREDEFAULT is empty, zero is used.
 296
 297         # A non-empty PREDEFAULT, an empty POSTDEFAULT and a zero
 298         # INVALID_P are specified, PREDEFAULT will be used as the
 299         # default for the non- multi-arch target.
 300
 301         # A zero PREDEFAULT function will force the fallback to call
 302         # internal_error().
 303
 304         # Variable declarations can refer to ``gdbarch'' which will
 305         # contain the current architecture.  Care should be taken.
 306
 307     postdefault ) : ;;
 308
 309         # A value to assign to MEMBER of the new gdbarch object should
 310         # the target architecture code fail to change the PREDEFAULT
 311         # value.
 312
 313         # If POSTDEFAULT is empty, no post update is performed.
 314
 315         # If both INVALID_P and POSTDEFAULT are non-empty then
 316         # INVALID_P will be used to determine if MEMBER should be
 317         # changed to POSTDEFAULT.
 318
 319         # If a non-empty POSTDEFAULT and a zero INVALID_P are
 320         # specified, POSTDEFAULT will be used as the default for the
 321         # non- multi-arch target (regardless of the value of
 322         # PREDEFAULT).
 323
 324         # You cannot specify both a zero INVALID_P and a POSTDEFAULT.
 325
 326         # Variable declarations can refer to ``gdbarch'' which will
 327         # contain the current architecture.  Care should be taken.
 328
 329     invalid_p ) : ;;
 330
 331         # A predicate equation that validates MEMBER.  Non-zero is
 332         # returned if the code creating the new architecture failed to
 333         # initialize MEMBER or the initialized the member is invalid.
 334         # If POSTDEFAULT is non-empty then MEMBER will be updated to
 335         # that value.  If POSTDEFAULT is empty then internal_error()
 336         # is called.
 337
 338         # If INVALID_P is empty, a check that MEMBER is no longer
 339         # equal to PREDEFAULT is used.
 340
 341         # The expression ``0'' disables the INVALID_P check making
 342         # PREDEFAULT a legitimate value.
 343
 344         # See also PREDEFAULT and POSTDEFAULT.
 345
 346     fmt ) : ;;
 347
 348         # printf style format string that can be used to print out the
 349         # MEMBER.  Sometimes "%s" is useful.  For functions, this is
 350         # ignored and the function address is printed.
 351
 352         # If FMT is empty, ``%ld'' is used.
 353
 354     print ) : ;;
 355
 356         # An optional equation that casts MEMBER to a value suitable
 357         # for formatting by FMT.
 358
 359         # If PRINT is empty, ``(long)'' is used.
 360
 361     print_p ) : ;;
 362
 363         # An optional indicator for any predicte to wrap around the
 364         # print member code.
 365
 366         #   () -> Call a custom function to do the dump.
 367         #   exp -> Wrap print up in ``if (${print_p}) ...
 368         #   ``'' -> No predicate
 369
 370         # If PRINT_P is empty, ``1'' is always used.
 371
 372     description ) : ;;
 373
 374         # Currently unused.
 375
 376     *)
 377         echo "Bad field ${field}"
 378         exit 1;;
 379   esac
 380 done
 381
 382
 383 function_list ()
 384 {
 385   # See below (DOCO) for description of each field
 386   cat <<EOF
 387 i:2:TARGET_ARCHITECTURE:const struct bfd_arch_info *:bfd_arch_info::::&bfd_default_arch_struct::::%s:TARGET_ARCHITECTURE->printable_name:TARGET_ARCHITECTURE != NULL
 388 #
 389 i:2:TARGET_BYTE_ORDER:int:byte_order::::BFD_ENDIAN_BIG
 390 #
 391 i:2:TARGET_OSABI:enum gdb_osabi:osabi::::GDB_OSABI_UNKNOWN
 392 # Number of bits in a char or unsigned char for the target machine.
 393 # Just like CHAR_BIT in <limits.h> but describes the target machine.
 394 # v:2:TARGET_CHAR_BIT:int:char_bit::::8 * sizeof (char):8::0:
 395 #
 396 # Number of bits in a short or unsigned short for the target machine.
 397 v:2:TARGET_SHORT_BIT:int:short_bit::::8 * sizeof (short):2*TARGET_CHAR_BIT::0
 398 # Number of bits in an int or unsigned int for the target machine.
 399 v:2:TARGET_INT_BIT:int:int_bit::::8 * sizeof (int):4*TARGET_CHAR_BIT::0
 400 # Number of bits in a long or unsigned long for the target machine.
 401 v:2:TARGET_LONG_BIT:int:long_bit::::8 * sizeof (long):4*TARGET_CHAR_BIT::0
 402 # Number of bits in a long long or unsigned long long for the target
 403 # machine.
 404 v:2:TARGET_LONG_LONG_BIT:int:long_long_bit::::8 * sizeof (LONGEST):2*TARGET_LONG_BIT::0
 405 # Number of bits in a float for the target machine.
 406 v:2:TARGET_FLOAT_BIT:int:float_bit::::8 * sizeof (float):4*TARGET_CHAR_BIT::0
 407 # Number of bits in a double for the target machine.
 408 v:2:TARGET_DOUBLE_BIT:int:double_bit::::8 * sizeof (double):8*TARGET_CHAR_BIT::0
 409 # Number of bits in a long double for the target machine.
 410 v:2:TARGET_LONG_DOUBLE_BIT:int:long_double_bit::::8 * sizeof (long double):8*TARGET_CHAR_BIT::0
 411 # For most targets, a pointer on the target and its representation as an
 412 # address in GDB have the same size and "look the same".  For such a
 413 # target, you need only set TARGET_PTR_BIT / ptr_bit and TARGET_ADDR_BIT
 414 # / addr_bit will be set from it.
 415 #
 416 # If TARGET_PTR_BIT and TARGET_ADDR_BIT are different, you'll probably
 417 # also need to set POINTER_TO_ADDRESS and ADDRESS_TO_POINTER as well.
 418 #
 419 # ptr_bit is the size of a pointer on the target
 420 v:2:TARGET_PTR_BIT:int:ptr_bit::::8 * sizeof (void*):TARGET_INT_BIT::0
 421 # addr_bit is the size of a target address as represented in gdb
 422 v:2:TARGET_ADDR_BIT:int:addr_bit::::8 * sizeof (void*):0:TARGET_PTR_BIT:
 423 # Number of bits in a BFD_VMA for the target object file format.
 424 v:2:TARGET_BFD_VMA_BIT:int:bfd_vma_bit::::8 * sizeof (void*):TARGET_ARCHITECTURE->bits_per_address::0
 425 #
 426 # One if \`char' acts like \`signed char', zero if \`unsigned char'.
 427 v:2:TARGET_CHAR_SIGNED:int:char_signed::::1:-1:1::::
 428 #
 429 F:2:TARGET_READ_PC:CORE_ADDR:read_pc:ptid_t ptid:ptid
 430 f:2:TARGET_WRITE_PC:void:write_pc:CORE_ADDR val, ptid_t ptid:val, ptid::0:generic_target_write_pc::0
 431 # UNWIND_SP is a direct replacement for TARGET_READ_SP.
 432 F:2:TARGET_READ_SP:CORE_ADDR:read_sp:void
 433 # The dummy call frame SP should be set by push_dummy_call.
 434 F:2:DEPRECATED_DUMMY_WRITE_SP:void:deprecated_dummy_write_sp:CORE_ADDR val:val
 435 # Function for getting target's idea of a frame pointer.  FIXME: GDB's
 436 # whole scheme for dealing with "frames" and "frame pointers" needs a
 437 # serious shakedown.
 438 f:2:TARGET_VIRTUAL_FRAME_POINTER:void:virtual_frame_pointer:CORE_ADDR pc, int *frame_regnum, LONGEST *frame_offset:pc, frame_regnum, frame_offset::0:legacy_virtual_frame_pointer::0
 439 #
 440 M:::void:pseudo_register_read:struct regcache *regcache, int cookednum, void *buf:regcache, cookednum, buf:
 441 M:::void:pseudo_register_write:struct regcache *regcache, int cookednum, const void *buf:regcache, cookednum, buf:
 442 #
 443 v:2:NUM_REGS:int:num_regs::::0:-1
 444 # This macro gives the number of pseudo-registers that live in the
 445 # register namespace but do not get fetched or stored on the target.
 446 # These pseudo-registers may be aliases for other registers,
 447 # combinations of other registers, or they may be computed by GDB.
 448 v:2:NUM_PSEUDO_REGS:int:num_pseudo_regs::::0:0::0:::
 449
 450 # GDB's standard (or well known) register numbers.  These can map onto
 451 # a real register or a pseudo (computed) register or not be defined at
 452 # all (-1).
 453 # SP_REGNUM will hopefully be replaced by UNWIND_SP.
 454 v:2:SP_REGNUM:int:sp_regnum::::-1:-1::0
 455 v:2:PC_REGNUM:int:pc_regnum::::-1:-1::0
 456 v:2:PS_REGNUM:int:ps_regnum::::-1:-1::0
 457 v:2:FP0_REGNUM:int:fp0_regnum::::0:-1::0
 458 v:2:NPC_REGNUM:int:npc_regnum::::0:-1::0
 459 # Convert stab register number (from \`r\' declaration) to a gdb REGNUM.
 460 f:2:STAB_REG_TO_REGNUM:int:stab_reg_to_regnum:int stab_regnr:stab_regnr:::no_op_reg_to_regnum::0
 461 # Provide a default mapping from a ecoff register number to a gdb REGNUM.
 462 f:2:ECOFF_REG_TO_REGNUM:int:ecoff_reg_to_regnum:int ecoff_regnr:ecoff_regnr:::no_op_reg_to_regnum::0
 463 # Provide a default mapping from a DWARF register number to a gdb REGNUM.
 464 f:2:DWARF_REG_TO_REGNUM:int:dwarf_reg_to_regnum:int dwarf_regnr:dwarf_regnr:::no_op_reg_to_regnum::0
 465 # Convert from an sdb register number to an internal gdb register number.
 466 # This should be defined in tm.h, if REGISTER_NAMES is not set up
 467 # to map one to one onto the sdb register numbers.
 468 f:2:SDB_REG_TO_REGNUM:int:sdb_reg_to_regnum:int sdb_regnr:sdb_regnr:::no_op_reg_to_regnum::0
 469 f:2:DWARF2_REG_TO_REGNUM:int:dwarf2_reg_to_regnum:int dwarf2_regnr:dwarf2_regnr:::no_op_reg_to_regnum::0
 470 f:2:REGISTER_NAME:const char *:register_name:int regnr:regnr:::legacy_register_name::0
 471 # See the dummy frame code.
 472 v::DEPRECATED_REGISTER_SIZE:int:deprecated_register_size
 473
 474 # REGISTER_TYPE is a direct replacement for REGISTER_VIRTUAL_TYPE.
 475 M:2:REGISTER_TYPE:struct type *:register_type:int reg_nr:reg_nr::0:
 476 # REGISTER_TYPE is a direct replacement for REGISTER_VIRTUAL_TYPE.
 477 F:2:REGISTER_VIRTUAL_TYPE:struct type *:deprecated_register_virtual_type:int reg_nr:reg_nr::0:0
 478 # DEPRECATED_REGISTER_BYTES can be deleted.  The value is computed
 479 # from REGISTER_TYPE.
 480 v::DEPRECATED_REGISTER_BYTES:int:deprecated_register_bytes
 481 # If the value returned by DEPRECATED_REGISTER_BYTE agrees with the
 482 # register offsets computed using just REGISTER_TYPE, this can be
 483 # deleted.  See: maint print registers.  NOTE: cagney/2002-05-02: This
 484 # function with predicate has a valid (callable) initial value.  As a
 485 # consequence, even when the predicate is false, the corresponding
 486 # function works.  This simplifies the migration process - old code,
 487 # calling DEPRECATED_REGISTER_BYTE, doesn't need to be modified.
 488 F::REGISTER_BYTE:int:deprecated_register_byte:int reg_nr:reg_nr::generic_register_byte:generic_register_byte
 489 # If all registers have identical raw and virtual sizes and those
 490 # sizes agree with the value computed from REGISTER_TYPE,
 491 # DEPRECATED_REGISTER_RAW_SIZE can be deleted.  See: maint print
 492 # registers.
 493 f:2:REGISTER_RAW_SIZE:int:deprecated_register_raw_size:int reg_nr:reg_nr::generic_register_size:generic_register_size::0
 494 # If all registers have identical raw and virtual sizes and those
 495 # sizes agree with the value computed from REGISTER_TYPE,
 496 # DEPRECATED_REGISTER_VIRTUAL_SIZE can be deleted.  See: maint print
 497 # registers.
 498 f:2:REGISTER_VIRTUAL_SIZE:int:deprecated_register_virtual_size:int reg_nr:reg_nr::generic_register_size:generic_register_size::0
 499 # DEPRECATED_MAX_REGISTER_RAW_SIZE can be deleted.  It has been
 500 # replaced by the constant MAX_REGISTER_SIZE.
 501 V:2:DEPRECATED_MAX_REGISTER_RAW_SIZE:int:deprecated_max_register_raw_size
 502 # DEPRECATED_MAX_REGISTER_VIRTUAL_SIZE can be deleted.  It has been
 503 # replaced by the constant MAX_REGISTER_SIZE.
 504 V:2:DEPRECATED_MAX_REGISTER_VIRTUAL_SIZE:int:deprecated_max_register_virtual_size
 505
 506 # See gdbint.texinfo, and PUSH_DUMMY_CALL.
 507 M::UNWIND_DUMMY_ID:struct frame_id:unwind_dummy_id:struct frame_info *info:info::0:0
 508 # Implement UNWIND_DUMMY_ID and PUSH_DUMMY_CALL, then delete
 509 # SAVE_DUMMY_FRAME_TOS.
 510 F:2:SAVE_DUMMY_FRAME_TOS:void:save_dummy_frame_tos:CORE_ADDR sp:sp::0:0
 511 # Implement UNWIND_DUMMY_ID and PUSH_DUMMY_CALL, then delete
 512 # DEPRECATED_FP_REGNUM.
 513 v:2:DEPRECATED_FP_REGNUM:int:deprecated_fp_regnum::::-1:-1::0
 514 # Implement UNWIND_DUMMY_ID and PUSH_DUMMY_CALL, then delete
 515 # DEPRECATED_TARGET_READ_FP.
 516 F::DEPRECATED_TARGET_READ_FP:CORE_ADDR:deprecated_target_read_fp:void
 517
 518 F:2:DEPRECATED_DO_REGISTERS_INFO:void:deprecated_do_registers_info:int reg_nr, int fpregs:reg_nr, fpregs
 519 m:2:PRINT_REGISTERS_INFO: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
 520 M:2:PRINT_FLOAT_INFO:void:print_float_info:struct ui_file *file, struct frame_info *frame, const char *args:file, frame, args
 521 M:2:PRINT_VECTOR_INFO:void:print_vector_info:struct ui_file *file, struct frame_info *frame, const char *args:file, frame, args
 522 # MAP a GDB RAW register number onto a simulator register number.  See
 523 # also include/...-sim.h.
 524 f:2:REGISTER_SIM_REGNO:int:register_sim_regno:int reg_nr:reg_nr:::legacy_register_sim_regno::0
 525 F:2:REGISTER_BYTES_OK:int:register_bytes_ok:long nr_bytes:nr_bytes::0:0
 526 f:2:CANNOT_FETCH_REGISTER:int:cannot_fetch_register:int regnum:regnum:::cannot_register_not::0
 527 f:2:CANNOT_STORE_REGISTER:int:cannot_store_register:int regnum:regnum:::cannot_register_not::0
 528 # setjmp/longjmp support.
 529 F:2:GET_LONGJMP_TARGET:int:get_longjmp_target:CORE_ADDR *pc:pc::0:0
 530 #
 531 # Non multi-arch DUMMY_FRAMES are a mess (multi-arch ones are not that
 532 # much better but at least they are vaguely consistent).  The headers
 533 # and body contain convoluted #if/#else sequences for determine how
 534 # things should be compiled.  Instead of trying to mimic that
 535 # behaviour here (and hence entrench it further) gdbarch simply
 536 # reqires that these methods be set up from the word go.  This also
 537 # avoids any potential problems with moving beyond multi-arch partial.
 538 v::DEPRECATED_USE_GENERIC_DUMMY_FRAMES:int:deprecated_use_generic_dummy_frames:::::1::0
 539 # Replaced by push_dummy_code.
 540 v::CALL_DUMMY_LOCATION:int:call_dummy_location:::::AT_ENTRY_POINT::0
 541 # Replaced by push_dummy_code.
 542 f::CALL_DUMMY_ADDRESS:CORE_ADDR:call_dummy_address:void::::entry_point_address::0
 543 # Replaced by push_dummy_code.
 544 v::DEPRECATED_CALL_DUMMY_START_OFFSET:CORE_ADDR:deprecated_call_dummy_start_offset
 545 # Replaced by push_dummy_code.
 546 v::DEPRECATED_CALL_DUMMY_BREAKPOINT_OFFSET:CORE_ADDR:deprecated_call_dummy_breakpoint_offset
 547 # Replaced by push_dummy_code.
 548 v::DEPRECATED_CALL_DUMMY_LENGTH:int:deprecated_call_dummy_length
 549 # NOTE: cagney/2002-11-24: This function with predicate has a valid
 550 # (callable) initial value.  As a consequence, even when the predicate
 551 # is false, the corresponding function works.  This simplifies the
 552 # migration process - old code, calling DEPRECATED_PC_IN_CALL_DUMMY(),
 553 # doesn't need to be modified.
 554 F::DEPRECATED_PC_IN_CALL_DUMMY:int:deprecated_pc_in_call_dummy:CORE_ADDR pc, CORE_ADDR sp, CORE_ADDR frame_address:pc, sp, frame_address::generic_pc_in_call_dummy:generic_pc_in_call_dummy
 555 # Replaced by push_dummy_code.
 556 v::DEPRECATED_CALL_DUMMY_WORDS:LONGEST *:deprecated_call_dummy_words::::0:legacy_call_dummy_words::0:0x%08lx
 557 # Replaced by push_dummy_code.
 558 v::DEPRECATED_SIZEOF_CALL_DUMMY_WORDS:int:deprecated_sizeof_call_dummy_words::::0:legacy_sizeof_call_dummy_words::0
 559 # Replaced by push_dummy_code.
 560 V:2:DEPRECATED_CALL_DUMMY_STACK_ADJUST:int:deprecated_call_dummy_stack_adjust::::0
 561 # Replaced by push_dummy_code.
 562 F::DEPRECATED_FIX_CALL_DUMMY:void:deprecated_fix_call_dummy:char *dummy, CORE_ADDR pc, CORE_ADDR fun, int nargs, struct value **args, struct type *type, int gcc_p:dummy, pc, fun, nargs, args, type, gcc_p
 563 # This is a replacement for DEPRECATED_FIX_CALL_DUMMY et.al.
 564 M::PUSH_DUMMY_CODE:CORE_ADDR:push_dummy_code:CORE_ADDR sp, CORE_ADDR funaddr, int using_gcc, struct value **args, int nargs, struct type *value_type, CORE_ADDR *real_pc, CORE_ADDR *bp_addr:sp, funaddr, using_gcc, args, nargs, value_type, real_pc, bp_addr:
 565 F:2:DEPRECATED_INIT_FRAME_PC_FIRST:CORE_ADDR:deprecated_init_frame_pc_first:int fromleaf, struct frame_info *prev:fromleaf, prev
 566 F:2:DEPRECATED_INIT_FRAME_PC:CORE_ADDR:deprecated_init_frame_pc:int fromleaf, struct frame_info *prev:fromleaf, prev
 567 #
 568 v:2:BELIEVE_PCC_PROMOTION:int:believe_pcc_promotion:::::::
 569 v::BELIEVE_PCC_PROMOTION_TYPE:int:believe_pcc_promotion_type:::::::
 570 F:2:DEPRECATED_GET_SAVED_REGISTER:void:deprecated_get_saved_register:char *raw_buffer, int *optimized, CORE_ADDR *addrp, struct frame_info *frame, int regnum, enum lval_type *lval:raw_buffer, optimized, addrp, frame, regnum, lval
 571 #
 572 # For register <-> value conversions, replaced by CONVERT_REGISTER_P et.al.
 573 # For raw <-> cooked register conversions, replaced by pseudo registers.
 574 f:2:DEPRECATED_REGISTER_CONVERTIBLE:int:deprecated_register_convertible:int nr:nr:::deprecated_register_convertible_not::0
 575 # For register <-> value conversions, replaced by CONVERT_REGISTER_P et.al.
 576 # For raw <-> cooked register conversions, replaced by pseudo registers.
 577 f:2:DEPRECATED_REGISTER_CONVERT_TO_VIRTUAL:void:deprecated_register_convert_to_virtual:int regnum, struct type *type, char *from, char *to:regnum, type, from, to:::0::0
 578 # For register <-> value conversions, replaced by CONVERT_REGISTER_P et.al.
 579 # For raw <-> cooked register conversions, replaced by pseudo registers.
 580 f:2:DEPRECATED_REGISTER_CONVERT_TO_RAW:void:deprecated_register_convert_to_raw:struct type *type, int regnum, const char *from, char *to:type, regnum, from, to:::0::0
 581 #
 582 f:1:CONVERT_REGISTER_P:int:convert_register_p:int regnum:regnum::0:legacy_convert_register_p::0
 583 f:1:REGISTER_TO_VALUE:void:register_to_value:int regnum, struct type *type, char *from, char *to:regnum, type, from, to::0:legacy_register_to_value::0
 584 f:1:VALUE_TO_REGISTER:void:value_to_register:struct type *type, int regnum, char *from, char *to:type, regnum, from, to::0:legacy_value_to_register::0
 585 #
 586 f:2:POINTER_TO_ADDRESS:CORE_ADDR:pointer_to_address:struct type *type, const void *buf:type, buf:::unsigned_pointer_to_address::0
 587 f:2:ADDRESS_TO_POINTER:void:address_to_pointer:struct type *type, void *buf, CORE_ADDR addr:type, buf, addr:::unsigned_address_to_pointer::0
 588 F:2:INTEGER_TO_ADDRESS:CORE_ADDR:integer_to_address:struct type *type, void *buf:type, buf
 589 #
 590 f:2:RETURN_VALUE_ON_STACK:int:return_value_on_stack:struct type *type:type:::generic_return_value_on_stack_not::0
 591 # Replaced by PUSH_DUMMY_CALL
 592 F:2:DEPRECATED_PUSH_ARGUMENTS:CORE_ADDR:deprecated_push_arguments:int nargs, struct value **args, CORE_ADDR sp, int struct_return, CORE_ADDR struct_addr:nargs, args, sp, struct_return, struct_addr
 593 M::PUSH_DUMMY_CALL:CORE_ADDR:push_dummy_call:CORE_ADDR func_addr, struct regcache *regcache, CORE_ADDR bp_addr, int nargs, struct value **args, CORE_ADDR sp, int struct_return, CORE_ADDR struct_addr:func_addr, regcache, bp_addr, nargs, args, sp, struct_return, struct_addr
 594 F:2:DEPRECATED_PUSH_DUMMY_FRAME:void:deprecated_push_dummy_frame:void:-:::0
 595 # NOTE: This can be handled directly in push_dummy_call.
 596 F:2:DEPRECATED_PUSH_RETURN_ADDRESS:CORE_ADDR:deprecated_push_return_address:CORE_ADDR pc, CORE_ADDR sp:pc, sp:::0
 597 F:2:DEPRECATED_POP_FRAME:void:deprecated_pop_frame:void:-:::0
 598 # NOTE: cagney/2003-03-24: Replaced by PUSH_ARGUMENTS.
 599 F:2:DEPRECATED_STORE_STRUCT_RETURN:void:deprecated_store_struct_return:CORE_ADDR addr, CORE_ADDR sp:addr, sp:::0
 600 #
 601 f:2:EXTRACT_RETURN_VALUE:void:extract_return_value:struct type *type, struct regcache *regcache, void *valbuf:type, regcache, valbuf:::legacy_extract_return_value::0
 602 f:2:STORE_RETURN_VALUE:void:store_return_value:struct type *type, struct regcache *regcache, const void *valbuf:type, regcache, valbuf:::legacy_store_return_value::0
 603 f:2:DEPRECATED_EXTRACT_RETURN_VALUE:void:deprecated_extract_return_value:struct type *type, char *regbuf, char *valbuf:type, regbuf, valbuf
 604 f:2:DEPRECATED_STORE_RETURN_VALUE:void:deprecated_store_return_value:struct type *type, char *valbuf:type, valbuf
 605 #
 606 F:2:EXTRACT_STRUCT_VALUE_ADDRESS:CORE_ADDR:extract_struct_value_address:struct regcache *regcache:regcache:::0
 607 F:2:DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS:CORE_ADDR:deprecated_extract_struct_value_address:char *regbuf:regbuf:::0
 608 f:2:USE_STRUCT_CONVENTION:int:use_struct_convention:int gcc_p, struct type *value_type:gcc_p, value_type:::generic_use_struct_convention::0
 609 #
 610 F:2:DEPRECATED_FRAME_INIT_SAVED_REGS:void:deprecated_frame_init_saved_regs:struct frame_info *frame:frame:::0
 611 F:2:DEPRECATED_INIT_EXTRA_FRAME_INFO:void:deprecated_init_extra_frame_info:int fromleaf, struct frame_info *frame:fromleaf, frame:::0
 612 #
 613 f:2:SKIP_PROLOGUE:CORE_ADDR:skip_prologue:CORE_ADDR ip:ip::0:0
 614 f:2:PROLOGUE_FRAMELESS_P:int:prologue_frameless_p:CORE_ADDR ip:ip::0:generic_prologue_frameless_p::0
 615 f:2:INNER_THAN:int:inner_than:CORE_ADDR lhs, CORE_ADDR rhs:lhs, rhs::0:0
 616 f::BREAKPOINT_FROM_PC:const unsigned char *:breakpoint_from_pc:CORE_ADDR *pcptr, int *lenptr:pcptr, lenptr:::0:
 617 f:2:MEMORY_INSERT_BREAKPOINT:int:memory_insert_breakpoint:CORE_ADDR addr, char *contents_cache:addr, contents_cache::0:default_memory_insert_breakpoint::0
 618 f:2:MEMORY_REMOVE_BREAKPOINT:int:memory_remove_breakpoint:CORE_ADDR addr, char *contents_cache:addr, contents_cache::0:default_memory_remove_breakpoint::0
 619 v:2:DECR_PC_AFTER_BREAK:CORE_ADDR:decr_pc_after_break::::0:-1
 620 f:2:PREPARE_TO_PROCEED:int:prepare_to_proceed:int select_it:select_it::0:default_prepare_to_proceed::0
 621 v:2:FUNCTION_START_OFFSET:CORE_ADDR:function_start_offset::::0:-1
 622 #
 623 m::REMOTE_TRANSLATE_XFER_ADDRESS:void:remote_translate_xfer_address:struct regcache *regcache, CORE_ADDR gdb_addr, int gdb_len, CORE_ADDR *rem_addr, int *rem_len:regcache, gdb_addr, gdb_len, rem_addr, rem_len:::generic_remote_translate_xfer_address::0
 624 #
 625 v:2:FRAME_ARGS_SKIP:CORE_ADDR:frame_args_skip::::0:-1
 626 f:2:FRAMELESS_FUNCTION_INVOCATION:int:frameless_function_invocation:struct frame_info *fi:fi:::generic_frameless_function_invocation_not::0
 627 F:2:DEPRECATED_FRAME_CHAIN:CORE_ADDR:deprecated_frame_chain:struct frame_info *frame:frame::0:0
 628 F:2:DEPRECATED_FRAME_CHAIN_VALID:int:deprecated_frame_chain_valid:CORE_ADDR chain, struct frame_info *thisframe:chain, thisframe::0:0
 629 # DEPRECATED_FRAME_SAVED_PC has been replaced by UNWIND_PC.  Please
 630 # note, per UNWIND_PC's doco, that while the two have similar
 631 # interfaces they have very different underlying implementations.
 632 F:2:DEPRECATED_FRAME_SAVED_PC:CORE_ADDR:deprecated_frame_saved_pc:struct frame_info *fi:fi::0:0
 633 M::UNWIND_PC:CORE_ADDR:unwind_pc:struct frame_info *next_frame:next_frame:
 634 M::UNWIND_SP:CORE_ADDR:unwind_sp:struct frame_info *next_frame:next_frame:
 635 f:2:FRAME_ARGS_ADDRESS:CORE_ADDR:frame_args_address:struct frame_info *fi:fi::0:get_frame_base::0
 636 f:2:FRAME_LOCALS_ADDRESS:CORE_ADDR:frame_locals_address:struct frame_info *fi:fi::0:get_frame_base::0
 637 F::DEPRECATED_SAVED_PC_AFTER_CALL:CORE_ADDR:deprecated_saved_pc_after_call:struct frame_info *frame:frame
 638 F:2:FRAME_NUM_ARGS:int:frame_num_args:struct frame_info *frame:frame
 639 #
 640 F:2:STACK_ALIGN:CORE_ADDR:stack_align:CORE_ADDR sp:sp::0:0
 641 M:::CORE_ADDR:frame_align:CORE_ADDR address:address
 642 # NOTE: cagney/2003-03-24: This is better handled by PUSH_ARGUMENTS.
 643 v:2:DEPRECATED_EXTRA_STACK_ALIGNMENT_NEEDED:int:deprecated_extra_stack_alignment_needed::::0:0::0:::
 644 F:2:REG_STRUCT_HAS_ADDR:int:reg_struct_has_addr:int gcc_p, struct type *type:gcc_p, type::0:0
 645 v:2:PARM_BOUNDARY:int:parm_boundary
 646 #
 647 v:2:TARGET_FLOAT_FORMAT:const struct floatformat *:float_format::::::default_float_format (gdbarch)::%s:(TARGET_FLOAT_FORMAT)->name
 648 v:2:TARGET_DOUBLE_FORMAT:const struct floatformat *:double_format::::::default_double_format (gdbarch)::%s:(TARGET_DOUBLE_FORMAT)->name
 649 v:2:TARGET_LONG_DOUBLE_FORMAT:const struct floatformat *:long_double_format::::::default_double_format (gdbarch)::%s:(TARGET_LONG_DOUBLE_FORMAT)->name
 650 f:2:CONVERT_FROM_FUNC_PTR_ADDR:CORE_ADDR:convert_from_func_ptr_addr:CORE_ADDR addr:addr:::core_addr_identity::0
 651 # On some machines there are bits in addresses which are not really
 652 # part of the address, but are used by the kernel, the hardware, etc.
 653 # for special purposes.  ADDR_BITS_REMOVE takes out any such bits so
 654 # we get a "real" address such as one would find in a symbol table.
 655 # This is used only for addresses of instructions, and even then I'm
 656 # not sure it's used in all contexts.  It exists to deal with there
 657 # being a few stray bits in the PC which would mislead us, not as some
 658 # sort of generic thing to handle alignment or segmentation (it's
 659 # possible it should be in TARGET_READ_PC instead).
 660 f:2:ADDR_BITS_REMOVE:CORE_ADDR:addr_bits_remove:CORE_ADDR addr:addr:::core_addr_identity::0
 661 # It is not at all clear why SMASH_TEXT_ADDRESS is not folded into
 662 # ADDR_BITS_REMOVE.
 663 f:2:SMASH_TEXT_ADDRESS:CORE_ADDR:smash_text_address:CORE_ADDR addr:addr:::core_addr_identity::0
 664 # FIXME/cagney/2001-01-18: This should be split in two.  A target method that indicates if
 665 # the target needs software single step.  An ISA method to implement it.
 666 #
 667 # FIXME/cagney/2001-01-18: This should be replaced with something that inserts breakpoints
 668 # using the breakpoint system instead of blatting memory directly (as with rs6000).
 669 #
 670 # FIXME/cagney/2001-01-18: The logic is backwards.  It should be asking if the target can
 671 # single step.  If not, then implement single step using breakpoints.
 672 F:2:SOFTWARE_SINGLE_STEP:void:software_single_step:enum target_signal sig, int insert_breakpoints_p:sig, insert_breakpoints_p::0:0
 673 f:2:TARGET_PRINT_INSN:int:print_insn:bfd_vma vma, disassemble_info *info:vma, info:::legacy_print_insn::0
 674 f:2:SKIP_TRAMPOLINE_CODE:CORE_ADDR:skip_trampoline_code:CORE_ADDR pc:pc:::generic_skip_trampoline_code::0
 675
 676
 677 # For SVR4 shared libraries, each call goes through a small piece of
 678 # trampoline code in the ".plt" section.  IN_SOLIB_CALL_TRAMPOLINE evaluates
 679 # to nonzero if we are currently stopped in one of these.
 680 f:2:IN_SOLIB_CALL_TRAMPOLINE:int:in_solib_call_trampoline:CORE_ADDR pc, char *name:pc, name:::generic_in_solib_call_trampoline::0
 681
 682 # Some systems also have trampoline code for returning from shared libs.
 683 f:2:IN_SOLIB_RETURN_TRAMPOLINE:int:in_solib_return_trampoline:CORE_ADDR pc, char *name:pc, name:::generic_in_solib_return_trampoline::0
 684
 685 # Sigtramp is a routine that the kernel calls (which then calls the
 686 # signal handler).  On most machines it is a library routine that is
 687 # linked into the executable.
 688 #
 689 # This macro, given a program counter value and the name of the
 690 # function in which that PC resides (which can be null if the name is
 691 # not known), returns nonzero if the PC and name show that we are in
 692 # sigtramp.
 693 #
 694 # On most machines just see if the name is sigtramp (and if we have
 695 # no name, assume we are not in sigtramp).
 696 #
 697 # FIXME: cagney/2002-04-21: The function find_pc_partial_function
 698 # calls find_pc_sect_partial_function() which calls PC_IN_SIGTRAMP.
 699 # This means PC_IN_SIGTRAMP function can't be implemented by doing its
 700 # own local NAME lookup.
 701 #
 702 # FIXME: cagney/2002-04-21: PC_IN_SIGTRAMP is something of a mess.
 703 # Some code also depends on SIGTRAMP_START and SIGTRAMP_END but other
 704 # does not.
 705 f:2:PC_IN_SIGTRAMP:int:pc_in_sigtramp:CORE_ADDR pc, char *name:pc, name:::legacy_pc_in_sigtramp::0
 706 F:2:SIGTRAMP_START:CORE_ADDR:sigtramp_start:CORE_ADDR pc:pc
 707 F:2:SIGTRAMP_END:CORE_ADDR:sigtramp_end:CORE_ADDR pc:pc
 708 # A target might have problems with watchpoints as soon as the stack
 709 # frame of the current function has been destroyed.  This mostly happens
 710 # as the first action in a funtion's epilogue.  in_function_epilogue_p()
 711 # is defined to return a non-zero value if either the given addr is one
 712 # instruction after the stack destroying instruction up to the trailing
 713 # return instruction or if we can figure out that the stack frame has
 714 # already been invalidated regardless of the value of addr.  Targets
 715 # which don't suffer from that problem could just let this functionality
 716 # untouched.
 717 m:::int:in_function_epilogue_p:CORE_ADDR addr:addr::0:generic_in_function_epilogue_p::0
 718 # Given a vector of command-line arguments, return a newly allocated
 719 # string which, when passed to the create_inferior function, will be
 720 # parsed (on Unix systems, by the shell) to yield the same vector.
 721 # This function should call error() if the argument vector is not
 722 # representable for this target or if this target does not support
 723 # command-line arguments.
 724 # ARGC is the number of elements in the vector.
 725 # ARGV is an array of strings, one per argument.
 726 m::CONSTRUCT_INFERIOR_ARGUMENTS:char *:construct_inferior_arguments:int argc, char **argv:argc, argv:::construct_inferior_arguments::0
 727 F:2:DWARF2_BUILD_FRAME_INFO:void:dwarf2_build_frame_info:struct objfile *objfile:objfile:::0
 728 f:2:ELF_MAKE_MSYMBOL_SPECIAL:void:elf_make_msymbol_special:asymbol *sym, struct minimal_symbol *msym:sym, msym:::default_elf_make_msymbol_special::0
 729 f:2:COFF_MAKE_MSYMBOL_SPECIAL:void:coff_make_msymbol_special:int val, struct minimal_symbol *msym:val, msym:::default_coff_make_msymbol_special::0
 730 v:2:NAME_OF_MALLOC:const char *:name_of_malloc::::"malloc":"malloc"::0:%s:NAME_OF_MALLOC
 731 v:2:CANNOT_STEP_BREAKPOINT:int:cannot_step_breakpoint::::0:0::0
 732 v:2:HAVE_NONSTEPPABLE_WATCHPOINT:int:have_nonsteppable_watchpoint::::0:0::0
 733 F:2:ADDRESS_CLASS_TYPE_FLAGS:int:address_class_type_flags:int byte_size, int dwarf2_addr_class:byte_size, dwarf2_addr_class
 734 M:2:ADDRESS_CLASS_TYPE_FLAGS_TO_NAME:const char *:address_class_type_flags_to_name:int type_flags:type_flags:
 735 M:2:ADDRESS_CLASS_NAME_TO_TYPE_FLAGS:int:address_class_name_to_type_flags:const char *name, int *type_flags_ptr:name, type_flags_ptr
 736 # Is a register in a group
 737 m:::int:register_reggroup_p:int regnum, struct reggroup *reggroup:regnum, reggroup:::default_register_reggroup_p::0
 738 # Fetch the pointer to the ith function argument.
 739 F::FETCH_POINTER_ARGUMENT:CORE_ADDR:fetch_pointer_argument:struct frame_info *frame, int argi, struct type *type:frame, argi, type:::::::::
 740 EOF
 741 }
 742
 743 #
 744 # The .log file
 745 #
 746 exec > new-gdbarch.log
 747 function_list | while do_read
 748 do
 749     cat <<EOF
 750 ${class} ${macro}(${actual})
 751   ${returntype} ${function} ($formal)${attrib}
 752 EOF
 753     for r in ${read}
 754     do
 755         eval echo \"\ \ \ \ ${r}=\${${r}}\"
 756     done
 757     if class_is_predicate_p && fallback_default_p
 758     then
 759         echo "Error: predicate function ${macro} can not have a non- multi-arch default" 1>&2
 760         kill $$
 761         exit 1
 762     fi
 763     if [ "x${invalid_p}" = "x0" -a -n "${postdefault}" ]
 764     then
 765         echo "Error: postdefault is useless when invalid_p=0" 1>&2
 766         kill $$
 767         exit 1
 768     fi
 769     if class_is_multiarch_p
 770     then
 771         if class_is_predicate_p ; then :
 772         elif test "x${predefault}" = "x"
 773         then
 774             echo "Error: pure multi-arch function must have a predefault" 1>&2
 775             kill $$
 776             exit 1
 777         fi
 778     fi
 779     echo ""
 780 done
 781
 782 exec 1>&2
 783 compare_new gdbarch.log
 784
 785
 786 copyright ()
 787 {
 788 cat <<EOF
 789 /* *INDENT-OFF* */ /* THIS FILE IS GENERATED */
 790
 791 /* Dynamic architecture support for GDB, the GNU debugger.
 792    Copyright 1998, 1999, 2000, 2001, 2002, 2003 Free Software Foundation, Inc.
 793
 794    This file is part of GDB.
 795
 796    This program is free software; you can redistribute it and/or modify
 797    it under the terms of the GNU General Public License as published by
 798    the Free Software Foundation; either version 2 of the License, or
 799    (at your option) any later version.
 800
 801    This program is distributed in the hope that it will be useful,
 802    but WITHOUT ANY WARRANTY; without even the implied warranty of
 803    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 804    GNU General Public License for more details.
 805
 806    You should have received a copy of the GNU General Public License
 807    along with this program; if not, write to the Free Software
 808    Foundation, Inc., 59 Temple Place - Suite 330,
 809    Boston, MA 02111-1307, USA.  */
 810
 811 /* This file was created with the aid of \`\`gdbarch.sh''.
 812
 813    The Bourne shell script \`\`gdbarch.sh'' creates the files
 814    \`\`new-gdbarch.c'' and \`\`new-gdbarch.h and then compares them
 815    against the existing \`\`gdbarch.[hc]''.  Any differences found
 816    being reported.
 817
 818    If editing this file, please also run gdbarch.sh and merge any
 819    changes into that script. Conversely, when making sweeping changes
 820    to this file, modifying gdbarch.sh and using its output may prove
 821    easier. */
 822
 823 EOF
 824 }
 825
 826 #
 827 # The .h file
 828 #
 829
 830 exec > new-gdbarch.h
 831 copyright
 832 cat <<EOF
 833 #ifndef GDBARCH_H
 834 #define GDBARCH_H
 835
 836 #include "dis-asm.h" /* Get defs for disassemble_info, which unfortunately is a typedef. */
 837 #if !GDB_MULTI_ARCH
 838 /* Pull in function declarations refered to, indirectly, via macros.  */
 839 #include "inferior.h"           /* For unsigned_address_to_pointer().  */
 840 #include "symfile.h"            /* For entry_point_address().  */
 841 #endif
 842
 843 struct floatformat;
 844 struct ui_file;
 845 struct frame_info;
 846 struct value;
 847 struct objfile;
 848 struct minimal_symbol;
 849 struct regcache;
 850 struct reggroup;
 851
 852 extern struct gdbarch *current_gdbarch;
 853
 854
 855 /* If any of the following are defined, the target wasn't correctly
 856    converted. */
 857
 858 #if (GDB_MULTI_ARCH >= GDB_MULTI_ARCH_PURE) && defined (GDB_TM_FILE)
 859 #error "GDB_TM_FILE: Pure multi-arch targets do not have a tm.h file."
 860 #endif
 861 EOF
 862
 863 # function typedef's
 864 printf "\n"
 865 printf "\n"
 866 printf "/* The following are pre-initialized by GDBARCH. */\n"
 867 function_list | while do_read
 868 do
 869     if class_is_info_p
 870     then
 871         printf "\n"
 872         printf "extern ${returntype} gdbarch_${function} (struct gdbarch *gdbarch);\n"
 873         printf "/* set_gdbarch_${function}() - not applicable - pre-initialized. */\n"
 874         printf "#if (GDB_MULTI_ARCH ${gt_level}) && defined (${macro})\n"
 875         printf "#error \"Non multi-arch definition of ${macro}\"\n"
 876         printf "#endif\n"
 877         printf "#if !defined (${macro})\n"
 878         printf "#define ${macro} (gdbarch_${function} (current_gdbarch))\n"
 879         printf "#endif\n"
 880     fi
 881 done
 882
 883 # function typedef's
 884 printf "\n"
 885 printf "\n"
 886 printf "/* The following are initialized by the target dependent code. */\n"
 887 function_list | while do_read
 888 do
 889     if [ -n "${comment}" ]
 890     then
 891         echo "${comment}" | sed \
 892             -e '2 s,#,/*,' \
 893             -e '3,$ s,#,  ,' \
 894             -e '$ s,$, */,'
 895     fi
 896     if class_is_multiarch_p
 897     then
 898         if class_is_predicate_p
 899         then
 900             printf "\n"
 901             printf "extern int gdbarch_${function}_p (struct gdbarch *gdbarch);\n"
 902         fi
 903     else
 904         if class_is_predicate_p
 905         then
 906             printf "\n"
 907             printf "#if defined (${macro})\n"
 908             printf "/* Legacy for systems yet to multi-arch ${macro} */\n"
 909             #printf "#if (GDB_MULTI_ARCH <= GDB_MULTI_ARCH_PARTIAL) && defined (${macro})\n"
 910             printf "#if !defined (${macro}_P)\n"
 911             printf "#define ${macro}_P() (1)\n"
 912             printf "#endif\n"
 913             printf "#endif\n"
 914             printf "\n"
 915             printf "/* Default predicate for non- multi-arch targets. */\n"
 916             printf "#if (!GDB_MULTI_ARCH) && !defined (${macro}_P)\n"
 917             printf "#define ${macro}_P() (0)\n"
 918             printf "#endif\n"
 919             printf "\n"
 920             printf "extern int gdbarch_${function}_p (struct gdbarch *gdbarch);\n"
 921             printf "#if (GDB_MULTI_ARCH ${gt_level}) && defined (${macro}_P)\n"
 922             printf "#error \"Non multi-arch definition of ${macro}\"\n"
 923             printf "#endif\n"
 924             printf "#if (GDB_MULTI_ARCH ${gt_level}) || !defined (${macro}_P)\n"
 925             printf "#define ${macro}_P() (gdbarch_${function}_p (current_gdbarch))\n"
 926             printf "#endif\n"
 927         fi
 928     fi
 929     if class_is_variable_p
 930     then
 931         if fallback_default_p || class_is_predicate_p
 932         then
 933             printf "\n"
 934             printf "/* Default (value) for non- multi-arch platforms. */\n"
 935             printf "#if (!GDB_MULTI_ARCH) && !defined (${macro})\n"
 936             echo "#define ${macro} (${fallbackdefault})" \
 937                 | sed -e 's/\([^a-z_]\)\(gdbarch[^a-z_]\)/\1current_\2/g'
 938             printf "#endif\n"
 939         fi
 940         printf "\n"
 941         printf "extern ${returntype} gdbarch_${function} (struct gdbarch *gdbarch);\n"
 942         printf "extern void set_gdbarch_${function} (struct gdbarch *gdbarch, ${returntype} ${function});\n"
 943         printf "#if (GDB_MULTI_ARCH ${gt_level}) && defined (${macro})\n"
 944         printf "#error \"Non multi-arch definition of ${macro}\"\n"
 945         printf "#endif\n"
 946         printf "#if !defined (${macro})\n"
 947         printf "#define ${macro} (gdbarch_${function} (current_gdbarch))\n"
 948         printf "#endif\n"
 949     fi
 950     if class_is_function_p
 951     then
 952         if class_is_multiarch_p ; then :
 953         elif fallback_default_p || class_is_predicate_p
 954         then
 955             printf "\n"
 956             printf "/* Default (function) for non- multi-arch platforms. */\n"
 957             printf "#if (!GDB_MULTI_ARCH) && !defined (${macro})\n"
 958             if [ "x${fallbackdefault}" = "x0" ]
 959             then
 960                 if [ "x${actual}" = "x-" ]
 961                 then
 962                     printf "#define ${macro} (internal_error (__FILE__, __LINE__, \"${macro}\"), 0)\n"
 963                 else
 964                     printf "#define ${macro}(${actual}) (internal_error (__FILE__, __LINE__, \"${macro}\"), 0)\n"
 965                 fi
 966             else
 967                 # FIXME: Should be passing current_gdbarch through!
 968                 echo "#define ${macro}(${actual}) (${fallbackdefault} (${actual}))" \
 969                     | sed -e 's/\([^a-z_]\)\(gdbarch[^a-z_]\)/\1current_\2/g'
 970             fi
 971             printf "#endif\n"
 972         fi
 973         printf "\n"
 974         if [ "x${formal}" = "xvoid" ] && class_is_multiarch_p
 975         then
 976             printf "typedef ${returntype} (gdbarch_${function}_ftype) (struct gdbarch *gdbarch);\n"
 977         elif class_is_multiarch_p
 978         then
 979             printf "typedef ${returntype} (gdbarch_${function}_ftype) (struct gdbarch *gdbarch, ${formal});\n"
 980         else
 981             printf "typedef ${returntype} (gdbarch_${function}_ftype) (${formal});\n"
 982         fi
 983         if [ "x${formal}" = "xvoid" ]
 984         then
 985           printf "extern ${returntype} gdbarch_${function} (struct gdbarch *gdbarch);\n"
 986         else
 987           printf "extern ${returntype} gdbarch_${function} (struct gdbarch *gdbarch, ${formal});\n"
 988         fi
 989         printf "extern void set_gdbarch_${function} (struct gdbarch *gdbarch, gdbarch_${function}_ftype *${function});\n"
 990         if class_is_multiarch_p ; then :
 991         else
 992             printf "#if (GDB_MULTI_ARCH ${gt_level}) && defined (${macro})\n"
 993             printf "#error \"Non multi-arch definition of ${macro}\"\n"
 994             printf "#endif\n"
 995             if [ "x${actual}" = "x" ]
 996             then
 997                 d="#define ${macro}() (gdbarch_${function} (current_gdbarch))"
 998             elif [ "x${actual}" = "x-" ]
 999             then
1000                 d="#define ${macro} (gdbarch_${function} (current_gdbarch))"
1001             else
1002                 d="#define ${macro}(${actual}) (gdbarch_${function} (current_gdbarch, ${actual}))"
1003             fi
1004             printf "#if !defined (${macro})\n"
1005             if [ "x${actual}" = "x" ]
1006             then
1007                 printf "#define ${macro}() (gdbarch_${function} (current_gdbarch))\n"
1008             elif [ "x${actual}" = "x-" ]
1009             then
1010                 printf "#define ${macro} (gdbarch_${function} (current_gdbarch))\n"
1011             else
1012                 printf "#define ${macro}(${actual}) (gdbarch_${function} (current_gdbarch, ${actual}))\n"
1013             fi
1014             printf "#endif\n"
1015         fi
1016     fi
1017 done
1018
1019 # close it off
1020 cat <<EOF
1021
1022 extern struct gdbarch_tdep *gdbarch_tdep (struct gdbarch *gdbarch);
1023
1024
1025 /* Mechanism for co-ordinating the selection of a specific
1026    architecture.
1027
1028    GDB targets (*-tdep.c) can register an interest in a specific
1029    architecture.  Other GDB components can register a need to maintain
1030    per-architecture data.
1031
1032    The mechanisms below ensures that there is only a loose connection
1033    between the set-architecture command and the various GDB
1034    components.  Each component can independently register their need
1035    to maintain architecture specific data with gdbarch.
1036
1037    Pragmatics:
1038
1039    Previously, a single TARGET_ARCHITECTURE_HOOK was provided.  It
1040    didn't scale.
1041
1042    The more traditional mega-struct containing architecture specific
1043    data for all the various GDB components was also considered.  Since
1044    GDB is built from a variable number of (fairly independent)
1045    components it was determined that the global aproach was not
1046    applicable. */
1047
1048
1049 /* Register a new architectural family with GDB.
1050
1051    Register support for the specified ARCHITECTURE with GDB.  When
1052    gdbarch determines that the specified architecture has been
1053    selected, the corresponding INIT function is called.
1054
1055    --
1056
1057    The INIT function takes two parameters: INFO which contains the
1058    information available to gdbarch about the (possibly new)
1059    architecture; ARCHES which is a list of the previously created
1060    \`\`struct gdbarch'' for this architecture.
1061
1062    The INFO parameter is, as far as possible, be pre-initialized with
1063    information obtained from INFO.ABFD or the previously selected
1064    architecture.
1065
1066    The ARCHES parameter is a linked list (sorted most recently used)
1067    of all the previously created architures for this architecture
1068    family.  The (possibly NULL) ARCHES->gdbarch can used to access
1069    values from the previously selected architecture for this
1070    architecture family.  The global \`\`current_gdbarch'' shall not be
1071    used.
1072
1073    The INIT function shall return any of: NULL - indicating that it
1074    doesn't recognize the selected architecture; an existing \`\`struct
1075    gdbarch'' from the ARCHES list - indicating that the new
1076    architecture is just a synonym for an earlier architecture (see
1077    gdbarch_list_lookup_by_info()); a newly created \`\`struct gdbarch''
1078    - that describes the selected architecture (see gdbarch_alloc()).
1079
1080    The DUMP_TDEP function shall print out all target specific values.
1081    Care should be taken to ensure that the function works in both the
1082    multi-arch and non- multi-arch cases. */
1083
1084 struct gdbarch_list
1085 {
1086   struct gdbarch *gdbarch;
1087   struct gdbarch_list *next;
1088 };
1089
1090 struct gdbarch_info
1091 {
1092   /* Use default: NULL (ZERO). */
1093   const struct bfd_arch_info *bfd_arch_info;
1094
1095   /* Use default: BFD_ENDIAN_UNKNOWN (NB: is not ZERO).  */
1096   int byte_order;
1097
1098   /* Use default: NULL (ZERO). */
1099   bfd *abfd;
1100
1101   /* Use default: NULL (ZERO). */
1102   struct gdbarch_tdep_info *tdep_info;
1103
1104   /* Use default: GDB_OSABI_UNINITIALIZED (-1).  */
1105   enum gdb_osabi osabi;
1106 };
1107
1108 typedef struct gdbarch *(gdbarch_init_ftype) (struct gdbarch_info info, struct gdbarch_list *arches);
1109 typedef void (gdbarch_dump_tdep_ftype) (struct gdbarch *gdbarch, struct ui_file *file);
1110
1111 /* DEPRECATED - use gdbarch_register() */
1112 extern void register_gdbarch_init (enum bfd_architecture architecture, gdbarch_init_ftype *);
1113
1114 extern void gdbarch_register (enum bfd_architecture architecture,
1115                               gdbarch_init_ftype *,
1116                               gdbarch_dump_tdep_ftype *);
1117
1118
1119 /* Return a freshly allocated, NULL terminated, array of the valid
1120    architecture names.  Since architectures are registered during the
1121    _initialize phase this function only returns useful information
1122    once initialization has been completed. */
1123
1124 extern const char **gdbarch_printable_names (void);
1125
1126
1127 /* Helper function.  Search the list of ARCHES for a GDBARCH that
1128    matches the information provided by INFO. */
1129
1130 extern struct gdbarch_list *gdbarch_list_lookup_by_info (struct gdbarch_list *arches,  const struct gdbarch_info *info);
1131
1132
1133 /* Helper function.  Create a preliminary \`\`struct gdbarch''.  Perform
1134    basic initialization using values obtained from the INFO andTDEP
1135    parameters.  set_gdbarch_*() functions are called to complete the
1136    initialization of the object. */
1137
1138 extern struct gdbarch *gdbarch_alloc (const struct gdbarch_info *info, struct gdbarch_tdep *tdep);
1139
1140
1141 /* Helper function.  Free a partially-constructed \`\`struct gdbarch''.
1142    It is assumed that the caller freeds the \`\`struct
1143    gdbarch_tdep''. */
1144
1145 extern void gdbarch_free (struct gdbarch *);
1146
1147
1148 /* Helper function. Force an update of the current architecture.
1149
1150    The actual architecture selected is determined by INFO, \`\`(gdb) set
1151    architecture'' et.al., the existing architecture and BFD's default
1152    architecture.  INFO should be initialized to zero and then selected
1153    fields should be updated.
1154
1155    Returns non-zero if the update succeeds */
1156
1157 extern int gdbarch_update_p (struct gdbarch_info info);
1158
1159
1160
1161 /* Register per-architecture data-pointer.
1162
1163    Reserve space for a per-architecture data-pointer.  An identifier
1164    for the reserved data-pointer is returned.  That identifer should
1165    be saved in a local static variable.
1166
1167    The per-architecture data-pointer is either initialized explicitly
1168    (set_gdbarch_data()) or implicitly (by INIT() via a call to
1169    gdbarch_data()).  FREE() is called to delete either an existing
1170    data-pointer overridden by set_gdbarch_data() or when the
1171    architecture object is being deleted.
1172
1173    When a previously created architecture is re-selected, the
1174    per-architecture data-pointer for that previous architecture is
1175    restored.  INIT() is not re-called.
1176
1177    Multiple registrarants for any architecture are allowed (and
1178    strongly encouraged).  */
1179
1180 struct gdbarch_data;
1181
1182 typedef void *(gdbarch_data_init_ftype) (struct gdbarch *gdbarch);
1183 typedef void (gdbarch_data_free_ftype) (struct gdbarch *gdbarch,
1184                                         void *pointer);
1185 extern struct gdbarch_data *register_gdbarch_data (gdbarch_data_init_ftype *init,
1186                                                    gdbarch_data_free_ftype *free);
1187 extern void set_gdbarch_data (struct gdbarch *gdbarch,
1188                               struct gdbarch_data *data,
1189                               void *pointer);
1190
1191 extern void *gdbarch_data (struct gdbarch *gdbarch, struct gdbarch_data *);
1192
1193
1194 /* Register per-architecture memory region.
1195
1196    Provide a memory-region swap mechanism.  Per-architecture memory
1197    region are created.  These memory regions are swapped whenever the
1198    architecture is changed.  For a new architecture, the memory region
1199    is initialized with zero (0) and the INIT function is called.
1200
1201    Memory regions are swapped / initialized in the order that they are
1202    registered.  NULL DATA and/or INIT values can be specified.
1203
1204    New code should use register_gdbarch_data(). */
1205
1206 typedef void (gdbarch_swap_ftype) (void);
1207 extern void register_gdbarch_swap (void *data, unsigned long size, gdbarch_swap_ftype *init);
1208 #define REGISTER_GDBARCH_SWAP(VAR) register_gdbarch_swap (&(VAR), sizeof ((VAR)), NULL)
1209
1210
1211
1212 /* The target-system-dependent byte order is dynamic */
1213
1214 extern int target_byte_order;
1215 #ifndef TARGET_BYTE_ORDER
1216 #define TARGET_BYTE_ORDER (target_byte_order + 0)
1217 #endif
1218
1219 extern int target_byte_order_auto;
1220 #ifndef TARGET_BYTE_ORDER_AUTO
1221 #define TARGET_BYTE_ORDER_AUTO (target_byte_order_auto + 0)
1222 #endif
1223
1224
1225
1226 /* The target-system-dependent BFD architecture is dynamic */
1227
1228 extern int target_architecture_auto;
1229 #ifndef TARGET_ARCHITECTURE_AUTO
1230 #define TARGET_ARCHITECTURE_AUTO (target_architecture_auto + 0)
1231 #endif
1232
1233 extern const struct bfd_arch_info *target_architecture;
1234 #ifndef TARGET_ARCHITECTURE
1235 #define TARGET_ARCHITECTURE (target_architecture + 0)
1236 #endif
1237
1238
1239 /* The target-system-dependent disassembler is semi-dynamic */
1240
1241 /* Use gdb_disassemble, and gdbarch_print_insn instead.  */
1242 extern int (*deprecated_tm_print_insn) (bfd_vma, disassemble_info*);
1243
1244 /* Use set_gdbarch_print_insn instead.  */
1245 extern disassemble_info deprecated_tm_print_insn_info;
1246
1247 /* Set the dynamic target-system-dependent parameters (architecture,
1248    byte-order, ...) using information found in the BFD */
1249
1250 extern void set_gdbarch_from_file (bfd *);
1251
1252
1253 /* Initialize the current architecture to the "first" one we find on
1254    our list.  */
1255
1256 extern void initialize_current_architecture (void);
1257
1258 /* For non-multiarched targets, do any initialization of the default
1259    gdbarch object necessary after the _initialize_MODULE functions
1260    have run.  */
1261 extern void initialize_non_multiarch (void);
1262
1263 /* gdbarch trace variable */
1264 extern int gdbarch_debug;
1265
1266 extern void gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file);
1267
1268 #endif
1269 EOF
1270 exec 1>&2
1271 #../move-if-change new-gdbarch.h gdbarch.h
1272 compare_new gdbarch.h
1273
1274
1275 #
1276 # C file
1277 #
1278
1279 exec > new-gdbarch.c
1280 copyright
1281 cat <<EOF
1282
1283 #include "defs.h"
1284 #include "arch-utils.h"
1285
1286 #if GDB_MULTI_ARCH
1287 #include "gdbcmd.h"
1288 #include "inferior.h" /* enum CALL_DUMMY_LOCATION et.al. */
1289 #else
1290 /* Just include everything in sight so that the every old definition
1291    of macro is visible. */
1292 #include "gdb_string.h"
1293 #include <ctype.h>
1294 #include "symtab.h"
1295 #include "frame.h"
1296 #include "inferior.h"
1297 #include "breakpoint.h"
1298 #include "gdb_wait.h"
1299 #include "gdbcore.h"
1300 #include "gdbcmd.h"
1301 #include "target.h"
1302 #include "gdbthread.h"
1303 #include "annotate.h"
1304 #include "symfile.h"            /* for overlay functions */
1305 #include "value.h"              /* For old tm.h/nm.h macros.  */
1306 #endif
1307 #include "symcat.h"
1308
1309 #include "floatformat.h"
1310
1311 #include "gdb_assert.h"
1312 #include "gdb_string.h"
1313 #include "gdb-events.h"
1314 #include "reggroups.h"
1315 #include "osabi.h"
1316 #include "symfile.h"            /* For entry_point_address.  */
1317
1318 /* Static function declarations */
1319
1320 static void verify_gdbarch (struct gdbarch *gdbarch);
1321 static void alloc_gdbarch_data (struct gdbarch *);
1322 static void free_gdbarch_data (struct gdbarch *);
1323 static void init_gdbarch_swap (struct gdbarch *);
1324 static void clear_gdbarch_swap (struct gdbarch *);
1325 static void swapout_gdbarch_swap (struct gdbarch *);
1326 static void swapin_gdbarch_swap (struct gdbarch *);
1327
1328 /* Non-zero if we want to trace architecture code.  */
1329
1330 #ifndef GDBARCH_DEBUG
1331 #define GDBARCH_DEBUG 0
1332 #endif
1333 int gdbarch_debug = GDBARCH_DEBUG;
1334
1335 EOF
1336
1337 # gdbarch open the gdbarch object
1338 printf "\n"
1339 printf "/* Maintain the struct gdbarch object */\n"
1340 printf "\n"
1341 printf "struct gdbarch\n"
1342 printf "{\n"
1343 printf "  /* Has this architecture been fully initialized?  */\n"
1344 printf "  int initialized_p;\n"
1345 printf "  /* basic architectural information */\n"
1346 function_list | while do_read
1347 do
1348     if class_is_info_p
1349     then
1350         printf "  ${returntype} ${function};\n"
1351     fi
1352 done
1353 printf "\n"
1354 printf "  /* target specific vector. */\n"
1355 printf "  struct gdbarch_tdep *tdep;\n"
1356 printf "  gdbarch_dump_tdep_ftype *dump_tdep;\n"
1357 printf "\n"
1358 printf "  /* per-architecture data-pointers */\n"
1359 printf "  unsigned nr_data;\n"
1360 printf "  void **data;\n"
1361 printf "\n"
1362 printf "  /* per-architecture swap-regions */\n"
1363 printf "  struct gdbarch_swap *swap;\n"
1364 printf "\n"
1365 cat <<EOF
1366   /* Multi-arch values.
1367
1368      When extending this structure you must:
1369
1370      Add the field below.
1371
1372      Declare set/get functions and define the corresponding
1373      macro in gdbarch.h.
1374
1375      gdbarch_alloc(): If zero/NULL is not a suitable default,
1376      initialize the new field.
1377
1378      verify_gdbarch(): Confirm that the target updated the field
1379      correctly.
1380
1381      gdbarch_dump(): Add a fprintf_unfiltered call so that the new
1382      field is dumped out
1383
1384      \`\`startup_gdbarch()'': Append an initial value to the static
1385      variable (base values on the host's c-type system).
1386
1387      get_gdbarch(): Implement the set/get functions (probably using
1388      the macro's as shortcuts).
1389
1390      */
1391
1392 EOF
1393 function_list | while do_read
1394 do
1395     if class_is_variable_p
1396     then
1397         printf "  ${returntype} ${function};\n"
1398     elif class_is_function_p
1399     then
1400         printf "  gdbarch_${function}_ftype *${function}${attrib};\n"
1401     fi
1402 done
1403 printf "};\n"
1404
1405 # A pre-initialized vector
1406 printf "\n"
1407 printf "\n"
1408 cat <<EOF
1409 /* The default architecture uses host values (for want of a better
1410    choice). */
1411 EOF
1412 printf "\n"
1413 printf "extern const struct bfd_arch_info bfd_default_arch_struct;\n"
1414 printf "\n"
1415 printf "struct gdbarch startup_gdbarch =\n"
1416 printf "{\n"
1417 printf "  1, /* Always initialized.  */\n"
1418 printf "  /* basic architecture information */\n"
1419 function_list | while do_read
1420 do
1421     if class_is_info_p
1422     then
1423         printf "  ${staticdefault},  /* ${function} */\n"
1424     fi
1425 done
1426 cat <<EOF
1427   /* target specific vector and its dump routine */
1428   NULL, NULL,
1429   /*per-architecture data-pointers and swap regions */
1430   0, NULL, NULL,
1431   /* Multi-arch values */
1432 EOF
1433 function_list | while do_read
1434 do
1435     if class_is_function_p || class_is_variable_p
1436     then
1437         printf "  ${staticdefault},  /* ${function} */\n"
1438     fi
1439 done
1440 cat <<EOF
1441   /* startup_gdbarch() */
1442 };
1443
1444 struct gdbarch *current_gdbarch = &startup_gdbarch;
1445
1446 /* Do any initialization needed for a non-multiarch configuration
1447    after the _initialize_MODULE functions have been run.  */
1448 void
1449 initialize_non_multiarch (void)
1450 {
1451   alloc_gdbarch_data (&startup_gdbarch);
1452   /* Ensure that all swap areas are zeroed so that they again think
1453      they are starting from scratch.  */
1454   clear_gdbarch_swap (&startup_gdbarch);
1455   init_gdbarch_swap (&startup_gdbarch);
1456 }
1457 EOF
1458
1459 # Create a new gdbarch struct
1460 printf "\n"
1461 printf "\n"
1462 cat <<EOF
1463 /* Create a new \`\`struct gdbarch'' based on information provided by
1464    \`\`struct gdbarch_info''. */
1465 EOF
1466 printf "\n"
1467 cat <<EOF
1468 struct gdbarch *
1469 gdbarch_alloc (const struct gdbarch_info *info,
1470                struct gdbarch_tdep *tdep)
1471 {
1472   /* NOTE: The new architecture variable is named \`\`current_gdbarch''
1473      so that macros such as TARGET_DOUBLE_BIT, when expanded, refer to
1474      the current local architecture and not the previous global
1475      architecture.  This ensures that the new architectures initial
1476      values are not influenced by the previous architecture.  Once
1477      everything is parameterised with gdbarch, this will go away.  */
1478   struct gdbarch *current_gdbarch = XMALLOC (struct gdbarch);
1479   memset (current_gdbarch, 0, sizeof (*current_gdbarch));
1480
1481   alloc_gdbarch_data (current_gdbarch);
1482
1483   current_gdbarch->tdep = tdep;
1484 EOF
1485 printf "\n"
1486 function_list | while do_read
1487 do
1488     if class_is_info_p
1489     then
1490         printf "  current_gdbarch->${function} = info->${function};\n"
1491     fi
1492 done
1493 printf "\n"
1494 printf "  /* Force the explicit initialization of these. */\n"
1495 function_list | while do_read
1496 do
1497     if class_is_function_p || class_is_variable_p
1498     then
1499         if [ -n "${predefault}" -a "x${predefault}" != "x0" ]
1500         then
1501           printf "  current_gdbarch->${function} = ${predefault};\n"
1502         fi
1503     fi
1504 done
1505 cat <<EOF
1506   /* gdbarch_alloc() */
1507
1508   return current_gdbarch;
1509 }
1510 EOF
1511
1512 # Free a gdbarch struct.
1513 printf "\n"
1514 printf "\n"
1515 cat <<EOF
1516 /* Free a gdbarch struct.  This should never happen in normal
1517    operation --- once you've created a gdbarch, you keep it around.
1518    However, if an architecture's init function encounters an error
1519    building the structure, it may need to clean up a partially
1520    constructed gdbarch.  */
1521
1522 void
1523 gdbarch_free (struct gdbarch *arch)
1524 {
1525   gdb_assert (arch != NULL);
1526   free_gdbarch_data (arch);
1527   xfree (arch);
1528 }
1529 EOF
1530
1531 # verify a new architecture
1532 printf "\n"
1533 printf "\n"
1534 printf "/* Ensure that all values in a GDBARCH are reasonable. */\n"
1535 printf "\n"
1536 cat <<EOF
1537 static void
1538 verify_gdbarch (struct gdbarch *gdbarch)
1539 {
1540   struct ui_file *log;
1541   struct cleanup *cleanups;
1542   long dummy;
1543   char *buf;
1544   /* Only perform sanity checks on a multi-arch target. */
1545   if (!GDB_MULTI_ARCH)
1546     return;
1547   log = mem_fileopen ();
1548   cleanups = make_cleanup_ui_file_delete (log);
1549   /* fundamental */
1550   if (gdbarch->byte_order == BFD_ENDIAN_UNKNOWN)
1551     fprintf_unfiltered (log, "\n\tbyte-order");
1552   if (gdbarch->bfd_arch_info == NULL)
1553     fprintf_unfiltered (log, "\n\tbfd_arch_info");
1554   /* Check those that need to be defined for the given multi-arch level. */
1555 EOF
1556 function_list | while do_read
1557 do
1558     if class_is_function_p || class_is_variable_p
1559     then
1560         if [ "x${invalid_p}" = "x0" ]
1561         then
1562             printf "  /* Skip verify of ${function}, invalid_p == 0 */\n"
1563         elif class_is_predicate_p
1564         then
1565             printf "  /* Skip verify of ${function}, has predicate */\n"
1566         # FIXME: See do_read for potential simplification
1567         elif [ -n "${invalid_p}" -a -n "${postdefault}" ]
1568         then
1569             printf "  if (${invalid_p})\n"
1570             printf "    gdbarch->${function} = ${postdefault};\n"
1571         elif [ -n "${predefault}" -a -n "${postdefault}" ]
1572         then
1573             printf "  if (gdbarch->${function} == ${predefault})\n"
1574             printf "    gdbarch->${function} = ${postdefault};\n"
1575         elif [ -n "${postdefault}" ]
1576         then
1577             printf "  if (gdbarch->${function} == 0)\n"
1578             printf "    gdbarch->${function} = ${postdefault};\n"
1579         elif [ -n "${invalid_p}" ]
1580         then
1581             printf "  if ((GDB_MULTI_ARCH ${gt_level})\n"
1582             printf "      && (${invalid_p}))\n"
1583             printf "    fprintf_unfiltered (log, \"\\\\n\\\\t${function}\");\n"
1584         elif [ -n "${predefault}" ]
1585         then
1586             printf "  if ((GDB_MULTI_ARCH ${gt_level})\n"
1587             printf "      && (gdbarch->${function} == ${predefault}))\n"
1588             printf "    fprintf_unfiltered (log, \"\\\\n\\\\t${function}\");\n"
1589         fi
1590     fi
1591 done
1592 cat <<EOF
1593   buf = ui_file_xstrdup (log, &dummy);
1594   make_cleanup (xfree, buf);
1595   if (strlen (buf) > 0)
1596     internal_error (__FILE__, __LINE__,
1597                     "verify_gdbarch: the following are invalid ...%s",
1598                     buf);
1599   do_cleanups (cleanups);
1600 }
1601 EOF
1602
1603 # dump the structure
1604 printf "\n"
1605 printf "\n"
1606 cat <<EOF
1607 /* Print out the details of the current architecture. */
1608
1609 /* NOTE/WARNING: The parameter is called \`\`current_gdbarch'' so that it
1610    just happens to match the global variable \`\`current_gdbarch''.  That
1611    way macros refering to that variable get the local and not the global
1612    version - ulgh.  Once everything is parameterised with gdbarch, this
1613    will go away. */
1614
1615 void
1616 gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file)
1617 {
1618   fprintf_unfiltered (file,
1619                       "gdbarch_dump: GDB_MULTI_ARCH = %d\\n",
1620                       GDB_MULTI_ARCH);
1621 EOF
1622 function_list | sort -t: -k 3 | while do_read
1623 do
1624     # First the predicate
1625     if class_is_predicate_p
1626     then
1627         if class_is_multiarch_p
1628         then
1629             printf "  if (GDB_MULTI_ARCH)\n"
1630             printf "    fprintf_unfiltered (file,\n"
1631             printf "                        \"gdbarch_dump: gdbarch_${function}_p() = %%d\\\\n\",\n"
1632             printf "                        gdbarch_${function}_p (current_gdbarch));\n"
1633         else
1634             printf "#ifdef ${macro}_P\n"
1635             printf "  fprintf_unfiltered (file,\n"
1636             printf "                      \"gdbarch_dump: %%s # %%s\\\\n\",\n"
1637             printf "                      \"${macro}_P()\",\n"
1638             printf "                      XSTRING (${macro}_P ()));\n"
1639             printf "  fprintf_unfiltered (file,\n"
1640             printf "                      \"gdbarch_dump: ${macro}_P() = %%d\\\\n\",\n"
1641             printf "                      ${macro}_P ());\n"
1642             printf "#endif\n"
1643         fi
1644     fi
1645     # multiarch functions don't have macros.
1646     if class_is_multiarch_p
1647     then
1648         printf "  if (GDB_MULTI_ARCH)\n"
1649         printf "    fprintf_unfiltered (file,\n"
1650         printf "                        \"gdbarch_dump: ${function} = 0x%%08lx\\\\n\",\n"
1651         printf "                        (long) current_gdbarch->${function});\n"
1652         continue
1653     fi
1654     # Print the macro definition.
1655     printf "#ifdef ${macro}\n"
1656     if [ "x${returntype}" = "xvoid" ]
1657     then
1658         printf "#if GDB_MULTI_ARCH\n"
1659         printf "  /* Macro might contain \`[{}]' when not multi-arch */\n"
1660     fi
1661     if class_is_function_p
1662     then
1663         printf "  fprintf_unfiltered (file,\n"
1664         printf "                      \"gdbarch_dump: %%s # %%s\\\\n\",\n"
1665         printf "                      \"${macro}(${actual})\",\n"
1666         printf "                      XSTRING (${macro} (${actual})));\n"
1667     else
1668         printf "  fprintf_unfiltered (file,\n"
1669         printf "                      \"gdbarch_dump: ${macro} # %%s\\\\n\",\n"
1670         printf "                      XSTRING (${macro}));\n"
1671     fi
1672     # Print the architecture vector value
1673     if [ "x${returntype}" = "xvoid" ]
1674     then
1675         printf "#endif\n"
1676     fi
1677     if [ "x${print_p}" = "x()" ]
1678     then
1679         printf "  gdbarch_dump_${function} (current_gdbarch);\n"
1680     elif [ "x${print_p}" = "x0" ]
1681     then
1682         printf "  /* skip print of ${macro}, print_p == 0. */\n"
1683     elif [ -n "${print_p}" ]
1684     then
1685         printf "  if (${print_p})\n"
1686         printf "    fprintf_unfiltered (file,\n"
1687         printf "                        \"gdbarch_dump: ${macro} = %s\\\\n\",\n" "${fmt}"
1688         printf "                        ${print});\n"
1689     elif class_is_function_p
1690     then
1691         printf "  if (GDB_MULTI_ARCH)\n"
1692         printf "    fprintf_unfiltered (file,\n"
1693         printf "                        \"gdbarch_dump: ${macro} = <0x%%08lx>\\\\n\",\n"
1694         printf "                        (long) current_gdbarch->${function}\n"
1695         printf "                        /*${macro} ()*/);\n"
1696     else
1697         printf "  fprintf_unfiltered (file,\n"
1698         printf "                      \"gdbarch_dump: ${macro} = %s\\\\n\",\n" "${fmt}"
1699         printf "                      ${print});\n"
1700     fi
1701     printf "#endif\n"
1702 done
1703 cat <<EOF
1704   if (current_gdbarch->dump_tdep != NULL)
1705     current_gdbarch->dump_tdep (current_gdbarch, file);
1706 }
1707 EOF
1708
1709
1710 # GET/SET
1711 printf "\n"
1712 cat <<EOF
1713 struct gdbarch_tdep *
1714 gdbarch_tdep (struct gdbarch *gdbarch)
1715 {
1716   if (gdbarch_debug >= 2)
1717     fprintf_unfiltered (gdb_stdlog, "gdbarch_tdep called\\n");
1718   return gdbarch->tdep;
1719 }
1720 EOF
1721 printf "\n"
1722 function_list | while do_read
1723 do
1724     if class_is_predicate_p
1725     then
1726         printf "\n"
1727         printf "int\n"
1728         printf "gdbarch_${function}_p (struct gdbarch *gdbarch)\n"
1729         printf "{\n"
1730         printf "  gdb_assert (gdbarch != NULL);\n"
1731         if [ -n "${predicate}" ]
1732         then
1733             printf "  return ${predicate};\n"
1734         else
1735             printf "  return gdbarch->${function} != 0;\n"
1736         fi
1737         printf "}\n"
1738     fi
1739     if class_is_function_p
1740     then
1741         printf "\n"
1742         printf "${returntype}\n"
1743         if [ "x${formal}" = "xvoid" ]
1744         then
1745           printf "gdbarch_${function} (struct gdbarch *gdbarch)\n"
1746         else
1747           printf "gdbarch_${function} (struct gdbarch *gdbarch, ${formal})\n"
1748         fi
1749         printf "{\n"
1750         printf "  gdb_assert (gdbarch != NULL);\n"
1751         printf "  if (gdbarch->${function} == 0)\n"
1752         printf "    internal_error (__FILE__, __LINE__,\n"
1753         printf "                    \"gdbarch: gdbarch_${function} invalid\");\n"
1754         if class_is_predicate_p && test -n "${predicate}"
1755         then
1756             # Allow a call to a function with a predicate.
1757             printf "  /* Ignore predicate (${predicate}).  */\n"
1758         fi
1759         printf "  if (gdbarch_debug >= 2)\n"
1760         printf "    fprintf_unfiltered (gdb_stdlog, \"gdbarch_${function} called\\\\n\");\n"
1761         if [ "x${actual}" = "x-" -o "x${actual}" = "x" ]
1762         then
1763             if class_is_multiarch_p
1764             then
1765                 params="gdbarch"
1766             else
1767                 params=""
1768             fi
1769         else
1770             if class_is_multiarch_p
1771             then
1772                 params="gdbarch, ${actual}"
1773             else
1774                 params="${actual}"
1775             fi
1776         fi
1777         if [ "x${returntype}" = "xvoid" ]
1778         then
1779           printf "  gdbarch->${function} (${params});\n"
1780         else
1781           printf "  return gdbarch->${function} (${params});\n"
1782         fi
1783         printf "}\n"
1784         printf "\n"
1785         printf "void\n"
1786         printf "set_gdbarch_${function} (struct gdbarch *gdbarch,\n"
1787         printf "            `echo ${function} | sed -e 's/./ /g'`  gdbarch_${function}_ftype ${function})\n"
1788         printf "{\n"
1789         printf "  gdbarch->${function} = ${function};\n"
1790         printf "}\n"
1791     elif class_is_variable_p
1792     then
1793         printf "\n"
1794         printf "${returntype}\n"
1795         printf "gdbarch_${function} (struct gdbarch *gdbarch)\n"
1796         printf "{\n"
1797         printf "  gdb_assert (gdbarch != NULL);\n"
1798         if [ "x${invalid_p}" = "x0" ]
1799         then
1800             printf "  /* Skip verify of ${function}, invalid_p == 0 */\n"
1801         elif [ -n "${invalid_p}" ]
1802         then
1803           printf "  if (${invalid_p})\n"
1804           printf "    internal_error (__FILE__, __LINE__,\n"
1805           printf "                    \"gdbarch: gdbarch_${function} invalid\");\n"
1806         elif [ -n "${predefault}" ]
1807         then
1808           printf "  if (gdbarch->${function} == ${predefault})\n"
1809           printf "    internal_error (__FILE__, __LINE__,\n"
1810           printf "                    \"gdbarch: gdbarch_${function} invalid\");\n"
1811         fi
1812         printf "  if (gdbarch_debug >= 2)\n"
1813         printf "    fprintf_unfiltered (gdb_stdlog, \"gdbarch_${function} called\\\\n\");\n"
1814         printf "  return gdbarch->${function};\n"
1815         printf "}\n"
1816         printf "\n"
1817         printf "void\n"
1818         printf "set_gdbarch_${function} (struct gdbarch *gdbarch,\n"
1819         printf "            `echo ${function} | sed -e 's/./ /g'`  ${returntype} ${function})\n"
1820         printf "{\n"
1821         printf "  gdbarch->${function} = ${function};\n"
1822         printf "}\n"
1823     elif class_is_info_p
1824     then
1825         printf "\n"
1826         printf "${returntype}\n"
1827         printf "gdbarch_${function} (struct gdbarch *gdbarch)\n"
1828         printf "{\n"
1829         printf "  gdb_assert (gdbarch != NULL);\n"
1830         printf "  if (gdbarch_debug >= 2)\n"
1831         printf "    fprintf_unfiltered (gdb_stdlog, \"gdbarch_${function} called\\\\n\");\n"
1832         printf "  return gdbarch->${function};\n"
1833         printf "}\n"
1834     fi
1835 done
1836
1837 # All the trailing guff
1838 cat <<EOF
1839
1840
1841 /* Keep a registry of per-architecture data-pointers required by GDB
1842    modules. */
1843
1844 struct gdbarch_data
1845 {
1846   unsigned index;
1847   int init_p;
1848   gdbarch_data_init_ftype *init;
1849   gdbarch_data_free_ftype *free;
1850 };
1851
1852 struct gdbarch_data_registration
1853 {
1854   struct gdbarch_data *data;
1855   struct gdbarch_data_registration *next;
1856 };
1857
1858 struct gdbarch_data_registry
1859 {
1860   unsigned nr;
1861   struct gdbarch_data_registration *registrations;
1862 };
1863
1864 struct gdbarch_data_registry gdbarch_data_registry =
1865 {
1866   0, NULL,
1867 };
1868
1869 struct gdbarch_data *
1870 register_gdbarch_data (gdbarch_data_init_ftype *init,
1871                        gdbarch_data_free_ftype *free)
1872 {
1873   struct gdbarch_data_registration **curr;
1874   /* Append the new registraration.  */
1875   for (curr = &gdbarch_data_registry.registrations;
1876        (*curr) != NULL;
1877        curr = &(*curr)->next);
1878   (*curr) = XMALLOC (struct gdbarch_data_registration);
1879   (*curr)->next = NULL;
1880   (*curr)->data = XMALLOC (struct gdbarch_data);
1881   (*curr)->data->index = gdbarch_data_registry.nr++;
1882   (*curr)->data->init = init;
1883   (*curr)->data->init_p = 1;
1884   (*curr)->data->free = free;
1885   return (*curr)->data;
1886 }
1887
1888
1889 /* Create/delete the gdbarch data vector. */
1890
1891 static void
1892 alloc_gdbarch_data (struct gdbarch *gdbarch)
1893 {
1894   gdb_assert (gdbarch->data == NULL);
1895   gdbarch->nr_data = gdbarch_data_registry.nr;
1896   gdbarch->data = xcalloc (gdbarch->nr_data, sizeof (void*));
1897 }
1898
1899 static void
1900 free_gdbarch_data (struct gdbarch *gdbarch)
1901 {
1902   struct gdbarch_data_registration *rego;
1903   gdb_assert (gdbarch->data != NULL);
1904   for (rego = gdbarch_data_registry.registrations;
1905        rego != NULL;
1906        rego = rego->next)
1907     {
1908       struct gdbarch_data *data = rego->data;
1909       gdb_assert (data->index < gdbarch->nr_data);
1910       if (data->free != NULL && gdbarch->data[data->index] != NULL)
1911         {
1912           data->free (gdbarch, gdbarch->data[data->index]);
1913           gdbarch->data[data->index] = NULL;
1914         }
1915     }
1916   xfree (gdbarch->data);
1917   gdbarch->data = NULL;
1918 }
1919
1920
1921 /* Initialize the current value of the specified per-architecture
1922    data-pointer. */
1923
1924 void
1925 set_gdbarch_data (struct gdbarch *gdbarch,
1926                   struct gdbarch_data *data,
1927                   void *pointer)
1928 {
1929   gdb_assert (data->index < gdbarch->nr_data);
1930   if (gdbarch->data[data->index] != NULL)
1931     {
1932       gdb_assert (data->free != NULL);
1933       data->free (gdbarch, gdbarch->data[data->index]);
1934     }
1935   gdbarch->data[data->index] = pointer;
1936 }
1937
1938 /* Return the current value of the specified per-architecture
1939    data-pointer. */
1940
1941 void *
1942 gdbarch_data (struct gdbarch *gdbarch, struct gdbarch_data *data)
1943 {
1944   gdb_assert (data->index < gdbarch->nr_data);
1945   /* The data-pointer isn't initialized, call init() to get a value but
1946      only if the architecture initializaiton has completed.  Otherwise
1947      punt - hope that the caller knows what they are doing.  */
1948   if (gdbarch->data[data->index] == NULL
1949       && gdbarch->initialized_p)
1950     {
1951       /* Be careful to detect an initialization cycle.  */
1952       gdb_assert (data->init_p);
1953       data->init_p = 0;
1954       gdb_assert (data->init != NULL);
1955       gdbarch->data[data->index] = data->init (gdbarch);
1956       data->init_p = 1;
1957       gdb_assert (gdbarch->data[data->index] != NULL);
1958     }
1959   return gdbarch->data[data->index];
1960 }
1961
1962
1963
1964 /* Keep a registry of swapped data required by GDB modules. */
1965
1966 struct gdbarch_swap
1967 {
1968   void *swap;
1969   struct gdbarch_swap_registration *source;
1970   struct gdbarch_swap *next;
1971 };
1972
1973 struct gdbarch_swap_registration
1974 {
1975   void *data;
1976   unsigned long sizeof_data;
1977   gdbarch_swap_ftype *init;
1978   struct gdbarch_swap_registration *next;
1979 };
1980
1981 struct gdbarch_swap_registry
1982 {
1983   int nr;
1984   struct gdbarch_swap_registration *registrations;
1985 };
1986
1987 struct gdbarch_swap_registry gdbarch_swap_registry =
1988 {
1989   0, NULL,
1990 };
1991
1992 void
1993 register_gdbarch_swap (void *data,
1994                        unsigned long sizeof_data,
1995                        gdbarch_swap_ftype *init)
1996 {
1997   struct gdbarch_swap_registration **rego;
1998   for (rego = &gdbarch_swap_registry.registrations;
1999        (*rego) != NULL;
2000        rego = &(*rego)->next);
2001   (*rego) = XMALLOC (struct gdbarch_swap_registration);
2002   (*rego)->next = NULL;
2003   (*rego)->init = init;
2004   (*rego)->data = data;
2005   (*rego)->sizeof_data = sizeof_data;
2006 }
2007
2008 static void
2009 clear_gdbarch_swap (struct gdbarch *gdbarch)
2010 {
2011   struct gdbarch_swap *curr;
2012   for (curr = gdbarch->swap;
2013        curr != NULL;
2014        curr = curr->next)
2015     {
2016       memset (curr->source->data, 0, curr->source->sizeof_data);
2017     }
2018 }
2019
2020 static void
2021 init_gdbarch_swap (struct gdbarch *gdbarch)
2022 {
2023   struct gdbarch_swap_registration *rego;
2024   struct gdbarch_swap **curr = &gdbarch->swap;
2025   for (rego = gdbarch_swap_registry.registrations;
2026        rego != NULL;
2027        rego = rego->next)
2028     {
2029       if (rego->data != NULL)
2030         {
2031           (*curr) = XMALLOC (struct gdbarch_swap);
2032           (*curr)->source = rego;
2033           (*curr)->swap = xmalloc (rego->sizeof_data);
2034           (*curr)->next = NULL;
2035           curr = &(*curr)->next;
2036         }
2037       if (rego->init != NULL)
2038         rego->init ();
2039     }
2040 }
2041
2042 static void
2043 swapout_gdbarch_swap (struct gdbarch *gdbarch)
2044 {
2045   struct gdbarch_swap *curr;
2046   for (curr = gdbarch->swap;
2047        curr != NULL;
2048        curr = curr->next)
2049     memcpy (curr->swap, curr->source->data, curr->source->sizeof_data);
2050 }
2051
2052 static void
2053 swapin_gdbarch_swap (struct gdbarch *gdbarch)
2054 {
2055   struct gdbarch_swap *curr;
2056   for (curr = gdbarch->swap;
2057        curr != NULL;
2058        curr = curr->next)
2059     memcpy (curr->source->data, curr->swap, curr->source->sizeof_data);
2060 }
2061
2062
2063 /* Keep a registry of the architectures known by GDB. */
2064
2065 struct gdbarch_registration
2066 {
2067   enum bfd_architecture bfd_architecture;
2068   gdbarch_init_ftype *init;
2069   gdbarch_dump_tdep_ftype *dump_tdep;
2070   struct gdbarch_list *arches;
2071   struct gdbarch_registration *next;
2072 };
2073
2074 static struct gdbarch_registration *gdbarch_registry = NULL;
2075
2076 static void
2077 append_name (const char ***buf, int *nr, const char *name)
2078 {
2079   *buf = xrealloc (*buf, sizeof (char**) * (*nr + 1));
2080   (*buf)[*nr] = name;
2081   *nr += 1;
2082 }
2083
2084 const char **
2085 gdbarch_printable_names (void)
2086 {
2087   if (GDB_MULTI_ARCH)
2088     {
2089       /* Accumulate a list of names based on the registed list of
2090          architectures. */
2091       enum bfd_architecture a;
2092       int nr_arches = 0;
2093       const char **arches = NULL;
2094       struct gdbarch_registration *rego;
2095       for (rego = gdbarch_registry;
2096            rego != NULL;
2097            rego = rego->next)
2098         {
2099           const struct bfd_arch_info *ap;
2100           ap = bfd_lookup_arch (rego->bfd_architecture, 0);
2101           if (ap == NULL)
2102             internal_error (__FILE__, __LINE__,
2103                             "gdbarch_architecture_names: multi-arch unknown");
2104           do
2105             {
2106               append_name (&arches, &nr_arches, ap->printable_name);
2107               ap = ap->next;
2108             }
2109           while (ap != NULL);
2110         }
2111       append_name (&arches, &nr_arches, NULL);
2112       return arches;
2113     }
2114   else
2115     /* Just return all the architectures that BFD knows.  Assume that
2116        the legacy architecture framework supports them. */
2117     return bfd_arch_list ();
2118 }
2119
2120
2121 void
2122 gdbarch_register (enum bfd_architecture bfd_architecture,
2123                   gdbarch_init_ftype *init,
2124                   gdbarch_dump_tdep_ftype *dump_tdep)
2125 {
2126   struct gdbarch_registration **curr;
2127   const struct bfd_arch_info *bfd_arch_info;
2128   /* Check that BFD recognizes this architecture */
2129   bfd_arch_info = bfd_lookup_arch (bfd_architecture, 0);
2130   if (bfd_arch_info == NULL)
2131     {
2132       internal_error (__FILE__, __LINE__,
2133                       "gdbarch: Attempt to register unknown architecture (%d)",
2134                       bfd_architecture);
2135     }
2136   /* Check that we haven't seen this architecture before */
2137   for (curr = &gdbarch_registry;
2138        (*curr) != NULL;
2139        curr = &(*curr)->next)
2140     {
2141       if (bfd_architecture == (*curr)->bfd_architecture)
2142         internal_error (__FILE__, __LINE__,
2143                         "gdbarch: Duplicate registraration of architecture (%s)",
2144                         bfd_arch_info->printable_name);
2145     }
2146   /* log it */
2147   if (gdbarch_debug)
2148     fprintf_unfiltered (gdb_stdlog, "register_gdbarch_init (%s, 0x%08lx)\n",
2149                         bfd_arch_info->printable_name,
2150                         (long) init);
2151   /* Append it */
2152   (*curr) = XMALLOC (struct gdbarch_registration);
2153   (*curr)->bfd_architecture = bfd_architecture;
2154   (*curr)->init = init;
2155   (*curr)->dump_tdep = dump_tdep;
2156   (*curr)->arches = NULL;
2157   (*curr)->next = NULL;
2158   /* When non- multi-arch, install whatever target dump routine we've
2159      been provided - hopefully that routine has been written correctly
2160      and works regardless of multi-arch. */
2161   if (!GDB_MULTI_ARCH && dump_tdep != NULL
2162       && startup_gdbarch.dump_tdep == NULL)
2163     startup_gdbarch.dump_tdep = dump_tdep;
2164 }
2165
2166 void
2167 register_gdbarch_init (enum bfd_architecture bfd_architecture,
2168                        gdbarch_init_ftype *init)
2169 {
2170   gdbarch_register (bfd_architecture, init, NULL);
2171 }
2172
2173
2174 /* Look for an architecture using gdbarch_info.  Base search on only
2175    BFD_ARCH_INFO and BYTE_ORDER. */
2176
2177 struct gdbarch_list *
2178 gdbarch_list_lookup_by_info (struct gdbarch_list *arches,
2179                              const struct gdbarch_info *info)
2180 {
2181   for (; arches != NULL; arches = arches->next)
2182     {
2183       if (info->bfd_arch_info != arches->gdbarch->bfd_arch_info)
2184         continue;
2185       if (info->byte_order != arches->gdbarch->byte_order)
2186         continue;
2187       if (info->osabi != arches->gdbarch->osabi)
2188         continue;
2189       return arches;
2190     }
2191   return NULL;
2192 }
2193
2194
2195 /* Update the current architecture. Return ZERO if the update request
2196    failed. */
2197
2198 int
2199 gdbarch_update_p (struct gdbarch_info info)
2200 {
2201   struct gdbarch *new_gdbarch;
2202   struct gdbarch *old_gdbarch;
2203   struct gdbarch_registration *rego;
2204
2205   /* Fill in missing parts of the INFO struct using a number of
2206      sources: \`\`set ...''; INFOabfd supplied; existing target.  */
2207
2208   /* \`\`(gdb) set architecture ...'' */
2209   if (info.bfd_arch_info == NULL
2210       && !TARGET_ARCHITECTURE_AUTO)
2211     info.bfd_arch_info = TARGET_ARCHITECTURE;
2212   if (info.bfd_arch_info == NULL
2213       && info.abfd != NULL
2214       && bfd_get_arch (info.abfd) != bfd_arch_unknown
2215       && bfd_get_arch (info.abfd) != bfd_arch_obscure)
2216     info.bfd_arch_info = bfd_get_arch_info (info.abfd);
2217   if (info.bfd_arch_info == NULL)
2218     info.bfd_arch_info = TARGET_ARCHITECTURE;
2219
2220   /* \`\`(gdb) set byte-order ...'' */
2221   if (info.byte_order == BFD_ENDIAN_UNKNOWN
2222       && !TARGET_BYTE_ORDER_AUTO)
2223     info.byte_order = TARGET_BYTE_ORDER;
2224   /* From the INFO struct. */
2225   if (info.byte_order == BFD_ENDIAN_UNKNOWN
2226       && info.abfd != NULL)
2227     info.byte_order = (bfd_big_endian (info.abfd) ? BFD_ENDIAN_BIG
2228                        : bfd_little_endian (info.abfd) ? BFD_ENDIAN_LITTLE
2229                        : BFD_ENDIAN_UNKNOWN);
2230   /* From the current target. */
2231   if (info.byte_order == BFD_ENDIAN_UNKNOWN)
2232     info.byte_order = TARGET_BYTE_ORDER;
2233
2234   /* \`\`(gdb) set osabi ...'' is handled by gdbarch_lookup_osabi.  */
2235   if (info.osabi == GDB_OSABI_UNINITIALIZED)
2236     info.osabi = gdbarch_lookup_osabi (info.abfd);
2237   if (info.osabi == GDB_OSABI_UNINITIALIZED)
2238     info.osabi = current_gdbarch->osabi;
2239
2240   /* Must have found some sort of architecture. */
2241   gdb_assert (info.bfd_arch_info != NULL);
2242
2243   if (gdbarch_debug)
2244     {
2245       fprintf_unfiltered (gdb_stdlog,
2246                           "gdbarch_update: info.bfd_arch_info %s\n",
2247                           (info.bfd_arch_info != NULL
2248                            ? info.bfd_arch_info->printable_name
2249                            : "(null)"));
2250       fprintf_unfiltered (gdb_stdlog,
2251                           "gdbarch_update: info.byte_order %d (%s)\n",
2252                           info.byte_order,
2253                           (info.byte_order == BFD_ENDIAN_BIG ? "big"
2254                            : info.byte_order == BFD_ENDIAN_LITTLE ? "little"
2255                            : "default"));
2256       fprintf_unfiltered (gdb_stdlog,
2257                           "gdbarch_update: info.osabi %d (%s)\n",
2258                           info.osabi, gdbarch_osabi_name (info.osabi));
2259       fprintf_unfiltered (gdb_stdlog,
2260                           "gdbarch_update: info.abfd 0x%lx\n",
2261                           (long) info.abfd);
2262       fprintf_unfiltered (gdb_stdlog,
2263                           "gdbarch_update: info.tdep_info 0x%lx\n",
2264                           (long) info.tdep_info);
2265     }
2266
2267   /* Find the target that knows about this architecture. */
2268   for (rego = gdbarch_registry;
2269        rego != NULL;
2270        rego = rego->next)
2271     if (rego->bfd_architecture == info.bfd_arch_info->arch)
2272       break;
2273   if (rego == NULL)
2274     {
2275       if (gdbarch_debug)
2276         fprintf_unfiltered (gdb_stdlog, "gdbarch_update: No matching architecture\\n");
2277       return 0;
2278     }
2279
2280   /* Swap the data belonging to the old target out setting the
2281      installed data to zero.  This stops the ->init() function trying
2282      to refer to the previous architecture's global data structures.  */
2283   swapout_gdbarch_swap (current_gdbarch);
2284   clear_gdbarch_swap (current_gdbarch);
2285
2286   /* Save the previously selected architecture, setting the global to
2287      NULL.  This stops ->init() trying to use the previous
2288      architecture's configuration.  The previous architecture may not
2289      even be of the same architecture family.  The most recent
2290      architecture of the same family is found at the head of the
2291      rego->arches list.  */
2292   old_gdbarch = current_gdbarch;
2293   current_gdbarch = NULL;
2294
2295   /* Ask the target for a replacement architecture. */
2296   new_gdbarch = rego->init (info, rego->arches);
2297
2298   /* Did the target like it?  No. Reject the change and revert to the
2299      old architecture.  */
2300   if (new_gdbarch == NULL)
2301     {
2302       if (gdbarch_debug)
2303         fprintf_unfiltered (gdb_stdlog, "gdbarch_update: Target rejected architecture\\n");
2304       swapin_gdbarch_swap (old_gdbarch);
2305       current_gdbarch = old_gdbarch;
2306       return 0;
2307     }
2308
2309   /* Did the architecture change?  No.  Oops, put the old architecture
2310      back.  */
2311   if (old_gdbarch == new_gdbarch)
2312     {
2313       if (gdbarch_debug)
2314         fprintf_unfiltered (gdb_stdlog, "gdbarch_update: Architecture 0x%08lx (%s) unchanged\\n",
2315                             (long) new_gdbarch,
2316                             new_gdbarch->bfd_arch_info->printable_name);
2317       swapin_gdbarch_swap (old_gdbarch);
2318       current_gdbarch = old_gdbarch;
2319       return 1;
2320     }
2321
2322   /* Is this a pre-existing architecture?  Yes. Move it to the front
2323      of the list of architectures (keeping the list sorted Most
2324      Recently Used) and then copy it in.  */
2325   {
2326     struct gdbarch_list **list;
2327     for (list = &rego->arches;
2328          (*list) != NULL;
2329          list = &(*list)->next)
2330       {
2331         if ((*list)->gdbarch == new_gdbarch)
2332           {
2333             struct gdbarch_list *this;
2334             if (gdbarch_debug)
2335               fprintf_unfiltered (gdb_stdlog,
2336                                   "gdbarch_update: Previous architecture 0x%08lx (%s) selected\n",
2337                                   (long) new_gdbarch,
2338                                   new_gdbarch->bfd_arch_info->printable_name);
2339             /* Unlink this.  */
2340             this = (*list);
2341             (*list) = this->next;
2342             /* Insert in the front.  */
2343             this->next = rego->arches;
2344             rego->arches = this;
2345             /* Copy the new architecture in.  */
2346             current_gdbarch = new_gdbarch;
2347             swapin_gdbarch_swap (new_gdbarch);
2348             architecture_changed_event ();
2349             return 1;
2350           }
2351       }
2352   }
2353
2354   /* Prepend this new architecture to the architecture list (keep the
2355      list sorted Most Recently Used).  */
2356   {
2357     struct gdbarch_list *this = XMALLOC (struct gdbarch_list);
2358     this->next = rego->arches;
2359     this->gdbarch = new_gdbarch;
2360     rego->arches = this;
2361   }
2362
2363   /* Switch to this new architecture marking it initialized.  */
2364   current_gdbarch = new_gdbarch;
2365   current_gdbarch->initialized_p = 1;
2366   if (gdbarch_debug)
2367     {
2368       fprintf_unfiltered (gdb_stdlog,
2369                           "gdbarch_update: New architecture 0x%08lx (%s) selected\\n",
2370                           (long) new_gdbarch,
2371                           new_gdbarch->bfd_arch_info->printable_name);
2372     }
2373
2374   /* Check that the newly installed architecture is valid.  Plug in
2375      any post init values.  */
2376   new_gdbarch->dump_tdep = rego->dump_tdep;
2377   verify_gdbarch (new_gdbarch);
2378
2379   /* Initialize the per-architecture memory (swap) areas.
2380      CURRENT_GDBARCH must be update before these modules are
2381      called. */
2382   init_gdbarch_swap (new_gdbarch);
2383
2384   /* Initialize the per-architecture data.  CURRENT_GDBARCH
2385      must be updated before these modules are called. */
2386   architecture_changed_event ();
2387
2388   if (gdbarch_debug)
2389     gdbarch_dump (current_gdbarch, gdb_stdlog);
2390
2391   return 1;
2392 }
2393
2394
2395 /* Disassembler */
2396
2397 /* Pointer to the target-dependent disassembly function.  */
2398 int (*deprecated_tm_print_insn) (bfd_vma, disassemble_info *);
2399
2400 extern void _initialize_gdbarch (void);
2401
2402 void
2403 _initialize_gdbarch (void)
2404 {
2405   struct cmd_list_element *c;
2406
2407   add_show_from_set (add_set_cmd ("arch",
2408                                   class_maintenance,
2409                                   var_zinteger,
2410                                   (char *)&gdbarch_debug,
2411                                   "Set architecture debugging.\\n\\
2412 When non-zero, architecture debugging is enabled.", &setdebuglist),
2413                      &showdebuglist);
2414   c = add_set_cmd ("archdebug",
2415                    class_maintenance,
2416                    var_zinteger,
2417                    (char *)&gdbarch_debug,
2418                    "Set architecture debugging.\\n\\
2419 When non-zero, architecture debugging is enabled.", &setlist);
2420
2421   deprecate_cmd (c, "set debug arch");
2422   deprecate_cmd (add_show_from_set (c, &showlist), "show debug arch");
2423 }
2424 EOF
2425
2426 # close things off
2427 exec 1>&2
2428 #../move-if-change new-gdbarch.c gdbarch.c
2429 compare_new gdbarch.c