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