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