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