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