gdb/gdbarch.sh

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