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
1133 /* Static function declarations */
1134
1135 static void verify_gdbarch (struct gdbarch *gdbarch);
1136 static void alloc_gdbarch_data (struct gdbarch *);
1137 static void init_gdbarch_data (struct gdbarch *);
1138 static void free_gdbarch_data (struct gdbarch *);
1139 static void init_gdbarch_swap (struct gdbarch *);
1140 static void swapout_gdbarch_swap (struct gdbarch *);
1141 static void swapin_gdbarch_swap (struct gdbarch *);
1142
1143 /* Convenience macro for allocting typesafe memory. */
1144
1145 #ifndef XMALLOC
1146 #define XMALLOC(TYPE) (TYPE*) xmalloc (sizeof (TYPE))
1147 #endif
1148
1149
1150 /* Non-zero if we want to trace architecture code.  */
1151
1152 #ifndef GDBARCH_DEBUG
1153 #define GDBARCH_DEBUG 0
1154 #endif
1155 int gdbarch_debug = GDBARCH_DEBUG;
1156
1157 EOF
1158
1159 # gdbarch open the gdbarch object
1160 printf "\n"
1161 printf "/* Maintain the struct gdbarch object */\n"
1162 printf "\n"
1163 printf "struct gdbarch\n"
1164 printf "{\n"
1165 printf "  /* basic architectural information */\n"
1166 function_list | while do_read
1167 do
1168     if class_is_info_p
1169     then
1170         printf "  ${returntype} ${function};\n"
1171     fi
1172 done
1173 printf "\n"
1174 printf "  /* target specific vector. */\n"
1175 printf "  struct gdbarch_tdep *tdep;\n"
1176 printf "  gdbarch_dump_tdep_ftype *dump_tdep;\n"
1177 printf "\n"
1178 printf "  /* per-architecture data-pointers */\n"
1179 printf "  unsigned nr_data;\n"
1180 printf "  void **data;\n"
1181 printf "\n"
1182 printf "  /* per-architecture swap-regions */\n"
1183 printf "  struct gdbarch_swap *swap;\n"
1184 printf "\n"
1185 cat <<EOF
1186   /* Multi-arch values.
1187
1188      When extending this structure you must:
1189
1190      Add the field below.
1191
1192      Declare set/get functions and define the corresponding
1193      macro in gdbarch.h.
1194
1195      gdbarch_alloc(): If zero/NULL is not a suitable default,
1196      initialize the new field.
1197
1198      verify_gdbarch(): Confirm that the target updated the field
1199      correctly.
1200
1201      gdbarch_dump(): Add a fprintf_unfiltered call so that the new
1202      field is dumped out
1203
1204      \`\`startup_gdbarch()'': Append an initial value to the static
1205      variable (base values on the host's c-type system).
1206
1207      get_gdbarch(): Implement the set/get functions (probably using
1208      the macro's as shortcuts).
1209
1210      */
1211
1212 EOF
1213 function_list | while do_read
1214 do
1215     if class_is_variable_p
1216     then
1217         printf "  ${returntype} ${function};\n"
1218     elif class_is_function_p
1219     then
1220         printf "  gdbarch_${function}_ftype *${function}${attrib};\n"
1221     fi
1222 done
1223 printf "};\n"
1224
1225 # A pre-initialized vector
1226 printf "\n"
1227 printf "\n"
1228 cat <<EOF
1229 /* The default architecture uses host values (for want of a better
1230    choice). */
1231 EOF
1232 printf "\n"
1233 printf "extern const struct bfd_arch_info bfd_default_arch_struct;\n"
1234 printf "\n"
1235 printf "struct gdbarch startup_gdbarch =\n"
1236 printf "{\n"
1237 printf "  /* basic architecture information */\n"
1238 function_list | while do_read
1239 do
1240     if class_is_info_p
1241     then
1242         printf "  ${staticdefault},\n"
1243     fi
1244 done
1245 cat <<EOF
1246   /* target specific vector and its dump routine */
1247   NULL, NULL,
1248   /*per-architecture data-pointers and swap regions */
1249   0, NULL, NULL,
1250   /* Multi-arch values */
1251 EOF
1252 function_list | while do_read
1253 do
1254     if class_is_function_p || class_is_variable_p
1255     then
1256         printf "  ${staticdefault},\n"
1257     fi
1258 done
1259 cat <<EOF
1260   /* startup_gdbarch() */
1261 };
1262
1263 struct gdbarch *current_gdbarch = &startup_gdbarch;
1264
1265 /* Do any initialization needed for a non-multiarch configuration
1266    after the _initialize_MODULE functions have been run.  */
1267 void
1268 initialize_non_multiarch ()
1269 {
1270   alloc_gdbarch_data (&startup_gdbarch);
1271   init_gdbarch_data (&startup_gdbarch);
1272 }
1273 EOF
1274
1275 # Create a new gdbarch struct
1276 printf "\n"
1277 printf "\n"
1278 cat <<EOF
1279 /* Create a new \`\`struct gdbarch'' based on information provided by
1280    \`\`struct gdbarch_info''. */
1281 EOF
1282 printf "\n"
1283 cat <<EOF
1284 struct gdbarch *
1285 gdbarch_alloc (const struct gdbarch_info *info,
1286                struct gdbarch_tdep *tdep)
1287 {
1288   struct gdbarch *gdbarch = XMALLOC (struct gdbarch);
1289   memset (gdbarch, 0, sizeof (*gdbarch));
1290
1291   alloc_gdbarch_data (gdbarch);
1292
1293   gdbarch->tdep = tdep;
1294 EOF
1295 printf "\n"
1296 function_list | while do_read
1297 do
1298     if class_is_info_p
1299     then
1300         printf "  gdbarch->${function} = info->${function};\n"
1301     fi
1302 done
1303 printf "\n"
1304 printf "  /* Force the explicit initialization of these. */\n"
1305 function_list | while do_read
1306 do
1307     if class_is_function_p || class_is_variable_p
1308     then
1309         if [ -n "${predefault}" -a "x${predefault}" != "x0" ]
1310         then
1311           printf "  gdbarch->${function} = ${predefault};\n"
1312         fi
1313     fi
1314 done
1315 cat <<EOF
1316   /* gdbarch_alloc() */
1317
1318   return gdbarch;
1319 }
1320 EOF
1321
1322 # Free a gdbarch struct.
1323 printf "\n"
1324 printf "\n"
1325 cat <<EOF
1326 /* Free a gdbarch struct.  This should never happen in normal
1327    operation --- once you've created a gdbarch, you keep it around.
1328    However, if an architecture's init function encounters an error
1329    building the structure, it may need to clean up a partially
1330    constructed gdbarch.  */
1331
1332 void
1333 gdbarch_free (struct gdbarch *arch)
1334 {
1335   gdb_assert (arch != NULL);
1336   free_gdbarch_data (arch);
1337   xfree (arch);
1338 }
1339 EOF
1340
1341 # verify a new architecture
1342 printf "\n"
1343 printf "\n"
1344 printf "/* Ensure that all values in a GDBARCH are reasonable. */\n"
1345 printf "\n"
1346 cat <<EOF
1347 static void
1348 verify_gdbarch (struct gdbarch *gdbarch)
1349 {
1350   /* Only perform sanity checks on a multi-arch target. */
1351   if (!GDB_MULTI_ARCH)
1352     return;
1353   /* fundamental */
1354   if (gdbarch->byte_order == 0)
1355     internal_error (__FILE__, __LINE__,
1356                     "verify_gdbarch: byte-order unset");
1357   if (gdbarch->bfd_arch_info == NULL)
1358     internal_error (__FILE__, __LINE__,
1359                     "verify_gdbarch: bfd_arch_info unset");
1360   /* Check those that need to be defined for the given multi-arch level. */
1361 EOF
1362 function_list | while do_read
1363 do
1364     if class_is_function_p || class_is_variable_p
1365     then
1366         if [ "x${invalid_p}" = "x0" ]
1367         then
1368             printf "  /* Skip verify of ${function}, invalid_p == 0 */\n"
1369         elif class_is_predicate_p
1370         then
1371             printf "  /* Skip verify of ${function}, has predicate */\n"
1372         # FIXME: See do_read for potential simplification
1373         elif [ -n "${invalid_p}" -a -n "${postdefault}" ]
1374         then
1375             printf "  if (${invalid_p})\n"
1376             printf "    gdbarch->${function} = ${postdefault};\n"
1377         elif [ -n "${predefault}" -a -n "${postdefault}" ]
1378         then
1379             printf "  if (gdbarch->${function} == ${predefault})\n"
1380             printf "    gdbarch->${function} = ${postdefault};\n"
1381         elif [ -n "${postdefault}" ]
1382         then
1383             printf "  if (gdbarch->${function} == 0)\n"
1384             printf "    gdbarch->${function} = ${postdefault};\n"
1385         elif [ -n "${invalid_p}" ]
1386         then
1387             printf "  if ((GDB_MULTI_ARCH >= ${level})\n"
1388             printf "      && (${invalid_p}))\n"
1389             printf "    internal_error (__FILE__, __LINE__,\n"
1390             printf "                    \"gdbarch: verify_gdbarch: ${function} invalid\");\n"
1391         elif [ -n "${predefault}" ]
1392         then
1393             printf "  if ((GDB_MULTI_ARCH >= ${level})\n"
1394             printf "      && (gdbarch->${function} == ${predefault}))\n"
1395             printf "    internal_error (__FILE__, __LINE__,\n"
1396             printf "                    \"gdbarch: verify_gdbarch: ${function} invalid\");\n"
1397         fi
1398     fi
1399 done
1400 cat <<EOF
1401 }
1402 EOF
1403
1404 # dump the structure
1405 printf "\n"
1406 printf "\n"
1407 cat <<EOF
1408 /* Print out the details of the current architecture. */
1409
1410 /* NOTE/WARNING: The parameter is called \`\`current_gdbarch'' so that it
1411    just happens to match the global variable \`\`current_gdbarch''.  That
1412    way macros refering to that variable get the local and not the global
1413    version - ulgh.  Once everything is parameterised with gdbarch, this
1414    will go away. */
1415
1416 void
1417 gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file)
1418 {
1419   fprintf_unfiltered (file,
1420                       "gdbarch_dump: GDB_MULTI_ARCH = %d\\n",
1421                       GDB_MULTI_ARCH);
1422 EOF
1423 function_list | while do_read
1424 do
1425     # multiarch functions don't have macros.
1426     class_is_multiarch_p && continue
1427     if [ "x${returntype}" = "xvoid" ]
1428     then
1429         printf "#if defined (${macro}) && GDB_MULTI_ARCH\n"
1430         printf "  /* Macro might contain \`[{}]' when not multi-arch */\n"
1431     else
1432         printf "#ifdef ${macro}\n"
1433     fi
1434     if class_is_function_p
1435     then
1436         printf "  fprintf_unfiltered (file,\n"
1437         printf "                      \"gdbarch_dump: %%s # %%s\\\\n\",\n"
1438         printf "                      \"${macro}(${actual})\",\n"
1439         printf "                      XSTRING (${macro} (${actual})));\n"
1440     else
1441         printf "  fprintf_unfiltered (file,\n"
1442         printf "                      \"gdbarch_dump: ${macro} # %%s\\\\n\",\n"
1443         printf "                      XSTRING (${macro}));\n"
1444     fi
1445     printf "#endif\n"
1446 done
1447 function_list | while do_read
1448 do
1449     if class_is_multiarch_p
1450     then
1451         printf "  if (GDB_MULTI_ARCH)\n"
1452         printf "    fprintf_unfiltered (file,\n"
1453         printf "                        \"gdbarch_dump: ${function} = 0x%%08lx\\\\n\",\n"
1454         printf "                        (long) current_gdbarch->${function});\n"
1455         continue
1456     fi
1457     printf "#ifdef ${macro}\n"
1458     if [ "x${print_p}" = "x()" ]
1459     then
1460         printf "  gdbarch_dump_${function} (current_gdbarch);\n"
1461     elif [ "x${print_p}" = "x0" ]
1462     then
1463         printf "  /* skip print of ${macro}, print_p == 0. */\n"
1464     elif [ -n "${print_p}" ]
1465     then
1466         printf "  if (${print_p})\n"
1467         printf "    fprintf_unfiltered (file,\n"
1468         printf "                        \"gdbarch_dump: ${macro} = %s\\\\n\",\n" "${fmt}"
1469         printf "                        ${print});\n"
1470     elif class_is_function_p
1471     then
1472         printf "  if (GDB_MULTI_ARCH)\n"
1473         printf "    fprintf_unfiltered (file,\n"
1474         printf "                        \"gdbarch_dump: ${macro} = 0x%%08lx\\\\n\",\n"
1475         printf "                        (long) current_gdbarch->${function}\n"
1476         printf "                        /*${macro} ()*/);\n"
1477     else
1478         printf "  fprintf_unfiltered (file,\n"
1479         printf "                      \"gdbarch_dump: ${macro} = %s\\\\n\",\n" "${fmt}"
1480         printf "                      ${print});\n"
1481     fi
1482     printf "#endif\n"
1483 done
1484 cat <<EOF
1485   if (current_gdbarch->dump_tdep != NULL)
1486     current_gdbarch->dump_tdep (current_gdbarch, file);
1487 }
1488 EOF
1489
1490
1491 # GET/SET
1492 printf "\n"
1493 cat <<EOF
1494 struct gdbarch_tdep *
1495 gdbarch_tdep (struct gdbarch *gdbarch)
1496 {
1497   if (gdbarch_debug >= 2)
1498     fprintf_unfiltered (gdb_stdlog, "gdbarch_tdep called\\n");
1499   return gdbarch->tdep;
1500 }
1501 EOF
1502 printf "\n"
1503 function_list | while do_read
1504 do
1505     if class_is_predicate_p
1506     then
1507         printf "\n"
1508         printf "int\n"
1509         printf "gdbarch_${function}_p (struct gdbarch *gdbarch)\n"
1510         printf "{\n"
1511         if [ -n "${valid_p}" ]
1512         then
1513             printf "  return ${valid_p};\n"
1514         else
1515             printf "#error \"gdbarch_${function}_p: not defined\"\n"
1516         fi
1517         printf "}\n"
1518     fi
1519     if class_is_function_p
1520     then
1521         printf "\n"
1522         printf "${returntype}\n"
1523         if [ "x${formal}" = "xvoid" ]
1524         then
1525           printf "gdbarch_${function} (struct gdbarch *gdbarch)\n"
1526         else
1527           printf "gdbarch_${function} (struct gdbarch *gdbarch, ${formal})\n"
1528         fi
1529         printf "{\n"
1530         printf "  if (gdbarch->${function} == 0)\n"
1531         printf "    internal_error (__FILE__, __LINE__,\n"
1532         printf "                    \"gdbarch: gdbarch_${function} invalid\");\n"
1533         printf "  if (gdbarch_debug >= 2)\n"
1534         printf "    fprintf_unfiltered (gdb_stdlog, \"gdbarch_${function} called\\\\n\");\n"
1535         if [ "x${actual}" = "x-" -o "x${actual}" = "x" ]
1536         then
1537             if class_is_multiarch_p
1538             then
1539                 params="gdbarch"
1540             else
1541                 params=""
1542             fi
1543         else
1544             if class_is_multiarch_p
1545             then
1546                 params="gdbarch, ${actual}"
1547             else
1548                 params="${actual}"
1549             fi
1550         fi
1551         if [ "x${returntype}" = "xvoid" ]
1552         then
1553           printf "  gdbarch->${function} (${params});\n"
1554         else
1555           printf "  return gdbarch->${function} (${params});\n"
1556         fi
1557         printf "}\n"
1558         printf "\n"
1559         printf "void\n"
1560         printf "set_gdbarch_${function} (struct gdbarch *gdbarch,\n"
1561         printf "            `echo ${function} | sed -e 's/./ /g'`  gdbarch_${function}_ftype ${function})\n"
1562         printf "{\n"
1563         printf "  gdbarch->${function} = ${function};\n"
1564         printf "}\n"
1565     elif class_is_variable_p
1566     then
1567         printf "\n"
1568         printf "${returntype}\n"
1569         printf "gdbarch_${function} (struct gdbarch *gdbarch)\n"
1570         printf "{\n"
1571         if [ "x${invalid_p}" = "x0" ]
1572         then
1573             printf "  /* Skip verify of ${function}, invalid_p == 0 */\n"
1574         elif [ -n "${invalid_p}" ]
1575         then
1576           printf "  if (${invalid_p})\n"
1577           printf "    internal_error (__FILE__, __LINE__,\n"
1578           printf "                    \"gdbarch: gdbarch_${function} invalid\");\n"
1579         elif [ -n "${predefault}" ]
1580         then
1581           printf "  if (gdbarch->${function} == ${predefault})\n"
1582           printf "    internal_error (__FILE__, __LINE__,\n"
1583           printf "                    \"gdbarch: gdbarch_${function} invalid\");\n"
1584         fi
1585         printf "  if (gdbarch_debug >= 2)\n"
1586         printf "    fprintf_unfiltered (gdb_stdlog, \"gdbarch_${function} called\\\\n\");\n"
1587         printf "  return gdbarch->${function};\n"
1588         printf "}\n"
1589         printf "\n"
1590         printf "void\n"
1591         printf "set_gdbarch_${function} (struct gdbarch *gdbarch,\n"
1592         printf "            `echo ${function} | sed -e 's/./ /g'`  ${returntype} ${function})\n"
1593         printf "{\n"
1594         printf "  gdbarch->${function} = ${function};\n"
1595         printf "}\n"
1596     elif class_is_info_p
1597     then
1598         printf "\n"
1599         printf "${returntype}\n"
1600         printf "gdbarch_${function} (struct gdbarch *gdbarch)\n"
1601         printf "{\n"
1602         printf "  if (gdbarch_debug >= 2)\n"
1603         printf "    fprintf_unfiltered (gdb_stdlog, \"gdbarch_${function} called\\\\n\");\n"
1604         printf "  return gdbarch->${function};\n"
1605         printf "}\n"
1606     fi
1607 done
1608
1609 # All the trailing guff
1610 cat <<EOF
1611
1612
1613 /* Keep a registry of per-architecture data-pointers required by GDB
1614    modules. */
1615
1616 struct gdbarch_data
1617 {
1618   unsigned index;
1619   gdbarch_data_init_ftype *init;
1620   gdbarch_data_free_ftype *free;
1621 };
1622
1623 struct gdbarch_data_registration
1624 {
1625   struct gdbarch_data *data;
1626   struct gdbarch_data_registration *next;
1627 };
1628
1629 struct gdbarch_data_registry
1630 {
1631   unsigned nr;
1632   struct gdbarch_data_registration *registrations;
1633 };
1634
1635 struct gdbarch_data_registry gdbarch_data_registry =
1636 {
1637   0, NULL,
1638 };
1639
1640 struct gdbarch_data *
1641 register_gdbarch_data (gdbarch_data_init_ftype *init,
1642                        gdbarch_data_free_ftype *free)
1643 {
1644   struct gdbarch_data_registration **curr;
1645   for (curr = &gdbarch_data_registry.registrations;
1646        (*curr) != NULL;
1647        curr = &(*curr)->next);
1648   (*curr) = XMALLOC (struct gdbarch_data_registration);
1649   (*curr)->next = NULL;
1650   (*curr)->data = XMALLOC (struct gdbarch_data);
1651   (*curr)->data->index = gdbarch_data_registry.nr++;
1652   (*curr)->data->init = init;
1653   (*curr)->data->free = free;
1654   return (*curr)->data;
1655 }
1656
1657
1658 /* Walk through all the registered users initializing each in turn. */
1659
1660 static void
1661 init_gdbarch_data (struct gdbarch *gdbarch)
1662 {
1663   struct gdbarch_data_registration *rego;
1664   for (rego = gdbarch_data_registry.registrations;
1665        rego != NULL;
1666        rego = rego->next)
1667     {
1668       struct gdbarch_data *data = rego->data;
1669       gdb_assert (data->index < gdbarch->nr_data);
1670       if (data->init != NULL)
1671         {
1672           void *pointer = data->init (gdbarch);
1673           set_gdbarch_data (gdbarch, data, pointer);
1674         }
1675     }
1676 }
1677
1678 /* Create/delete the gdbarch data vector. */
1679
1680 static void
1681 alloc_gdbarch_data (struct gdbarch *gdbarch)
1682 {
1683   gdb_assert (gdbarch->data == NULL);
1684   gdbarch->nr_data = gdbarch_data_registry.nr;
1685   gdbarch->data = xcalloc (gdbarch->nr_data, sizeof (void*));
1686 }
1687
1688 static void
1689 free_gdbarch_data (struct gdbarch *gdbarch)
1690 {
1691   struct gdbarch_data_registration *rego;
1692   gdb_assert (gdbarch->data != NULL);
1693   for (rego = gdbarch_data_registry.registrations;
1694        rego != NULL;
1695        rego = rego->next)
1696     {
1697       struct gdbarch_data *data = rego->data;
1698       gdb_assert (data->index < gdbarch->nr_data);
1699       if (data->free != NULL && gdbarch->data[data->index] != NULL)
1700         {
1701           data->free (gdbarch, gdbarch->data[data->index]);
1702           gdbarch->data[data->index] = NULL;
1703         }
1704     }
1705   xfree (gdbarch->data);
1706   gdbarch->data = NULL;
1707 }
1708
1709
1710 /* Initialize the current value of thee specified per-architecture
1711    data-pointer. */
1712
1713 void
1714 set_gdbarch_data (struct gdbarch *gdbarch,
1715                   struct gdbarch_data *data,
1716                   void *pointer)
1717 {
1718   gdb_assert (data->index < gdbarch->nr_data);
1719   if (data->free != NULL && gdbarch->data[data->index] != NULL)
1720     data->free (gdbarch, gdbarch->data[data->index]);
1721   gdbarch->data[data->index] = pointer;
1722 }
1723
1724 /* Return the current value of the specified per-architecture
1725    data-pointer. */
1726
1727 void *
1728 gdbarch_data (struct gdbarch_data *data)
1729 {
1730   gdb_assert (data->index < current_gdbarch->nr_data);
1731   return current_gdbarch->data[data->index];
1732 }
1733
1734
1735
1736 /* Keep a registry of swapped data required by GDB modules. */
1737
1738 struct gdbarch_swap
1739 {
1740   void *swap;
1741   struct gdbarch_swap_registration *source;
1742   struct gdbarch_swap *next;
1743 };
1744
1745 struct gdbarch_swap_registration
1746 {
1747   void *data;
1748   unsigned long sizeof_data;
1749   gdbarch_swap_ftype *init;
1750   struct gdbarch_swap_registration *next;
1751 };
1752
1753 struct gdbarch_swap_registry
1754 {
1755   int nr;
1756   struct gdbarch_swap_registration *registrations;
1757 };
1758
1759 struct gdbarch_swap_registry gdbarch_swap_registry =
1760 {
1761   0, NULL,
1762 };
1763
1764 void
1765 register_gdbarch_swap (void *data,
1766                        unsigned long sizeof_data,
1767                        gdbarch_swap_ftype *init)
1768 {
1769   struct gdbarch_swap_registration **rego;
1770   for (rego = &gdbarch_swap_registry.registrations;
1771        (*rego) != NULL;
1772        rego = &(*rego)->next);
1773   (*rego) = XMALLOC (struct gdbarch_swap_registration);
1774   (*rego)->next = NULL;
1775   (*rego)->init = init;
1776   (*rego)->data = data;
1777   (*rego)->sizeof_data = sizeof_data;
1778 }
1779
1780
1781 static void
1782 init_gdbarch_swap (struct gdbarch *gdbarch)
1783 {
1784   struct gdbarch_swap_registration *rego;
1785   struct gdbarch_swap **curr = &gdbarch->swap;
1786   for (rego = gdbarch_swap_registry.registrations;
1787        rego != NULL;
1788        rego = rego->next)
1789     {
1790       if (rego->data != NULL)
1791         {
1792           (*curr) = XMALLOC (struct gdbarch_swap);
1793           (*curr)->source = rego;
1794           (*curr)->swap = xmalloc (rego->sizeof_data);
1795           (*curr)->next = NULL;
1796           memset (rego->data, 0, rego->sizeof_data);
1797           curr = &(*curr)->next;
1798         }
1799       if (rego->init != NULL)
1800         rego->init ();
1801     }
1802 }
1803
1804 static void
1805 swapout_gdbarch_swap (struct gdbarch *gdbarch)
1806 {
1807   struct gdbarch_swap *curr;
1808   for (curr = gdbarch->swap;
1809        curr != NULL;
1810        curr = curr->next)
1811     memcpy (curr->swap, curr->source->data, curr->source->sizeof_data);
1812 }
1813
1814 static void
1815 swapin_gdbarch_swap (struct gdbarch *gdbarch)
1816 {
1817   struct gdbarch_swap *curr;
1818   for (curr = gdbarch->swap;
1819        curr != NULL;
1820        curr = curr->next)
1821     memcpy (curr->source->data, curr->swap, curr->source->sizeof_data);
1822 }
1823
1824
1825 /* Keep a registry of the architectures known by GDB. */
1826
1827 struct gdbarch_registration
1828 {
1829   enum bfd_architecture bfd_architecture;
1830   gdbarch_init_ftype *init;
1831   gdbarch_dump_tdep_ftype *dump_tdep;
1832   struct gdbarch_list *arches;
1833   struct gdbarch_registration *next;
1834 };
1835
1836 static struct gdbarch_registration *gdbarch_registry = NULL;
1837
1838 static void
1839 append_name (const char ***buf, int *nr, const char *name)
1840 {
1841   *buf = xrealloc (*buf, sizeof (char**) * (*nr + 1));
1842   (*buf)[*nr] = name;
1843   *nr += 1;
1844 }
1845
1846 const char **
1847 gdbarch_printable_names (void)
1848 {
1849   if (GDB_MULTI_ARCH)
1850     {
1851       /* Accumulate a list of names based on the registed list of
1852          architectures. */
1853       enum bfd_architecture a;
1854       int nr_arches = 0;
1855       const char **arches = NULL;
1856       struct gdbarch_registration *rego;
1857       for (rego = gdbarch_registry;
1858            rego != NULL;
1859            rego = rego->next)
1860         {
1861           const struct bfd_arch_info *ap;
1862           ap = bfd_lookup_arch (rego->bfd_architecture, 0);
1863           if (ap == NULL)
1864             internal_error (__FILE__, __LINE__,
1865                             "gdbarch_architecture_names: multi-arch unknown");
1866           do
1867             {
1868               append_name (&arches, &nr_arches, ap->printable_name);
1869               ap = ap->next;
1870             }
1871           while (ap != NULL);
1872         }
1873       append_name (&arches, &nr_arches, NULL);
1874       return arches;
1875     }
1876   else
1877     /* Just return all the architectures that BFD knows.  Assume that
1878        the legacy architecture framework supports them. */
1879     return bfd_arch_list ();
1880 }
1881
1882
1883 void
1884 gdbarch_register (enum bfd_architecture bfd_architecture,
1885                   gdbarch_init_ftype *init,
1886                   gdbarch_dump_tdep_ftype *dump_tdep)
1887 {
1888   struct gdbarch_registration **curr;
1889   const struct bfd_arch_info *bfd_arch_info;
1890   /* Check that BFD recognizes this architecture */
1891   bfd_arch_info = bfd_lookup_arch (bfd_architecture, 0);
1892   if (bfd_arch_info == NULL)
1893     {
1894       internal_error (__FILE__, __LINE__,
1895                       "gdbarch: Attempt to register unknown architecture (%d)",
1896                       bfd_architecture);
1897     }
1898   /* Check that we haven't seen this architecture before */
1899   for (curr = &gdbarch_registry;
1900        (*curr) != NULL;
1901        curr = &(*curr)->next)
1902     {
1903       if (bfd_architecture == (*curr)->bfd_architecture)
1904         internal_error (__FILE__, __LINE__,
1905                         "gdbarch: Duplicate registraration of architecture (%s)",
1906                         bfd_arch_info->printable_name);
1907     }
1908   /* log it */
1909   if (gdbarch_debug)
1910     fprintf_unfiltered (gdb_stdlog, "register_gdbarch_init (%s, 0x%08lx)\n",
1911                         bfd_arch_info->printable_name,
1912                         (long) init);
1913   /* Append it */
1914   (*curr) = XMALLOC (struct gdbarch_registration);
1915   (*curr)->bfd_architecture = bfd_architecture;
1916   (*curr)->init = init;
1917   (*curr)->dump_tdep = dump_tdep;
1918   (*curr)->arches = NULL;
1919   (*curr)->next = NULL;
1920   /* When non- multi-arch, install whatever target dump routine we've
1921      been provided - hopefully that routine has been written correctly
1922      and works regardless of multi-arch. */
1923   if (!GDB_MULTI_ARCH && dump_tdep != NULL
1924       && startup_gdbarch.dump_tdep == NULL)
1925     startup_gdbarch.dump_tdep = dump_tdep;
1926 }
1927
1928 void
1929 register_gdbarch_init (enum bfd_architecture bfd_architecture,
1930                        gdbarch_init_ftype *init)
1931 {
1932   gdbarch_register (bfd_architecture, init, NULL);
1933 }
1934
1935
1936 /* Look for an architecture using gdbarch_info.  Base search on only
1937    BFD_ARCH_INFO and BYTE_ORDER. */
1938
1939 struct gdbarch_list *
1940 gdbarch_list_lookup_by_info (struct gdbarch_list *arches,
1941                              const struct gdbarch_info *info)
1942 {
1943   for (; arches != NULL; arches = arches->next)
1944     {
1945       if (info->bfd_arch_info != arches->gdbarch->bfd_arch_info)
1946         continue;
1947       if (info->byte_order != arches->gdbarch->byte_order)
1948         continue;
1949       return arches;
1950     }
1951   return NULL;
1952 }
1953
1954
1955 /* Update the current architecture. Return ZERO if the update request
1956    failed. */
1957
1958 int
1959 gdbarch_update_p (struct gdbarch_info info)
1960 {
1961   struct gdbarch *new_gdbarch;
1962   struct gdbarch_list **list;
1963   struct gdbarch_registration *rego;
1964
1965   /* Fill in missing parts of the INFO struct using a number of
1966      sources: \`\`set ...''; INFOabfd supplied; existing target.  */
1967
1968   /* \`\`(gdb) set architecture ...'' */
1969   if (info.bfd_arch_info == NULL
1970       && !TARGET_ARCHITECTURE_AUTO)
1971     info.bfd_arch_info = TARGET_ARCHITECTURE;
1972   if (info.bfd_arch_info == NULL
1973       && info.abfd != NULL
1974       && bfd_get_arch (info.abfd) != bfd_arch_unknown
1975       && bfd_get_arch (info.abfd) != bfd_arch_obscure)
1976     info.bfd_arch_info = bfd_get_arch_info (info.abfd);
1977   if (info.bfd_arch_info == NULL)
1978     info.bfd_arch_info = TARGET_ARCHITECTURE;
1979
1980   /* \`\`(gdb) set byte-order ...'' */
1981   if (info.byte_order == 0
1982       && !TARGET_BYTE_ORDER_AUTO)
1983     info.byte_order = TARGET_BYTE_ORDER;
1984   /* From the INFO struct. */
1985   if (info.byte_order == 0
1986       && info.abfd != NULL)
1987     info.byte_order = (bfd_big_endian (info.abfd) ? BIG_ENDIAN
1988                        : bfd_little_endian (info.abfd) ? LITTLE_ENDIAN
1989                        : 0);
1990   /* From the current target. */
1991   if (info.byte_order == 0)
1992     info.byte_order = TARGET_BYTE_ORDER;
1993
1994   /* Must have found some sort of architecture. */
1995   gdb_assert (info.bfd_arch_info != NULL);
1996
1997   if (gdbarch_debug)
1998     {
1999       fprintf_unfiltered (gdb_stdlog,
2000                           "gdbarch_update: info.bfd_arch_info %s\n",
2001                           (info.bfd_arch_info != NULL
2002                            ? info.bfd_arch_info->printable_name
2003                            : "(null)"));
2004       fprintf_unfiltered (gdb_stdlog,
2005                           "gdbarch_update: info.byte_order %d (%s)\n",
2006                           info.byte_order,
2007                           (info.byte_order == BIG_ENDIAN ? "big"
2008                            : info.byte_order == LITTLE_ENDIAN ? "little"
2009                            : "default"));
2010       fprintf_unfiltered (gdb_stdlog,
2011                           "gdbarch_update: info.abfd 0x%lx\n",
2012                           (long) info.abfd);
2013       fprintf_unfiltered (gdb_stdlog,
2014                           "gdbarch_update: info.tdep_info 0x%lx\n",
2015                           (long) info.tdep_info);
2016     }
2017
2018   /* Find the target that knows about this architecture. */
2019   for (rego = gdbarch_registry;
2020        rego != NULL;
2021        rego = rego->next)
2022     if (rego->bfd_architecture == info.bfd_arch_info->arch)
2023       break;
2024   if (rego == NULL)
2025     {
2026       if (gdbarch_debug)
2027         fprintf_unfiltered (gdb_stdlog, "gdbarch_update: No matching architecture\\n");
2028       return 0;
2029     }
2030
2031   /* Ask the target for a replacement architecture. */
2032   new_gdbarch = rego->init (info, rego->arches);
2033
2034   /* Did the target like it?  No. Reject the change. */
2035   if (new_gdbarch == NULL)
2036     {
2037       if (gdbarch_debug)
2038         fprintf_unfiltered (gdb_stdlog, "gdbarch_update: Target rejected architecture\\n");
2039       return 0;
2040     }
2041
2042   /* Did the architecture change?  No. Do nothing. */
2043   if (current_gdbarch == new_gdbarch)
2044     {
2045       if (gdbarch_debug)
2046         fprintf_unfiltered (gdb_stdlog, "gdbarch_update: Architecture 0x%08lx (%s) unchanged\\n",
2047                             (long) new_gdbarch,
2048                             new_gdbarch->bfd_arch_info->printable_name);
2049       return 1;
2050     }
2051
2052   /* Swap all data belonging to the old target out */
2053   swapout_gdbarch_swap (current_gdbarch);
2054
2055   /* Is this a pre-existing architecture?  Yes. Swap it in.  */
2056   for (list = &rego->arches;
2057        (*list) != NULL;
2058        list = &(*list)->next)
2059     {
2060       if ((*list)->gdbarch == new_gdbarch)
2061         {
2062           if (gdbarch_debug)
2063             fprintf_unfiltered (gdb_stdlog,
2064                                 "gdbarch_update: Previous architecture 0x%08lx (%s) selected\\n",
2065                                 (long) new_gdbarch,
2066                                 new_gdbarch->bfd_arch_info->printable_name);
2067           current_gdbarch = new_gdbarch;
2068           swapin_gdbarch_swap (new_gdbarch);
2069           return 1;
2070         }
2071     }
2072
2073   /* Append this new architecture to this targets list. */
2074   (*list) = XMALLOC (struct gdbarch_list);
2075   (*list)->next = NULL;
2076   (*list)->gdbarch = new_gdbarch;
2077
2078   /* Switch to this new architecture.  Dump it out. */
2079   current_gdbarch = new_gdbarch;
2080   if (gdbarch_debug)
2081     {
2082       fprintf_unfiltered (gdb_stdlog,
2083                           "gdbarch_update: New architecture 0x%08lx (%s) selected\\n",
2084                           (long) new_gdbarch,
2085                           new_gdbarch->bfd_arch_info->printable_name);
2086     }
2087
2088   /* Check that the newly installed architecture is valid.  Plug in
2089      any post init values.  */
2090   new_gdbarch->dump_tdep = rego->dump_tdep;
2091   verify_gdbarch (new_gdbarch);
2092
2093   /* Initialize the per-architecture memory (swap) areas.
2094      CURRENT_GDBARCH must be update before these modules are
2095      called. */
2096   init_gdbarch_swap (new_gdbarch);
2097
2098   /* Initialize the per-architecture data-pointer of all parties that
2099      registered an interest in this architecture.  CURRENT_GDBARCH
2100      must be updated before these modules are called. */
2101   init_gdbarch_data (new_gdbarch);
2102
2103   if (gdbarch_debug)
2104     gdbarch_dump (current_gdbarch, gdb_stdlog);
2105
2106   return 1;
2107 }
2108
2109
2110 /* Disassembler */
2111
2112 /* Pointer to the target-dependent disassembly function.  */
2113 int (*tm_print_insn) (bfd_vma, disassemble_info *);
2114 disassemble_info tm_print_insn_info;
2115
2116
2117 extern void _initialize_gdbarch (void);
2118
2119 void
2120 _initialize_gdbarch (void)
2121 {
2122   struct cmd_list_element *c;
2123
2124   INIT_DISASSEMBLE_INFO_NO_ARCH (tm_print_insn_info, gdb_stdout, (fprintf_ftype)fprintf_filtered);
2125   tm_print_insn_info.flavour = bfd_target_unknown_flavour;
2126   tm_print_insn_info.read_memory_func = dis_asm_read_memory;
2127   tm_print_insn_info.memory_error_func = dis_asm_memory_error;
2128   tm_print_insn_info.print_address_func = dis_asm_print_address;
2129
2130   add_show_from_set (add_set_cmd ("arch",
2131                                   class_maintenance,
2132                                   var_zinteger,
2133                                   (char *)&gdbarch_debug,
2134                                   "Set architecture debugging.\\n\\
2135 When non-zero, architecture debugging is enabled.", &setdebuglist),
2136                      &showdebuglist);
2137   c = add_set_cmd ("archdebug",
2138                    class_maintenance,
2139                    var_zinteger,
2140                    (char *)&gdbarch_debug,
2141                    "Set architecture debugging.\\n\\
2142 When non-zero, architecture debugging is enabled.", &setlist);
2143
2144   deprecate_cmd (c, "set debug arch");
2145   deprecate_cmd (add_show_from_set (c, &showlist), "show debug arch");
2146 }
2147 EOF
2148
2149 # close things off
2150 exec 1>&2
2151 #../move-if-change new-gdbarch.c gdbarch.c
2152 compare_new gdbarch.c