gdb/gdbarch.sh

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