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