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