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