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