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