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