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