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