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: bfd_arch_unknown (ZERO). */
 842   enum bfd_architecture bfd_architecture;
 843
 844   /* Use default: NULL (ZERO). */
 845   const struct bfd_arch_info *bfd_arch_info;
 846
 847   /* Use default: 0 (ZERO). */
 848   int byte_order;
 849
 850   /* Use default: NULL (ZERO). */
 851   bfd *abfd;
 852
 853   /* Use default: NULL (ZERO). */
 854   struct gdbarch_tdep_info *tdep_info;
 855 };
 856
 857 typedef struct gdbarch *(gdbarch_init_ftype) (struct gdbarch_info info, struct gdbarch_list *arches);
 858 typedef void (gdbarch_dump_tdep_ftype) (struct gdbarch *gdbarch, struct ui_file *file);
 859
 860 /* DEPRECATED - use gdbarch_register() */
 861 extern void register_gdbarch_init (enum bfd_architecture architecture, gdbarch_init_ftype *);
 862
 863 extern void gdbarch_register (enum bfd_architecture architecture,
 864                               gdbarch_init_ftype *,
 865                               gdbarch_dump_tdep_ftype *);
 866
 867
 868 /* Return a freshly allocated, NULL terminated, array of the valid
 869    architecture names.  Since architectures are registered during the
 870    _initialize phase this function only returns useful information
 871    once initialization has been completed. */
 872
 873 extern const char **gdbarch_printable_names (void);
 874
 875
 876 /* Helper function.  Search the list of ARCHES for a GDBARCH that
 877    matches the information provided by INFO. */
 878
 879 extern struct gdbarch_list *gdbarch_list_lookup_by_info (struct gdbarch_list *arches,  const struct gdbarch_info *info);
 880
 881
 882 /* Helper function.  Create a preliminary \`\`struct gdbarch''.  Perform
 883    basic initialization using values obtained from the INFO andTDEP
 884    parameters.  set_gdbarch_*() functions are called to complete the
 885    initialization of the object. */
 886
 887 extern struct gdbarch *gdbarch_alloc (const struct gdbarch_info *info, struct gdbarch_tdep *tdep);
 888
 889
 890 /* Helper function.  Free a partially-constructed \`\`struct gdbarch''.
 891    It is assumed that the caller freeds the \`\`struct
 892    gdbarch_tdep''. */
 893
 894 extern void gdbarch_free (struct gdbarch *);
 895
 896
 897 /* Helper function. Force an update of the current architecture.  Used
 898    by legacy targets that have added their own target specific
 899    architecture manipulation commands.
 900
 901    The INFO parameter shall be fully initialized (\`\`memset (&INFO,
 902    sizeof (info), 0)'' set relevant fields) before gdbarch_update_p()
 903    is called.  gdbarch_update_p() shall initialize any \`\`default''
 904    fields using information obtained from the previous architecture or
 905    INFO.ABFD (if specified) before calling the corresponding
 906    architectures INIT function.
 907
 908    Returns non-zero if the update succeeds */
 909
 910 extern int gdbarch_update_p (struct gdbarch_info info);
 911
 912
 913
 914 /* Register per-architecture data-pointer.
 915
 916    Reserve space for a per-architecture data-pointer.  An identifier
 917    for the reserved data-pointer is returned.  That identifer should
 918    be saved in a local static variable.
 919
 920    The per-architecture data-pointer can be initialized in one of two
 921    ways: The value can be set explicitly using a call to
 922    set_gdbarch_data(); the value can be set implicitly using the value
 923    returned by a non-NULL INIT() callback.  INIT(), when non-NULL is
 924    called after the basic architecture vector has been created.
 925
 926    When a previously created architecture is re-selected, the
 927    per-architecture data-pointer for that previous architecture is
 928    restored.  INIT() is not called.
 929
 930    During initialization, multiple assignments of the data-pointer are
 931    allowed, non-NULL values are deleted by calling FREE().  If the
 932    architecture is deleted using gdbarch_free() all non-NULL data
 933    pointers are also deleted using FREE().
 934
 935    Multiple registrarants for any architecture are allowed (and
 936    strongly encouraged).  */
 937
 938 struct gdbarch_data;
 939
 940 typedef void *(gdbarch_data_init_ftype) (struct gdbarch *gdbarch);
 941 typedef void (gdbarch_data_free_ftype) (struct gdbarch *gdbarch,
 942                                         void *pointer);
 943 extern struct gdbarch_data *register_gdbarch_data (gdbarch_data_init_ftype *init,
 944                                                    gdbarch_data_free_ftype *free);
 945 extern void set_gdbarch_data (struct gdbarch *gdbarch,
 946                               struct gdbarch_data *data,
 947                               void *pointer);
 948
 949 extern void *gdbarch_data (struct gdbarch_data*);
 950
 951
 952 /* Register per-architecture memory region.
 953
 954    Provide a memory-region swap mechanism.  Per-architecture memory
 955    region are created.  These memory regions are swapped whenever the
 956    architecture is changed.  For a new architecture, the memory region
 957    is initialized with zero (0) and the INIT function is called.
 958
 959    Memory regions are swapped / initialized in the order that they are
 960    registered.  NULL DATA and/or INIT values can be specified.
 961
 962    New code should use register_gdbarch_data(). */
 963
 964 typedef void (gdbarch_swap_ftype) (void);
 965 extern void register_gdbarch_swap (void *data, unsigned long size, gdbarch_swap_ftype *init);
 966 #define REGISTER_GDBARCH_SWAP(VAR) register_gdbarch_swap (&(VAR), sizeof ((VAR)), NULL)
 967
 968
 969
 970 /* The target-system-dependent byte order is dynamic */
 971
 972 /* TARGET_BYTE_ORDER_SELECTABLE_P determines if the target endianness
 973    is selectable at runtime.  The user can use the \`\`set endian''
 974    command to change it.  TARGET_BYTE_ORDER_AUTO is nonzero when
 975    target_byte_order should be auto-detected (from the program image
 976    say). */
 977
 978 #if GDB_MULTI_ARCH
 979 /* Multi-arch GDB is always bi-endian. */
 980 #define TARGET_BYTE_ORDER_SELECTABLE_P 1
 981 #endif
 982
 983 #ifndef TARGET_BYTE_ORDER_SELECTABLE_P
 984 /* compat - Catch old targets that define TARGET_BYTE_ORDER_SLECTABLE
 985    when they should have defined TARGET_BYTE_ORDER_SELECTABLE_P 1 */
 986 #ifdef TARGET_BYTE_ORDER_SELECTABLE
 987 #define TARGET_BYTE_ORDER_SELECTABLE_P 1
 988 #else
 989 #define TARGET_BYTE_ORDER_SELECTABLE_P 0
 990 #endif
 991 #endif
 992
 993 extern int target_byte_order;
 994 #ifdef TARGET_BYTE_ORDER_SELECTABLE
 995 /* compat - Catch old targets that define TARGET_BYTE_ORDER_SELECTABLE
 996    and expect defs.h to re-define TARGET_BYTE_ORDER. */
 997 #undef TARGET_BYTE_ORDER
 998 #endif
 999 #ifndef TARGET_BYTE_ORDER
1000 #define TARGET_BYTE_ORDER (target_byte_order + 0)
1001 #endif
1002
1003 extern int target_byte_order_auto;
1004 #ifndef TARGET_BYTE_ORDER_AUTO
1005 #define TARGET_BYTE_ORDER_AUTO (target_byte_order_auto + 0)
1006 #endif
1007
1008
1009
1010 /* The target-system-dependent BFD architecture is dynamic */
1011
1012 extern int target_architecture_auto;
1013 #ifndef TARGET_ARCHITECTURE_AUTO
1014 #define TARGET_ARCHITECTURE_AUTO (target_architecture_auto + 0)
1015 #endif
1016
1017 extern const struct bfd_arch_info *target_architecture;
1018 #ifndef TARGET_ARCHITECTURE
1019 #define TARGET_ARCHITECTURE (target_architecture + 0)
1020 #endif
1021
1022
1023 /* The target-system-dependent disassembler is semi-dynamic */
1024
1025 #include "dis-asm.h"            /* Get defs for disassemble_info */
1026
1027 extern int dis_asm_read_memory (bfd_vma memaddr, bfd_byte *myaddr,
1028                                 unsigned int len, disassemble_info *info);
1029
1030 extern void dis_asm_memory_error (int status, bfd_vma memaddr,
1031                                   disassemble_info *info);
1032
1033 extern void dis_asm_print_address (bfd_vma addr,
1034                                    disassemble_info *info);
1035
1036 extern int (*tm_print_insn) (bfd_vma, disassemble_info*);
1037 extern disassemble_info tm_print_insn_info;
1038 #ifndef TARGET_PRINT_INSN
1039 #define TARGET_PRINT_INSN(vma, info) (*tm_print_insn) (vma, info)
1040 #endif
1041 #ifndef TARGET_PRINT_INSN_INFO
1042 #define TARGET_PRINT_INSN_INFO (&tm_print_insn_info)
1043 #endif
1044
1045
1046
1047 /* Explicit test for D10V architecture.
1048    USE of these macro's is *STRONGLY* discouraged. */
1049
1050 #define GDB_TARGET_IS_D10V (TARGET_ARCHITECTURE->arch == bfd_arch_d10v)
1051
1052
1053 /* Fallback definition for EXTRACT_STRUCT_VALUE_ADDRESS */
1054 #ifndef EXTRACT_STRUCT_VALUE_ADDRESS
1055 #define EXTRACT_STRUCT_VALUE_ADDRESS_P (0)
1056 #define EXTRACT_STRUCT_VALUE_ADDRESS(X) (internal_error (__FILE__, __LINE__, "gdbarch: EXTRACT_STRUCT_VALUE_ADDRESS"), 0)
1057 #else
1058 #ifndef EXTRACT_STRUCT_VALUE_ADDRESS_P
1059 #define EXTRACT_STRUCT_VALUE_ADDRESS_P (1)
1060 #endif
1061 #endif
1062
1063
1064 /* Set the dynamic target-system-dependent parameters (architecture,
1065    byte-order, ...) using information found in the BFD */
1066
1067 extern void set_gdbarch_from_file (bfd *);
1068
1069
1070 /* Initialize the current architecture to the "first" one we find on
1071    our list.  */
1072
1073 extern void initialize_current_architecture (void);
1074
1075
1076 /* gdbarch trace variable */
1077 extern int gdbarch_debug;
1078
1079 extern void gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file);
1080
1081 #endif
1082 EOF
1083 exec 1>&2
1084 #../move-if-change new-gdbarch.h gdbarch.h
1085 compare_new gdbarch.h
1086
1087
1088 #
1089 # C file
1090 #
1091
1092 exec > new-gdbarch.c
1093 copyright
1094 cat <<EOF
1095
1096 #include "defs.h"
1097 #include "arch-utils.h"
1098
1099 #if GDB_MULTI_ARCH
1100 #include "gdbcmd.h"
1101 #include "inferior.h" /* enum CALL_DUMMY_LOCATION et.al. */
1102 #else
1103 /* Just include everything in sight so that the every old definition
1104    of macro is visible. */
1105 #include "gdb_string.h"
1106 #include <ctype.h>
1107 #include "symtab.h"
1108 #include "frame.h"
1109 #include "inferior.h"
1110 #include "breakpoint.h"
1111 #include "gdb_wait.h"
1112 #include "gdbcore.h"
1113 #include "gdbcmd.h"
1114 #include "target.h"
1115 #include "gdbthread.h"
1116 #include "annotate.h"
1117 #include "symfile.h"            /* for overlay functions */
1118 #endif
1119 #include "symcat.h"
1120
1121 #include "floatformat.h"
1122
1123 #include "gdb_assert.h"
1124
1125 /* Static function declarations */
1126
1127 static void verify_gdbarch (struct gdbarch *gdbarch);
1128 static void alloc_gdbarch_data (struct gdbarch *);
1129 static void init_gdbarch_data (struct gdbarch *);
1130 static void free_gdbarch_data (struct gdbarch *);
1131 static void init_gdbarch_swap (struct gdbarch *);
1132 static void swapout_gdbarch_swap (struct gdbarch *);
1133 static void swapin_gdbarch_swap (struct gdbarch *);
1134
1135 /* Convenience macro for allocting typesafe memory. */
1136
1137 #ifndef XMALLOC
1138 #define XMALLOC(TYPE) (TYPE*) xmalloc (sizeof (TYPE))
1139 #endif
1140
1141
1142 /* Non-zero if we want to trace architecture code.  */
1143
1144 #ifndef GDBARCH_DEBUG
1145 #define GDBARCH_DEBUG 0
1146 #endif
1147 int gdbarch_debug = GDBARCH_DEBUG;
1148
1149 EOF
1150
1151 # gdbarch open the gdbarch object
1152 printf "\n"
1153 printf "/* Maintain the struct gdbarch object */\n"
1154 printf "\n"
1155 printf "struct gdbarch\n"
1156 printf "{\n"
1157 printf "  /* basic architectural information */\n"
1158 function_list | while do_read
1159 do
1160     if class_is_info_p
1161     then
1162         printf "  ${returntype} ${function};\n"
1163     fi
1164 done
1165 printf "\n"
1166 printf "  /* target specific vector. */\n"
1167 printf "  struct gdbarch_tdep *tdep;\n"
1168 printf "  gdbarch_dump_tdep_ftype *dump_tdep;\n"
1169 printf "\n"
1170 printf "  /* per-architecture data-pointers */\n"
1171 printf "  unsigned nr_data;\n"
1172 printf "  void **data;\n"
1173 printf "\n"
1174 printf "  /* per-architecture swap-regions */\n"
1175 printf "  struct gdbarch_swap *swap;\n"
1176 printf "\n"
1177 cat <<EOF
1178   /* Multi-arch values.
1179
1180      When extending this structure you must:
1181
1182      Add the field below.
1183
1184      Declare set/get functions and define the corresponding
1185      macro in gdbarch.h.
1186
1187      gdbarch_alloc(): If zero/NULL is not a suitable default,
1188      initialize the new field.
1189
1190      verify_gdbarch(): Confirm that the target updated the field
1191      correctly.
1192
1193      gdbarch_dump(): Add a fprintf_unfiltered call so that the new
1194      field is dumped out
1195
1196      \`\`startup_gdbarch()'': Append an initial value to the static
1197      variable (base values on the host's c-type system).
1198
1199      get_gdbarch(): Implement the set/get functions (probably using
1200      the macro's as shortcuts).
1201
1202      */
1203
1204 EOF
1205 function_list | while do_read
1206 do
1207     if class_is_variable_p
1208     then
1209         printf "  ${returntype} ${function};\n"
1210     elif class_is_function_p
1211     then
1212         printf "  gdbarch_${function}_ftype *${function}${attrib};\n"
1213     fi
1214 done
1215 printf "};\n"
1216
1217 # A pre-initialized vector
1218 printf "\n"
1219 printf "\n"
1220 cat <<EOF
1221 /* The default architecture uses host values (for want of a better
1222    choice). */
1223 EOF
1224 printf "\n"
1225 printf "extern const struct bfd_arch_info bfd_default_arch_struct;\n"
1226 printf "\n"
1227 printf "struct gdbarch startup_gdbarch =\n"
1228 printf "{\n"
1229 printf "  /* basic architecture information */\n"
1230 function_list | while do_read
1231 do
1232     if class_is_info_p
1233     then
1234         printf "  ${staticdefault},\n"
1235     fi
1236 done
1237 cat <<EOF
1238   /* target specific vector and its dump routine */
1239   NULL, NULL,
1240   /*per-architecture data-pointers and swap regions */
1241   0, NULL, NULL,
1242   /* Multi-arch values */
1243 EOF
1244 function_list | while do_read
1245 do
1246     if class_is_function_p || class_is_variable_p
1247     then
1248         printf "  ${staticdefault},\n"
1249     fi
1250 done
1251 cat <<EOF
1252   /* startup_gdbarch() */
1253 };
1254
1255 struct gdbarch *current_gdbarch = &startup_gdbarch;
1256 EOF
1257
1258 # Create a new gdbarch struct
1259 printf "\n"
1260 printf "\n"
1261 cat <<EOF
1262 /* Create a new \`\`struct gdbarch'' based on information provided by
1263    \`\`struct gdbarch_info''. */
1264 EOF
1265 printf "\n"
1266 cat <<EOF
1267 struct gdbarch *
1268 gdbarch_alloc (const struct gdbarch_info *info,
1269                struct gdbarch_tdep *tdep)
1270 {
1271   struct gdbarch *gdbarch = XMALLOC (struct gdbarch);
1272   memset (gdbarch, 0, sizeof (*gdbarch));
1273
1274   alloc_gdbarch_data (gdbarch);
1275
1276   gdbarch->tdep = tdep;
1277 EOF
1278 printf "\n"
1279 function_list | while do_read
1280 do
1281     if class_is_info_p
1282     then
1283         printf "  gdbarch->${function} = info->${function};\n"
1284     fi
1285 done
1286 printf "\n"
1287 printf "  /* Force the explicit initialization of these. */\n"
1288 function_list | while do_read
1289 do
1290     if class_is_function_p || class_is_variable_p
1291     then
1292         if [ "${predefault}" != "" -a "${predefault}" != "0" ]
1293         then
1294           printf "  gdbarch->${function} = ${predefault};\n"
1295         fi
1296     fi
1297 done
1298 cat <<EOF
1299   /* gdbarch_alloc() */
1300
1301   return gdbarch;
1302 }
1303 EOF
1304
1305 # Free a gdbarch struct.
1306 printf "\n"
1307 printf "\n"
1308 cat <<EOF
1309 /* Free a gdbarch struct.  This should never happen in normal
1310    operation --- once you've created a gdbarch, you keep it around.
1311    However, if an architecture's init function encounters an error
1312    building the structure, it may need to clean up a partially
1313    constructed gdbarch.  */
1314
1315 void
1316 gdbarch_free (struct gdbarch *arch)
1317 {
1318   gdb_assert (arch != NULL);
1319   free_gdbarch_data (arch);
1320   xfree (arch);
1321 }
1322 EOF
1323
1324 # verify a new architecture
1325 printf "\n"
1326 printf "\n"
1327 printf "/* Ensure that all values in a GDBARCH are reasonable. */\n"
1328 printf "\n"
1329 cat <<EOF
1330 static void
1331 verify_gdbarch (struct gdbarch *gdbarch)
1332 {
1333   /* Only perform sanity checks on a multi-arch target. */
1334   if (!GDB_MULTI_ARCH)
1335     return;
1336   /* fundamental */
1337   if (gdbarch->byte_order == 0)
1338     internal_error (__FILE__, __LINE__,
1339                     "verify_gdbarch: byte-order unset");
1340   if (gdbarch->bfd_arch_info == NULL)
1341     internal_error (__FILE__, __LINE__,
1342                     "verify_gdbarch: bfd_arch_info unset");
1343   /* Check those that need to be defined for the given multi-arch level. */
1344 EOF
1345 function_list | while do_read
1346 do
1347     if class_is_function_p || class_is_variable_p
1348     then
1349         if [ "${invalid_p}" = "0" ]
1350         then
1351             printf "  /* Skip verify of ${function}, invalid_p == 0 */\n"
1352         elif class_is_predicate_p
1353         then
1354             printf "  /* Skip verify of ${function}, has predicate */\n"
1355         # FIXME: See do_read for potential simplification
1356         elif [ "${invalid_p}" -a "${postdefault}" ]
1357         then
1358             printf "  if (${invalid_p})\n"
1359             printf "    gdbarch->${function} = ${postdefault};\n"
1360         elif [ "${predefault}" -a "${postdefault}" ]
1361         then
1362             printf "  if (gdbarch->${function} == ${predefault})\n"
1363             printf "    gdbarch->${function} = ${postdefault};\n"
1364         elif [ "${postdefault}" ]
1365         then
1366             printf "  if (gdbarch->${function} == 0)\n"
1367             printf "    gdbarch->${function} = ${postdefault};\n"
1368         elif [ "${invalid_p}" ]
1369         then
1370             printf "  if ((GDB_MULTI_ARCH >= ${level})\n"
1371             printf "      && (${invalid_p}))\n"
1372             printf "    internal_error (__FILE__, __LINE__,\n"
1373             printf "                    \"gdbarch: verify_gdbarch: ${function} invalid\");\n"
1374         elif [ "${predefault}" ]
1375         then
1376             printf "  if ((GDB_MULTI_ARCH >= ${level})\n"
1377             printf "      && (gdbarch->${function} == ${predefault}))\n"
1378             printf "    internal_error (__FILE__, __LINE__,\n"
1379             printf "                    \"gdbarch: verify_gdbarch: ${function} invalid\");\n"
1380         fi
1381     fi
1382 done
1383 cat <<EOF
1384 }
1385 EOF
1386
1387 # dump the structure
1388 printf "\n"
1389 printf "\n"
1390 cat <<EOF
1391 /* Print out the details of the current architecture. */
1392
1393 /* NOTE/WARNING: The parameter is called \`\`current_gdbarch'' so that it
1394    just happens to match the global variable \`\`current_gdbarch''.  That
1395    way macros refering to that variable get the local and not the global
1396    version - ulgh.  Once everything is parameterised with gdbarch, this
1397    will go away. */
1398
1399 void
1400 gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file)
1401 {
1402   fprintf_unfiltered (file,
1403                       "gdbarch_dump: GDB_MULTI_ARCH = %d\\n",
1404                       GDB_MULTI_ARCH);
1405 EOF
1406 function_list | while do_read
1407 do
1408     # multiarch functions don't have macros.
1409     class_is_multiarch_p && continue
1410     if [ "${returntype}" = "void" ]
1411     then
1412         printf "#if defined (${macro}) && GDB_MULTI_ARCH\n"
1413         printf "  /* Macro might contain \`[{}]' when not multi-arch */\n"
1414     else
1415         printf "#ifdef ${macro}\n"
1416     fi
1417     if class_is_function_p
1418     then
1419         printf "  fprintf_unfiltered (file,\n"
1420         printf "                      \"gdbarch_dump: %%s # %%s\\\\n\",\n"
1421         printf "                      \"${macro}(${actual})\",\n"
1422         printf "                      XSTRING (${macro} (${actual})));\n"
1423     else
1424         printf "  fprintf_unfiltered (file,\n"
1425         printf "                      \"gdbarch_dump: ${macro} # %%s\\\\n\",\n"
1426         printf "                      XSTRING (${macro}));\n"
1427     fi
1428     printf "#endif\n"
1429 done
1430 function_list | while do_read
1431 do
1432     if class_is_multiarch_p
1433     then
1434         printf "  if (GDB_MULTI_ARCH)\n"
1435         printf "    fprintf_unfiltered (file,\n"
1436         printf "                        \"gdbarch_dump: ${function} = 0x%%08lx\\\\n\",\n"
1437         printf "                        (long) current_gdbarch->${function});\n"
1438         continue
1439     fi
1440     printf "#ifdef ${macro}\n"
1441     if [ "${print_p}" = "()" ]
1442     then
1443         printf "  gdbarch_dump_${function} (current_gdbarch);\n"
1444     elif [ "${print_p}" = "0" ]
1445     then
1446         printf "  /* skip print of ${macro}, print_p == 0. */\n"
1447     elif [ "${print_p}" ]
1448     then
1449         printf "  if (${print_p})\n"
1450         printf "    fprintf_unfiltered (file,\n"
1451         printf "                        \"gdbarch_dump: ${macro} = %s\\\\n\",\n" "${fmt}"
1452         printf "                        ${print});\n"
1453     elif class_is_function_p
1454     then
1455         printf "  if (GDB_MULTI_ARCH)\n"
1456         printf "    fprintf_unfiltered (file,\n"
1457         printf "                        \"gdbarch_dump: ${macro} = 0x%%08lx\\\\n\",\n"
1458         printf "                        (long) current_gdbarch->${function}\n"
1459         printf "                        /*${macro} ()*/);\n"
1460     else
1461         printf "  fprintf_unfiltered (file,\n"
1462         printf "                      \"gdbarch_dump: ${macro} = %s\\\\n\",\n" "${fmt}"
1463         printf "                      ${print});\n"
1464     fi
1465     printf "#endif\n"
1466 done
1467 cat <<EOF
1468   if (current_gdbarch->dump_tdep != NULL)
1469     current_gdbarch->dump_tdep (current_gdbarch, file);
1470 }
1471 EOF
1472
1473
1474 # GET/SET
1475 printf "\n"
1476 cat <<EOF
1477 struct gdbarch_tdep *
1478 gdbarch_tdep (struct gdbarch *gdbarch)
1479 {
1480   if (gdbarch_debug >= 2)
1481     fprintf_unfiltered (gdb_stdlog, "gdbarch_tdep called\\n");
1482   return gdbarch->tdep;
1483 }
1484 EOF
1485 printf "\n"
1486 function_list | while do_read
1487 do
1488     if class_is_predicate_p
1489     then
1490         printf "\n"
1491         printf "int\n"
1492         printf "gdbarch_${function}_p (struct gdbarch *gdbarch)\n"
1493         printf "{\n"
1494         if [ "${valid_p}" ]
1495         then
1496             printf "  return ${valid_p};\n"
1497         else
1498             printf "#error \"gdbarch_${function}_p: not defined\"\n"
1499         fi
1500         printf "}\n"
1501     fi
1502     if class_is_function_p
1503     then
1504         printf "\n"
1505         printf "${returntype}\n"
1506         if [ "${formal}" = "void" ]
1507         then
1508           printf "gdbarch_${function} (struct gdbarch *gdbarch)\n"
1509         else
1510           printf "gdbarch_${function} (struct gdbarch *gdbarch, ${formal})\n"
1511         fi
1512         printf "{\n"
1513         printf "  if (gdbarch->${function} == 0)\n"
1514         printf "    internal_error (__FILE__, __LINE__,\n"
1515         printf "                    \"gdbarch: gdbarch_${function} invalid\");\n"
1516         printf "  if (gdbarch_debug >= 2)\n"
1517         printf "    fprintf_unfiltered (gdb_stdlog, \"gdbarch_${function} called\\\\n\");\n"
1518         if [ "${actual}" = "-" -o "${actual}" = "" ]
1519         then
1520             if class_is_multiarch_p
1521             then
1522                 params="gdbarch"
1523             else
1524                 params=""
1525             fi
1526         else
1527             if class_is_multiarch_p
1528             then
1529                 params="gdbarch, ${actual}"
1530             else
1531                 params="${actual}"
1532             fi
1533         fi
1534         if [ "${returntype}" = "void" ]
1535         then
1536           printf "  gdbarch->${function} (${params});\n"
1537         else
1538           printf "  return gdbarch->${function} (${params});\n"
1539         fi
1540         printf "}\n"
1541         printf "\n"
1542         printf "void\n"
1543         printf "set_gdbarch_${function} (struct gdbarch *gdbarch,\n"
1544         printf "            `echo ${function} | sed -e 's/./ /g'`  gdbarch_${function}_ftype ${function})\n"
1545         printf "{\n"
1546         printf "  gdbarch->${function} = ${function};\n"
1547         printf "}\n"
1548     elif class_is_variable_p
1549     then
1550         printf "\n"
1551         printf "${returntype}\n"
1552         printf "gdbarch_${function} (struct gdbarch *gdbarch)\n"
1553         printf "{\n"
1554         if [ "${invalid_p}" = "0" ]
1555         then
1556             printf "  /* Skip verify of ${function}, invalid_p == 0 */\n"
1557         elif [ "${invalid_p}" ]
1558         then
1559           printf "  if (${invalid_p})\n"
1560           printf "    internal_error (__FILE__, __LINE__,\n"
1561           printf "                    \"gdbarch: gdbarch_${function} invalid\");\n"
1562         elif [ "${predefault}" ]
1563         then
1564           printf "  if (gdbarch->${function} == ${predefault})\n"
1565           printf "    internal_error (__FILE__, __LINE__,\n"
1566           printf "                    \"gdbarch: gdbarch_${function} invalid\");\n"
1567         fi
1568         printf "  if (gdbarch_debug >= 2)\n"
1569         printf "    fprintf_unfiltered (gdb_stdlog, \"gdbarch_${function} called\\\\n\");\n"
1570         printf "  return gdbarch->${function};\n"
1571         printf "}\n"
1572         printf "\n"
1573         printf "void\n"
1574         printf "set_gdbarch_${function} (struct gdbarch *gdbarch,\n"
1575         printf "            `echo ${function} | sed -e 's/./ /g'`  ${returntype} ${function})\n"
1576         printf "{\n"
1577         printf "  gdbarch->${function} = ${function};\n"
1578         printf "}\n"
1579     elif class_is_info_p
1580     then
1581         printf "\n"
1582         printf "${returntype}\n"
1583         printf "gdbarch_${function} (struct gdbarch *gdbarch)\n"
1584         printf "{\n"
1585         printf "  if (gdbarch_debug >= 2)\n"
1586         printf "    fprintf_unfiltered (gdb_stdlog, \"gdbarch_${function} called\\\\n\");\n"
1587         printf "  return gdbarch->${function};\n"
1588         printf "}\n"
1589     fi
1590 done
1591
1592 # All the trailing guff
1593 cat <<EOF
1594
1595
1596 /* Keep a registry of per-architecture data-pointers required by GDB
1597    modules. */
1598
1599 struct gdbarch_data
1600 {
1601   unsigned index;
1602   gdbarch_data_init_ftype *init;
1603   gdbarch_data_free_ftype *free;
1604 };
1605
1606 struct gdbarch_data_registration
1607 {
1608   struct gdbarch_data *data;
1609   struct gdbarch_data_registration *next;
1610 };
1611
1612 struct gdbarch_data_registry
1613 {
1614   unsigned nr;
1615   struct gdbarch_data_registration *registrations;
1616 };
1617
1618 struct gdbarch_data_registry gdbarch_data_registry =
1619 {
1620   0, NULL,
1621 };
1622
1623 struct gdbarch_data *
1624 register_gdbarch_data (gdbarch_data_init_ftype *init,
1625                        gdbarch_data_free_ftype *free)
1626 {
1627   struct gdbarch_data_registration **curr;
1628   for (curr = &gdbarch_data_registry.registrations;
1629        (*curr) != NULL;
1630        curr = &(*curr)->next);
1631   (*curr) = XMALLOC (struct gdbarch_data_registration);
1632   (*curr)->next = NULL;
1633   (*curr)->data = XMALLOC (struct gdbarch_data);
1634   (*curr)->data->index = gdbarch_data_registry.nr++;
1635   (*curr)->data->init = init;
1636   (*curr)->data->free = free;
1637   return (*curr)->data;
1638 }
1639
1640
1641 /* Walk through all the registered users initializing each in turn. */
1642
1643 static void
1644 init_gdbarch_data (struct gdbarch *gdbarch)
1645 {
1646   struct gdbarch_data_registration *rego;
1647   for (rego = gdbarch_data_registry.registrations;
1648        rego != NULL;
1649        rego = rego->next)
1650     {
1651       struct gdbarch_data *data = rego->data;
1652       gdb_assert (data->index < gdbarch->nr_data);
1653       if (data->init != NULL)
1654         {
1655           void *pointer = data->init (gdbarch);
1656           set_gdbarch_data (gdbarch, data, pointer);
1657         }
1658     }
1659 }
1660
1661 /* Create/delete the gdbarch data vector. */
1662
1663 static void
1664 alloc_gdbarch_data (struct gdbarch *gdbarch)
1665 {
1666   gdb_assert (gdbarch->data == NULL);
1667   gdbarch->nr_data = gdbarch_data_registry.nr;
1668   gdbarch->data = xcalloc (gdbarch->nr_data, sizeof (void*));
1669 }
1670
1671 static void
1672 free_gdbarch_data (struct gdbarch *gdbarch)
1673 {
1674   struct gdbarch_data_registration *rego;
1675   gdb_assert (gdbarch->data != NULL);
1676   for (rego = gdbarch_data_registry.registrations;
1677        rego != NULL;
1678        rego = rego->next)
1679     {
1680       struct gdbarch_data *data = rego->data;
1681       gdb_assert (data->index < gdbarch->nr_data);
1682       if (data->free != NULL && gdbarch->data[data->index] != NULL)
1683         {
1684           data->free (gdbarch, gdbarch->data[data->index]);
1685           gdbarch->data[data->index] = NULL;
1686         }
1687     }
1688   xfree (gdbarch->data);
1689   gdbarch->data = NULL;
1690 }
1691
1692
1693 /* Initialize the current value of thee specified per-architecture
1694    data-pointer. */
1695
1696 void
1697 set_gdbarch_data (struct gdbarch *gdbarch,
1698                   struct gdbarch_data *data,
1699                   void *pointer)
1700 {
1701   gdb_assert (data->index < gdbarch->nr_data);
1702   if (data->free != NULL && gdbarch->data[data->index] != NULL)
1703     data->free (gdbarch, gdbarch->data[data->index]);
1704   gdbarch->data[data->index] = pointer;
1705 }
1706
1707 /* Return the current value of the specified per-architecture
1708    data-pointer. */
1709
1710 void *
1711 gdbarch_data (struct gdbarch_data *data)
1712 {
1713   gdb_assert (data->index < current_gdbarch->nr_data);
1714   return current_gdbarch->data[data->index];
1715 }
1716
1717
1718
1719 /* Keep a registry of swapped data required by GDB modules. */
1720
1721 struct gdbarch_swap
1722 {
1723   void *swap;
1724   struct gdbarch_swap_registration *source;
1725   struct gdbarch_swap *next;
1726 };
1727
1728 struct gdbarch_swap_registration
1729 {
1730   void *data;
1731   unsigned long sizeof_data;
1732   gdbarch_swap_ftype *init;
1733   struct gdbarch_swap_registration *next;
1734 };
1735
1736 struct gdbarch_swap_registry
1737 {
1738   int nr;
1739   struct gdbarch_swap_registration *registrations;
1740 };
1741
1742 struct gdbarch_swap_registry gdbarch_swap_registry =
1743 {
1744   0, NULL,
1745 };
1746
1747 void
1748 register_gdbarch_swap (void *data,
1749                        unsigned long sizeof_data,
1750                        gdbarch_swap_ftype *init)
1751 {
1752   struct gdbarch_swap_registration **rego;
1753   for (rego = &gdbarch_swap_registry.registrations;
1754        (*rego) != NULL;
1755        rego = &(*rego)->next);
1756   (*rego) = XMALLOC (struct gdbarch_swap_registration);
1757   (*rego)->next = NULL;
1758   (*rego)->init = init;
1759   (*rego)->data = data;
1760   (*rego)->sizeof_data = sizeof_data;
1761 }
1762
1763
1764 static void
1765 init_gdbarch_swap (struct gdbarch *gdbarch)
1766 {
1767   struct gdbarch_swap_registration *rego;
1768   struct gdbarch_swap **curr = &gdbarch->swap;
1769   for (rego = gdbarch_swap_registry.registrations;
1770        rego != NULL;
1771        rego = rego->next)
1772     {
1773       if (rego->data != NULL)
1774         {
1775           (*curr) = XMALLOC (struct gdbarch_swap);
1776           (*curr)->source = rego;
1777           (*curr)->swap = xmalloc (rego->sizeof_data);
1778           (*curr)->next = NULL;
1779           memset (rego->data, 0, rego->sizeof_data);
1780           curr = &(*curr)->next;
1781         }
1782       if (rego->init != NULL)
1783         rego->init ();
1784     }
1785 }
1786
1787 static void
1788 swapout_gdbarch_swap (struct gdbarch *gdbarch)
1789 {
1790   struct gdbarch_swap *curr;
1791   for (curr = gdbarch->swap;
1792        curr != NULL;
1793        curr = curr->next)
1794     memcpy (curr->swap, curr->source->data, curr->source->sizeof_data);
1795 }
1796
1797 static void
1798 swapin_gdbarch_swap (struct gdbarch *gdbarch)
1799 {
1800   struct gdbarch_swap *curr;
1801   for (curr = gdbarch->swap;
1802        curr != NULL;
1803        curr = curr->next)
1804     memcpy (curr->source->data, curr->swap, curr->source->sizeof_data);
1805 }
1806
1807
1808 /* Keep a registry of the architectures known by GDB. */
1809
1810 struct gdbarch_registration
1811 {
1812   enum bfd_architecture bfd_architecture;
1813   gdbarch_init_ftype *init;
1814   gdbarch_dump_tdep_ftype *dump_tdep;
1815   struct gdbarch_list *arches;
1816   struct gdbarch_registration *next;
1817 };
1818
1819 static struct gdbarch_registration *gdbarch_registry = NULL;
1820
1821 static void
1822 append_name (const char ***buf, int *nr, const char *name)
1823 {
1824   *buf = xrealloc (*buf, sizeof (char**) * (*nr + 1));
1825   (*buf)[*nr] = name;
1826   *nr += 1;
1827 }
1828
1829 const char **
1830 gdbarch_printable_names (void)
1831 {
1832   if (GDB_MULTI_ARCH)
1833     {
1834       /* Accumulate a list of names based on the registed list of
1835          architectures. */
1836       enum bfd_architecture a;
1837       int nr_arches = 0;
1838       const char **arches = NULL;
1839       struct gdbarch_registration *rego;
1840       for (rego = gdbarch_registry;
1841            rego != NULL;
1842            rego = rego->next)
1843         {
1844           const struct bfd_arch_info *ap;
1845           ap = bfd_lookup_arch (rego->bfd_architecture, 0);
1846           if (ap == NULL)
1847             internal_error (__FILE__, __LINE__,
1848                             "gdbarch_architecture_names: multi-arch unknown");
1849           do
1850             {
1851               append_name (&arches, &nr_arches, ap->printable_name);
1852               ap = ap->next;
1853             }
1854           while (ap != NULL);
1855         }
1856       append_name (&arches, &nr_arches, NULL);
1857       return arches;
1858     }
1859   else
1860     /* Just return all the architectures that BFD knows.  Assume that
1861        the legacy architecture framework supports them. */
1862     return bfd_arch_list ();
1863 }
1864
1865
1866 void
1867 gdbarch_register (enum bfd_architecture bfd_architecture,
1868                   gdbarch_init_ftype *init,
1869                   gdbarch_dump_tdep_ftype *dump_tdep)
1870 {
1871   struct gdbarch_registration **curr;
1872   const struct bfd_arch_info *bfd_arch_info;
1873   /* Check that BFD recognizes this architecture */
1874   bfd_arch_info = bfd_lookup_arch (bfd_architecture, 0);
1875   if (bfd_arch_info == NULL)
1876     {
1877       internal_error (__FILE__, __LINE__,
1878                       "gdbarch: Attempt to register unknown architecture (%d)",
1879                       bfd_architecture);
1880     }
1881   /* Check that we haven't seen this architecture before */
1882   for (curr = &gdbarch_registry;
1883        (*curr) != NULL;
1884        curr = &(*curr)->next)
1885     {
1886       if (bfd_architecture == (*curr)->bfd_architecture)
1887         internal_error (__FILE__, __LINE__,
1888                         "gdbarch: Duplicate registraration of architecture (%s)",
1889                         bfd_arch_info->printable_name);
1890     }
1891   /* log it */
1892   if (gdbarch_debug)
1893     fprintf_unfiltered (gdb_stdlog, "register_gdbarch_init (%s, 0x%08lx)\n",
1894                         bfd_arch_info->printable_name,
1895                         (long) init);
1896   /* Append it */
1897   (*curr) = XMALLOC (struct gdbarch_registration);
1898   (*curr)->bfd_architecture = bfd_architecture;
1899   (*curr)->init = init;
1900   (*curr)->dump_tdep = dump_tdep;
1901   (*curr)->arches = NULL;
1902   (*curr)->next = NULL;
1903   /* When non- multi-arch, install whatever target dump routine we've
1904      been provided - hopefully that routine has been written correctly
1905      and works regardless of multi-arch. */
1906   if (!GDB_MULTI_ARCH && dump_tdep != NULL
1907       && startup_gdbarch.dump_tdep == NULL)
1908     startup_gdbarch.dump_tdep = dump_tdep;
1909 }
1910
1911 void
1912 register_gdbarch_init (enum bfd_architecture bfd_architecture,
1913                        gdbarch_init_ftype *init)
1914 {
1915   gdbarch_register (bfd_architecture, init, NULL);
1916 }
1917
1918
1919 /* Look for an architecture using gdbarch_info.  Base search on only
1920    BFD_ARCH_INFO and BYTE_ORDER. */
1921
1922 struct gdbarch_list *
1923 gdbarch_list_lookup_by_info (struct gdbarch_list *arches,
1924                              const struct gdbarch_info *info)
1925 {
1926   for (; arches != NULL; arches = arches->next)
1927     {
1928       if (info->bfd_arch_info != arches->gdbarch->bfd_arch_info)
1929         continue;
1930       if (info->byte_order != arches->gdbarch->byte_order)
1931         continue;
1932       return arches;
1933     }
1934   return NULL;
1935 }
1936
1937
1938 /* Update the current architecture. Return ZERO if the update request
1939    failed. */
1940
1941 int
1942 gdbarch_update_p (struct gdbarch_info info)
1943 {
1944   struct gdbarch *new_gdbarch;
1945   struct gdbarch_list **list;
1946   struct gdbarch_registration *rego;
1947
1948   /* Fill in any missing bits. Most important is the bfd_architecture
1949      which is used to select the target architecture. */
1950   if (info.bfd_architecture == bfd_arch_unknown)
1951     {
1952       if (info.bfd_arch_info != NULL)
1953         info.bfd_architecture = info.bfd_arch_info->arch;
1954       else if (info.abfd != NULL)
1955         info.bfd_architecture = bfd_get_arch (info.abfd);
1956       /* FIXME - should query BFD for its default architecture. */
1957       else
1958         info.bfd_architecture = current_gdbarch->bfd_arch_info->arch;
1959     }
1960   if (info.bfd_arch_info == NULL)
1961     {
1962       if (target_architecture_auto && info.abfd != NULL)
1963         info.bfd_arch_info = bfd_get_arch_info (info.abfd);
1964       else
1965         info.bfd_arch_info = current_gdbarch->bfd_arch_info;
1966     }
1967   if (info.byte_order == 0)
1968     {
1969       if (target_byte_order_auto && info.abfd != NULL)
1970         info.byte_order = (bfd_big_endian (info.abfd) ? BIG_ENDIAN
1971                            : bfd_little_endian (info.abfd) ? LITTLE_ENDIAN
1972                            : 0);
1973       else
1974         info.byte_order = current_gdbarch->byte_order;
1975       /* FIXME - should query BFD for its default byte-order. */
1976     }
1977   /* A default for abfd? */
1978
1979   /* Find the target that knows about this architecture. */
1980   for (rego = gdbarch_registry;
1981        rego != NULL;
1982        rego = rego->next)
1983     if (rego->bfd_architecture == info.bfd_architecture)
1984       break;
1985   if (rego == NULL)
1986     {
1987       if (gdbarch_debug)
1988         fprintf_unfiltered (gdb_stdlog, "gdbarch_update: No matching architecture\\n");
1989       return 0;
1990     }
1991
1992   if (gdbarch_debug)
1993     {
1994       fprintf_unfiltered (gdb_stdlog,
1995                           "gdbarch_update: info.bfd_architecture %d (%s)\\n",
1996                           info.bfd_architecture,
1997                           bfd_lookup_arch (info.bfd_architecture, 0)->printable_name);
1998       fprintf_unfiltered (gdb_stdlog,
1999                           "gdbarch_update: info.bfd_arch_info %s\\n",
2000                           (info.bfd_arch_info != NULL
2001                            ? info.bfd_arch_info->printable_name
2002                            : "(null)"));
2003       fprintf_unfiltered (gdb_stdlog,
2004                           "gdbarch_update: info.byte_order %d (%s)\\n",
2005                           info.byte_order,
2006                           (info.byte_order == BIG_ENDIAN ? "big"
2007                            : info.byte_order == LITTLE_ENDIAN ? "little"
2008                            : "default"));
2009       fprintf_unfiltered (gdb_stdlog,
2010                           "gdbarch_update: info.abfd 0x%lx\\n",
2011                           (long) info.abfd);
2012       fprintf_unfiltered (gdb_stdlog,
2013                           "gdbarch_update: info.tdep_info 0x%lx\\n",
2014                           (long) info.tdep_info);
2015     }
2016
2017   /* Ask the target for a replacement architecture. */
2018   new_gdbarch = rego->init (info, rego->arches);
2019
2020   /* Did the target like it?  No. Reject the change. */
2021   if (new_gdbarch == NULL)
2022     {
2023       if (gdbarch_debug)
2024         fprintf_unfiltered (gdb_stdlog, "gdbarch_update: Target rejected architecture\\n");
2025       return 0;
2026     }
2027
2028   /* Did the architecture change?  No. Do nothing. */
2029   if (current_gdbarch == new_gdbarch)
2030     {
2031       if (gdbarch_debug)
2032         fprintf_unfiltered (gdb_stdlog, "gdbarch_update: Architecture 0x%08lx (%s) unchanged\\n",
2033                             (long) new_gdbarch,
2034                             new_gdbarch->bfd_arch_info->printable_name);
2035       return 1;
2036     }
2037
2038   /* Swap all data belonging to the old target out */
2039   swapout_gdbarch_swap (current_gdbarch);
2040
2041   /* Is this a pre-existing architecture?  Yes. Swap it in.  */
2042   for (list = &rego->arches;
2043        (*list) != NULL;
2044        list = &(*list)->next)
2045     {
2046       if ((*list)->gdbarch == new_gdbarch)
2047         {
2048           if (gdbarch_debug)
2049             fprintf_unfiltered (gdb_stdlog,
2050                                 "gdbarch_update: Previous architecture 0x%08lx (%s) selected\\n",
2051                                 (long) new_gdbarch,
2052                                 new_gdbarch->bfd_arch_info->printable_name);
2053           current_gdbarch = new_gdbarch;
2054           swapin_gdbarch_swap (new_gdbarch);
2055           return 1;
2056         }
2057     }
2058
2059   /* Append this new architecture to this targets list. */
2060   (*list) = XMALLOC (struct gdbarch_list);
2061   (*list)->next = NULL;
2062   (*list)->gdbarch = new_gdbarch;
2063
2064   /* Switch to this new architecture.  Dump it out. */
2065   current_gdbarch = new_gdbarch;
2066   if (gdbarch_debug)
2067     {
2068       fprintf_unfiltered (gdb_stdlog,
2069                           "gdbarch_update: New architecture 0x%08lx (%s) selected\\n",
2070                           (long) new_gdbarch,
2071                           new_gdbarch->bfd_arch_info->printable_name);
2072     }
2073
2074   /* Check that the newly installed architecture is valid.  Plug in
2075      any post init values.  */
2076   new_gdbarch->dump_tdep = rego->dump_tdep;
2077   verify_gdbarch (new_gdbarch);
2078
2079   /* Initialize the per-architecture memory (swap) areas.
2080      CURRENT_GDBARCH must be update before these modules are
2081      called. */
2082   init_gdbarch_swap (new_gdbarch);
2083
2084   /* Initialize the per-architecture data-pointer of all parties that
2085      registered an interest in this architecture.  CURRENT_GDBARCH
2086      must be updated before these modules are called. */
2087   init_gdbarch_data (new_gdbarch);
2088
2089   if (gdbarch_debug)
2090     gdbarch_dump (current_gdbarch, gdb_stdlog);
2091
2092   return 1;
2093 }
2094
2095
2096 /* Disassembler */
2097
2098 /* Pointer to the target-dependent disassembly function.  */
2099 int (*tm_print_insn) (bfd_vma, disassemble_info *);
2100 disassemble_info tm_print_insn_info;
2101
2102
2103 extern void _initialize_gdbarch (void);
2104
2105 void
2106 _initialize_gdbarch (void)
2107 {
2108   struct cmd_list_element *c;
2109
2110   INIT_DISASSEMBLE_INFO_NO_ARCH (tm_print_insn_info, gdb_stdout, (fprintf_ftype)fprintf_filtered);
2111   tm_print_insn_info.flavour = bfd_target_unknown_flavour;
2112   tm_print_insn_info.read_memory_func = dis_asm_read_memory;
2113   tm_print_insn_info.memory_error_func = dis_asm_memory_error;
2114   tm_print_insn_info.print_address_func = dis_asm_print_address;
2115
2116   add_show_from_set (add_set_cmd ("arch",
2117                                   class_maintenance,
2118                                   var_zinteger,
2119                                   (char *)&gdbarch_debug,
2120                                   "Set architecture debugging.\\n\\
2121 When non-zero, architecture debugging is enabled.", &setdebuglist),
2122                      &showdebuglist);
2123   c = add_set_cmd ("archdebug",
2124                    class_maintenance,
2125                    var_zinteger,
2126                    (char *)&gdbarch_debug,
2127                    "Set architecture debugging.\\n\\
2128 When non-zero, architecture debugging is enabled.", &setlist);
2129
2130   deprecate_cmd (c, "set debug arch");
2131   deprecate_cmd (add_show_from_set (c, &showlist), "show debug arch");
2132 }
2133 EOF
2134
2135 # close things off
2136 exec 1>&2
2137 #../move-if-change new-gdbarch.c gdbarch.c
2138 compare_new gdbarch.c