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 (__FILE__, __LINE__, \"${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 (__FILE__, __LINE__, "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 (__FILE__, __LINE__,
1279                     "verify_gdbarch: byte-order unset");
1280   if (gdbarch->bfd_arch_info == NULL)
1281     internal_error (__FILE__, __LINE__,
1282                     "verify_gdbarch: bfd_arch_info unset");
1283   /* Check those that need to be defined for the given multi-arch level. */
1284 EOF
1285 function_list | while do_read
1286 do
1287     if class_is_function_p || class_is_variable_p
1288     then
1289         if [ "${invalid_p}" = "0" ]
1290         then
1291             printf "  /* Skip verify of ${function}, invalid_p == 0 */\n"
1292         elif class_is_predicate_p
1293         then
1294             printf "  /* Skip verify of ${function}, has predicate */\n"
1295         # FIXME: See do_read for potential simplification
1296         elif [ "${invalid_p}" -a "${postdefault}" ]
1297         then
1298             printf "  if (${invalid_p})\n"
1299             printf "    gdbarch->${function} = ${postdefault};\n"
1300         elif [ "${predefault}" -a "${postdefault}" ]
1301         then
1302             printf "  if (gdbarch->${function} == ${predefault})\n"
1303             printf "    gdbarch->${function} = ${postdefault};\n"
1304         elif [ "${postdefault}" ]
1305         then
1306             printf "  if (gdbarch->${function} == 0)\n"
1307             printf "    gdbarch->${function} = ${postdefault};\n"
1308         elif [ "${invalid_p}" ]
1309         then
1310             printf "  if ((GDB_MULTI_ARCH >= ${level})\n"
1311             printf "      && (${invalid_p}))\n"
1312             printf "    internal_error (__FILE__, __LINE__,\n"
1313             printf "                    \"gdbarch: verify_gdbarch: ${function} invalid\");\n"
1314         elif [ "${predefault}" ]
1315         then
1316             printf "  if ((GDB_MULTI_ARCH >= ${level})\n"
1317             printf "      && (gdbarch->${function} == ${predefault}))\n"
1318             printf "    internal_error (__FILE__, __LINE__,\n"
1319             printf "                    \"gdbarch: verify_gdbarch: ${function} invalid\");\n"
1320         fi
1321     fi
1322 done
1323 cat <<EOF
1324 }
1325 EOF
1326
1327 # dump the structure
1328 printf "\n"
1329 printf "\n"
1330 cat <<EOF
1331 /* Print out the details of the current architecture. */
1332
1333 /* NOTE/WARNING: The parameter is called \`\`current_gdbarch'' so that it
1334    just happens to match the global variable \`\`current_gdbarch''.  That
1335    way macros refering to that variable get the local and not the global
1336    version - ulgh.  Once everything is parameterised with gdbarch, this
1337    will go away. */
1338
1339 void
1340 gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file)
1341 {
1342   fprintf_unfiltered (file,
1343                       "gdbarch_dump: GDB_MULTI_ARCH = %d\\n",
1344                       GDB_MULTI_ARCH);
1345 EOF
1346 function_list | while do_read
1347 do
1348     if [ "${returntype}" = "void" ]
1349     then
1350         printf "#if defined (${macro}) && GDB_MULTI_ARCH\n"
1351         printf "  /* Macro might contain \`[{}]' when not multi-arch */\n"
1352     else
1353         printf "#ifdef ${macro}\n"
1354     fi
1355     if class_is_function_p
1356     then
1357         printf "  fprintf_unfiltered (file,\n"
1358         printf "                      \"gdbarch_dump: %%s # %%s\\\\n\",\n"
1359         printf "                      \"${macro}(${actual})\",\n"
1360         printf "                      XSTRING (${macro} (${actual})));\n"
1361     else
1362         printf "  fprintf_unfiltered (file,\n"
1363         printf "                      \"gdbarch_dump: ${macro} # %%s\\\\n\",\n"
1364         printf "                      XSTRING (${macro}));\n"
1365     fi
1366     printf "#endif\n"
1367 done
1368 function_list | while do_read
1369 do
1370     printf "#ifdef ${macro}\n"
1371     if [ "${print_p}" = "()" ]
1372     then
1373         printf "  gdbarch_dump_${function} (current_gdbarch);\n"
1374     elif [ "${print_p}" = "0" ]
1375     then
1376         printf "  /* skip print of ${macro}, print_p == 0. */\n"
1377     elif [ "${print_p}" ]
1378     then
1379         printf "  if (${print_p})\n"
1380         printf "    fprintf_unfiltered (file,\n"
1381         printf "                        \"gdbarch_dump: ${macro} = %s\\\\n\",\n" "${fmt}"
1382         printf "                        ${print});\n"
1383     elif class_is_function_p
1384     then
1385         printf "  if (GDB_MULTI_ARCH)\n"
1386         printf "    fprintf_unfiltered (file,\n"
1387         printf "                        \"gdbarch_dump: ${macro} = 0x%%08lx\\\\n\",\n"
1388         printf "                        (long) current_gdbarch->${function}\n"
1389         printf "                        /*${macro} ()*/);\n"
1390     else
1391         printf "  fprintf_unfiltered (file,\n"
1392         printf "                      \"gdbarch_dump: ${macro} = %s\\\\n\",\n" "${fmt}"
1393         printf "                      ${print});\n"
1394     fi
1395     printf "#endif\n"
1396 done
1397 cat <<EOF
1398   if (current_gdbarch->dump_tdep != NULL)
1399     current_gdbarch->dump_tdep (current_gdbarch, file);
1400 }
1401 EOF
1402
1403
1404 # GET/SET
1405 printf "\n"
1406 cat <<EOF
1407 struct gdbarch_tdep *
1408 gdbarch_tdep (struct gdbarch *gdbarch)
1409 {
1410   if (gdbarch_debug >= 2)
1411     fprintf_unfiltered (gdb_stdlog, "gdbarch_tdep called\\n");
1412   return gdbarch->tdep;
1413 }
1414 EOF
1415 printf "\n"
1416 function_list | while do_read
1417 do
1418     if class_is_predicate_p
1419     then
1420         printf "\n"
1421         printf "int\n"
1422         printf "gdbarch_${function}_p (struct gdbarch *gdbarch)\n"
1423         printf "{\n"
1424         if [ "${valid_p}" ]
1425         then
1426             printf "  return ${valid_p};\n"
1427         else
1428             printf "#error \"gdbarch_${function}_p: not defined\"\n"
1429         fi
1430         printf "}\n"
1431     fi
1432     if class_is_function_p
1433     then
1434         printf "\n"
1435         printf "${returntype}\n"
1436         if [ "${formal}" = "void" ]
1437         then
1438           printf "gdbarch_${function} (struct gdbarch *gdbarch)\n"
1439         else
1440           printf "gdbarch_${function} (struct gdbarch *gdbarch, ${formal})\n"
1441         fi
1442         printf "{\n"
1443         printf "  if (gdbarch->${function} == 0)\n"
1444         printf "    internal_error (__FILE__, __LINE__,\n"
1445         printf "                    \"gdbarch: gdbarch_${function} invalid\");\n"
1446         printf "  if (gdbarch_debug >= 2)\n"
1447         printf "    fprintf_unfiltered (gdb_stdlog, \"gdbarch_${function} called\\\\n\");\n"
1448         test "${actual}" = "-" && actual=""
1449         if [ "${returntype}" = "void" ]
1450         then
1451           printf "  gdbarch->${function} (${actual});\n"
1452         else
1453           printf "  return gdbarch->${function} (${actual});\n"
1454         fi
1455         printf "}\n"
1456         printf "\n"
1457         printf "void\n"
1458         printf "set_gdbarch_${function} (struct gdbarch *gdbarch,\n"
1459         printf "            `echo ${function} | sed -e 's/./ /g'`  gdbarch_${function}_ftype ${function})\n"
1460         printf "{\n"
1461         printf "  gdbarch->${function} = ${function};\n"
1462         printf "}\n"
1463     elif class_is_variable_p
1464     then
1465         printf "\n"
1466         printf "${returntype}\n"
1467         printf "gdbarch_${function} (struct gdbarch *gdbarch)\n"
1468         printf "{\n"
1469         if [ "${invalid_p}" = "0" ]
1470         then
1471             printf "  /* Skip verify of ${function}, invalid_p == 0 */\n"
1472         elif [ "${invalid_p}" ]
1473         then
1474           printf "  if (${invalid_p})\n"
1475           printf "    internal_error (__FILE__, __LINE__,\n"
1476           printf "                    \"gdbarch: gdbarch_${function} invalid\");\n"
1477         elif [ "${predefault}" ]
1478         then
1479           printf "  if (gdbarch->${function} == ${predefault})\n"
1480           printf "    internal_error (__FILE__, __LINE__,\n"
1481           printf "                    \"gdbarch: gdbarch_${function} invalid\");\n"
1482         fi
1483         printf "  if (gdbarch_debug >= 2)\n"
1484         printf "    fprintf_unfiltered (gdb_stdlog, \"gdbarch_${function} called\\\\n\");\n"
1485         printf "  return gdbarch->${function};\n"
1486         printf "}\n"
1487         printf "\n"
1488         printf "void\n"
1489         printf "set_gdbarch_${function} (struct gdbarch *gdbarch,\n"
1490         printf "            `echo ${function} | sed -e 's/./ /g'`  ${returntype} ${function})\n"
1491         printf "{\n"
1492         printf "  gdbarch->${function} = ${function};\n"
1493         printf "}\n"
1494     elif class_is_info_p
1495     then
1496         printf "\n"
1497         printf "${returntype}\n"
1498         printf "gdbarch_${function} (struct gdbarch *gdbarch)\n"
1499         printf "{\n"
1500         printf "  if (gdbarch_debug >= 2)\n"
1501         printf "    fprintf_unfiltered (gdb_stdlog, \"gdbarch_${function} called\\\\n\");\n"
1502         printf "  return gdbarch->${function};\n"
1503         printf "}\n"
1504     fi
1505 done
1506
1507 # All the trailing guff
1508 cat <<EOF
1509
1510
1511 /* Keep a registry of per-architecture data-pointers required by GDB
1512    modules. */
1513
1514 struct gdbarch_data
1515 {
1516   unsigned index;
1517   gdbarch_data_init_ftype *init;
1518   gdbarch_data_free_ftype *free;
1519 };
1520
1521 struct gdbarch_data_registration
1522 {
1523   struct gdbarch_data *data;
1524   struct gdbarch_data_registration *next;
1525 };
1526
1527 struct gdbarch_data_registry
1528 {
1529   unsigned nr;
1530   struct gdbarch_data_registration *registrations;
1531 };
1532
1533 struct gdbarch_data_registry gdbarch_data_registry =
1534 {
1535   0, NULL,
1536 };
1537
1538 struct gdbarch_data *
1539 register_gdbarch_data (gdbarch_data_init_ftype *init,
1540                        gdbarch_data_free_ftype *free)
1541 {
1542   struct gdbarch_data_registration **curr;
1543   for (curr = &gdbarch_data_registry.registrations;
1544        (*curr) != NULL;
1545        curr = &(*curr)->next);
1546   (*curr) = XMALLOC (struct gdbarch_data_registration);
1547   (*curr)->next = NULL;
1548   (*curr)->data = XMALLOC (struct gdbarch_data);
1549   (*curr)->data->index = gdbarch_data_registry.nr++;
1550   (*curr)->data->init = init;
1551   (*curr)->data->free = free;
1552   return (*curr)->data;
1553 }
1554
1555
1556 /* Walk through all the registered users initializing each in turn. */
1557
1558 static void
1559 init_gdbarch_data (struct gdbarch *gdbarch)
1560 {
1561   struct gdbarch_data_registration *rego;
1562   for (rego = gdbarch_data_registry.registrations;
1563        rego != NULL;
1564        rego = rego->next)
1565     {
1566       struct gdbarch_data *data = rego->data;
1567       gdb_assert (data->index < gdbarch->nr_data);
1568       if (data->init != NULL)
1569         {
1570           void *pointer = data->init (gdbarch);
1571           set_gdbarch_data (gdbarch, data, pointer);
1572         }
1573     }
1574 }
1575
1576 /* Create/delete the gdbarch data vector. */
1577
1578 static void
1579 alloc_gdbarch_data (struct gdbarch *gdbarch)
1580 {
1581   gdb_assert (gdbarch->data == NULL);
1582   gdbarch->nr_data = gdbarch_data_registry.nr;
1583   gdbarch->data = xcalloc (gdbarch->nr_data, sizeof (void*));
1584 }
1585
1586 static void
1587 free_gdbarch_data (struct gdbarch *gdbarch)
1588 {
1589   struct gdbarch_data_registration *rego;
1590   gdb_assert (gdbarch->data != NULL);
1591   for (rego = gdbarch_data_registry.registrations;
1592        rego != NULL;
1593        rego = rego->next)
1594     {
1595       struct gdbarch_data *data = rego->data;
1596       gdb_assert (data->index < gdbarch->nr_data);
1597       if (data->free != NULL && gdbarch->data[data->index] != NULL)
1598         {
1599           data->free (gdbarch, gdbarch->data[data->index]);
1600           gdbarch->data[data->index] = NULL;
1601         }
1602     }
1603   xfree (gdbarch->data);
1604   gdbarch->data = NULL;
1605 }
1606
1607
1608 /* Initialize the current value of thee specified per-architecture
1609    data-pointer. */
1610
1611 void
1612 set_gdbarch_data (struct gdbarch *gdbarch,
1613                   struct gdbarch_data *data,
1614                   void *pointer)
1615 {
1616   gdb_assert (data->index < gdbarch->nr_data);
1617   if (data->free != NULL && gdbarch->data[data->index] != NULL)
1618     data->free (gdbarch, gdbarch->data[data->index]);
1619   gdbarch->data[data->index] = pointer;
1620 }
1621
1622 /* Return the current value of the specified per-architecture
1623    data-pointer. */
1624
1625 void *
1626 gdbarch_data (struct gdbarch_data *data)
1627 {
1628   gdb_assert (data->index < current_gdbarch->nr_data);
1629   return current_gdbarch->data[data->index];
1630 }
1631
1632
1633
1634 /* Keep a registry of swapped data required by GDB modules. */
1635
1636 struct gdbarch_swap
1637 {
1638   void *swap;
1639   struct gdbarch_swap_registration *source;
1640   struct gdbarch_swap *next;
1641 };
1642
1643 struct gdbarch_swap_registration
1644 {
1645   void *data;
1646   unsigned long sizeof_data;
1647   gdbarch_swap_ftype *init;
1648   struct gdbarch_swap_registration *next;
1649 };
1650
1651 struct gdbarch_swap_registry
1652 {
1653   int nr;
1654   struct gdbarch_swap_registration *registrations;
1655 };
1656
1657 struct gdbarch_swap_registry gdbarch_swap_registry =
1658 {
1659   0, NULL,
1660 };
1661
1662 void
1663 register_gdbarch_swap (void *data,
1664                        unsigned long sizeof_data,
1665                        gdbarch_swap_ftype *init)
1666 {
1667   struct gdbarch_swap_registration **rego;
1668   for (rego = &gdbarch_swap_registry.registrations;
1669        (*rego) != NULL;
1670        rego = &(*rego)->next);
1671   (*rego) = XMALLOC (struct gdbarch_swap_registration);
1672   (*rego)->next = NULL;
1673   (*rego)->init = init;
1674   (*rego)->data = data;
1675   (*rego)->sizeof_data = sizeof_data;
1676 }
1677
1678
1679 static void
1680 init_gdbarch_swap (struct gdbarch *gdbarch)
1681 {
1682   struct gdbarch_swap_registration *rego;
1683   struct gdbarch_swap **curr = &gdbarch->swap;
1684   for (rego = gdbarch_swap_registry.registrations;
1685        rego != NULL;
1686        rego = rego->next)
1687     {
1688       if (rego->data != NULL)
1689         {
1690           (*curr) = XMALLOC (struct gdbarch_swap);
1691           (*curr)->source = rego;
1692           (*curr)->swap = xmalloc (rego->sizeof_data);
1693           (*curr)->next = NULL;
1694           memset (rego->data, 0, rego->sizeof_data);
1695           curr = &(*curr)->next;
1696         }
1697       if (rego->init != NULL)
1698         rego->init ();
1699     }
1700 }
1701
1702 static void
1703 swapout_gdbarch_swap (struct gdbarch *gdbarch)
1704 {
1705   struct gdbarch_swap *curr;
1706   for (curr = gdbarch->swap;
1707        curr != NULL;
1708        curr = curr->next)
1709     memcpy (curr->swap, curr->source->data, curr->source->sizeof_data);
1710 }
1711
1712 static void
1713 swapin_gdbarch_swap (struct gdbarch *gdbarch)
1714 {
1715   struct gdbarch_swap *curr;
1716   for (curr = gdbarch->swap;
1717        curr != NULL;
1718        curr = curr->next)
1719     memcpy (curr->source->data, curr->swap, curr->source->sizeof_data);
1720 }
1721
1722
1723 /* Keep a registry of the architectures known by GDB. */
1724
1725 struct gdbarch_registration
1726 {
1727   enum bfd_architecture bfd_architecture;
1728   gdbarch_init_ftype *init;
1729   gdbarch_dump_tdep_ftype *dump_tdep;
1730   struct gdbarch_list *arches;
1731   struct gdbarch_registration *next;
1732 };
1733
1734 static struct gdbarch_registration *gdbarch_registry = NULL;
1735
1736 static void
1737 append_name (const char ***buf, int *nr, const char *name)
1738 {
1739   *buf = xrealloc (*buf, sizeof (char**) * (*nr + 1));
1740   (*buf)[*nr] = name;
1741   *nr += 1;
1742 }
1743
1744 const char **
1745 gdbarch_printable_names (void)
1746 {
1747   if (GDB_MULTI_ARCH)
1748     {
1749       /* Accumulate a list of names based on the registed list of
1750          architectures. */
1751       enum bfd_architecture a;
1752       int nr_arches = 0;
1753       const char **arches = NULL;
1754       struct gdbarch_registration *rego;
1755       for (rego = gdbarch_registry;
1756            rego != NULL;
1757            rego = rego->next)
1758         {
1759           const struct bfd_arch_info *ap;
1760           ap = bfd_lookup_arch (rego->bfd_architecture, 0);
1761           if (ap == NULL)
1762             internal_error (__FILE__, __LINE__,
1763                             "gdbarch_architecture_names: multi-arch unknown");
1764           do
1765             {
1766               append_name (&arches, &nr_arches, ap->printable_name);
1767               ap = ap->next;
1768             }
1769           while (ap != NULL);
1770         }
1771       append_name (&arches, &nr_arches, NULL);
1772       return arches;
1773     }
1774   else
1775     /* Just return all the architectures that BFD knows.  Assume that
1776        the legacy architecture framework supports them. */
1777     return bfd_arch_list ();
1778 }
1779
1780
1781 void
1782 gdbarch_register (enum bfd_architecture bfd_architecture,
1783                   gdbarch_init_ftype *init,
1784                   gdbarch_dump_tdep_ftype *dump_tdep)
1785 {
1786   struct gdbarch_registration **curr;
1787   const struct bfd_arch_info *bfd_arch_info;
1788   /* Check that BFD recognizes this architecture */
1789   bfd_arch_info = bfd_lookup_arch (bfd_architecture, 0);
1790   if (bfd_arch_info == NULL)
1791     {
1792       internal_error (__FILE__, __LINE__,
1793                       "gdbarch: Attempt to register unknown architecture (%d)",
1794                       bfd_architecture);
1795     }
1796   /* Check that we haven't seen this architecture before */
1797   for (curr = &gdbarch_registry;
1798        (*curr) != NULL;
1799        curr = &(*curr)->next)
1800     {
1801       if (bfd_architecture == (*curr)->bfd_architecture)
1802         internal_error (__FILE__, __LINE__,
1803                         "gdbarch: Duplicate registraration of architecture (%s)",
1804                         bfd_arch_info->printable_name);
1805     }
1806   /* log it */
1807   if (gdbarch_debug)
1808     fprintf_unfiltered (gdb_stdlog, "register_gdbarch_init (%s, 0x%08lx)\n",
1809                         bfd_arch_info->printable_name,
1810                         (long) init);
1811   /* Append it */
1812   (*curr) = XMALLOC (struct gdbarch_registration);
1813   (*curr)->bfd_architecture = bfd_architecture;
1814   (*curr)->init = init;
1815   (*curr)->dump_tdep = dump_tdep;
1816   (*curr)->arches = NULL;
1817   (*curr)->next = NULL;
1818   /* When non- multi-arch, install whatever target dump routine we've
1819      been provided - hopefully that routine has been written correctly
1820      and works regardless of multi-arch. */
1821   if (!GDB_MULTI_ARCH && dump_tdep != NULL
1822       && startup_gdbarch.dump_tdep == NULL)
1823     startup_gdbarch.dump_tdep = dump_tdep;
1824 }
1825
1826 void
1827 register_gdbarch_init (enum bfd_architecture bfd_architecture,
1828                        gdbarch_init_ftype *init)
1829 {
1830   gdbarch_register (bfd_architecture, init, NULL);
1831 }
1832
1833
1834 /* Look for an architecture using gdbarch_info.  Base search on only
1835    BFD_ARCH_INFO and BYTE_ORDER. */
1836
1837 struct gdbarch_list *
1838 gdbarch_list_lookup_by_info (struct gdbarch_list *arches,
1839                              const struct gdbarch_info *info)
1840 {
1841   for (; arches != NULL; arches = arches->next)
1842     {
1843       if (info->bfd_arch_info != arches->gdbarch->bfd_arch_info)
1844         continue;
1845       if (info->byte_order != arches->gdbarch->byte_order)
1846         continue;
1847       return arches;
1848     }
1849   return NULL;
1850 }
1851
1852
1853 /* Update the current architecture. Return ZERO if the update request
1854    failed. */
1855
1856 int
1857 gdbarch_update_p (struct gdbarch_info info)
1858 {
1859   struct gdbarch *new_gdbarch;
1860   struct gdbarch_list **list;
1861   struct gdbarch_registration *rego;
1862
1863   /* Fill in any missing bits. Most important is the bfd_architecture
1864      which is used to select the target architecture. */
1865   if (info.bfd_architecture == bfd_arch_unknown)
1866     {
1867       if (info.bfd_arch_info != NULL)
1868         info.bfd_architecture = info.bfd_arch_info->arch;
1869       else if (info.abfd != NULL)
1870         info.bfd_architecture = bfd_get_arch (info.abfd);
1871       /* FIXME - should query BFD for its default architecture. */
1872       else
1873         info.bfd_architecture = current_gdbarch->bfd_arch_info->arch;
1874     }
1875   if (info.bfd_arch_info == NULL)
1876     {
1877       if (target_architecture_auto && info.abfd != NULL)
1878         info.bfd_arch_info = bfd_get_arch_info (info.abfd);
1879       else
1880         info.bfd_arch_info = current_gdbarch->bfd_arch_info;
1881     }
1882   if (info.byte_order == 0)
1883     {
1884       if (target_byte_order_auto && info.abfd != NULL)
1885         info.byte_order = (bfd_big_endian (info.abfd) ? BIG_ENDIAN
1886                            : bfd_little_endian (info.abfd) ? LITTLE_ENDIAN
1887                            : 0);
1888       else
1889         info.byte_order = current_gdbarch->byte_order;
1890       /* FIXME - should query BFD for its default byte-order. */
1891     }
1892   /* A default for abfd? */
1893
1894   /* Find the target that knows about this architecture. */
1895   for (rego = gdbarch_registry;
1896        rego != NULL;
1897        rego = rego->next)
1898     if (rego->bfd_architecture == info.bfd_architecture)
1899       break;
1900   if (rego == NULL)
1901     {
1902       if (gdbarch_debug)
1903         fprintf_unfiltered (gdb_stdlog, "gdbarch_update: No matching architecture\\n");
1904       return 0;
1905     }
1906
1907   if (gdbarch_debug)
1908     {
1909       fprintf_unfiltered (gdb_stdlog,
1910                           "gdbarch_update: info.bfd_architecture %d (%s)\\n",
1911                           info.bfd_architecture,
1912                           bfd_lookup_arch (info.bfd_architecture, 0)->printable_name);
1913       fprintf_unfiltered (gdb_stdlog,
1914                           "gdbarch_update: info.bfd_arch_info %s\\n",
1915                           (info.bfd_arch_info != NULL
1916                            ? info.bfd_arch_info->printable_name
1917                            : "(null)"));
1918       fprintf_unfiltered (gdb_stdlog,
1919                           "gdbarch_update: info.byte_order %d (%s)\\n",
1920                           info.byte_order,
1921                           (info.byte_order == BIG_ENDIAN ? "big"
1922                            : info.byte_order == LITTLE_ENDIAN ? "little"
1923                            : "default"));
1924       fprintf_unfiltered (gdb_stdlog,
1925                           "gdbarch_update: info.abfd 0x%lx\\n",
1926                           (long) info.abfd);
1927       fprintf_unfiltered (gdb_stdlog,
1928                           "gdbarch_update: info.tdep_info 0x%lx\\n",
1929                           (long) info.tdep_info);
1930     }
1931
1932   /* Ask the target for a replacement architecture. */
1933   new_gdbarch = rego->init (info, rego->arches);
1934
1935   /* Did the target like it?  No. Reject the change. */
1936   if (new_gdbarch == NULL)
1937     {
1938       if (gdbarch_debug)
1939         fprintf_unfiltered (gdb_stdlog, "gdbarch_update: Target rejected architecture\\n");
1940       return 0;
1941     }
1942
1943   /* Did the architecture change?  No. Do nothing. */
1944   if (current_gdbarch == new_gdbarch)
1945     {
1946       if (gdbarch_debug)
1947         fprintf_unfiltered (gdb_stdlog, "gdbarch_update: Architecture 0x%08lx (%s) unchanged\\n",
1948                             (long) new_gdbarch,
1949                             new_gdbarch->bfd_arch_info->printable_name);
1950       return 1;
1951     }
1952
1953   /* Swap all data belonging to the old target out */
1954   swapout_gdbarch_swap (current_gdbarch);
1955
1956   /* Is this a pre-existing architecture?  Yes. Swap it in.  */
1957   for (list = &rego->arches;
1958        (*list) != NULL;
1959        list = &(*list)->next)
1960     {
1961       if ((*list)->gdbarch == new_gdbarch)
1962         {
1963           if (gdbarch_debug)
1964             fprintf_unfiltered (gdb_stdlog,
1965                                 "gdbarch_update: Previous architecture 0x%08lx (%s) selected\\n",
1966                                 (long) new_gdbarch,
1967                                 new_gdbarch->bfd_arch_info->printable_name);
1968           current_gdbarch = new_gdbarch;
1969           swapin_gdbarch_swap (new_gdbarch);
1970           return 1;
1971         }
1972     }
1973
1974   /* Append this new architecture to this targets list. */
1975   (*list) = XMALLOC (struct gdbarch_list);
1976   (*list)->next = NULL;
1977   (*list)->gdbarch = new_gdbarch;
1978
1979   /* Switch to this new architecture.  Dump it out. */
1980   current_gdbarch = new_gdbarch;
1981   if (gdbarch_debug)
1982     {
1983       fprintf_unfiltered (gdb_stdlog,
1984                           "gdbarch_update: New architecture 0x%08lx (%s) selected\\n",
1985                           (long) new_gdbarch,
1986                           new_gdbarch->bfd_arch_info->printable_name);
1987     }
1988
1989   /* Check that the newly installed architecture is valid.  Plug in
1990      any post init values.  */
1991   new_gdbarch->dump_tdep = rego->dump_tdep;
1992   verify_gdbarch (new_gdbarch);
1993
1994   /* Initialize the per-architecture memory (swap) areas.
1995      CURRENT_GDBARCH must be update before these modules are
1996      called. */
1997   init_gdbarch_swap (new_gdbarch);
1998
1999   /* Initialize the per-architecture data-pointer of all parties that
2000      registered an interest in this architecture.  CURRENT_GDBARCH
2001      must be updated before these modules are called. */
2002   init_gdbarch_data (new_gdbarch);
2003
2004   if (gdbarch_debug)
2005     gdbarch_dump (current_gdbarch, gdb_stdlog);
2006
2007   return 1;
2008 }
2009
2010
2011 /* Disassembler */
2012
2013 /* Pointer to the target-dependent disassembly function.  */
2014 int (*tm_print_insn) (bfd_vma, disassemble_info *);
2015 disassemble_info tm_print_insn_info;
2016
2017
2018 extern void _initialize_gdbarch (void);
2019
2020 void
2021 _initialize_gdbarch (void)
2022 {
2023   struct cmd_list_element *c;
2024
2025   INIT_DISASSEMBLE_INFO_NO_ARCH (tm_print_insn_info, gdb_stdout, (fprintf_ftype)fprintf_filtered);
2026   tm_print_insn_info.flavour = bfd_target_unknown_flavour;
2027   tm_print_insn_info.read_memory_func = dis_asm_read_memory;
2028   tm_print_insn_info.memory_error_func = dis_asm_memory_error;
2029   tm_print_insn_info.print_address_func = dis_asm_print_address;
2030
2031   add_show_from_set (add_set_cmd ("arch",
2032                                   class_maintenance,
2033                                   var_zinteger,
2034                                   (char *)&gdbarch_debug,
2035                                   "Set architecture debugging.\\n\\
2036 When non-zero, architecture debugging is enabled.", &setdebuglist),
2037                      &showdebuglist);
2038   c = add_set_cmd ("archdebug",
2039                    class_maintenance,
2040                    var_zinteger,
2041                    (char *)&gdbarch_debug,
2042                    "Set architecture debugging.\\n\\
2043 When non-zero, architecture debugging is enabled.", &setlist);
2044
2045   deprecate_cmd (c, "set debug arch");
2046   deprecate_cmd (add_show_from_set (c, &showlist), "show debug arch");
2047 }
2048 EOF
2049
2050 # close things off
2051 exec 1>&2
2052 #../move-if-change new-gdbarch.c gdbarch.c
2053 compare_new gdbarch.c