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