gdb/gdbarch.sh

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