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         # 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 [ "x${invalid_p}" = "x0" -a -n "${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 [ -n "${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 [ "x${fallbackdefault}" = "x0" ]
 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 [ "x${formal}" = "xvoid" ] && 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 [ "x${formal}" = "xvoid" ]
 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 [ "x${actual}" = "x" ]
 760             then
 761                 printf "#define ${macro}() (gdbarch_${function} (current_gdbarch))\n"
 762             elif [ "x${actual}" = "x-" ]
 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 /* For non-multiarched targets, do any initialization of the default
1069    gdbarch object necessary after the _initialize_MODULE functions
1070    have run.  */
1071 extern void initialize_non_multiarch ();
1072
1073 /* gdbarch trace variable */
1074 extern int gdbarch_debug;
1075
1076 extern void gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file);
1077
1078 #endif
1079 EOF
1080 exec 1>&2
1081 #../move-if-change new-gdbarch.h gdbarch.h
1082 compare_new gdbarch.h
1083
1084
1085 #
1086 # C file
1087 #
1088
1089 exec > new-gdbarch.c
1090 copyright
1091 cat <<EOF
1092
1093 #include "defs.h"
1094 #include "arch-utils.h"
1095
1096 #if GDB_MULTI_ARCH
1097 #include "gdbcmd.h"
1098 #include "inferior.h" /* enum CALL_DUMMY_LOCATION et.al. */
1099 #else
1100 /* Just include everything in sight so that the every old definition
1101    of macro is visible. */
1102 #include "gdb_string.h"
1103 #include <ctype.h>
1104 #include "symtab.h"
1105 #include "frame.h"
1106 #include "inferior.h"
1107 #include "breakpoint.h"
1108 #include "gdb_wait.h"
1109 #include "gdbcore.h"
1110 #include "gdbcmd.h"
1111 #include "target.h"
1112 #include "gdbthread.h"
1113 #include "annotate.h"
1114 #include "symfile.h"            /* for overlay functions */
1115 #endif
1116 #include "symcat.h"
1117
1118 #include "floatformat.h"
1119
1120 #include "gdb_assert.h"
1121
1122 /* Static function declarations */
1123
1124 static void verify_gdbarch (struct gdbarch *gdbarch);
1125 static void alloc_gdbarch_data (struct gdbarch *);
1126 static void init_gdbarch_data (struct gdbarch *);
1127 static void free_gdbarch_data (struct gdbarch *);
1128 static void init_gdbarch_swap (struct gdbarch *);
1129 static void swapout_gdbarch_swap (struct gdbarch *);
1130 static void swapin_gdbarch_swap (struct gdbarch *);
1131
1132 /* Convenience macro for allocting typesafe memory. */
1133
1134 #ifndef XMALLOC
1135 #define XMALLOC(TYPE) (TYPE*) xmalloc (sizeof (TYPE))
1136 #endif
1137
1138
1139 /* Non-zero if we want to trace architecture code.  */
1140
1141 #ifndef GDBARCH_DEBUG
1142 #define GDBARCH_DEBUG 0
1143 #endif
1144 int gdbarch_debug = GDBARCH_DEBUG;
1145
1146 EOF
1147
1148 # gdbarch open the gdbarch object
1149 printf "\n"
1150 printf "/* Maintain the struct gdbarch object */\n"
1151 printf "\n"
1152 printf "struct gdbarch\n"
1153 printf "{\n"
1154 printf "  /* basic architectural information */\n"
1155 function_list | while do_read
1156 do
1157     if class_is_info_p
1158     then
1159         printf "  ${returntype} ${function};\n"
1160     fi
1161 done
1162 printf "\n"
1163 printf "  /* target specific vector. */\n"
1164 printf "  struct gdbarch_tdep *tdep;\n"
1165 printf "  gdbarch_dump_tdep_ftype *dump_tdep;\n"
1166 printf "\n"
1167 printf "  /* per-architecture data-pointers */\n"
1168 printf "  unsigned nr_data;\n"
1169 printf "  void **data;\n"
1170 printf "\n"
1171 printf "  /* per-architecture swap-regions */\n"
1172 printf "  struct gdbarch_swap *swap;\n"
1173 printf "\n"
1174 cat <<EOF
1175   /* Multi-arch values.
1176
1177      When extending this structure you must:
1178
1179      Add the field below.
1180
1181      Declare set/get functions and define the corresponding
1182      macro in gdbarch.h.
1183
1184      gdbarch_alloc(): If zero/NULL is not a suitable default,
1185      initialize the new field.
1186
1187      verify_gdbarch(): Confirm that the target updated the field
1188      correctly.
1189
1190      gdbarch_dump(): Add a fprintf_unfiltered call so that the new
1191      field is dumped out
1192
1193      \`\`startup_gdbarch()'': Append an initial value to the static
1194      variable (base values on the host's c-type system).
1195
1196      get_gdbarch(): Implement the set/get functions (probably using
1197      the macro's as shortcuts).
1198
1199      */
1200
1201 EOF
1202 function_list | while do_read
1203 do
1204     if class_is_variable_p
1205     then
1206         printf "  ${returntype} ${function};\n"
1207     elif class_is_function_p
1208     then
1209         printf "  gdbarch_${function}_ftype *${function}${attrib};\n"
1210     fi
1211 done
1212 printf "};\n"
1213
1214 # A pre-initialized vector
1215 printf "\n"
1216 printf "\n"
1217 cat <<EOF
1218 /* The default architecture uses host values (for want of a better
1219    choice). */
1220 EOF
1221 printf "\n"
1222 printf "extern const struct bfd_arch_info bfd_default_arch_struct;\n"
1223 printf "\n"
1224 printf "struct gdbarch startup_gdbarch =\n"
1225 printf "{\n"
1226 printf "  /* basic architecture information */\n"
1227 function_list | while do_read
1228 do
1229     if class_is_info_p
1230     then
1231         printf "  ${staticdefault},\n"
1232     fi
1233 done
1234 cat <<EOF
1235   /* target specific vector and its dump routine */
1236   NULL, NULL,
1237   /*per-architecture data-pointers and swap regions */
1238   0, NULL, NULL,
1239   /* Multi-arch values */
1240 EOF
1241 function_list | while do_read
1242 do
1243     if class_is_function_p || class_is_variable_p
1244     then
1245         printf "  ${staticdefault},\n"
1246     fi
1247 done
1248 cat <<EOF
1249   /* startup_gdbarch() */
1250 };
1251
1252 struct gdbarch *current_gdbarch = &startup_gdbarch;
1253
1254 /* Do any initialization needed for a non-multiarch configuration
1255    after the _initialize_MODULE functions have been run.  */
1256 void
1257 initialize_non_multiarch ()
1258 {
1259   alloc_gdbarch_data (&startup_gdbarch);
1260   init_gdbarch_data (&startup_gdbarch);
1261 }
1262 EOF
1263
1264 # Create a new gdbarch struct
1265 printf "\n"
1266 printf "\n"
1267 cat <<EOF
1268 /* Create a new \`\`struct gdbarch'' based on information provided by
1269    \`\`struct gdbarch_info''. */
1270 EOF
1271 printf "\n"
1272 cat <<EOF
1273 struct gdbarch *
1274 gdbarch_alloc (const struct gdbarch_info *info,
1275                struct gdbarch_tdep *tdep)
1276 {
1277   struct gdbarch *gdbarch = XMALLOC (struct gdbarch);
1278   memset (gdbarch, 0, sizeof (*gdbarch));
1279
1280   alloc_gdbarch_data (gdbarch);
1281
1282   gdbarch->tdep = tdep;
1283 EOF
1284 printf "\n"
1285 function_list | while do_read
1286 do
1287     if class_is_info_p
1288     then
1289         printf "  gdbarch->${function} = info->${function};\n"
1290     fi
1291 done
1292 printf "\n"
1293 printf "  /* Force the explicit initialization of these. */\n"
1294 function_list | while do_read
1295 do
1296     if class_is_function_p || class_is_variable_p
1297     then
1298         if [ -n "${predefault}" -a "x${predefault}" != "x0" ]
1299         then
1300           printf "  gdbarch->${function} = ${predefault};\n"
1301         fi
1302     fi
1303 done
1304 cat <<EOF
1305   /* gdbarch_alloc() */
1306
1307   return gdbarch;
1308 }
1309 EOF
1310
1311 # Free a gdbarch struct.
1312 printf "\n"
1313 printf "\n"
1314 cat <<EOF
1315 /* Free a gdbarch struct.  This should never happen in normal
1316    operation --- once you've created a gdbarch, you keep it around.
1317    However, if an architecture's init function encounters an error
1318    building the structure, it may need to clean up a partially
1319    constructed gdbarch.  */
1320
1321 void
1322 gdbarch_free (struct gdbarch *arch)
1323 {
1324   gdb_assert (arch != NULL);
1325   free_gdbarch_data (arch);
1326   xfree (arch);
1327 }
1328 EOF
1329
1330 # verify a new architecture
1331 printf "\n"
1332 printf "\n"
1333 printf "/* Ensure that all values in a GDBARCH are reasonable. */\n"
1334 printf "\n"
1335 cat <<EOF
1336 static void
1337 verify_gdbarch (struct gdbarch *gdbarch)
1338 {
1339   /* Only perform sanity checks on a multi-arch target. */
1340   if (!GDB_MULTI_ARCH)
1341     return;
1342   /* fundamental */
1343   if (gdbarch->byte_order == 0)
1344     internal_error (__FILE__, __LINE__,
1345                     "verify_gdbarch: byte-order unset");
1346   if (gdbarch->bfd_arch_info == NULL)
1347     internal_error (__FILE__, __LINE__,
1348                     "verify_gdbarch: bfd_arch_info unset");
1349   /* Check those that need to be defined for the given multi-arch level. */
1350 EOF
1351 function_list | while do_read
1352 do
1353     if class_is_function_p || class_is_variable_p
1354     then
1355         if [ "x${invalid_p}" = "x0" ]
1356         then
1357             printf "  /* Skip verify of ${function}, invalid_p == 0 */\n"
1358         elif class_is_predicate_p
1359         then
1360             printf "  /* Skip verify of ${function}, has predicate */\n"
1361         # FIXME: See do_read for potential simplification
1362         elif [ -n "${invalid_p}" -a -n "${postdefault}" ]
1363         then
1364             printf "  if (${invalid_p})\n"
1365             printf "    gdbarch->${function} = ${postdefault};\n"
1366         elif [ -n "${predefault}" -a -n "${postdefault}" ]
1367         then
1368             printf "  if (gdbarch->${function} == ${predefault})\n"
1369             printf "    gdbarch->${function} = ${postdefault};\n"
1370         elif [ -n "${postdefault}" ]
1371         then
1372             printf "  if (gdbarch->${function} == 0)\n"
1373             printf "    gdbarch->${function} = ${postdefault};\n"
1374         elif [ -n "${invalid_p}" ]
1375         then
1376             printf "  if ((GDB_MULTI_ARCH >= ${level})\n"
1377             printf "      && (${invalid_p}))\n"
1378             printf "    internal_error (__FILE__, __LINE__,\n"
1379             printf "                    \"gdbarch: verify_gdbarch: ${function} invalid\");\n"
1380         elif [ -n "${predefault}" ]
1381         then
1382             printf "  if ((GDB_MULTI_ARCH >= ${level})\n"
1383             printf "      && (gdbarch->${function} == ${predefault}))\n"
1384             printf "    internal_error (__FILE__, __LINE__,\n"
1385             printf "                    \"gdbarch: verify_gdbarch: ${function} invalid\");\n"
1386         fi
1387     fi
1388 done
1389 cat <<EOF
1390 }
1391 EOF
1392
1393 # dump the structure
1394 printf "\n"
1395 printf "\n"
1396 cat <<EOF
1397 /* Print out the details of the current architecture. */
1398
1399 /* NOTE/WARNING: The parameter is called \`\`current_gdbarch'' so that it
1400    just happens to match the global variable \`\`current_gdbarch''.  That
1401    way macros refering to that variable get the local and not the global
1402    version - ulgh.  Once everything is parameterised with gdbarch, this
1403    will go away. */
1404
1405 void
1406 gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file)
1407 {
1408   fprintf_unfiltered (file,
1409                       "gdbarch_dump: GDB_MULTI_ARCH = %d\\n",
1410                       GDB_MULTI_ARCH);
1411 EOF
1412 function_list | while do_read
1413 do
1414     # multiarch functions don't have macros.
1415     class_is_multiarch_p && continue
1416     if [ "x${returntype}" = "xvoid" ]
1417     then
1418         printf "#if defined (${macro}) && GDB_MULTI_ARCH\n"
1419         printf "  /* Macro might contain \`[{}]' when not multi-arch */\n"
1420     else
1421         printf "#ifdef ${macro}\n"
1422     fi
1423     if class_is_function_p
1424     then
1425         printf "  fprintf_unfiltered (file,\n"
1426         printf "                      \"gdbarch_dump: %%s # %%s\\\\n\",\n"
1427         printf "                      \"${macro}(${actual})\",\n"
1428         printf "                      XSTRING (${macro} (${actual})));\n"
1429     else
1430         printf "  fprintf_unfiltered (file,\n"
1431         printf "                      \"gdbarch_dump: ${macro} # %%s\\\\n\",\n"
1432         printf "                      XSTRING (${macro}));\n"
1433     fi
1434     printf "#endif\n"
1435 done
1436 function_list | while do_read
1437 do
1438     if class_is_multiarch_p
1439     then
1440         printf "  if (GDB_MULTI_ARCH)\n"
1441         printf "    fprintf_unfiltered (file,\n"
1442         printf "                        \"gdbarch_dump: ${function} = 0x%%08lx\\\\n\",\n"
1443         printf "                        (long) current_gdbarch->${function});\n"
1444         continue
1445     fi
1446     printf "#ifdef ${macro}\n"
1447     if [ "x${print_p}" = "x()" ]
1448     then
1449         printf "  gdbarch_dump_${function} (current_gdbarch);\n"
1450     elif [ "x${print_p}" = "x0" ]
1451     then
1452         printf "  /* skip print of ${macro}, print_p == 0. */\n"
1453     elif [ -n "${print_p}" ]
1454     then
1455         printf "  if (${print_p})\n"
1456         printf "    fprintf_unfiltered (file,\n"
1457         printf "                        \"gdbarch_dump: ${macro} = %s\\\\n\",\n" "${fmt}"
1458         printf "                        ${print});\n"
1459     elif class_is_function_p
1460     then
1461         printf "  if (GDB_MULTI_ARCH)\n"
1462         printf "    fprintf_unfiltered (file,\n"
1463         printf "                        \"gdbarch_dump: ${macro} = 0x%%08lx\\\\n\",\n"
1464         printf "                        (long) current_gdbarch->${function}\n"
1465         printf "                        /*${macro} ()*/);\n"
1466     else
1467         printf "  fprintf_unfiltered (file,\n"
1468         printf "                      \"gdbarch_dump: ${macro} = %s\\\\n\",\n" "${fmt}"
1469         printf "                      ${print});\n"
1470     fi
1471     printf "#endif\n"
1472 done
1473 cat <<EOF
1474   if (current_gdbarch->dump_tdep != NULL)
1475     current_gdbarch->dump_tdep (current_gdbarch, file);
1476 }
1477 EOF
1478
1479
1480 # GET/SET
1481 printf "\n"
1482 cat <<EOF
1483 struct gdbarch_tdep *
1484 gdbarch_tdep (struct gdbarch *gdbarch)
1485 {
1486   if (gdbarch_debug >= 2)
1487     fprintf_unfiltered (gdb_stdlog, "gdbarch_tdep called\\n");
1488   return gdbarch->tdep;
1489 }
1490 EOF
1491 printf "\n"
1492 function_list | while do_read
1493 do
1494     if class_is_predicate_p
1495     then
1496         printf "\n"
1497         printf "int\n"
1498         printf "gdbarch_${function}_p (struct gdbarch *gdbarch)\n"
1499         printf "{\n"
1500         if [ -n "${valid_p}" ]
1501         then
1502             printf "  return ${valid_p};\n"
1503         else
1504             printf "#error \"gdbarch_${function}_p: not defined\"\n"
1505         fi
1506         printf "}\n"
1507     fi
1508     if class_is_function_p
1509     then
1510         printf "\n"
1511         printf "${returntype}\n"
1512         if [ "x${formal}" = "xvoid" ]
1513         then
1514           printf "gdbarch_${function} (struct gdbarch *gdbarch)\n"
1515         else
1516           printf "gdbarch_${function} (struct gdbarch *gdbarch, ${formal})\n"
1517         fi
1518         printf "{\n"
1519         printf "  if (gdbarch->${function} == 0)\n"
1520         printf "    internal_error (__FILE__, __LINE__,\n"
1521         printf "                    \"gdbarch: gdbarch_${function} invalid\");\n"
1522         printf "  if (gdbarch_debug >= 2)\n"
1523         printf "    fprintf_unfiltered (gdb_stdlog, \"gdbarch_${function} called\\\\n\");\n"
1524         if [ "x${actual}" = "x-" -o "x${actual}" = "x" ]
1525         then
1526             if class_is_multiarch_p
1527             then
1528                 params="gdbarch"
1529             else
1530                 params=""
1531             fi
1532         else
1533             if class_is_multiarch_p
1534             then
1535                 params="gdbarch, ${actual}"
1536             else
1537                 params="${actual}"
1538             fi
1539         fi
1540         if [ "x${returntype}" = "xvoid" ]
1541         then
1542           printf "  gdbarch->${function} (${params});\n"
1543         else
1544           printf "  return gdbarch->${function} (${params});\n"
1545         fi
1546         printf "}\n"
1547         printf "\n"
1548         printf "void\n"
1549         printf "set_gdbarch_${function} (struct gdbarch *gdbarch,\n"
1550         printf "            `echo ${function} | sed -e 's/./ /g'`  gdbarch_${function}_ftype ${function})\n"
1551         printf "{\n"
1552         printf "  gdbarch->${function} = ${function};\n"
1553         printf "}\n"
1554     elif class_is_variable_p
1555     then
1556         printf "\n"
1557         printf "${returntype}\n"
1558         printf "gdbarch_${function} (struct gdbarch *gdbarch)\n"
1559         printf "{\n"
1560         if [ "x${invalid_p}" = "x0" ]
1561         then
1562             printf "  /* Skip verify of ${function}, invalid_p == 0 */\n"
1563         elif [ -n "${invalid_p}" ]
1564         then
1565           printf "  if (${invalid_p})\n"
1566           printf "    internal_error (__FILE__, __LINE__,\n"
1567           printf "                    \"gdbarch: gdbarch_${function} invalid\");\n"
1568         elif [ -n "${predefault}" ]
1569         then
1570           printf "  if (gdbarch->${function} == ${predefault})\n"
1571           printf "    internal_error (__FILE__, __LINE__,\n"
1572           printf "                    \"gdbarch: gdbarch_${function} invalid\");\n"
1573         fi
1574         printf "  if (gdbarch_debug >= 2)\n"
1575         printf "    fprintf_unfiltered (gdb_stdlog, \"gdbarch_${function} called\\\\n\");\n"
1576         printf "  return gdbarch->${function};\n"
1577         printf "}\n"
1578         printf "\n"
1579         printf "void\n"
1580         printf "set_gdbarch_${function} (struct gdbarch *gdbarch,\n"
1581         printf "            `echo ${function} | sed -e 's/./ /g'`  ${returntype} ${function})\n"
1582         printf "{\n"
1583         printf "  gdbarch->${function} = ${function};\n"
1584         printf "}\n"
1585     elif class_is_info_p
1586     then
1587         printf "\n"
1588         printf "${returntype}\n"
1589         printf "gdbarch_${function} (struct gdbarch *gdbarch)\n"
1590         printf "{\n"
1591         printf "  if (gdbarch_debug >= 2)\n"
1592         printf "    fprintf_unfiltered (gdb_stdlog, \"gdbarch_${function} called\\\\n\");\n"
1593         printf "  return gdbarch->${function};\n"
1594         printf "}\n"
1595     fi
1596 done
1597
1598 # All the trailing guff
1599 cat <<EOF
1600
1601
1602 /* Keep a registry of per-architecture data-pointers required by GDB
1603    modules. */
1604
1605 struct gdbarch_data
1606 {
1607   unsigned index;
1608   gdbarch_data_init_ftype *init;
1609   gdbarch_data_free_ftype *free;
1610 };
1611
1612 struct gdbarch_data_registration
1613 {
1614   struct gdbarch_data *data;
1615   struct gdbarch_data_registration *next;
1616 };
1617
1618 struct gdbarch_data_registry
1619 {
1620   unsigned nr;
1621   struct gdbarch_data_registration *registrations;
1622 };
1623
1624 struct gdbarch_data_registry gdbarch_data_registry =
1625 {
1626   0, NULL,
1627 };
1628
1629 struct gdbarch_data *
1630 register_gdbarch_data (gdbarch_data_init_ftype *init,
1631                        gdbarch_data_free_ftype *free)
1632 {
1633   struct gdbarch_data_registration **curr;
1634   for (curr = &gdbarch_data_registry.registrations;
1635        (*curr) != NULL;
1636        curr = &(*curr)->next);
1637   (*curr) = XMALLOC (struct gdbarch_data_registration);
1638   (*curr)->next = NULL;
1639   (*curr)->data = XMALLOC (struct gdbarch_data);
1640   (*curr)->data->index = gdbarch_data_registry.nr++;
1641   (*curr)->data->init = init;
1642   (*curr)->data->free = free;
1643   return (*curr)->data;
1644 }
1645
1646
1647 /* Walk through all the registered users initializing each in turn. */
1648
1649 static void
1650 init_gdbarch_data (struct gdbarch *gdbarch)
1651 {
1652   struct gdbarch_data_registration *rego;
1653   for (rego = gdbarch_data_registry.registrations;
1654        rego != NULL;
1655        rego = rego->next)
1656     {
1657       struct gdbarch_data *data = rego->data;
1658       gdb_assert (data->index < gdbarch->nr_data);
1659       if (data->init != NULL)
1660         {
1661           void *pointer = data->init (gdbarch);
1662           set_gdbarch_data (gdbarch, data, pointer);
1663         }
1664     }
1665 }
1666
1667 /* Create/delete the gdbarch data vector. */
1668
1669 static void
1670 alloc_gdbarch_data (struct gdbarch *gdbarch)
1671 {
1672   gdb_assert (gdbarch->data == NULL);
1673   gdbarch->nr_data = gdbarch_data_registry.nr;
1674   gdbarch->data = xcalloc (gdbarch->nr_data, sizeof (void*));
1675 }
1676
1677 static void
1678 free_gdbarch_data (struct gdbarch *gdbarch)
1679 {
1680   struct gdbarch_data_registration *rego;
1681   gdb_assert (gdbarch->data != NULL);
1682   for (rego = gdbarch_data_registry.registrations;
1683        rego != NULL;
1684        rego = rego->next)
1685     {
1686       struct gdbarch_data *data = rego->data;
1687       gdb_assert (data->index < gdbarch->nr_data);
1688       if (data->free != NULL && gdbarch->data[data->index] != NULL)
1689         {
1690           data->free (gdbarch, gdbarch->data[data->index]);
1691           gdbarch->data[data->index] = NULL;
1692         }
1693     }
1694   xfree (gdbarch->data);
1695   gdbarch->data = NULL;
1696 }
1697
1698
1699 /* Initialize the current value of thee specified per-architecture
1700    data-pointer. */
1701
1702 void
1703 set_gdbarch_data (struct gdbarch *gdbarch,
1704                   struct gdbarch_data *data,
1705                   void *pointer)
1706 {
1707   gdb_assert (data->index < gdbarch->nr_data);
1708   if (data->free != NULL && gdbarch->data[data->index] != NULL)
1709     data->free (gdbarch, gdbarch->data[data->index]);
1710   gdbarch->data[data->index] = pointer;
1711 }
1712
1713 /* Return the current value of the specified per-architecture
1714    data-pointer. */
1715
1716 void *
1717 gdbarch_data (struct gdbarch_data *data)
1718 {
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   /* Initialize the per-architecture data-pointer of all parties that
2088      registered an interest in this architecture.  CURRENT_GDBARCH
2089      must be updated before these modules are called. */
2090   init_gdbarch_data (new_gdbarch);
2091
2092   if (gdbarch_debug)
2093     gdbarch_dump (current_gdbarch, gdb_stdlog);
2094
2095   return 1;
2096 }
2097
2098
2099 /* Disassembler */
2100
2101 /* Pointer to the target-dependent disassembly function.  */
2102 int (*tm_print_insn) (bfd_vma, disassemble_info *);
2103 disassemble_info tm_print_insn_info;
2104
2105
2106 extern void _initialize_gdbarch (void);
2107
2108 void
2109 _initialize_gdbarch (void)
2110 {
2111   struct cmd_list_element *c;
2112
2113   INIT_DISASSEMBLE_INFO_NO_ARCH (tm_print_insn_info, gdb_stdout, (fprintf_ftype)fprintf_filtered);
2114   tm_print_insn_info.flavour = bfd_target_unknown_flavour;
2115   tm_print_insn_info.read_memory_func = dis_asm_read_memory;
2116   tm_print_insn_info.memory_error_func = dis_asm_memory_error;
2117   tm_print_insn_info.print_address_func = dis_asm_print_address;
2118
2119   add_show_from_set (add_set_cmd ("arch",
2120                                   class_maintenance,
2121                                   var_zinteger,
2122                                   (char *)&gdbarch_debug,
2123                                   "Set architecture debugging.\\n\\
2124 When non-zero, architecture debugging is enabled.", &setdebuglist),
2125                      &showdebuglist);
2126   c = add_set_cmd ("archdebug",
2127                    class_maintenance,
2128                    var_zinteger,
2129                    (char *)&gdbarch_debug,
2130                    "Set architecture debugging.\\n\\
2131 When non-zero, architecture debugging is enabled.", &setlist);
2132
2133   deprecate_cmd (c, "set debug arch");
2134   deprecate_cmd (add_show_from_set (c, &showlist), "show debug arch");
2135 }
2136 EOF
2137
2138 # close things off
2139 exec 1>&2
2140 #../move-if-change new-gdbarch.c gdbarch.c
2141 compare_new gdbarch.c