gdb/gdbarch.sh

   1 #!/bin/sh -u
   2
   3 # Architecture commands for GDB, the GNU debugger.
   4 # Copyright 1998, 1999, 2000, 2001 Free Software Foundation, Inc.
   5 #
   6 # This file is part of GDB.
   7 #
   8 # This program is free software; you can redistribute it and/or modify
   9 # it under the terms of the GNU General Public License as published by
  10 # the Free Software Foundation; either version 2 of the License, or
  11 # (at your option) any later version.
  12 #
  13 # This program is distributed in the hope that it will be useful,
  14 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 # GNU General Public License for more details.
  17 #
  18 # You should have received a copy of the GNU General Public License
  19 # along with this program; if not, write to the Free Software
  20 # Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  21
  22 compare_new ()
  23 {
  24     file=$1
  25     if test ! -r ${file}
  26     then
  27         echo "${file} missing? cp new-${file} ${file}" 1>&2
  28     elif diff -c ${file} new-${file}
  29     then
  30         echo "${file} unchanged" 1>&2
  31     else
  32         echo "${file} has changed? cp new-${file} ${file}" 1>&2
  33     fi
  34 }
  35
  36
  37 # Format of the input table
  38 read="class level macro returntype function formal actual attrib staticdefault predefault postdefault invalid_p fmt print print_p description"
  39
  40 do_read ()
  41 {
  42     comment=""
  43     class=""
  44     while read line
  45     do
  46         if test "${line}" = ""
  47         then
  48             continue
  49         elif test "${line}" = "#" -a "${comment}" = ""
  50         then
  51             continue
  52         elif expr "${line}" : "#" > /dev/null
  53         then
  54             comment="${comment}
  55 ${line}"
  56         else
  57
  58             # The semantics of IFS varies between different SH's.  Some
  59             # treat ``::' as three fields while some treat it as just too.
  60             # Work around this by eliminating ``::'' ....
  61             line="`echo "${line}" | sed -e 's/::/: :/g' -e 's/::/: :/g'`"
  62
  63             OFS="${IFS}" ; IFS="[:]"
  64             eval read ${read} <<EOF
  65 ${line}
  66 EOF
  67             IFS="${OFS}"
  68
  69             # .... and then going back through each field and strip out those
  70             # that ended up with just that space character.
  71             for r in ${read}
  72             do
  73                 if eval test \"\${${r}}\" = \"\ \"
  74                 then
  75                     eval ${r}=""
  76                 fi
  77             done
  78
  79             test "${staticdefault}" || staticdefault=0
  80             # NOT YET: Breaks BELIEVE_PCC_PROMOTION and confuses non-
  81             # multi-arch defaults.
  82             # test "${predefault}" || predefault=0
  83             test "${fmt}" || fmt="%ld"
  84             test "${print}" || print="(long) ${macro}"
  85             case "${invalid_p}" in
  86                 0 ) valid_p=1 ;;
  87                 "" )
  88                     if [ -n "${predefault}" ]
  89                     then
  90                         #invalid_p="gdbarch->${function} == ${predefault}"
  91                         valid_p="gdbarch->${function} != ${predefault}"
  92                     else
  93                         #invalid_p="gdbarch->${function} == 0"
  94                         valid_p="gdbarch->${function} != 0"
  95                     fi
  96                     ;;
  97                 * ) valid_p="!(${invalid_p})"
  98             esac
  99
 100             # PREDEFAULT is a valid fallback definition of MEMBER when
 101             # multi-arch is not enabled.  This ensures that the
 102             # default value, when multi-arch is the same as the
 103             # default value when not multi-arch.  POSTDEFAULT is
 104             # always a valid definition of MEMBER as this again
 105             # ensures consistency.
 106
 107             if [ -n "${postdefault}" ]
 108             then
 109                 fallbackdefault="${postdefault}"
 110             elif [ -n "${predefault}" ]
 111             then
 112                 fallbackdefault="${predefault}"
 113             else
 114                 fallbackdefault=""
 115             fi
 116
 117             #NOT YET: See gdbarch.log for basic verification of
 118             # database
 119
 120             break
 121         fi
 122     done
 123     if [ -n "${class}" ]
 124     then
 125         true
 126     else
 127         false
 128     fi
 129 }
 130
 131
 132 fallback_default_p ()
 133 {
 134     [ -n "${postdefault}" -a "x${invalid_p}" != "x0" ] \
 135         || [ -n "${predefault}" -a "x${invalid_p}" = "x0" ]
 136 }
 137
 138 class_is_variable_p ()
 139 {
 140     case "${class}" in
 141         *v* | *V* ) true ;;
 142         * ) false ;;
 143     esac
 144 }
 145
 146 class_is_function_p ()
 147 {
 148     case "${class}" in
 149         *f* | *F* | *m* | *M* ) true ;;
 150         * ) false ;;
 151     esac
 152 }
 153
 154 class_is_multiarch_p ()
 155 {
 156     case "${class}" in
 157         *m* | *M* ) true ;;
 158         * ) false ;;
 159     esac
 160 }
 161
 162 class_is_predicate_p ()
 163 {
 164     case "${class}" in
 165         *F* | *V* | *M* ) true ;;
 166         * ) false ;;
 167     esac
 168 }
 169
 170 class_is_info_p ()
 171 {
 172     case "${class}" in
 173         *i* ) true ;;
 174         * ) false ;;
 175     esac
 176 }
 177
 178
 179 # dump out/verify the doco
 180 for field in ${read}
 181 do
 182   case ${field} in
 183
 184     class ) : ;;
 185
 186         # # -> line disable
 187         # f -> function
 188         #   hiding a function
 189         # F -> function + predicate
 190         #   hiding a function + predicate to test function validity
 191         # v -> variable
 192         #   hiding a variable
 193         # V -> variable + predicate
 194         #   hiding a variable + predicate to test variables validity
 195         # i -> set from info
 196         #   hiding something from the ``struct info'' object
 197         # m -> multi-arch function
 198         #   hiding a multi-arch function (parameterised with the architecture)
 199         # M -> multi-arch function + predicate
 200         #   hiding a multi-arch function + predicate to test function validity
 201
 202     level ) : ;;
 203
 204         # See GDB_MULTI_ARCH description.  Having GDB_MULTI_ARCH >=
 205         # LEVEL is a predicate on checking that a given method is
 206         # initialized (using INVALID_P).
 207
 208     macro ) : ;;
 209
 210         # The name of the MACRO that this method is to be accessed by.
 211
 212     returntype ) : ;;
 213
 214         # For functions, the return type; for variables, the data type
 215
 216     function ) : ;;
 217
 218         # For functions, the member function name; for variables, the
 219         # variable name.  Member function names are always prefixed with
 220         # ``gdbarch_'' for name-space purity.
 221
 222     formal ) : ;;
 223
 224         # The formal argument list.  It is assumed that the formal
 225         # argument list includes the actual name of each list element.
 226         # A function with no arguments shall have ``void'' as the
 227         # formal argument list.
 228
 229     actual ) : ;;
 230
 231         # The list of actual arguments.  The arguments specified shall
 232         # match the FORMAL list given above.  Functions with out
 233         # arguments leave this blank.
 234
 235     attrib ) : ;;
 236
 237         # Any GCC attributes that should be attached to the function
 238         # declaration.  At present this field is unused.
 239
 240     staticdefault ) : ;;
 241
 242         # To help with the GDB startup a static gdbarch object is
 243         # created.  STATICDEFAULT is the value to insert into that
 244         # static gdbarch object.  Since this a static object only
 245         # simple expressions can be used.
 246
 247         # If STATICDEFAULT is empty, zero is used.
 248
 249     predefault ) : ;;
 250
 251         # An initial value to assign to MEMBER of the freshly
 252         # malloc()ed gdbarch object.  After initialization, the
 253         # freshly malloc()ed object is passed to the target
 254         # architecture code for further updates.
 255
 256         # If PREDEFAULT is empty, zero is used.
 257
 258         # A non-empty PREDEFAULT, an empty POSTDEFAULT and a zero
 259         # INVALID_P are specified, PREDEFAULT will be used as the
 260         # default for the non- multi-arch target.
 261
 262         # A zero PREDEFAULT function will force the fallback to call
 263         # internal_error().
 264
 265         # Variable declarations can refer to ``gdbarch'' which will
 266         # contain the current architecture.  Care should be taken.
 267
 268     postdefault ) : ;;
 269
 270         # A value to assign to MEMBER of the new gdbarch object should
 271         # the target architecture code fail to change the PREDEFAULT
 272         # value.
 273
 274         # If POSTDEFAULT is empty, no post update is performed.
 275
 276         # If both INVALID_P and POSTDEFAULT are non-empty then
 277         # INVALID_P will be used to determine if MEMBER should be
 278         # changed to POSTDEFAULT.
 279
 280         # If a non-empty POSTDEFAULT and a zero INVALID_P are
 281         # specified, POSTDEFAULT will be used as the default for the
 282         # non- multi-arch target (regardless of the value of
 283         # PREDEFAULT).
 284
 285         # You cannot specify both a zero INVALID_P and a POSTDEFAULT.
 286
 287         # Variable declarations can refer to ``gdbarch'' which will
 288         # contain the current architecture.  Care should be taken.
 289
 290     invalid_p ) : ;;
 291
 292         # A predicate equation that validates MEMBER.  Non-zero is
 293         # returned if the code creating the new architecture failed to
 294         # initialize MEMBER or the initialized the member is invalid.
 295         # If POSTDEFAULT is non-empty then MEMBER will be updated to
 296         # that value.  If POSTDEFAULT is empty then internal_error()
 297         # is called.
 298
 299         # If INVALID_P is empty, a check that MEMBER is no longer
 300         # equal to PREDEFAULT is used.
 301
 302         # The expression ``0'' disables the INVALID_P check making
 303         # PREDEFAULT a legitimate value.
 304
 305         # See also PREDEFAULT and POSTDEFAULT.
 306
 307     fmt ) : ;;
 308
 309         # printf style format string that can be used to print out the
 310         # MEMBER.  Sometimes "%s" is useful.  For functions, this is
 311         # ignored and the function address is printed.
 312
 313         # If FMT is empty, ``%ld'' is used.
 314
 315     print ) : ;;
 316
 317         # An optional equation that casts MEMBER to a value suitable
 318         # for formatting by FMT.
 319
 320         # If PRINT is empty, ``(long)'' is used.
 321
 322     print_p ) : ;;
 323
 324         # An optional indicator for any predicte to wrap around the
 325         # print member code.
 326
 327         #   () -> Call a custom function to do the dump.
 328         #   exp -> Wrap print up in ``if (${print_p}) ...
 329         #   ``'' -> No predicate
 330
 331         # If PRINT_P is empty, ``1'' is always used.
 332
 333     description ) : ;;
 334
 335         # Currently unused.
 336
 337     *) exit 1;;
 338   esac
 339 done
 340
 341
 342 function_list ()
 343 {
 344   # See below (DOCO) for description of each field
 345   cat <<EOF
 346 i:2:TARGET_ARCHITECTURE:const struct bfd_arch_info *:bfd_arch_info::::&bfd_default_arch_struct::::%s:TARGET_ARCHITECTURE->printable_name:TARGET_ARCHITECTURE != NULL
 347 #
 348 i:2:TARGET_BYTE_ORDER:int:byte_order::::BIG_ENDIAN
 349 # Number of bits in a char or unsigned char for the target machine.
 350 # Just like CHAR_BIT in <limits.h> but describes the target machine.
 351 # v::TARGET_CHAR_BIT:int:char_bit::::8 * sizeof (char):8::0:
 352 #
 353 # Number of bits in a short or unsigned short for the target machine.
 354 v::TARGET_SHORT_BIT:int:short_bit::::8 * sizeof (short):2*TARGET_CHAR_BIT::0
 355 # Number of bits in an int or unsigned int for the target machine.
 356 v::TARGET_INT_BIT:int:int_bit::::8 * sizeof (int):4*TARGET_CHAR_BIT::0
 357 # Number of bits in a long or unsigned long for the target machine.
 358 v::TARGET_LONG_BIT:int:long_bit::::8 * sizeof (long):4*TARGET_CHAR_BIT::0
 359 # Number of bits in a long long or unsigned long long for the target
 360 # machine.
 361 v::TARGET_LONG_LONG_BIT:int:long_long_bit::::8 * sizeof (LONGEST):2*TARGET_LONG_BIT::0
 362 # Number of bits in a float for the target machine.
 363 v::TARGET_FLOAT_BIT:int:float_bit::::8 * sizeof (float):4*TARGET_CHAR_BIT::0
 364 # Number of bits in a double for the target machine.
 365 v::TARGET_DOUBLE_BIT:int:double_bit::::8 * sizeof (double):8*TARGET_CHAR_BIT::0
 366 # Number of bits in a long double for the target machine.
 367 v::TARGET_LONG_DOUBLE_BIT:int:long_double_bit::::8 * sizeof (long double):2*TARGET_DOUBLE_BIT::0
 368 # For most targets, a pointer on the target and its representation as an
 369 # address in GDB have the same size and "look the same".  For such a
 370 # target, you need only set TARGET_PTR_BIT / ptr_bit and TARGET_ADDR_BIT
 371 # / addr_bit will be set from it.
 372 #
 373 # If TARGET_PTR_BIT and TARGET_ADDR_BIT are different, you'll probably
 374 # also need to set POINTER_TO_ADDRESS and ADDRESS_TO_POINTER as well.
 375 #
 376 # ptr_bit is the size of a pointer on the target
 377 v::TARGET_PTR_BIT:int:ptr_bit::::8 * sizeof (void*):TARGET_INT_BIT::0
 378 # addr_bit is the size of a target address as represented in gdb
 379 v::TARGET_ADDR_BIT:int:addr_bit::::8 * sizeof (void*):0:TARGET_PTR_BIT:
 380 # Number of bits in a BFD_VMA for the target object file format.
 381 v::TARGET_BFD_VMA_BIT:int:bfd_vma_bit::::8 * sizeof (void*):TARGET_ARCHITECTURE->bits_per_address::0
 382 #
 383 v::IEEE_FLOAT:int:ieee_float::::0:0::0:::
 384 #
 385 f::TARGET_READ_PC:CORE_ADDR:read_pc:ptid_t ptid:ptid::0:generic_target_read_pc::0
 386 f::TARGET_WRITE_PC:void:write_pc:CORE_ADDR val, ptid_t ptid:val, ptid::0:generic_target_write_pc::0
 387 f::TARGET_READ_FP:CORE_ADDR:read_fp:void:::0:generic_target_read_fp::0
 388 f::TARGET_WRITE_FP:void:write_fp:CORE_ADDR val:val::0:generic_target_write_fp::0
 389 f::TARGET_READ_SP:CORE_ADDR:read_sp:void:::0:generic_target_read_sp::0
 390 f::TARGET_WRITE_SP:void:write_sp:CORE_ADDR val:val::0:generic_target_write_sp::0
 391 #
 392 M:::void:register_read:int regnum, char *buf:regnum, buf:
 393 M:::void:register_write:int regnum, char *buf:regnum, buf:
 394 #
 395 v:2:NUM_REGS:int:num_regs::::0:-1
 396 # This macro gives the number of pseudo-registers that live in the
 397 # register namespace but do not get fetched or stored on the target.
 398 # These pseudo-registers may be aliases for other registers,
 399 # combinations of other registers, or they may be computed by GDB.
 400 v:2:NUM_PSEUDO_REGS:int:num_pseudo_regs::::0:0::0:::
 401 v:2:SP_REGNUM:int:sp_regnum::::0:-1
 402 v:2:FP_REGNUM:int:fp_regnum::::0:-1
 403 v:2:PC_REGNUM:int:pc_regnum::::0:-1
 404 v:2:FP0_REGNUM:int:fp0_regnum::::0:-1::0
 405 v:2:NPC_REGNUM:int:npc_regnum::::0:-1::0
 406 v:2:NNPC_REGNUM:int:nnpc_regnum::::0:-1::0
 407 # Convert stab register number (from \`r\' declaration) to a gdb REGNUM.
 408 f:2:STAB_REG_TO_REGNUM:int:stab_reg_to_regnum:int stab_regnr:stab_regnr:::no_op_reg_to_regnum::0
 409 # Provide a default mapping from a ecoff register number to a gdb REGNUM.
 410 f:2:ECOFF_REG_TO_REGNUM:int:ecoff_reg_to_regnum:int ecoff_regnr:ecoff_regnr:::no_op_reg_to_regnum::0
 411 # Provide a default mapping from a DWARF register number to a gdb REGNUM.
 412 f:2:DWARF_REG_TO_REGNUM:int:dwarf_reg_to_regnum:int dwarf_regnr:dwarf_regnr:::no_op_reg_to_regnum::0
 413 # Convert from an sdb register number to an internal gdb register number.
 414 # This should be defined in tm.h, if REGISTER_NAMES is not set up
 415 # to map one to one onto the sdb register numbers.
 416 f:2:SDB_REG_TO_REGNUM:int:sdb_reg_to_regnum:int sdb_regnr:sdb_regnr:::no_op_reg_to_regnum::0
 417 f:2:DWARF2_REG_TO_REGNUM:int:dwarf2_reg_to_regnum:int dwarf2_regnr:dwarf2_regnr:::no_op_reg_to_regnum::0
 418 f:2:REGISTER_NAME:char *:register_name:int regnr:regnr:::legacy_register_name::0
 419 v:2:REGISTER_SIZE:int:register_size::::0:-1
 420 v:2:REGISTER_BYTES:int:register_bytes::::0:-1
 421 f:2:REGISTER_BYTE:int:register_byte:int reg_nr:reg_nr::0:0
 422 f:2:REGISTER_RAW_SIZE:int:register_raw_size:int reg_nr:reg_nr::0:0
 423 v:2:MAX_REGISTER_RAW_SIZE:int:max_register_raw_size::::0:-1
 424 f:2:REGISTER_VIRTUAL_SIZE:int:register_virtual_size:int reg_nr:reg_nr::0:0
 425 v:2:MAX_REGISTER_VIRTUAL_SIZE:int:max_register_virtual_size::::0:-1
 426 f:2:REGISTER_VIRTUAL_TYPE:struct type *:register_virtual_type:int reg_nr:reg_nr::0:0
 427 f:2:DO_REGISTERS_INFO:void:do_registers_info:int reg_nr, int fpregs:reg_nr, fpregs:::do_registers_info::0
 428 # MAP a GDB RAW register number onto a simulator register number.  See
 429 # also include/...-sim.h.
 430 f:2:REGISTER_SIM_REGNO:int:register_sim_regno:int reg_nr:reg_nr:::default_register_sim_regno::0
 431 F:2:REGISTER_BYTES_OK:int:register_bytes_ok:long nr_bytes:nr_bytes::0:0
 432 f:2:CANNOT_FETCH_REGISTER:int:cannot_fetch_register:int regnum:regnum:::cannot_register_not::0
 433 f:2:CANNOT_STORE_REGISTER:int:cannot_store_register:int regnum:regnum:::cannot_register_not::0
 434 #
 435 v:1:USE_GENERIC_DUMMY_FRAMES:int:use_generic_dummy_frames::::0:-1
 436 v:2:CALL_DUMMY_LOCATION:int:call_dummy_location::::0:0
 437 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
 438 v:2:CALL_DUMMY_START_OFFSET:CORE_ADDR:call_dummy_start_offset::::0:-1:::0x%08lx
 439 v:2:CALL_DUMMY_BREAKPOINT_OFFSET:CORE_ADDR:call_dummy_breakpoint_offset::::0:-1:::0x%08lx::CALL_DUMMY_BREAKPOINT_OFFSET_P
 440 v:1:CALL_DUMMY_BREAKPOINT_OFFSET_P:int:call_dummy_breakpoint_offset_p::::0:-1
 441 v:2:CALL_DUMMY_LENGTH:int:call_dummy_length::::0:-1:::::CALL_DUMMY_LOCATION == BEFORE_TEXT_END || CALL_DUMMY_LOCATION == AFTER_TEXT_END
 442 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
 443 v:1:CALL_DUMMY_P:int:call_dummy_p::::0:-1
 444 v:2:CALL_DUMMY_WORDS:LONGEST *:call_dummy_words::::0:legacy_call_dummy_words::0:0x%08lx
 445 v:2:SIZEOF_CALL_DUMMY_WORDS:int:sizeof_call_dummy_words::::0:legacy_sizeof_call_dummy_words::0:0x%08lx
 446 v:1:CALL_DUMMY_STACK_ADJUST_P:int:call_dummy_stack_adjust_p::::0:-1:::0x%08lx
 447 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
 448 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
 449 f:2:INIT_FRAME_PC_FIRST:void:init_frame_pc_first:int fromleaf, struct frame_info *prev:fromleaf, prev:::init_frame_pc_noop::0
 450 f:2:INIT_FRAME_PC:void:init_frame_pc:int fromleaf, struct frame_info *prev:fromleaf, prev:::init_frame_pc_default::0
 451 #
 452 v:2:BELIEVE_PCC_PROMOTION:int:believe_pcc_promotion:::::::
 453 v:2:BELIEVE_PCC_PROMOTION_TYPE:int:believe_pcc_promotion_type:::::::
 454 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
 455 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
 456 #
 457 f:1:REGISTER_CONVERTIBLE:int:register_convertible:int nr:nr:::generic_register_convertible_not::0
 458 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
 459 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
 460 # This function is called when the value of a pseudo-register needs to
 461 # be updated.  Typically it will be defined on a per-architecture
 462 # basis.
 463 f:2:FETCH_PSEUDO_REGISTER:void:fetch_pseudo_register:int regnum:regnum:::0::0
 464 # This function is called when the value of a pseudo-register needs to
 465 # be set or stored.  Typically it will be defined on a
 466 # per-architecture basis.
 467 f:2:STORE_PSEUDO_REGISTER:void:store_pseudo_register:int regnum:regnum:::0::0
 468 #
 469 f:2:POINTER_TO_ADDRESS:CORE_ADDR:pointer_to_address:struct type *type, void *buf:type, buf:::unsigned_pointer_to_address::0
 470 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
 471 #
 472 f:2:RETURN_VALUE_ON_STACK:int:return_value_on_stack:struct type *type:type:::generic_return_value_on_stack_not::0
 473 f:2:EXTRACT_RETURN_VALUE:void:extract_return_value:struct type *type, char *regbuf, char *valbuf:type, regbuf, valbuf::0:0
 474 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
 475 f:2:PUSH_DUMMY_FRAME:void:push_dummy_frame:void:-:::0
 476 f:1:PUSH_RETURN_ADDRESS:CORE_ADDR:push_return_address:CORE_ADDR pc, CORE_ADDR sp:pc, sp:::0
 477 f:2:POP_FRAME:void:pop_frame:void:-:::0
 478 #
 479 # I wish that these would just go away....
 480 f:2:D10V_MAKE_DADDR:CORE_ADDR:d10v_make_daddr:CORE_ADDR x:x:::0::0
 481 f:2:D10V_MAKE_IADDR:CORE_ADDR:d10v_make_iaddr:CORE_ADDR x:x:::0::0
 482 f:2:D10V_DADDR_P:int:d10v_daddr_p:CORE_ADDR x:x:::0::0
 483 f:2:D10V_IADDR_P:int:d10v_iaddr_p:CORE_ADDR x:x:::0::0
 484 f:2:D10V_CONVERT_DADDR_TO_RAW:CORE_ADDR:d10v_convert_daddr_to_raw:CORE_ADDR x:x:::0::0
 485 f:2:D10V_CONVERT_IADDR_TO_RAW:CORE_ADDR:d10v_convert_iaddr_to_raw:CORE_ADDR x:x:::0::0
 486 #
 487 f:2:STORE_STRUCT_RETURN:void:store_struct_return:CORE_ADDR addr, CORE_ADDR sp:addr, sp:::0
 488 f:2:STORE_RETURN_VALUE:void:store_return_value:struct type *type, char *valbuf:type, valbuf:::0
 489 F:2:EXTRACT_STRUCT_VALUE_ADDRESS:CORE_ADDR:extract_struct_value_address:char *regbuf:regbuf:::0
 490 f:2:USE_STRUCT_CONVENTION:int:use_struct_convention:int gcc_p, struct type *value_type:gcc_p, value_type:::0
 491 #
 492 f:2:FRAME_INIT_SAVED_REGS:void:frame_init_saved_regs:struct frame_info *frame:frame::0:0
 493 f:2:INIT_EXTRA_FRAME_INFO:void:init_extra_frame_info:int fromleaf, struct frame_info *frame:fromleaf, frame:::0
 494 #
 495 f:2:SKIP_PROLOGUE:CORE_ADDR:skip_prologue:CORE_ADDR ip:ip::0:0
 496 f:2:PROLOGUE_FRAMELESS_P:int:prologue_frameless_p:CORE_ADDR ip:ip::0:generic_prologue_frameless_p::0
 497 f:2:INNER_THAN:int:inner_than:CORE_ADDR lhs, CORE_ADDR rhs:lhs, rhs::0:0
 498 f:2:BREAKPOINT_FROM_PC:unsigned char *:breakpoint_from_pc:CORE_ADDR *pcptr, int *lenptr:pcptr, lenptr:::legacy_breakpoint_from_pc::0
 499 f:2:MEMORY_INSERT_BREAKPOINT:int:memory_insert_breakpoint:CORE_ADDR addr, char *contents_cache:addr, contents_cache::0:default_memory_insert_breakpoint::0
 500 f:2:MEMORY_REMOVE_BREAKPOINT:int:memory_remove_breakpoint:CORE_ADDR addr, char *contents_cache:addr, contents_cache::0:default_memory_remove_breakpoint::0
 501 v:2:DECR_PC_AFTER_BREAK:CORE_ADDR:decr_pc_after_break::::0:-1
 502 f::PREPARE_TO_PROCEED:int:prepare_to_proceed:int select_it:select_it::0:default_prepare_to_proceed::0
 503 v:2:FUNCTION_START_OFFSET:CORE_ADDR:function_start_offset::::0:-1
 504 #
 505 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
 506 #
 507 v:2:FRAME_ARGS_SKIP:CORE_ADDR:frame_args_skip::::0:-1
 508 f:2:FRAMELESS_FUNCTION_INVOCATION:int:frameless_function_invocation:struct frame_info *fi:fi:::generic_frameless_function_invocation_not::0
 509 f:2:FRAME_CHAIN:CORE_ADDR:frame_chain:struct frame_info *frame:frame::0:0
 510 f:1:FRAME_CHAIN_VALID:int:frame_chain_valid:CORE_ADDR chain, struct frame_info *thisframe:chain, thisframe::0:0
 511 f:2:FRAME_SAVED_PC:CORE_ADDR:frame_saved_pc:struct frame_info *fi:fi::0:0
 512 f:2:FRAME_ARGS_ADDRESS:CORE_ADDR:frame_args_address:struct frame_info *fi:fi::0:0
 513 f:2:FRAME_LOCALS_ADDRESS:CORE_ADDR:frame_locals_address:struct frame_info *fi:fi::0:0
 514 f:2:SAVED_PC_AFTER_CALL:CORE_ADDR:saved_pc_after_call:struct frame_info *frame:frame::0:0
 515 f:2:FRAME_NUM_ARGS:int:frame_num_args:struct frame_info *frame:frame::0:0
 516 #
 517 F:2:STACK_ALIGN:CORE_ADDR:stack_align:CORE_ADDR sp:sp::0:0
 518 v:1:EXTRA_STACK_ALIGNMENT_NEEDED:int:extra_stack_alignment_needed::::0:1::0:::
 519 F:2:REG_STRUCT_HAS_ADDR:int:reg_struct_has_addr:int gcc_p, struct type *type:gcc_p, type::0:0
 520 F:2:SAVE_DUMMY_FRAME_TOS:void:save_dummy_frame_tos:CORE_ADDR sp:sp::0:0
 521 v:2:PARM_BOUNDARY:int:parm_boundary
 522 #
 523 v:2:TARGET_FLOAT_FORMAT:const struct floatformat *:float_format::::::default_float_format (gdbarch)
 524 v:2:TARGET_DOUBLE_FORMAT:const struct floatformat *:double_format::::::default_double_format (gdbarch)
 525 v:2:TARGET_LONG_DOUBLE_FORMAT:const struct floatformat *:long_double_format::::::&floatformat_unknown
 526 f:2:CONVERT_FROM_FUNC_PTR_ADDR:CORE_ADDR:convert_from_func_ptr_addr:CORE_ADDR addr:addr:::core_addr_identity::0
 527 # On some machines there are bits in addresses which are not really
 528 # part of the address, but are used by the kernel, the hardware, etc.
 529 # for special purposes.  ADDR_BITS_REMOVE takes out any such bits so
 530 # we get a "real" address such as one would find in a symbol table.
 531 # This is used only for addresses of instructions, and even then I'm
 532 # not sure it's used in all contexts.  It exists to deal with there
 533 # being a few stray bits in the PC which would mislead us, not as some
 534 # sort of generic thing to handle alignment or segmentation (it's
 535 # possible it should be in TARGET_READ_PC instead).
 536 f:2:ADDR_BITS_REMOVE:CORE_ADDR:addr_bits_remove:CORE_ADDR addr:addr:::core_addr_identity::0
 537 # FIXME/cagney/2001-01-18: This should be split in two.  A target method that indicates if
 538 # the target needs software single step.  An ISA method to implement it.
 539 #
 540 # FIXME/cagney/2001-01-18: This should be replaced with something that inserts breakpoints
 541 # using the breakpoint system instead of blatting memory directly (as with rs6000).
 542 #
 543 # FIXME/cagney/2001-01-18: The logic is backwards.  It should be asking if the target can
 544 # single step.  If not, then implement single step using breakpoints.
 545 F:2:SOFTWARE_SINGLE_STEP:void:software_single_step:enum target_signal sig, int insert_breakpoints_p:sig, insert_breakpoints_p::0:0
 546 EOF
 547 }
 548
 549 #
 550 # The .log file
 551 #
 552 exec > new-gdbarch.log
 553 function_list | while do_read
 554 do
 555     cat <<EOF
 556 ${class} ${macro}(${actual})
 557   ${returntype} ${function} ($formal)${attrib}
 558 EOF
 559     for r in ${read}
 560     do
 561         eval echo \"\ \ \ \ ${r}=\${${r}}\"
 562     done
 563 #    #fallbackdefault=${fallbackdefault}
 564 #    #valid_p=${valid_p}
 565 #EOF
 566     if class_is_predicate_p && fallback_default_p
 567     then
 568         echo "Error: predicate function ${macro} can not have a non- multi-arch default" 1>&2
 569         kill $$
 570         exit 1
 571     fi
 572     if [ "x${invalid_p}" = "x0" -a -n "${postdefault}" ]
 573     then
 574         echo "Error: postdefault is useless when invalid_p=0" 1>&2
 575         kill $$
 576         exit 1
 577     fi
 578     echo ""
 579 done
 580
 581 exec 1>&2
 582 compare_new gdbarch.log
 583
 584
 585 copyright ()
 586 {
 587 cat <<EOF
 588 /* *INDENT-OFF* */ /* THIS FILE IS GENERATED */
 589
 590 /* Dynamic architecture support for GDB, the GNU debugger.
 591    Copyright 1998, 1999, 2000, 2001 Free Software Foundation, Inc.
 592
 593    This file is part of GDB.
 594
 595    This program is free software; you can redistribute it and/or modify
 596    it under the terms of the GNU General Public License as published by
 597    the Free Software Foundation; either version 2 of the License, or
 598    (at your option) any later version.
 599
 600    This program is distributed in the hope that it will be useful,
 601    but WITHOUT ANY WARRANTY; without even the implied warranty of
 602    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 603    GNU General Public License for more details.
 604
 605    You should have received a copy of the GNU General Public License
 606    along with this program; if not, write to the Free Software
 607    Foundation, Inc., 59 Temple Place - Suite 330,
 608    Boston, MA 02111-1307, USA.  */
 609
 610 /* This file was created with the aid of \`\`gdbarch.sh''.
 611
 612    The Bourne shell script \`\`gdbarch.sh'' creates the files
 613    \`\`new-gdbarch.c'' and \`\`new-gdbarch.h and then compares them
 614    against the existing \`\`gdbarch.[hc]''.  Any differences found
 615    being reported.
 616
 617    If editing this file, please also run gdbarch.sh and merge any
 618    changes into that script. Conversely, when making sweeping changes
 619    to this file, modifying gdbarch.sh and using its output may prove
 620    easier. */
 621
 622 EOF
 623 }
 624
 625 #
 626 # The .h file
 627 #
 628
 629 exec > new-gdbarch.h
 630 copyright
 631 cat <<EOF
 632 #ifndef GDBARCH_H
 633 #define GDBARCH_H
 634
 635 struct frame_info;
 636 struct value;
 637
 638
 639 extern struct gdbarch *current_gdbarch;
 640
 641
 642 /* If any of the following are defined, the target wasn't correctly
 643    converted. */
 644
 645 #if GDB_MULTI_ARCH
 646 #if defined (EXTRA_FRAME_INFO)
 647 #error "EXTRA_FRAME_INFO: replaced by struct frame_extra_info"
 648 #endif
 649 #endif
 650
 651 #if GDB_MULTI_ARCH
 652 #if defined (FRAME_FIND_SAVED_REGS)
 653 #error "FRAME_FIND_SAVED_REGS: replaced by FRAME_INIT_SAVED_REGS"
 654 #endif
 655 #endif
 656
 657 #if (GDB_MULTI_ARCH >= GDB_MULTI_ARCH_PURE) && defined (GDB_TM_FILE)
 658 #error "GDB_TM_FILE: Pure multi-arch targets do not have a tm.h file."
 659 #endif
 660 EOF
 661
 662 # function typedef's
 663 printf "\n"
 664 printf "\n"
 665 printf "/* The following are pre-initialized by GDBARCH. */\n"
 666 function_list | while do_read
 667 do
 668     if class_is_info_p
 669     then
 670         printf "\n"
 671         printf "extern ${returntype} gdbarch_${function} (struct gdbarch *gdbarch);\n"
 672         printf "/* set_gdbarch_${function}() - not applicable - pre-initialized. */\n"
 673         printf "#if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (${macro})\n"
 674         printf "#error \"Non multi-arch definition of ${macro}\"\n"
 675         printf "#endif\n"
 676         printf "#if GDB_MULTI_ARCH\n"
 677         printf "#if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (${macro})\n"
 678         printf "#define ${macro} (gdbarch_${function} (current_gdbarch))\n"
 679         printf "#endif\n"
 680         printf "#endif\n"
 681     fi
 682 done
 683
 684 # function typedef's
 685 printf "\n"
 686 printf "\n"
 687 printf "/* The following are initialized by the target dependent code. */\n"
 688 function_list | while do_read
 689 do
 690     if [ -n "${comment}" ]
 691     then
 692         echo "${comment}" | sed \
 693             -e '2 s,#,/*,' \
 694             -e '3,$ s,#,  ,' \
 695             -e '$ s,$, */,'
 696     fi
 697     if class_is_multiarch_p
 698     then
 699         if class_is_predicate_p
 700         then
 701             printf "\n"
 702             printf "extern int gdbarch_${function}_p (struct gdbarch *gdbarch);\n"
 703         fi
 704     else
 705         if class_is_predicate_p
 706         then
 707             printf "\n"
 708             printf "#if defined (${macro})\n"
 709             printf "/* Legacy for systems yet to multi-arch ${macro} */\n"
 710             #printf "#if (GDB_MULTI_ARCH <= GDB_MULTI_ARCH_PARTIAL) && defined (${macro})\n"
 711             printf "#if !defined (${macro}_P)\n"
 712             printf "#define ${macro}_P() (1)\n"
 713             printf "#endif\n"
 714             printf "#endif\n"
 715             printf "\n"
 716             printf "/* Default predicate for non- multi-arch targets. */\n"
 717             printf "#if (!GDB_MULTI_ARCH) && !defined (${macro}_P)\n"
 718             printf "#define ${macro}_P() (0)\n"
 719             printf "#endif\n"
 720             printf "\n"
 721             printf "extern int gdbarch_${function}_p (struct gdbarch *gdbarch);\n"
 722             printf "#if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (${macro}_P)\n"
 723             printf "#error \"Non multi-arch definition of ${macro}\"\n"
 724             printf "#endif\n"
 725             printf "#if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (${macro}_P)\n"
 726             printf "#define ${macro}_P() (gdbarch_${function}_p (current_gdbarch))\n"
 727             printf "#endif\n"
 728         fi
 729     fi
 730     if class_is_variable_p
 731     then
 732         if fallback_default_p || class_is_predicate_p
 733         then
 734             printf "\n"
 735             printf "/* Default (value) for non- multi-arch platforms. */\n"
 736             printf "#if (!GDB_MULTI_ARCH) && !defined (${macro})\n"
 737             echo "#define ${macro} (${fallbackdefault})" \
 738                 | sed -e 's/\([^a-z_]\)\(gdbarch[^a-z_]\)/\1current_\2/g'
 739             printf "#endif\n"
 740         fi
 741         printf "\n"
 742         printf "extern ${returntype} gdbarch_${function} (struct gdbarch *gdbarch);\n"
 743         printf "extern void set_gdbarch_${function} (struct gdbarch *gdbarch, ${returntype} ${function});\n"
 744         printf "#if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (${macro})\n"
 745         printf "#error \"Non multi-arch definition of ${macro}\"\n"
 746         printf "#endif\n"
 747         printf "#if GDB_MULTI_ARCH\n"
 748         printf "#if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (${macro})\n"
 749         printf "#define ${macro} (gdbarch_${function} (current_gdbarch))\n"
 750         printf "#endif\n"
 751         printf "#endif\n"
 752     fi
 753     if class_is_function_p
 754     then
 755         if class_is_multiarch_p ; then :
 756         elif fallback_default_p || class_is_predicate_p
 757         then
 758             printf "\n"
 759             printf "/* Default (function) for non- multi-arch platforms. */\n"
 760             printf "#if (!GDB_MULTI_ARCH) && !defined (${macro})\n"
 761             if [ "x${fallbackdefault}" = "x0" ]
 762             then
 763                 printf "#define ${macro}(${actual}) (internal_error (__FILE__, __LINE__, \"${macro}\"), 0)\n"
 764             else
 765                 # FIXME: Should be passing current_gdbarch through!
 766                 echo "#define ${macro}(${actual}) (${fallbackdefault} (${actual}))" \
 767                     | sed -e 's/\([^a-z_]\)\(gdbarch[^a-z_]\)/\1current_\2/g'
 768             fi
 769             printf "#endif\n"
 770         fi
 771         printf "\n"
 772         if [ "x${formal}" = "xvoid" ] && class_is_multiarch_p
 773         then
 774             printf "typedef ${returntype} (gdbarch_${function}_ftype) (struct gdbarch *gdbarch);\n"
 775         elif class_is_multiarch_p
 776         then
 777             printf "typedef ${returntype} (gdbarch_${function}_ftype) (struct gdbarch *gdbarch, ${formal});\n"
 778         else
 779             printf "typedef ${returntype} (gdbarch_${function}_ftype) (${formal});\n"
 780         fi
 781         if [ "x${formal}" = "xvoid" ]
 782         then
 783           printf "extern ${returntype} gdbarch_${function} (struct gdbarch *gdbarch);\n"
 784         else
 785           printf "extern ${returntype} gdbarch_${function} (struct gdbarch *gdbarch, ${formal});\n"
 786         fi
 787         printf "extern void set_gdbarch_${function} (struct gdbarch *gdbarch, gdbarch_${function}_ftype *${function});\n"
 788         if class_is_multiarch_p ; then :
 789         else
 790             printf "#if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (${macro})\n"
 791             printf "#error \"Non multi-arch definition of ${macro}\"\n"
 792             printf "#endif\n"
 793             printf "#if GDB_MULTI_ARCH\n"
 794             printf "#if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (${macro})\n"
 795             if [ "x${actual}" = "x" ]
 796             then
 797                 printf "#define ${macro}() (gdbarch_${function} (current_gdbarch))\n"
 798             elif [ "x${actual}" = "x-" ]
 799             then
 800                 printf "#define ${macro} (gdbarch_${function} (current_gdbarch))\n"
 801             else
 802                 printf "#define ${macro}(${actual}) (gdbarch_${function} (current_gdbarch, ${actual}))\n"
 803             fi
 804             printf "#endif\n"
 805             printf "#endif\n"
 806         fi
 807     fi
 808 done
 809
 810 # close it off
 811 cat <<EOF
 812
 813 extern struct gdbarch_tdep *gdbarch_tdep (struct gdbarch *gdbarch);
 814
 815
 816 /* Mechanism for co-ordinating the selection of a specific
 817    architecture.
 818
 819    GDB targets (*-tdep.c) can register an interest in a specific
 820    architecture.  Other GDB components can register a need to maintain
 821    per-architecture data.
 822
 823    The mechanisms below ensures that there is only a loose connection
 824    between the set-architecture command and the various GDB
 825    components.  Each component can independently register their need
 826    to maintain architecture specific data with gdbarch.
 827
 828    Pragmatics:
 829
 830    Previously, a single TARGET_ARCHITECTURE_HOOK was provided.  It
 831    didn't scale.
 832
 833    The more traditional mega-struct containing architecture specific
 834    data for all the various GDB components was also considered.  Since
 835    GDB is built from a variable number of (fairly independent)
 836    components it was determined that the global aproach was not
 837    applicable. */
 838
 839
 840 /* Register a new architectural family with GDB.
 841
 842    Register support for the specified ARCHITECTURE with GDB.  When
 843    gdbarch determines that the specified architecture has been
 844    selected, the corresponding INIT function is called.
 845
 846    --
 847
 848    The INIT function takes two parameters: INFO which contains the
 849    information available to gdbarch about the (possibly new)
 850    architecture; ARCHES which is a list of the previously created
 851    \`\`struct gdbarch'' for this architecture.
 852
 853    The INIT function parameter INFO shall, as far as possible, be
 854    pre-initialized with information obtained from INFO.ABFD or
 855    previously selected architecture (if similar).  INIT shall ensure
 856    that the INFO.BYTE_ORDER is non-zero.
 857
 858    The INIT function shall return any of: NULL - indicating that it
 859    doesn't recognize the selected architecture; an existing \`\`struct
 860    gdbarch'' from the ARCHES list - indicating that the new
 861    architecture is just a synonym for an earlier architecture (see
 862    gdbarch_list_lookup_by_info()); a newly created \`\`struct gdbarch''
 863    - that describes the selected architecture (see gdbarch_alloc()).
 864
 865    The DUMP_TDEP function shall print out all target specific values.
 866    Care should be taken to ensure that the function works in both the
 867    multi-arch and non- multi-arch cases. */
 868
 869 struct gdbarch_list
 870 {
 871   struct gdbarch *gdbarch;
 872   struct gdbarch_list *next;
 873 };
 874
 875 struct gdbarch_info
 876 {
 877   /* Use default: NULL (ZERO). */
 878   const struct bfd_arch_info *bfd_arch_info;
 879
 880   /* Use default: 0 (ZERO). */
 881   int byte_order;
 882
 883   /* Use default: NULL (ZERO). */
 884   bfd *abfd;
 885
 886   /* Use default: NULL (ZERO). */
 887   struct gdbarch_tdep_info *tdep_info;
 888 };
 889
 890 typedef struct gdbarch *(gdbarch_init_ftype) (struct gdbarch_info info, struct gdbarch_list *arches);
 891 typedef void (gdbarch_dump_tdep_ftype) (struct gdbarch *gdbarch, struct ui_file *file);
 892
 893 /* DEPRECATED - use gdbarch_register() */
 894 extern void register_gdbarch_init (enum bfd_architecture architecture, gdbarch_init_ftype *);
 895
 896 extern void gdbarch_register (enum bfd_architecture architecture,
 897                               gdbarch_init_ftype *,
 898                               gdbarch_dump_tdep_ftype *);
 899
 900
 901 /* Return a freshly allocated, NULL terminated, array of the valid
 902    architecture names.  Since architectures are registered during the
 903    _initialize phase this function only returns useful information
 904    once initialization has been completed. */
 905
 906 extern const char **gdbarch_printable_names (void);
 907
 908
 909 /* Helper function.  Search the list of ARCHES for a GDBARCH that
 910    matches the information provided by INFO. */
 911
 912 extern struct gdbarch_list *gdbarch_list_lookup_by_info (struct gdbarch_list *arches,  const struct gdbarch_info *info);
 913
 914
 915 /* Helper function.  Create a preliminary \`\`struct gdbarch''.  Perform
 916    basic initialization using values obtained from the INFO andTDEP
 917    parameters.  set_gdbarch_*() functions are called to complete the
 918    initialization of the object. */
 919
 920 extern struct gdbarch *gdbarch_alloc (const struct gdbarch_info *info, struct gdbarch_tdep *tdep);
 921
 922
 923 /* Helper function.  Free a partially-constructed \`\`struct gdbarch''.
 924    It is assumed that the caller freeds the \`\`struct
 925    gdbarch_tdep''. */
 926
 927 extern void gdbarch_free (struct gdbarch *);
 928
 929
 930 /* Helper function. Force an update of the current architecture.
 931
 932    The actual architecture selected is determined by INFO, \`\`(gdb) set
 933    architecture'' et.al., the existing architecture and BFD's default
 934    architecture.  INFO should be initialized to zero and then selected
 935    fields should be updated.
 936
 937    Returns non-zero if the update succeeds */
 938
 939 extern int gdbarch_update_p (struct gdbarch_info info);
 940
 941
 942
 943 /* Register per-architecture data-pointer.
 944
 945    Reserve space for a per-architecture data-pointer.  An identifier
 946    for the reserved data-pointer is returned.  That identifer should
 947    be saved in a local static variable.
 948
 949    The per-architecture data-pointer can be initialized in one of two
 950    ways: The value can be set explicitly using a call to
 951    set_gdbarch_data(); the value can be set implicitly using the value
 952    returned by a non-NULL INIT() callback.  INIT(), when non-NULL is
 953    called after the basic architecture vector has been created.
 954
 955    When a previously created architecture is re-selected, the
 956    per-architecture data-pointer for that previous architecture is
 957    restored.  INIT() is not called.
 958
 959    During initialization, multiple assignments of the data-pointer are
 960    allowed, non-NULL values are deleted by calling FREE().  If the
 961    architecture is deleted using gdbarch_free() all non-NULL data
 962    pointers are also deleted using FREE().
 963
 964    Multiple registrarants for any architecture are allowed (and
 965    strongly encouraged).  */
 966
 967 struct gdbarch_data;
 968
 969 typedef void *(gdbarch_data_init_ftype) (struct gdbarch *gdbarch);
 970 typedef void (gdbarch_data_free_ftype) (struct gdbarch *gdbarch,
 971                                         void *pointer);
 972 extern struct gdbarch_data *register_gdbarch_data (gdbarch_data_init_ftype *init,
 973                                                    gdbarch_data_free_ftype *free);
 974 extern void set_gdbarch_data (struct gdbarch *gdbarch,
 975                               struct gdbarch_data *data,
 976                               void *pointer);
 977
 978 extern void *gdbarch_data (struct gdbarch_data*);
 979
 980
 981 /* Register per-architecture memory region.
 982
 983    Provide a memory-region swap mechanism.  Per-architecture memory
 984    region are created.  These memory regions are swapped whenever the
 985    architecture is changed.  For a new architecture, the memory region
 986    is initialized with zero (0) and the INIT function is called.
 987
 988    Memory regions are swapped / initialized in the order that they are
 989    registered.  NULL DATA and/or INIT values can be specified.
 990
 991    New code should use register_gdbarch_data(). */
 992
 993 typedef void (gdbarch_swap_ftype) (void);
 994 extern void register_gdbarch_swap (void *data, unsigned long size, gdbarch_swap_ftype *init);
 995 #define REGISTER_GDBARCH_SWAP(VAR) register_gdbarch_swap (&(VAR), sizeof ((VAR)), NULL)
 996
 997
 998
 999 /* The target-system-dependent byte order is dynamic */
1000
1001 /* TARGET_BYTE_ORDER_SELECTABLE_P determines if the target endianness
1002    is selectable at runtime.  The user can use the \`\`set endian''
1003    command to change it.  TARGET_BYTE_ORDER_AUTO is nonzero when
1004    target_byte_order should be auto-detected (from the program image
1005    say). */
1006
1007 #if GDB_MULTI_ARCH
1008 /* Multi-arch GDB is always bi-endian. */
1009 #define TARGET_BYTE_ORDER_SELECTABLE_P 1
1010 #endif
1011
1012 #ifndef TARGET_BYTE_ORDER_SELECTABLE_P
1013 /* compat - Catch old targets that define TARGET_BYTE_ORDER_SLECTABLE
1014    when they should have defined TARGET_BYTE_ORDER_SELECTABLE_P 1 */
1015 #ifdef TARGET_BYTE_ORDER_SELECTABLE
1016 #define TARGET_BYTE_ORDER_SELECTABLE_P 1
1017 #else
1018 #define TARGET_BYTE_ORDER_SELECTABLE_P 0
1019 #endif
1020 #endif
1021
1022 extern int target_byte_order;
1023 #ifdef TARGET_BYTE_ORDER_SELECTABLE
1024 /* compat - Catch old targets that define TARGET_BYTE_ORDER_SELECTABLE
1025    and expect defs.h to re-define TARGET_BYTE_ORDER. */
1026 #undef TARGET_BYTE_ORDER
1027 #endif
1028 #ifndef TARGET_BYTE_ORDER
1029 #define TARGET_BYTE_ORDER (target_byte_order + 0)
1030 #endif
1031
1032 extern int target_byte_order_auto;
1033 #ifndef TARGET_BYTE_ORDER_AUTO
1034 #define TARGET_BYTE_ORDER_AUTO (target_byte_order_auto + 0)
1035 #endif
1036
1037
1038
1039 /* The target-system-dependent BFD architecture is dynamic */
1040
1041 extern int target_architecture_auto;
1042 #ifndef TARGET_ARCHITECTURE_AUTO
1043 #define TARGET_ARCHITECTURE_AUTO (target_architecture_auto + 0)
1044 #endif
1045
1046 extern const struct bfd_arch_info *target_architecture;
1047 #ifndef TARGET_ARCHITECTURE
1048 #define TARGET_ARCHITECTURE (target_architecture + 0)
1049 #endif
1050
1051
1052 /* The target-system-dependent disassembler is semi-dynamic */
1053
1054 #include "dis-asm.h"            /* Get defs for disassemble_info */
1055
1056 extern int dis_asm_read_memory (bfd_vma memaddr, bfd_byte *myaddr,
1057                                 unsigned int len, disassemble_info *info);
1058
1059 extern void dis_asm_memory_error (int status, bfd_vma memaddr,
1060                                   disassemble_info *info);
1061
1062 extern void dis_asm_print_address (bfd_vma addr,
1063                                    disassemble_info *info);
1064
1065 extern int (*tm_print_insn) (bfd_vma, disassemble_info*);
1066 extern disassemble_info tm_print_insn_info;
1067 #ifndef TARGET_PRINT_INSN
1068 #define TARGET_PRINT_INSN(vma, info) (*tm_print_insn) (vma, info)
1069 #endif
1070 #ifndef TARGET_PRINT_INSN_INFO
1071 #define TARGET_PRINT_INSN_INFO (&tm_print_insn_info)
1072 #endif
1073
1074
1075
1076 /* Explicit test for D10V architecture.
1077    USE of these macro's is *STRONGLY* discouraged. */
1078
1079 #define GDB_TARGET_IS_D10V (TARGET_ARCHITECTURE->arch == bfd_arch_d10v)
1080
1081
1082 /* Set the dynamic target-system-dependent parameters (architecture,
1083    byte-order, ...) using information found in the BFD */
1084
1085 extern void set_gdbarch_from_file (bfd *);
1086
1087
1088 /* Initialize the current architecture to the "first" one we find on
1089    our list.  */
1090
1091 extern void initialize_current_architecture (void);
1092
1093 /* For non-multiarched targets, do any initialization of the default
1094    gdbarch object necessary after the _initialize_MODULE functions
1095    have run.  */
1096 extern void initialize_non_multiarch ();
1097
1098 /* gdbarch trace variable */
1099 extern int gdbarch_debug;
1100
1101 extern void gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file);
1102
1103 #endif
1104 EOF
1105 exec 1>&2
1106 #../move-if-change new-gdbarch.h gdbarch.h
1107 compare_new gdbarch.h
1108
1109
1110 #
1111 # C file
1112 #
1113
1114 exec > new-gdbarch.c
1115 copyright
1116 cat <<EOF
1117
1118 #include "defs.h"
1119 #include "arch-utils.h"
1120
1121 #if GDB_MULTI_ARCH
1122 #include "gdbcmd.h"
1123 #include "inferior.h" /* enum CALL_DUMMY_LOCATION et.al. */
1124 #else
1125 /* Just include everything in sight so that the every old definition
1126    of macro is visible. */
1127 #include "gdb_string.h"
1128 #include <ctype.h>
1129 #include "symtab.h"
1130 #include "frame.h"
1131 #include "inferior.h"
1132 #include "breakpoint.h"
1133 #include "gdb_wait.h"
1134 #include "gdbcore.h"
1135 #include "gdbcmd.h"
1136 #include "target.h"
1137 #include "gdbthread.h"
1138 #include "annotate.h"
1139 #include "symfile.h"            /* for overlay functions */
1140 #endif
1141 #include "symcat.h"
1142
1143 #include "floatformat.h"
1144
1145 #include "gdb_assert.h"
1146
1147 /* Static function declarations */
1148
1149 static void verify_gdbarch (struct gdbarch *gdbarch);
1150 static void alloc_gdbarch_data (struct gdbarch *);
1151 static void init_gdbarch_data (struct gdbarch *);
1152 static void free_gdbarch_data (struct gdbarch *);
1153 static void init_gdbarch_swap (struct gdbarch *);
1154 static void swapout_gdbarch_swap (struct gdbarch *);
1155 static void swapin_gdbarch_swap (struct gdbarch *);
1156
1157 /* Convenience macro for allocting typesafe memory. */
1158
1159 #ifndef XMALLOC
1160 #define XMALLOC(TYPE) (TYPE*) xmalloc (sizeof (TYPE))
1161 #endif
1162
1163
1164 /* Non-zero if we want to trace architecture code.  */
1165
1166 #ifndef GDBARCH_DEBUG
1167 #define GDBARCH_DEBUG 0
1168 #endif
1169 int gdbarch_debug = GDBARCH_DEBUG;
1170
1171 EOF
1172
1173 # gdbarch open the gdbarch object
1174 printf "\n"
1175 printf "/* Maintain the struct gdbarch object */\n"
1176 printf "\n"
1177 printf "struct gdbarch\n"
1178 printf "{\n"
1179 printf "  /* basic architectural information */\n"
1180 function_list | while do_read
1181 do
1182     if class_is_info_p
1183     then
1184         printf "  ${returntype} ${function};\n"
1185     fi
1186 done
1187 printf "\n"
1188 printf "  /* target specific vector. */\n"
1189 printf "  struct gdbarch_tdep *tdep;\n"
1190 printf "  gdbarch_dump_tdep_ftype *dump_tdep;\n"
1191 printf "\n"
1192 printf "  /* per-architecture data-pointers */\n"
1193 printf "  unsigned nr_data;\n"
1194 printf "  void **data;\n"
1195 printf "\n"
1196 printf "  /* per-architecture swap-regions */\n"
1197 printf "  struct gdbarch_swap *swap;\n"
1198 printf "\n"
1199 cat <<EOF
1200   /* Multi-arch values.
1201
1202      When extending this structure you must:
1203
1204      Add the field below.
1205
1206      Declare set/get functions and define the corresponding
1207      macro in gdbarch.h.
1208
1209      gdbarch_alloc(): If zero/NULL is not a suitable default,
1210      initialize the new field.
1211
1212      verify_gdbarch(): Confirm that the target updated the field
1213      correctly.
1214
1215      gdbarch_dump(): Add a fprintf_unfiltered call so that the new
1216      field is dumped out
1217
1218      \`\`startup_gdbarch()'': Append an initial value to the static
1219      variable (base values on the host's c-type system).
1220
1221      get_gdbarch(): Implement the set/get functions (probably using
1222      the macro's as shortcuts).
1223
1224      */
1225
1226 EOF
1227 function_list | while do_read
1228 do
1229     if class_is_variable_p
1230     then
1231         printf "  ${returntype} ${function};\n"
1232     elif class_is_function_p
1233     then
1234         printf "  gdbarch_${function}_ftype *${function}${attrib};\n"
1235     fi
1236 done
1237 printf "};\n"
1238
1239 # A pre-initialized vector
1240 printf "\n"
1241 printf "\n"
1242 cat <<EOF
1243 /* The default architecture uses host values (for want of a better
1244    choice). */
1245 EOF
1246 printf "\n"
1247 printf "extern const struct bfd_arch_info bfd_default_arch_struct;\n"
1248 printf "\n"
1249 printf "struct gdbarch startup_gdbarch =\n"
1250 printf "{\n"
1251 printf "  /* basic architecture information */\n"
1252 function_list | while do_read
1253 do
1254     if class_is_info_p
1255     then
1256         printf "  ${staticdefault},\n"
1257     fi
1258 done
1259 cat <<EOF
1260   /* target specific vector and its dump routine */
1261   NULL, NULL,
1262   /*per-architecture data-pointers and swap regions */
1263   0, NULL, NULL,
1264   /* Multi-arch values */
1265 EOF
1266 function_list | while do_read
1267 do
1268     if class_is_function_p || class_is_variable_p
1269     then
1270         printf "  ${staticdefault},\n"
1271     fi
1272 done
1273 cat <<EOF
1274   /* startup_gdbarch() */
1275 };
1276
1277 struct gdbarch *current_gdbarch = &startup_gdbarch;
1278
1279 /* Do any initialization needed for a non-multiarch configuration
1280    after the _initialize_MODULE functions have been run.  */
1281 void
1282 initialize_non_multiarch ()
1283 {
1284   alloc_gdbarch_data (&startup_gdbarch);
1285   init_gdbarch_data (&startup_gdbarch);
1286 }
1287 EOF
1288
1289 # Create a new gdbarch struct
1290 printf "\n"
1291 printf "\n"
1292 cat <<EOF
1293 /* Create a new \`\`struct gdbarch'' based on information provided by
1294    \`\`struct gdbarch_info''. */
1295 EOF
1296 printf "\n"
1297 cat <<EOF
1298 struct gdbarch *
1299 gdbarch_alloc (const struct gdbarch_info *info,
1300                struct gdbarch_tdep *tdep)
1301 {
1302   struct gdbarch *gdbarch = XMALLOC (struct gdbarch);
1303   memset (gdbarch, 0, sizeof (*gdbarch));
1304
1305   alloc_gdbarch_data (gdbarch);
1306
1307   gdbarch->tdep = tdep;
1308 EOF
1309 printf "\n"
1310 function_list | while do_read
1311 do
1312     if class_is_info_p
1313     then
1314         printf "  gdbarch->${function} = info->${function};\n"
1315     fi
1316 done
1317 printf "\n"
1318 printf "  /* Force the explicit initialization of these. */\n"
1319 function_list | while do_read
1320 do
1321     if class_is_function_p || class_is_variable_p
1322     then
1323         if [ -n "${predefault}" -a "x${predefault}" != "x0" ]
1324         then
1325           printf "  gdbarch->${function} = ${predefault};\n"
1326         fi
1327     fi
1328 done
1329 cat <<EOF
1330   /* gdbarch_alloc() */
1331
1332   return gdbarch;
1333 }
1334 EOF
1335
1336 # Free a gdbarch struct.
1337 printf "\n"
1338 printf "\n"
1339 cat <<EOF
1340 /* Free a gdbarch struct.  This should never happen in normal
1341    operation --- once you've created a gdbarch, you keep it around.
1342    However, if an architecture's init function encounters an error
1343    building the structure, it may need to clean up a partially
1344    constructed gdbarch.  */
1345
1346 void
1347 gdbarch_free (struct gdbarch *arch)
1348 {
1349   gdb_assert (arch != NULL);
1350   free_gdbarch_data (arch);
1351   xfree (arch);
1352 }
1353 EOF
1354
1355 # verify a new architecture
1356 printf "\n"
1357 printf "\n"
1358 printf "/* Ensure that all values in a GDBARCH are reasonable. */\n"
1359 printf "\n"
1360 cat <<EOF
1361 static void
1362 verify_gdbarch (struct gdbarch *gdbarch)
1363 {
1364   /* Only perform sanity checks on a multi-arch target. */
1365   if (!GDB_MULTI_ARCH)
1366     return;
1367   /* fundamental */
1368   if (gdbarch->byte_order == 0)
1369     internal_error (__FILE__, __LINE__,
1370                     "verify_gdbarch: byte-order unset");
1371   if (gdbarch->bfd_arch_info == NULL)
1372     internal_error (__FILE__, __LINE__,
1373                     "verify_gdbarch: bfd_arch_info unset");
1374   /* Check those that need to be defined for the given multi-arch level. */
1375 EOF
1376 function_list | while do_read
1377 do
1378     if class_is_function_p || class_is_variable_p
1379     then
1380         if [ "x${invalid_p}" = "x0" ]
1381         then
1382             printf "  /* Skip verify of ${function}, invalid_p == 0 */\n"
1383         elif class_is_predicate_p
1384         then
1385             printf "  /* Skip verify of ${function}, has predicate */\n"
1386         # FIXME: See do_read for potential simplification
1387         elif [ -n "${invalid_p}" -a -n "${postdefault}" ]
1388         then
1389             printf "  if (${invalid_p})\n"
1390             printf "    gdbarch->${function} = ${postdefault};\n"
1391         elif [ -n "${predefault}" -a -n "${postdefault}" ]
1392         then
1393             printf "  if (gdbarch->${function} == ${predefault})\n"
1394             printf "    gdbarch->${function} = ${postdefault};\n"
1395         elif [ -n "${postdefault}" ]
1396         then
1397             printf "  if (gdbarch->${function} == 0)\n"
1398             printf "    gdbarch->${function} = ${postdefault};\n"
1399         elif [ -n "${invalid_p}" ]
1400         then
1401             printf "  if ((GDB_MULTI_ARCH >= ${level})\n"
1402             printf "      && (${invalid_p}))\n"
1403             printf "    internal_error (__FILE__, __LINE__,\n"
1404             printf "                    \"gdbarch: verify_gdbarch: ${function} invalid\");\n"
1405         elif [ -n "${predefault}" ]
1406         then
1407             printf "  if ((GDB_MULTI_ARCH >= ${level})\n"
1408             printf "      && (gdbarch->${function} == ${predefault}))\n"
1409             printf "    internal_error (__FILE__, __LINE__,\n"
1410             printf "                    \"gdbarch: verify_gdbarch: ${function} invalid\");\n"
1411         fi
1412     fi
1413 done
1414 cat <<EOF
1415 }
1416 EOF
1417
1418 # dump the structure
1419 printf "\n"
1420 printf "\n"
1421 cat <<EOF
1422 /* Print out the details of the current architecture. */
1423
1424 /* NOTE/WARNING: The parameter is called \`\`current_gdbarch'' so that it
1425    just happens to match the global variable \`\`current_gdbarch''.  That
1426    way macros refering to that variable get the local and not the global
1427    version - ulgh.  Once everything is parameterised with gdbarch, this
1428    will go away. */
1429
1430 void
1431 gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file)
1432 {
1433   fprintf_unfiltered (file,
1434                       "gdbarch_dump: GDB_MULTI_ARCH = %d\\n",
1435                       GDB_MULTI_ARCH);
1436 EOF
1437 function_list | while do_read
1438 do
1439     # multiarch functions don't have macros.
1440     class_is_multiarch_p && continue
1441     if [ "x${returntype}" = "xvoid" ]
1442     then
1443         printf "#if defined (${macro}) && GDB_MULTI_ARCH\n"
1444         printf "  /* Macro might contain \`[{}]' when not multi-arch */\n"
1445     else
1446         printf "#ifdef ${macro}\n"
1447     fi
1448     if class_is_function_p
1449     then
1450         printf "  fprintf_unfiltered (file,\n"
1451         printf "                      \"gdbarch_dump: %%s # %%s\\\\n\",\n"
1452         printf "                      \"${macro}(${actual})\",\n"
1453         printf "                      XSTRING (${macro} (${actual})));\n"
1454     else
1455         printf "  fprintf_unfiltered (file,\n"
1456         printf "                      \"gdbarch_dump: ${macro} # %%s\\\\n\",\n"
1457         printf "                      XSTRING (${macro}));\n"
1458     fi
1459     printf "#endif\n"
1460 done
1461 function_list | while do_read
1462 do
1463     if class_is_multiarch_p
1464     then
1465         printf "  if (GDB_MULTI_ARCH)\n"
1466         printf "    fprintf_unfiltered (file,\n"
1467         printf "                        \"gdbarch_dump: ${function} = 0x%%08lx\\\\n\",\n"
1468         printf "                        (long) current_gdbarch->${function});\n"
1469         continue
1470     fi
1471     printf "#ifdef ${macro}\n"
1472     if [ "x${print_p}" = "x()" ]
1473     then
1474         printf "  gdbarch_dump_${function} (current_gdbarch);\n"
1475     elif [ "x${print_p}" = "x0" ]
1476     then
1477         printf "  /* skip print of ${macro}, print_p == 0. */\n"
1478     elif [ -n "${print_p}" ]
1479     then
1480         printf "  if (${print_p})\n"
1481         printf "    fprintf_unfiltered (file,\n"
1482         printf "                        \"gdbarch_dump: ${macro} = %s\\\\n\",\n" "${fmt}"
1483         printf "                        ${print});\n"
1484     elif class_is_function_p
1485     then
1486         printf "  if (GDB_MULTI_ARCH)\n"
1487         printf "    fprintf_unfiltered (file,\n"
1488         printf "                        \"gdbarch_dump: ${macro} = 0x%%08lx\\\\n\",\n"
1489         printf "                        (long) current_gdbarch->${function}\n"
1490         printf "                        /*${macro} ()*/);\n"
1491     else
1492         printf "  fprintf_unfiltered (file,\n"
1493         printf "                      \"gdbarch_dump: ${macro} = %s\\\\n\",\n" "${fmt}"
1494         printf "                      ${print});\n"
1495     fi
1496     printf "#endif\n"
1497 done
1498 cat <<EOF
1499   if (current_gdbarch->dump_tdep != NULL)
1500     current_gdbarch->dump_tdep (current_gdbarch, file);
1501 }
1502 EOF
1503
1504
1505 # GET/SET
1506 printf "\n"
1507 cat <<EOF
1508 struct gdbarch_tdep *
1509 gdbarch_tdep (struct gdbarch *gdbarch)
1510 {
1511   if (gdbarch_debug >= 2)
1512     fprintf_unfiltered (gdb_stdlog, "gdbarch_tdep called\\n");
1513   return gdbarch->tdep;
1514 }
1515 EOF
1516 printf "\n"
1517 function_list | while do_read
1518 do
1519     if class_is_predicate_p
1520     then
1521         printf "\n"
1522         printf "int\n"
1523         printf "gdbarch_${function}_p (struct gdbarch *gdbarch)\n"
1524         printf "{\n"
1525         if [ -n "${valid_p}" ]
1526         then
1527             printf "  return ${valid_p};\n"
1528         else
1529             printf "#error \"gdbarch_${function}_p: not defined\"\n"
1530         fi
1531         printf "}\n"
1532     fi
1533     if class_is_function_p
1534     then
1535         printf "\n"
1536         printf "${returntype}\n"
1537         if [ "x${formal}" = "xvoid" ]
1538         then
1539           printf "gdbarch_${function} (struct gdbarch *gdbarch)\n"
1540         else
1541           printf "gdbarch_${function} (struct gdbarch *gdbarch, ${formal})\n"
1542         fi
1543         printf "{\n"
1544         printf "  if (gdbarch->${function} == 0)\n"
1545         printf "    internal_error (__FILE__, __LINE__,\n"
1546         printf "                    \"gdbarch: gdbarch_${function} invalid\");\n"
1547         printf "  if (gdbarch_debug >= 2)\n"
1548         printf "    fprintf_unfiltered (gdb_stdlog, \"gdbarch_${function} called\\\\n\");\n"
1549         if [ "x${actual}" = "x-" -o "x${actual}" = "x" ]
1550         then
1551             if class_is_multiarch_p
1552             then
1553                 params="gdbarch"
1554             else
1555                 params=""
1556             fi
1557         else
1558             if class_is_multiarch_p
1559             then
1560                 params="gdbarch, ${actual}"
1561             else
1562                 params="${actual}"
1563             fi
1564         fi
1565         if [ "x${returntype}" = "xvoid" ]
1566         then
1567           printf "  gdbarch->${function} (${params});\n"
1568         else
1569           printf "  return gdbarch->${function} (${params});\n"
1570         fi
1571         printf "}\n"
1572         printf "\n"
1573         printf "void\n"
1574         printf "set_gdbarch_${function} (struct gdbarch *gdbarch,\n"
1575         printf "            `echo ${function} | sed -e 's/./ /g'`  gdbarch_${function}_ftype ${function})\n"
1576         printf "{\n"
1577         printf "  gdbarch->${function} = ${function};\n"
1578         printf "}\n"
1579     elif class_is_variable_p
1580     then
1581         printf "\n"
1582         printf "${returntype}\n"
1583         printf "gdbarch_${function} (struct gdbarch *gdbarch)\n"
1584         printf "{\n"
1585         if [ "x${invalid_p}" = "x0" ]
1586         then
1587             printf "  /* Skip verify of ${function}, invalid_p == 0 */\n"
1588         elif [ -n "${invalid_p}" ]
1589         then
1590           printf "  if (${invalid_p})\n"
1591           printf "    internal_error (__FILE__, __LINE__,\n"
1592           printf "                    \"gdbarch: gdbarch_${function} invalid\");\n"
1593         elif [ -n "${predefault}" ]
1594         then
1595           printf "  if (gdbarch->${function} == ${predefault})\n"
1596           printf "    internal_error (__FILE__, __LINE__,\n"
1597           printf "                    \"gdbarch: gdbarch_${function} invalid\");\n"
1598         fi
1599         printf "  if (gdbarch_debug >= 2)\n"
1600         printf "    fprintf_unfiltered (gdb_stdlog, \"gdbarch_${function} called\\\\n\");\n"
1601         printf "  return gdbarch->${function};\n"
1602         printf "}\n"
1603         printf "\n"
1604         printf "void\n"
1605         printf "set_gdbarch_${function} (struct gdbarch *gdbarch,\n"
1606         printf "            `echo ${function} | sed -e 's/./ /g'`  ${returntype} ${function})\n"
1607         printf "{\n"
1608         printf "  gdbarch->${function} = ${function};\n"
1609         printf "}\n"
1610     elif class_is_info_p
1611     then
1612         printf "\n"
1613         printf "${returntype}\n"
1614         printf "gdbarch_${function} (struct gdbarch *gdbarch)\n"
1615         printf "{\n"
1616         printf "  if (gdbarch_debug >= 2)\n"
1617         printf "    fprintf_unfiltered (gdb_stdlog, \"gdbarch_${function} called\\\\n\");\n"
1618         printf "  return gdbarch->${function};\n"
1619         printf "}\n"
1620     fi
1621 done
1622
1623 # All the trailing guff
1624 cat <<EOF
1625
1626
1627 /* Keep a registry of per-architecture data-pointers required by GDB
1628    modules. */
1629
1630 struct gdbarch_data
1631 {
1632   unsigned index;
1633   gdbarch_data_init_ftype *init;
1634   gdbarch_data_free_ftype *free;
1635 };
1636
1637 struct gdbarch_data_registration
1638 {
1639   struct gdbarch_data *data;
1640   struct gdbarch_data_registration *next;
1641 };
1642
1643 struct gdbarch_data_registry
1644 {
1645   unsigned nr;
1646   struct gdbarch_data_registration *registrations;
1647 };
1648
1649 struct gdbarch_data_registry gdbarch_data_registry =
1650 {
1651   0, NULL,
1652 };
1653
1654 struct gdbarch_data *
1655 register_gdbarch_data (gdbarch_data_init_ftype *init,
1656                        gdbarch_data_free_ftype *free)
1657 {
1658   struct gdbarch_data_registration **curr;
1659   for (curr = &gdbarch_data_registry.registrations;
1660        (*curr) != NULL;
1661        curr = &(*curr)->next);
1662   (*curr) = XMALLOC (struct gdbarch_data_registration);
1663   (*curr)->next = NULL;
1664   (*curr)->data = XMALLOC (struct gdbarch_data);
1665   (*curr)->data->index = gdbarch_data_registry.nr++;
1666   (*curr)->data->init = init;
1667   (*curr)->data->free = free;
1668   return (*curr)->data;
1669 }
1670
1671
1672 /* Walk through all the registered users initializing each in turn. */
1673
1674 static void
1675 init_gdbarch_data (struct gdbarch *gdbarch)
1676 {
1677   struct gdbarch_data_registration *rego;
1678   for (rego = gdbarch_data_registry.registrations;
1679        rego != NULL;
1680        rego = rego->next)
1681     {
1682       struct gdbarch_data *data = rego->data;
1683       gdb_assert (data->index < gdbarch->nr_data);
1684       if (data->init != NULL)
1685         {
1686           void *pointer = data->init (gdbarch);
1687           set_gdbarch_data (gdbarch, data, pointer);
1688         }
1689     }
1690 }
1691
1692 /* Create/delete the gdbarch data vector. */
1693
1694 static void
1695 alloc_gdbarch_data (struct gdbarch *gdbarch)
1696 {
1697   gdb_assert (gdbarch->data == NULL);
1698   gdbarch->nr_data = gdbarch_data_registry.nr;
1699   gdbarch->data = xcalloc (gdbarch->nr_data, sizeof (void*));
1700 }
1701
1702 static void
1703 free_gdbarch_data (struct gdbarch *gdbarch)
1704 {
1705   struct gdbarch_data_registration *rego;
1706   gdb_assert (gdbarch->data != NULL);
1707   for (rego = gdbarch_data_registry.registrations;
1708        rego != NULL;
1709        rego = rego->next)
1710     {
1711       struct gdbarch_data *data = rego->data;
1712       gdb_assert (data->index < gdbarch->nr_data);
1713       if (data->free != NULL && gdbarch->data[data->index] != NULL)
1714         {
1715           data->free (gdbarch, gdbarch->data[data->index]);
1716           gdbarch->data[data->index] = NULL;
1717         }
1718     }
1719   xfree (gdbarch->data);
1720   gdbarch->data = NULL;
1721 }
1722
1723
1724 /* Initialize the current value of thee specified per-architecture
1725    data-pointer. */
1726
1727 void
1728 set_gdbarch_data (struct gdbarch *gdbarch,
1729                   struct gdbarch_data *data,
1730                   void *pointer)
1731 {
1732   gdb_assert (data->index < gdbarch->nr_data);
1733   if (data->free != NULL && gdbarch->data[data->index] != NULL)
1734     data->free (gdbarch, gdbarch->data[data->index]);
1735   gdbarch->data[data->index] = pointer;
1736 }
1737
1738 /* Return the current value of the specified per-architecture
1739    data-pointer. */
1740
1741 void *
1742 gdbarch_data (struct gdbarch_data *data)
1743 {
1744   gdb_assert (data->index < current_gdbarch->nr_data);
1745   return current_gdbarch->data[data->index];
1746 }
1747
1748
1749
1750 /* Keep a registry of swapped data required by GDB modules. */
1751
1752 struct gdbarch_swap
1753 {
1754   void *swap;
1755   struct gdbarch_swap_registration *source;
1756   struct gdbarch_swap *next;
1757 };
1758
1759 struct gdbarch_swap_registration
1760 {
1761   void *data;
1762   unsigned long sizeof_data;
1763   gdbarch_swap_ftype *init;
1764   struct gdbarch_swap_registration *next;
1765 };
1766
1767 struct gdbarch_swap_registry
1768 {
1769   int nr;
1770   struct gdbarch_swap_registration *registrations;
1771 };
1772
1773 struct gdbarch_swap_registry gdbarch_swap_registry =
1774 {
1775   0, NULL,
1776 };
1777
1778 void
1779 register_gdbarch_swap (void *data,
1780                        unsigned long sizeof_data,
1781                        gdbarch_swap_ftype *init)
1782 {
1783   struct gdbarch_swap_registration **rego;
1784   for (rego = &gdbarch_swap_registry.registrations;
1785        (*rego) != NULL;
1786        rego = &(*rego)->next);
1787   (*rego) = XMALLOC (struct gdbarch_swap_registration);
1788   (*rego)->next = NULL;
1789   (*rego)->init = init;
1790   (*rego)->data = data;
1791   (*rego)->sizeof_data = sizeof_data;
1792 }
1793
1794
1795 static void
1796 init_gdbarch_swap (struct gdbarch *gdbarch)
1797 {
1798   struct gdbarch_swap_registration *rego;
1799   struct gdbarch_swap **curr = &gdbarch->swap;
1800   for (rego = gdbarch_swap_registry.registrations;
1801        rego != NULL;
1802        rego = rego->next)
1803     {
1804       if (rego->data != NULL)
1805         {
1806           (*curr) = XMALLOC (struct gdbarch_swap);
1807           (*curr)->source = rego;
1808           (*curr)->swap = xmalloc (rego->sizeof_data);
1809           (*curr)->next = NULL;
1810           memset (rego->data, 0, rego->sizeof_data);
1811           curr = &(*curr)->next;
1812         }
1813       if (rego->init != NULL)
1814         rego->init ();
1815     }
1816 }
1817
1818 static void
1819 swapout_gdbarch_swap (struct gdbarch *gdbarch)
1820 {
1821   struct gdbarch_swap *curr;
1822   for (curr = gdbarch->swap;
1823        curr != NULL;
1824        curr = curr->next)
1825     memcpy (curr->swap, curr->source->data, curr->source->sizeof_data);
1826 }
1827
1828 static void
1829 swapin_gdbarch_swap (struct gdbarch *gdbarch)
1830 {
1831   struct gdbarch_swap *curr;
1832   for (curr = gdbarch->swap;
1833        curr != NULL;
1834        curr = curr->next)
1835     memcpy (curr->source->data, curr->swap, curr->source->sizeof_data);
1836 }
1837
1838
1839 /* Keep a registry of the architectures known by GDB. */
1840
1841 struct gdbarch_registration
1842 {
1843   enum bfd_architecture bfd_architecture;
1844   gdbarch_init_ftype *init;
1845   gdbarch_dump_tdep_ftype *dump_tdep;
1846   struct gdbarch_list *arches;
1847   struct gdbarch_registration *next;
1848 };
1849
1850 static struct gdbarch_registration *gdbarch_registry = NULL;
1851
1852 static void
1853 append_name (const char ***buf, int *nr, const char *name)
1854 {
1855   *buf = xrealloc (*buf, sizeof (char**) * (*nr + 1));
1856   (*buf)[*nr] = name;
1857   *nr += 1;
1858 }
1859
1860 const char **
1861 gdbarch_printable_names (void)
1862 {
1863   if (GDB_MULTI_ARCH)
1864     {
1865       /* Accumulate a list of names based on the registed list of
1866          architectures. */
1867       enum bfd_architecture a;
1868       int nr_arches = 0;
1869       const char **arches = NULL;
1870       struct gdbarch_registration *rego;
1871       for (rego = gdbarch_registry;
1872            rego != NULL;
1873            rego = rego->next)
1874         {
1875           const struct bfd_arch_info *ap;
1876           ap = bfd_lookup_arch (rego->bfd_architecture, 0);
1877           if (ap == NULL)
1878             internal_error (__FILE__, __LINE__,
1879                             "gdbarch_architecture_names: multi-arch unknown");
1880           do
1881             {
1882               append_name (&arches, &nr_arches, ap->printable_name);
1883               ap = ap->next;
1884             }
1885           while (ap != NULL);
1886         }
1887       append_name (&arches, &nr_arches, NULL);
1888       return arches;
1889     }
1890   else
1891     /* Just return all the architectures that BFD knows.  Assume that
1892        the legacy architecture framework supports them. */
1893     return bfd_arch_list ();
1894 }
1895
1896
1897 void
1898 gdbarch_register (enum bfd_architecture bfd_architecture,
1899                   gdbarch_init_ftype *init,
1900                   gdbarch_dump_tdep_ftype *dump_tdep)
1901 {
1902   struct gdbarch_registration **curr;
1903   const struct bfd_arch_info *bfd_arch_info;
1904   /* Check that BFD recognizes this architecture */
1905   bfd_arch_info = bfd_lookup_arch (bfd_architecture, 0);
1906   if (bfd_arch_info == NULL)
1907     {
1908       internal_error (__FILE__, __LINE__,
1909                       "gdbarch: Attempt to register unknown architecture (%d)",
1910                       bfd_architecture);
1911     }
1912   /* Check that we haven't seen this architecture before */
1913   for (curr = &gdbarch_registry;
1914        (*curr) != NULL;
1915        curr = &(*curr)->next)
1916     {
1917       if (bfd_architecture == (*curr)->bfd_architecture)
1918         internal_error (__FILE__, __LINE__,
1919                         "gdbarch: Duplicate registraration of architecture (%s)",
1920                         bfd_arch_info->printable_name);
1921     }
1922   /* log it */
1923   if (gdbarch_debug)
1924     fprintf_unfiltered (gdb_stdlog, "register_gdbarch_init (%s, 0x%08lx)\n",
1925                         bfd_arch_info->printable_name,
1926                         (long) init);
1927   /* Append it */
1928   (*curr) = XMALLOC (struct gdbarch_registration);
1929   (*curr)->bfd_architecture = bfd_architecture;
1930   (*curr)->init = init;
1931   (*curr)->dump_tdep = dump_tdep;
1932   (*curr)->arches = NULL;
1933   (*curr)->next = NULL;
1934   /* When non- multi-arch, install whatever target dump routine we've
1935      been provided - hopefully that routine has been written correctly
1936      and works regardless of multi-arch. */
1937   if (!GDB_MULTI_ARCH && dump_tdep != NULL
1938       && startup_gdbarch.dump_tdep == NULL)
1939     startup_gdbarch.dump_tdep = dump_tdep;
1940 }
1941
1942 void
1943 register_gdbarch_init (enum bfd_architecture bfd_architecture,
1944                        gdbarch_init_ftype *init)
1945 {
1946   gdbarch_register (bfd_architecture, init, NULL);
1947 }
1948
1949
1950 /* Look for an architecture using gdbarch_info.  Base search on only
1951    BFD_ARCH_INFO and BYTE_ORDER. */
1952
1953 struct gdbarch_list *
1954 gdbarch_list_lookup_by_info (struct gdbarch_list *arches,
1955                              const struct gdbarch_info *info)
1956 {
1957   for (; arches != NULL; arches = arches->next)
1958     {
1959       if (info->bfd_arch_info != arches->gdbarch->bfd_arch_info)
1960         continue;
1961       if (info->byte_order != arches->gdbarch->byte_order)
1962         continue;
1963       return arches;
1964     }
1965   return NULL;
1966 }
1967
1968
1969 /* Update the current architecture. Return ZERO if the update request
1970    failed. */
1971
1972 int
1973 gdbarch_update_p (struct gdbarch_info info)
1974 {
1975   struct gdbarch *new_gdbarch;
1976   struct gdbarch_list **list;
1977   struct gdbarch_registration *rego;
1978
1979   /* Fill in missing parts of the INFO struct using a number of
1980      sources: \`\`set ...''; INFOabfd supplied; existing target.  */
1981
1982   /* \`\`(gdb) set architecture ...'' */
1983   if (info.bfd_arch_info == NULL
1984       && !TARGET_ARCHITECTURE_AUTO)
1985     info.bfd_arch_info = TARGET_ARCHITECTURE;
1986   if (info.bfd_arch_info == NULL
1987       && info.abfd != NULL
1988       && bfd_get_arch (info.abfd) != bfd_arch_unknown
1989       && bfd_get_arch (info.abfd) != bfd_arch_obscure)
1990     info.bfd_arch_info = bfd_get_arch_info (info.abfd);
1991   if (info.bfd_arch_info == NULL)
1992     info.bfd_arch_info = TARGET_ARCHITECTURE;
1993
1994   /* \`\`(gdb) set byte-order ...'' */
1995   if (info.byte_order == 0
1996       && !TARGET_BYTE_ORDER_AUTO)
1997     info.byte_order = TARGET_BYTE_ORDER;
1998   /* From the INFO struct. */
1999   if (info.byte_order == 0
2000       && info.abfd != NULL)
2001     info.byte_order = (bfd_big_endian (info.abfd) ? BIG_ENDIAN
2002                        : bfd_little_endian (info.abfd) ? LITTLE_ENDIAN
2003                        : 0);
2004   /* From the current target. */
2005   if (info.byte_order == 0)
2006     info.byte_order = TARGET_BYTE_ORDER;
2007
2008   /* Must have found some sort of architecture. */
2009   gdb_assert (info.bfd_arch_info != NULL);
2010
2011   if (gdbarch_debug)
2012     {
2013       fprintf_unfiltered (gdb_stdlog,
2014                           "gdbarch_update: info.bfd_arch_info %s\n",
2015                           (info.bfd_arch_info != NULL
2016                            ? info.bfd_arch_info->printable_name
2017                            : "(null)"));
2018       fprintf_unfiltered (gdb_stdlog,
2019                           "gdbarch_update: info.byte_order %d (%s)\n",
2020                           info.byte_order,
2021                           (info.byte_order == BIG_ENDIAN ? "big"
2022                            : info.byte_order == LITTLE_ENDIAN ? "little"
2023                            : "default"));
2024       fprintf_unfiltered (gdb_stdlog,
2025                           "gdbarch_update: info.abfd 0x%lx\n",
2026                           (long) info.abfd);
2027       fprintf_unfiltered (gdb_stdlog,
2028                           "gdbarch_update: info.tdep_info 0x%lx\n",
2029                           (long) info.tdep_info);
2030     }
2031
2032   /* Find the target that knows about this architecture. */
2033   for (rego = gdbarch_registry;
2034        rego != NULL;
2035        rego = rego->next)
2036     if (rego->bfd_architecture == info.bfd_arch_info->arch)
2037       break;
2038   if (rego == NULL)
2039     {
2040       if (gdbarch_debug)
2041         fprintf_unfiltered (gdb_stdlog, "gdbarch_update: No matching architecture\\n");
2042       return 0;
2043     }
2044
2045   /* Ask the target for a replacement architecture. */
2046   new_gdbarch = rego->init (info, rego->arches);
2047
2048   /* Did the target like it?  No. Reject the change. */
2049   if (new_gdbarch == NULL)
2050     {
2051       if (gdbarch_debug)
2052         fprintf_unfiltered (gdb_stdlog, "gdbarch_update: Target rejected architecture\\n");
2053       return 0;
2054     }
2055
2056   /* Did the architecture change?  No. Do nothing. */
2057   if (current_gdbarch == new_gdbarch)
2058     {
2059       if (gdbarch_debug)
2060         fprintf_unfiltered (gdb_stdlog, "gdbarch_update: Architecture 0x%08lx (%s) unchanged\\n",
2061                             (long) new_gdbarch,
2062                             new_gdbarch->bfd_arch_info->printable_name);
2063       return 1;
2064     }
2065
2066   /* Swap all data belonging to the old target out */
2067   swapout_gdbarch_swap (current_gdbarch);
2068
2069   /* Is this a pre-existing architecture?  Yes. Swap it in.  */
2070   for (list = &rego->arches;
2071        (*list) != NULL;
2072        list = &(*list)->next)
2073     {
2074       if ((*list)->gdbarch == new_gdbarch)
2075         {
2076           if (gdbarch_debug)
2077             fprintf_unfiltered (gdb_stdlog,
2078                                 "gdbarch_update: Previous architecture 0x%08lx (%s) selected\\n",
2079                                 (long) new_gdbarch,
2080                                 new_gdbarch->bfd_arch_info->printable_name);
2081           current_gdbarch = new_gdbarch;
2082           swapin_gdbarch_swap (new_gdbarch);
2083           return 1;
2084         }
2085     }
2086
2087   /* Append this new architecture to this targets list. */
2088   (*list) = XMALLOC (struct gdbarch_list);
2089   (*list)->next = NULL;
2090   (*list)->gdbarch = new_gdbarch;
2091
2092   /* Switch to this new architecture.  Dump it out. */
2093   current_gdbarch = new_gdbarch;
2094   if (gdbarch_debug)
2095     {
2096       fprintf_unfiltered (gdb_stdlog,
2097                           "gdbarch_update: New architecture 0x%08lx (%s) selected\\n",
2098                           (long) new_gdbarch,
2099                           new_gdbarch->bfd_arch_info->printable_name);
2100     }
2101
2102   /* Check that the newly installed architecture is valid.  Plug in
2103      any post init values.  */
2104   new_gdbarch->dump_tdep = rego->dump_tdep;
2105   verify_gdbarch (new_gdbarch);
2106
2107   /* Initialize the per-architecture memory (swap) areas.
2108      CURRENT_GDBARCH must be update before these modules are
2109      called. */
2110   init_gdbarch_swap (new_gdbarch);
2111
2112   /* Initialize the per-architecture data-pointer of all parties that
2113      registered an interest in this architecture.  CURRENT_GDBARCH
2114      must be updated before these modules are called. */
2115   init_gdbarch_data (new_gdbarch);
2116
2117   if (gdbarch_debug)
2118     gdbarch_dump (current_gdbarch, gdb_stdlog);
2119
2120   return 1;
2121 }
2122
2123
2124 /* Disassembler */
2125
2126 /* Pointer to the target-dependent disassembly function.  */
2127 int (*tm_print_insn) (bfd_vma, disassemble_info *);
2128 disassemble_info tm_print_insn_info;
2129
2130
2131 extern void _initialize_gdbarch (void);
2132
2133 void
2134 _initialize_gdbarch (void)
2135 {
2136   struct cmd_list_element *c;
2137
2138   INIT_DISASSEMBLE_INFO_NO_ARCH (tm_print_insn_info, gdb_stdout, (fprintf_ftype)fprintf_filtered);
2139   tm_print_insn_info.flavour = bfd_target_unknown_flavour;
2140   tm_print_insn_info.read_memory_func = dis_asm_read_memory;
2141   tm_print_insn_info.memory_error_func = dis_asm_memory_error;
2142   tm_print_insn_info.print_address_func = dis_asm_print_address;
2143
2144   add_show_from_set (add_set_cmd ("arch",
2145                                   class_maintenance,
2146                                   var_zinteger,
2147                                   (char *)&gdbarch_debug,
2148                                   "Set architecture debugging.\\n\\
2149 When non-zero, architecture debugging is enabled.", &setdebuglist),
2150                      &showdebuglist);
2151   c = add_set_cmd ("archdebug",
2152                    class_maintenance,
2153                    var_zinteger,
2154                    (char *)&gdbarch_debug,
2155                    "Set architecture debugging.\\n\\
2156 When non-zero, architecture debugging is enabled.", &setlist);
2157
2158   deprecate_cmd (c, "set debug arch");
2159   deprecate_cmd (add_show_from_set (c, &showlist), "show debug arch");
2160 }
2161 EOF
2162
2163 # close things off
2164 exec 1>&2
2165 #../move-if-change new-gdbarch.c gdbarch.c
2166 compare_new gdbarch.c