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