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