gdb/gdbarch.sh

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