gdb/gdbarch.sh

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