gdb/gdbarch.sh

   1 #!/bin/sh -u
   2
   3 # Architecture commands for GDB, the GNU debugger.
   4 # Copyright 1998-2000 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 #
 484 v:2:TARGET_FLOAT_FORMAT:const struct floatformat *:float_format::::::default_float_format (gdbarch)
 485 v:2:TARGET_DOUBLE_FORMAT:const struct floatformat *:double_format::::::default_double_format (gdbarch)
 486 v:2:TARGET_LONG_DOUBLE_FORMAT:const struct floatformat *:long_double_format::::::&floatformat_unknown
 487 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
 488 EOF
 489 }
 490
 491 #
 492 # The .log file
 493 #
 494 exec > new-gdbarch.log
 495 function_list | while do_read
 496 do
 497     cat <<EOF
 498 ${class} ${macro}(${actual})
 499   ${returntype} ${function} ($formal)${attrib}
 500 EOF
 501     for r in ${read}
 502     do
 503         eval echo \"\ \ \ \ ${r}=\${${r}}\"
 504     done
 505 #    #fallbackdefault=${fallbackdefault}
 506 #    #valid_p=${valid_p}
 507 #EOF
 508     if class_is_predicate_p && fallback_default_p
 509     then
 510         echo "Error: predicate function ${macro} can not have a non- multi-arch default" 1>&2
 511         kill $$
 512         exit 1
 513     fi
 514     if [ "${invalid_p}" = "0" -a "${postdefault}" != "" ]
 515     then
 516         echo "Error: postdefault is useless when invalid_p=0" 1>&2
 517         kill $$
 518         exit 1
 519     fi
 520     echo ""
 521 done
 522
 523 exec 1>&2
 524 compare_new gdbarch.log
 525
 526
 527 copyright ()
 528 {
 529 cat <<EOF
 530 /* *INDENT-OFF* */ /* THIS FILE IS GENERATED */
 531
 532 /* Dynamic architecture support for GDB, the GNU debugger.
 533    Copyright 1998-1999, Free Software Foundation, Inc.
 534
 535    This file is part of GDB.
 536
 537    This program is free software; you can redistribute it and/or modify
 538    it under the terms of the GNU General Public License as published by
 539    the Free Software Foundation; either version 2 of the License, or
 540    (at your option) any later version.
 541
 542    This program is distributed in the hope that it will be useful,
 543    but WITHOUT ANY WARRANTY; without even the implied warranty of
 544    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 545    GNU General Public License for more details.
 546
 547    You should have received a copy of the GNU General Public License
 548    along with this program; if not, write to the Free Software
 549    Foundation, Inc., 59 Temple Place - Suite 330,
 550    Boston, MA 02111-1307, USA.  */
 551
 552 /* This file was created with the aid of \`\`gdbarch.sh''.
 553
 554    The Bourne shell script \`\`gdbarch.sh'' creates the files
 555    \`\`new-gdbarch.c'' and \`\`new-gdbarch.h and then compares them
 556    against the existing \`\`gdbarch.[hc]''.  Any differences found
 557    being reported.
 558
 559    If editing this file, please also run gdbarch.sh and merge any
 560    changes into that script. Conversely, when making sweeping changes
 561    to this file, modifying gdbarch.sh and using its output may prove
 562    easier. */
 563
 564 EOF
 565 }
 566
 567 #
 568 # The .h file
 569 #
 570
 571 exec > new-gdbarch.h
 572 copyright
 573 cat <<EOF
 574 #ifndef GDBARCH_H
 575 #define GDBARCH_H
 576
 577 struct frame_info;
 578 struct value;
 579
 580
 581 extern struct gdbarch *current_gdbarch;
 582
 583
 584 /* If any of the following are defined, the target wasn't correctly
 585    converted. */
 586
 587 #if GDB_MULTI_ARCH
 588 #if defined (EXTRA_FRAME_INFO)
 589 #error "EXTRA_FRAME_INFO: replaced by struct frame_extra_info"
 590 #endif
 591 #endif
 592
 593 #if GDB_MULTI_ARCH
 594 #if defined (FRAME_FIND_SAVED_REGS)
 595 #error "FRAME_FIND_SAVED_REGS: replaced by FRAME_INIT_SAVED_REGS"
 596 #endif
 597 #endif
 598 EOF
 599
 600 # function typedef's
 601 printf "\n"
 602 printf "\n"
 603 printf "/* The following are pre-initialized by GDBARCH. */\n"
 604 function_list | while do_read
 605 do
 606     if class_is_info_p
 607     then
 608         printf "\n"
 609         printf "extern ${returntype} gdbarch_${function} (struct gdbarch *gdbarch);\n"
 610         printf "/* set_gdbarch_${function}() - not applicable - pre-initialized. */\n"
 611         printf "#if GDB_MULTI_ARCH\n"
 612         printf "#if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (${macro})\n"
 613         printf "#define ${macro} (gdbarch_${function} (current_gdbarch))\n"
 614         printf "#endif\n"
 615         printf "#endif\n"
 616     fi
 617 done
 618
 619 # function typedef's
 620 printf "\n"
 621 printf "\n"
 622 printf "/* The following are initialized by the target dependent code. */\n"
 623 function_list | while do_read
 624 do
 625     if [ "${comment}" ]
 626     then
 627         echo "${comment}" | sed \
 628             -e '2 s,#,/*,' \
 629             -e '3,$ s,#,  ,' \
 630             -e '$ s,$, */,'
 631     fi
 632     if class_is_predicate_p
 633     then
 634         printf "\n"
 635         printf "#if defined (${macro})\n"
 636         printf "/* Legacy for systems yet to multi-arch ${macro} */\n"
 637 #       printf "#if (GDB_MULTI_ARCH <= GDB_MULTI_ARCH_PARTIAL) && defined (${macro})\n"
 638         printf "#define ${macro}_P() (1)\n"
 639         printf "#endif\n"
 640         printf "\n"
 641         printf "/* Default predicate for non- multi-arch targets. */\n"
 642         printf "#if (!GDB_MULTI_ARCH) && !defined (${macro}_P)\n"
 643         printf "#define ${macro}_P() (0)\n"
 644         printf "#endif\n"
 645         printf "\n"
 646         printf "extern int gdbarch_${function}_p (struct gdbarch *gdbarch);\n"
 647         printf "#if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (${macro}_P)\n"
 648         printf "#define ${macro}_P() (gdbarch_${function}_p (current_gdbarch))\n"
 649         printf "#endif\n"
 650     fi
 651     if class_is_variable_p
 652     then
 653         if fallback_default_p || class_is_predicate_p
 654         then
 655             printf "\n"
 656             printf "/* Default (value) for non- multi-arch platforms. */\n"
 657             printf "#if (!GDB_MULTI_ARCH) && !defined (${macro})\n"
 658             echo "#define ${macro} (${fallbackdefault})" \
 659                 | sed -e 's/\([^a-z_]\)\(gdbarch[^a-z_]\)/\1current_\2/g'
 660             printf "#endif\n"
 661         fi
 662         printf "\n"
 663         printf "extern ${returntype} gdbarch_${function} (struct gdbarch *gdbarch);\n"
 664         printf "extern void set_gdbarch_${function} (struct gdbarch *gdbarch, ${returntype} ${function});\n"
 665         printf "#if GDB_MULTI_ARCH\n"
 666         printf "#if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (${macro})\n"
 667         printf "#define ${macro} (gdbarch_${function} (current_gdbarch))\n"
 668         printf "#endif\n"
 669         printf "#endif\n"
 670     fi
 671     if class_is_function_p
 672     then
 673         if fallback_default_p || class_is_predicate_p
 674         then
 675             printf "\n"
 676             printf "/* Default (function) for non- multi-arch platforms. */\n"
 677             printf "#if (!GDB_MULTI_ARCH) && !defined (${macro})\n"
 678             if [ "${fallbackdefault}" = "0" ]
 679             then
 680                 printf "#define ${macro}(${actual}) (internal_error (\"${macro}\"), 0)\n"
 681             else
 682                 # FIXME: Should be passing current_gdbarch through!
 683                 echo "#define ${macro}(${actual}) (${fallbackdefault} (${actual}))" \
 684                     | sed -e 's/\([^a-z_]\)\(gdbarch[^a-z_]\)/\1current_\2/g'
 685             fi
 686             printf "#endif\n"
 687         fi
 688         printf "\n"
 689         printf "typedef ${returntype} (gdbarch_${function}_ftype) (${formal});\n"
 690         if [ "${formal}" = "void" ]
 691         then
 692           printf "extern ${returntype} gdbarch_${function} (struct gdbarch *gdbarch);\n"
 693         else
 694           printf "extern ${returntype} gdbarch_${function} (struct gdbarch *gdbarch, ${formal});\n"
 695         fi
 696         printf "extern void set_gdbarch_${function} (struct gdbarch *gdbarch, gdbarch_${function}_ftype *${function});\n"
 697         printf "#if GDB_MULTI_ARCH\n"
 698         printf "#if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (${macro})\n"
 699         if [ "${actual}" = "" ]
 700         then
 701           printf "#define ${macro}() (gdbarch_${function} (current_gdbarch))\n"
 702         elif [ "${actual}" = "-" ]
 703         then
 704           printf "#define ${macro} (gdbarch_${function} (current_gdbarch))\n"
 705         else
 706           printf "#define ${macro}(${actual}) (gdbarch_${function} (current_gdbarch, ${actual}))\n"
 707         fi
 708         printf "#endif\n"
 709         printf "#endif\n"
 710     fi
 711 done
 712
 713 # close it off
 714 cat <<EOF
 715
 716 extern struct gdbarch_tdep *gdbarch_tdep (struct gdbarch *gdbarch);
 717
 718
 719 /* Mechanism for co-ordinating the selection of a specific
 720    architecture.
 721
 722    GDB targets (*-tdep.c) can register an interest in a specific
 723    architecture.  Other GDB components can register a need to maintain
 724    per-architecture data.
 725
 726    The mechanisms below ensures that there is only a loose connection
 727    between the set-architecture command and the various GDB
 728    components.  Each component can independently register their need
 729    to maintain architecture specific data with gdbarch.
 730
 731    Pragmatics:
 732
 733    Previously, a single TARGET_ARCHITECTURE_HOOK was provided.  It
 734    didn't scale.
 735
 736    The more traditional mega-struct containing architecture specific
 737    data for all the various GDB components was also considered.  Since
 738    GDB is built from a variable number of (fairly independent)
 739    components it was determined that the global aproach was not
 740    applicable. */
 741
 742
 743 /* Register a new architectural family with GDB.
 744
 745    Register support for the specified ARCHITECTURE with GDB.  When
 746    gdbarch determines that the specified architecture has been
 747    selected, the corresponding INIT function is called.
 748
 749    --
 750
 751    The INIT function takes two parameters: INFO which contains the
 752    information available to gdbarch about the (possibly new)
 753    architecture; ARCHES which is a list of the previously created
 754    \`\`struct gdbarch'' for this architecture.
 755
 756    The INIT function parameter INFO shall, as far as possible, be
 757    pre-initialized with information obtained from INFO.ABFD or
 758    previously selected architecture (if similar).  INIT shall ensure
 759    that the INFO.BYTE_ORDER is non-zero.
 760
 761    The INIT function shall return any of: NULL - indicating that it
 762    doesn't recognize the selected architecture; an existing \`\`struct
 763    gdbarch'' from the ARCHES list - indicating that the new
 764    architecture is just a synonym for an earlier architecture (see
 765    gdbarch_list_lookup_by_info()); a newly created \`\`struct gdbarch''
 766    - that describes the selected architecture (see gdbarch_alloc()).
 767
 768    The DUMP_TDEP function shall print out all target specific values.
 769    Care should be taken to ensure that the function works in both the
 770    multi-arch and non- multi-arch cases. */
 771
 772 struct gdbarch_list
 773 {
 774   struct gdbarch *gdbarch;
 775   struct gdbarch_list *next;
 776 };
 777
 778 struct gdbarch_info
 779 {
 780   /* Use default: bfd_arch_unknown (ZERO). */
 781   enum bfd_architecture bfd_architecture;
 782
 783   /* Use default: NULL (ZERO). */
 784   const struct bfd_arch_info *bfd_arch_info;
 785
 786   /* Use default: 0 (ZERO). */
 787   int byte_order;
 788
 789   /* Use default: NULL (ZERO). */
 790   bfd *abfd;
 791
 792   /* Use default: NULL (ZERO). */
 793   struct gdbarch_tdep_info *tdep_info;
 794 };
 795
 796 typedef struct gdbarch *(gdbarch_init_ftype) (struct gdbarch_info info, struct gdbarch_list *arches);
 797 typedef void (gdbarch_dump_tdep_ftype) (struct gdbarch *gdbarch, struct ui_file *file);
 798
 799 /* DEPRECATED - use gdbarch_register() */
 800 extern void register_gdbarch_init (enum bfd_architecture architecture, gdbarch_init_ftype *);
 801
 802 extern void gdbarch_register (enum bfd_architecture architecture,
 803                               gdbarch_init_ftype *,
 804                               gdbarch_dump_tdep_ftype *);
 805
 806
 807 /* Return a freshly allocated, NULL terminated, array of the valid
 808    architecture names.  Since architectures are registered during the
 809    _initialize phase this function only returns useful information
 810    once initialization has been completed. */
 811
 812 extern const char **gdbarch_printable_names (void);
 813
 814
 815 /* Helper function.  Search the list of ARCHES for a GDBARCH that
 816    matches the information provided by INFO. */
 817
 818 extern struct gdbarch_list *gdbarch_list_lookup_by_info (struct gdbarch_list *arches,  const struct gdbarch_info *info);
 819
 820
 821 /* Helper function.  Create a preliminary \`\`struct gdbarch''.  Perform
 822    basic initialization using values obtained from the INFO andTDEP
 823    parameters.  set_gdbarch_*() functions are called to complete the
 824    initialization of the object. */
 825
 826 extern struct gdbarch *gdbarch_alloc (const struct gdbarch_info *info, struct gdbarch_tdep *tdep);
 827
 828
 829 /* Helper function.  Free a partially-constructed \`\`struct gdbarch''.
 830    It is assumed that the caller freeds the \`\`struct
 831    gdbarch_tdep''. */
 832
 833 extern void gdbarch_free (struct gdbarch *);
 834
 835
 836 /* Helper function. Force an update of the current architecture.  Used
 837    by legacy targets that have added their own target specific
 838    architecture manipulation commands.
 839
 840    The INFO parameter shall be fully initialized (\`\`memset (&INFO,
 841    sizeof (info), 0)'' set relevant fields) before gdbarch_update_p()
 842    is called.  gdbarch_update_p() shall initialize any \`\`default''
 843    fields using information obtained from the previous architecture or
 844    INFO.ABFD (if specified) before calling the corresponding
 845    architectures INIT function.
 846
 847    Returns non-zero if the update succeeds */
 848
 849 extern int gdbarch_update_p (struct gdbarch_info info);
 850
 851
 852
 853 /* Register per-architecture data-pointer.
 854
 855    Reserve space for a per-architecture data-pointer.  An identifier
 856    for the reserved data-pointer is returned.  That identifer should
 857    be saved in a local static.
 858
 859    When a new architecture is selected, INIT() is called.  When a
 860    previous architecture is re-selected, the per-architecture
 861    data-pointer for that previous architecture is restored (INIT() is
 862    not called).
 863
 864    INIT() shall return the initial value for the per-architecture
 865    data-pointer for the current architecture.
 866
 867    Multiple registrarants for any architecture are allowed (and
 868    strongly encouraged).  */
 869
 870 typedef void *(gdbarch_data_ftype) (void);
 871 extern struct gdbarch_data *register_gdbarch_data (gdbarch_data_ftype *init);
 872
 873 /* Return the value of the per-architecture data-pointer for the
 874    current architecture. */
 875
 876 extern void *gdbarch_data (struct gdbarch_data*);
 877
 878
 879
 880 /* Register per-architecture memory region.
 881
 882    Provide a memory-region swap mechanism.  Per-architecture memory
 883    region are created.  These memory regions are swapped whenever the
 884    architecture is changed.  For a new architecture, the memory region
 885    is initialized with zero (0) and the INIT function is called.
 886
 887    Memory regions are swapped / initialized in the order that they are
 888    registered.  NULL DATA and/or INIT values can be specified.
 889
 890    New code should use register_gdbarch_data(). */
 891
 892 typedef void (gdbarch_swap_ftype) (void);
 893 extern void register_gdbarch_swap (void *data, unsigned long size, gdbarch_swap_ftype *init);
 894 #define REGISTER_GDBARCH_SWAP(VAR) register_gdbarch_swap (&(VAR), sizeof ((VAR)), NULL)
 895
 896
 897
 898 /* The target-system-dependent byte order is dynamic */
 899
 900 /* TARGET_BYTE_ORDER_SELECTABLE_P determines if the target endianness
 901    is selectable at runtime.  The user can use the \`\`set endian''
 902    command to change it.  TARGET_BYTE_ORDER_AUTO is nonzero when
 903    target_byte_order should be auto-detected (from the program image
 904    say). */
 905
 906 #if GDB_MULTI_ARCH
 907 /* Multi-arch GDB is always bi-endian. */
 908 #define TARGET_BYTE_ORDER_SELECTABLE_P 1
 909 #endif
 910
 911 #ifndef TARGET_BYTE_ORDER_SELECTABLE_P
 912 /* compat - Catch old targets that define TARGET_BYTE_ORDER_SLECTABLE
 913    when they should have defined TARGET_BYTE_ORDER_SELECTABLE_P 1 */
 914 #ifdef TARGET_BYTE_ORDER_SELECTABLE
 915 #define TARGET_BYTE_ORDER_SELECTABLE_P 1
 916 #else
 917 #define TARGET_BYTE_ORDER_SELECTABLE_P 0
 918 #endif
 919 #endif
 920
 921 extern int target_byte_order;
 922 #ifdef TARGET_BYTE_ORDER_SELECTABLE
 923 /* compat - Catch old targets that define TARGET_BYTE_ORDER_SELECTABLE
 924    and expect defs.h to re-define TARGET_BYTE_ORDER. */
 925 #undef TARGET_BYTE_ORDER
 926 #endif
 927 #ifndef TARGET_BYTE_ORDER
 928 #define TARGET_BYTE_ORDER (target_byte_order + 0)
 929 #endif
 930
 931 extern int target_byte_order_auto;
 932 #ifndef TARGET_BYTE_ORDER_AUTO
 933 #define TARGET_BYTE_ORDER_AUTO (target_byte_order_auto + 0)
 934 #endif
 935
 936
 937
 938 /* The target-system-dependent BFD architecture is dynamic */
 939
 940 extern int target_architecture_auto;
 941 #ifndef TARGET_ARCHITECTURE_AUTO
 942 #define TARGET_ARCHITECTURE_AUTO (target_architecture_auto + 0)
 943 #endif
 944
 945 extern const struct bfd_arch_info *target_architecture;
 946 #ifndef TARGET_ARCHITECTURE
 947 #define TARGET_ARCHITECTURE (target_architecture + 0)
 948 #endif
 949
 950
 951 /* The target-system-dependent disassembler is semi-dynamic */
 952
 953 #include "dis-asm.h"            /* Get defs for disassemble_info */
 954
 955 extern int dis_asm_read_memory (bfd_vma memaddr, bfd_byte *myaddr,
 956                                 unsigned int len, disassemble_info *info);
 957
 958 extern void dis_asm_memory_error (int status, bfd_vma memaddr,
 959                                   disassemble_info *info);
 960
 961 extern void dis_asm_print_address (bfd_vma addr,
 962                                    disassemble_info *info);
 963
 964 extern int (*tm_print_insn) (bfd_vma, disassemble_info*);
 965 extern disassemble_info tm_print_insn_info;
 966 #ifndef TARGET_PRINT_INSN
 967 #define TARGET_PRINT_INSN(vma, info) (*tm_print_insn) (vma, info)
 968 #endif
 969 #ifndef TARGET_PRINT_INSN_INFO
 970 #define TARGET_PRINT_INSN_INFO (&tm_print_insn_info)
 971 #endif
 972
 973
 974
 975 /* Explicit test for D10V architecture.
 976    USE of these macro's is *STRONGLY* discouraged. */
 977
 978 #define GDB_TARGET_IS_D10V (TARGET_ARCHITECTURE->arch == bfd_arch_d10v)
 979
 980
 981 /* Fallback definition for EXTRACT_STRUCT_VALUE_ADDRESS */
 982 #ifndef EXTRACT_STRUCT_VALUE_ADDRESS
 983 #define EXTRACT_STRUCT_VALUE_ADDRESS_P (0)
 984 #define EXTRACT_STRUCT_VALUE_ADDRESS(X) (internal_error ("gdbarch: EXTRACT_STRUCT_VALUE_ADDRESS"), 0)
 985 #else
 986 #ifndef EXTRACT_STRUCT_VALUE_ADDRESS_P
 987 #define EXTRACT_STRUCT_VALUE_ADDRESS_P (1)
 988 #endif
 989 #endif
 990
 991
 992 /* Set the dynamic target-system-dependent parameters (architecture,
 993    byte-order, ...) using information found in the BFD */
 994
 995 extern void set_gdbarch_from_file (bfd *);
 996
 997
 998 /* Initialize the current architecture to the "first" one we find on
 999    our list.  */
1000
1001 extern void initialize_current_architecture (void);
1002
1003
1004 /* gdbarch trace variable */
1005 extern int gdbarch_debug;
1006
1007 extern void gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file);
1008
1009 #endif
1010 EOF
1011 exec 1>&2
1012 #../move-if-change new-gdbarch.h gdbarch.h
1013 compare_new gdbarch.h
1014
1015
1016 #
1017 # C file
1018 #
1019
1020 exec > new-gdbarch.c
1021 copyright
1022 cat <<EOF
1023
1024 #include "defs.h"
1025 #include "arch-utils.h"
1026
1027 #if GDB_MULTI_ARCH
1028 #include "gdbcmd.h"
1029 #include "inferior.h" /* enum CALL_DUMMY_LOCATION et.al. */
1030 #else
1031 /* Just include everything in sight so that the every old definition
1032    of macro is visible. */
1033 #include "gdb_string.h"
1034 #include <ctype.h>
1035 #include "symtab.h"
1036 #include "frame.h"
1037 #include "inferior.h"
1038 #include "breakpoint.h"
1039 #include "gdb_wait.h"
1040 #include "gdbcore.h"
1041 #include "gdbcmd.h"
1042 #include "target.h"
1043 #include "gdbthread.h"
1044 #include "annotate.h"
1045 #include "symfile.h"            /* for overlay functions */
1046 #endif
1047 #include "symcat.h"
1048
1049 #include "floatformat.h"
1050
1051 /* Static function declarations */
1052
1053 static void verify_gdbarch (struct gdbarch *gdbarch);
1054 static void init_gdbarch_data (struct gdbarch *);
1055 static void init_gdbarch_swap (struct gdbarch *);
1056 static void swapout_gdbarch_swap (struct gdbarch *);
1057 static void swapin_gdbarch_swap (struct gdbarch *);
1058
1059 /* Convenience macro for allocting typesafe memory. */
1060
1061 #ifndef XMALLOC
1062 #define XMALLOC(TYPE) (TYPE*) xmalloc (sizeof (TYPE))
1063 #endif
1064
1065
1066 /* Non-zero if we want to trace architecture code.  */
1067
1068 #ifndef GDBARCH_DEBUG
1069 #define GDBARCH_DEBUG 0
1070 #endif
1071 int gdbarch_debug = GDBARCH_DEBUG;
1072
1073 EOF
1074
1075 # gdbarch open the gdbarch object
1076 printf "\n"
1077 printf "/* Maintain the struct gdbarch object */\n"
1078 printf "\n"
1079 printf "struct gdbarch\n"
1080 printf "{\n"
1081 printf "  /* basic architectural information */\n"
1082 function_list | while do_read
1083 do
1084     if class_is_info_p
1085     then
1086         printf "  ${returntype} ${function};\n"
1087     fi
1088 done
1089 printf "\n"
1090 printf "  /* target specific vector. */\n"
1091 printf "  struct gdbarch_tdep *tdep;\n"
1092 printf "  gdbarch_dump_tdep_ftype *dump_tdep;\n"
1093 printf "\n"
1094 printf "  /* per-architecture data-pointers */\n"
1095 printf "  int nr_data;\n"
1096 printf "  void **data;\n"
1097 printf "\n"
1098 printf "  /* per-architecture swap-regions */\n"
1099 printf "  struct gdbarch_swap *swap;\n"
1100 printf "\n"
1101 cat <<EOF
1102   /* Multi-arch values.
1103
1104      When extending this structure you must:
1105
1106      Add the field below.
1107
1108      Declare set/get functions and define the corresponding
1109      macro in gdbarch.h.
1110
1111      gdbarch_alloc(): If zero/NULL is not a suitable default,
1112      initialize the new field.
1113
1114      verify_gdbarch(): Confirm that the target updated the field
1115      correctly.
1116
1117      gdbarch_dump(): Add a fprintf_unfiltered call so that the new
1118      field is dumped out
1119
1120      \`\`startup_gdbarch()'': Append an initial value to the static
1121      variable (base values on the host's c-type system).
1122
1123      get_gdbarch(): Implement the set/get functions (probably using
1124      the macro's as shortcuts).
1125
1126      */
1127
1128 EOF
1129 function_list | while do_read
1130 do
1131     if class_is_variable_p
1132     then
1133         printf "  ${returntype} ${function};\n"
1134     elif class_is_function_p
1135     then
1136         printf "  gdbarch_${function}_ftype *${function}${attrib};\n"
1137     fi
1138 done
1139 printf "};\n"
1140
1141 # A pre-initialized vector
1142 printf "\n"
1143 printf "\n"
1144 cat <<EOF
1145 /* The default architecture uses host values (for want of a better
1146    choice). */
1147 EOF
1148 printf "\n"
1149 printf "extern const struct bfd_arch_info bfd_default_arch_struct;\n"
1150 printf "\n"
1151 printf "struct gdbarch startup_gdbarch =\n"
1152 printf "{\n"
1153 printf "  /* basic architecture information */\n"
1154 function_list | while do_read
1155 do
1156     if class_is_info_p
1157     then
1158         printf "  ${staticdefault},\n"
1159     fi
1160 done
1161 cat <<EOF
1162   /* target specific vector and its dump routine */
1163   NULL, NULL,
1164   /*per-architecture data-pointers and swap regions */
1165   0, NULL, NULL,
1166   /* Multi-arch values */
1167 EOF
1168 function_list | while do_read
1169 do
1170     if class_is_function_p || class_is_variable_p
1171     then
1172         printf "  ${staticdefault},\n"
1173     fi
1174 done
1175 cat <<EOF
1176   /* startup_gdbarch() */
1177 };
1178
1179 struct gdbarch *current_gdbarch = &startup_gdbarch;
1180 EOF
1181
1182 # Create a new gdbarch struct
1183 printf "\n"
1184 printf "\n"
1185 cat <<EOF
1186 /* Create a new \`\`struct gdbarch'' based on information provided by
1187    \`\`struct gdbarch_info''. */
1188 EOF
1189 printf "\n"
1190 cat <<EOF
1191 struct gdbarch *
1192 gdbarch_alloc (const struct gdbarch_info *info,
1193                struct gdbarch_tdep *tdep)
1194 {
1195   struct gdbarch *gdbarch = XMALLOC (struct gdbarch);
1196   memset (gdbarch, 0, sizeof (*gdbarch));
1197
1198   gdbarch->tdep = tdep;
1199 EOF
1200 printf "\n"
1201 function_list | while do_read
1202 do
1203     if class_is_info_p
1204     then
1205         printf "  gdbarch->${function} = info->${function};\n"
1206     fi
1207 done
1208 printf "\n"
1209 printf "  /* Force the explicit initialization of these. */\n"
1210 function_list | while do_read
1211 do
1212     if class_is_function_p || class_is_variable_p
1213     then
1214         if [ "${predefault}" != "" -a "${predefault}" != "0" ]
1215         then
1216           printf "  gdbarch->${function} = ${predefault};\n"
1217         fi
1218     fi
1219 done
1220 cat <<EOF
1221   /* gdbarch_alloc() */
1222
1223   return gdbarch;
1224 }
1225 EOF
1226
1227 # Free a gdbarch struct.
1228 printf "\n"
1229 printf "\n"
1230 cat <<EOF
1231 /* Free a gdbarch struct.  This should never happen in normal
1232    operation --- once you've created a gdbarch, you keep it around.
1233    However, if an architecture's init function encounters an error
1234    building the structure, it may need to clean up a partially
1235    constructed gdbarch.  */
1236
1237 void
1238 gdbarch_free (struct gdbarch *arch)
1239 {
1240   /* At the moment, this is trivial.  */
1241   free (arch);
1242 }
1243 EOF
1244
1245 # verify a new architecture
1246 printf "\n"
1247 printf "\n"
1248 printf "/* Ensure that all values in a GDBARCH are reasonable. */\n"
1249 printf "\n"
1250 cat <<EOF
1251 static void
1252 verify_gdbarch (struct gdbarch *gdbarch)
1253 {
1254   /* Only perform sanity checks on a multi-arch target. */
1255   if (!GDB_MULTI_ARCH)
1256     return;
1257   /* fundamental */
1258   if (gdbarch->byte_order == 0)
1259     internal_error ("verify_gdbarch: byte-order unset");
1260   if (gdbarch->bfd_arch_info == NULL)
1261     internal_error ("verify_gdbarch: bfd_arch_info unset");
1262   /* Check those that need to be defined for the given multi-arch level. */
1263 EOF
1264 function_list | while do_read
1265 do
1266     if class_is_function_p || class_is_variable_p
1267     then
1268         if [ "${invalid_p}" = "0" ]
1269         then
1270             printf "  /* Skip verify of ${function}, invalid_p == 0 */\n"
1271         elif class_is_predicate_p
1272         then
1273             printf "  /* Skip verify of ${function}, has predicate */\n"
1274         # FIXME: See do_read for potential simplification
1275         elif [ "${invalid_p}" -a "${postdefault}" ]
1276         then
1277             printf "  if (${invalid_p})\n"
1278             printf "    gdbarch->${function} = ${postdefault};\n"
1279         elif [ "${predefault}" -a "${postdefault}" ]
1280         then
1281             printf "  if (gdbarch->${function} == ${predefault})\n"
1282             printf "    gdbarch->${function} = ${postdefault};\n"
1283         elif [ "${postdefault}" ]
1284         then
1285             printf "  if (gdbarch->${function} == 0)\n"
1286             printf "    gdbarch->${function} = ${postdefault};\n"
1287         elif [ "${invalid_p}" ]
1288         then
1289             printf "  if ((GDB_MULTI_ARCH >= ${level})\n"
1290             printf "      && (${invalid_p}))\n"
1291             printf "    internal_error (\"gdbarch: verify_gdbarch: ${function} invalid\");\n"
1292         elif [ "${predefault}" ]
1293         then
1294             printf "  if ((GDB_MULTI_ARCH >= ${level})\n"
1295             printf "      && (gdbarch->${function} == ${predefault}))\n"
1296             printf "    internal_error (\"gdbarch: verify_gdbarch: ${function} invalid\");\n"
1297         fi
1298     fi
1299 done
1300 cat <<EOF
1301 }
1302 EOF
1303
1304 # dump the structure
1305 printf "\n"
1306 printf "\n"
1307 cat <<EOF
1308 /* Print out the details of the current architecture. */
1309
1310 /* NOTE/WARNING: The parameter is called \`\`current_gdbarch'' so that it
1311    just happens to match the global variable \`\`current_gdbarch''.  That
1312    way macros refering to that variable get the local and not the global
1313    version - ulgh.  Once everything is parameterised with gdbarch, this
1314    will go away. */
1315
1316 void
1317 gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file)
1318 {
1319   fprintf_unfiltered (file,
1320                       "gdbarch_dump: GDB_MULTI_ARCH = %d\\n",
1321                       GDB_MULTI_ARCH);
1322 EOF
1323 function_list | while do_read
1324 do
1325     if [ "${returntype}" = "void" ]
1326     then
1327         printf "#if defined (${macro}) && GDB_MULTI_ARCH\n"
1328         printf "  /* Macro might contain \`[{}]' when not multi-arch */\n"
1329     else
1330         printf "#ifdef ${macro}\n"
1331     fi
1332     if class_is_function_p
1333     then
1334         printf "  fprintf_unfiltered (file,\n"
1335         printf "                      \"gdbarch_dump: %%s # %%s\\\\n\",\n"
1336         printf "                      \"${macro}(${actual})\",\n"
1337         printf "                      XSTRING (${macro} (${actual})));\n"
1338     else
1339         printf "  fprintf_unfiltered (file,\n"
1340         printf "                      \"gdbarch_dump: ${macro} # %%s\\\\n\",\n"
1341         printf "                      XSTRING (${macro}));\n"
1342     fi
1343     printf "#endif\n"
1344 done
1345 function_list | while do_read
1346 do
1347     printf "#ifdef ${macro}\n"
1348     if [ "${print_p}" = "()" ]
1349     then
1350         printf "  gdbarch_dump_${function} (current_gdbarch);\n"
1351     elif [ "${print_p}" = "0" ]
1352     then
1353         printf "  /* skip print of ${macro}, print_p == 0. */\n"
1354     elif [ "${print_p}" ]
1355     then
1356         printf "  if (${print_p})\n"
1357         printf "    fprintf_unfiltered (file,\n"
1358         printf "                        \"gdbarch_dump: ${macro} = %s\\\\n\",\n" "${fmt}"
1359         printf "                        ${print});\n"
1360     elif class_is_function_p
1361     then
1362         printf "  if (GDB_MULTI_ARCH)\n"
1363         printf "    fprintf_unfiltered (file,\n"
1364         printf "                        \"gdbarch_dump: ${macro} = 0x%%08lx\\\\n\",\n"
1365         printf "                        (long) current_gdbarch->${function}\n"
1366         printf "                        /*${macro} ()*/);\n"
1367     else
1368         printf "  fprintf_unfiltered (file,\n"
1369         printf "                      \"gdbarch_dump: ${macro} = %s\\\\n\",\n" "${fmt}"
1370         printf "                      ${print});\n"
1371     fi
1372     printf "#endif\n"
1373 done
1374 cat <<EOF
1375   if (current_gdbarch->dump_tdep != NULL)
1376     current_gdbarch->dump_tdep (current_gdbarch, file);
1377 }
1378 EOF
1379
1380
1381 # GET/SET
1382 printf "\n"
1383 cat <<EOF
1384 struct gdbarch_tdep *
1385 gdbarch_tdep (struct gdbarch *gdbarch)
1386 {
1387   if (gdbarch_debug >= 2)
1388     fprintf_unfiltered (gdb_stdlog, "gdbarch_tdep called\\n");
1389   return gdbarch->tdep;
1390 }
1391 EOF
1392 printf "\n"
1393 function_list | while do_read
1394 do
1395     if class_is_predicate_p
1396     then
1397         printf "\n"
1398         printf "int\n"
1399         printf "gdbarch_${function}_p (struct gdbarch *gdbarch)\n"
1400         printf "{\n"
1401         if [ "${valid_p}" ]
1402         then
1403             printf "  return ${valid_p};\n"
1404         else
1405             printf "#error \"gdbarch_${function}_p: not defined\"\n"
1406         fi
1407         printf "}\n"
1408     fi
1409     if class_is_function_p
1410     then
1411         printf "\n"
1412         printf "${returntype}\n"
1413         if [ "${formal}" = "void" ]
1414         then
1415           printf "gdbarch_${function} (struct gdbarch *gdbarch)\n"
1416         else
1417           printf "gdbarch_${function} (struct gdbarch *gdbarch, ${formal})\n"
1418         fi
1419         printf "{\n"
1420         printf "  if (gdbarch->${function} == 0)\n"
1421         printf "    internal_error (\"gdbarch: gdbarch_${function} invalid\");\n"
1422         printf "  if (gdbarch_debug >= 2)\n"
1423         printf "    fprintf_unfiltered (gdb_stdlog, \"gdbarch_${function} called\\\\n\");\n"
1424         test "${actual}" = "-" && actual=""
1425         if [ "${returntype}" = "void" ]
1426         then
1427           printf "  gdbarch->${function} (${actual});\n"
1428         else
1429           printf "  return gdbarch->${function} (${actual});\n"
1430         fi
1431         printf "}\n"
1432         printf "\n"
1433         printf "void\n"
1434         printf "set_gdbarch_${function} (struct gdbarch *gdbarch,\n"
1435         printf "            `echo ${function} | sed -e 's/./ /g'`  gdbarch_${function}_ftype ${function})\n"
1436         printf "{\n"
1437         printf "  gdbarch->${function} = ${function};\n"
1438         printf "}\n"
1439     elif class_is_variable_p
1440     then
1441         printf "\n"
1442         printf "${returntype}\n"
1443         printf "gdbarch_${function} (struct gdbarch *gdbarch)\n"
1444         printf "{\n"
1445         if [ "${invalid_p}" = "0" ]
1446         then
1447             printf "  /* Skip verify of ${function}, invalid_p == 0 */\n"
1448         elif [ "${invalid_p}" ]
1449         then
1450           printf "  if (${invalid_p})\n"
1451           printf "    internal_error (\"gdbarch: gdbarch_${function} invalid\");\n"
1452         elif [ "${predefault}" ]
1453         then
1454           printf "  if (gdbarch->${function} == ${predefault})\n"
1455           printf "    internal_error (\"gdbarch: gdbarch_${function} invalid\");\n"
1456         fi
1457         printf "  if (gdbarch_debug >= 2)\n"
1458         printf "    fprintf_unfiltered (gdb_stdlog, \"gdbarch_${function} called\\\\n\");\n"
1459         printf "  return gdbarch->${function};\n"
1460         printf "}\n"
1461         printf "\n"
1462         printf "void\n"
1463         printf "set_gdbarch_${function} (struct gdbarch *gdbarch,\n"
1464         printf "            `echo ${function} | sed -e 's/./ /g'`  ${returntype} ${function})\n"
1465         printf "{\n"
1466         printf "  gdbarch->${function} = ${function};\n"
1467         printf "}\n"
1468     elif class_is_info_p
1469     then
1470         printf "\n"
1471         printf "${returntype}\n"
1472         printf "gdbarch_${function} (struct gdbarch *gdbarch)\n"
1473         printf "{\n"
1474         printf "  if (gdbarch_debug >= 2)\n"
1475         printf "    fprintf_unfiltered (gdb_stdlog, \"gdbarch_${function} called\\\\n\");\n"
1476         printf "  return gdbarch->${function};\n"
1477         printf "}\n"
1478     fi
1479 done
1480
1481 # All the trailing guff
1482 cat <<EOF
1483
1484
1485 /* Keep a registry of per-architecture data-pointers required by GDB
1486    modules. */
1487
1488 struct gdbarch_data
1489 {
1490   int index;
1491 };
1492
1493 struct gdbarch_data_registration
1494 {
1495   gdbarch_data_ftype *init;
1496   struct gdbarch_data *data;
1497   struct gdbarch_data_registration *next;
1498 };
1499
1500 struct gdbarch_data_registry
1501 {
1502   int nr;
1503   struct gdbarch_data_registration *registrations;
1504 };
1505
1506 struct gdbarch_data_registry gdbarch_data_registry =
1507 {
1508   0, NULL,
1509 };
1510
1511 struct gdbarch_data *
1512 register_gdbarch_data (gdbarch_data_ftype *init)
1513 {
1514   struct gdbarch_data_registration **curr;
1515   for (curr = &gdbarch_data_registry.registrations;
1516        (*curr) != NULL;
1517        curr = &(*curr)->next);
1518   (*curr) = XMALLOC (struct gdbarch_data_registration);
1519   (*curr)->next = NULL;
1520   (*curr)->init = init;
1521   (*curr)->data = XMALLOC (struct gdbarch_data);
1522   (*curr)->data->index = gdbarch_data_registry.nr++;
1523   return (*curr)->data;
1524 }
1525
1526
1527 /* Walk through all the registered users initializing each in turn. */
1528
1529 static void
1530 init_gdbarch_data (struct gdbarch *gdbarch)
1531 {
1532   struct gdbarch_data_registration *rego;
1533   gdbarch->nr_data = gdbarch_data_registry.nr + 1;
1534   gdbarch->data = xmalloc (sizeof (void*) * gdbarch->nr_data);
1535   for (rego = gdbarch_data_registry.registrations;
1536        rego != NULL;
1537        rego = rego->next)
1538     {
1539       if (rego->data->index < gdbarch->nr_data)
1540         gdbarch->data[rego->data->index] = rego->init ();
1541     }
1542 }
1543
1544
1545 /* Return the current value of the specified per-architecture
1546    data-pointer. */
1547
1548 void *
1549 gdbarch_data (struct gdbarch_data *data)
1550 {
1551   if (data->index >= current_gdbarch->nr_data)
1552     internal_error ("gdbarch_data: request for non-existant data.");
1553   return current_gdbarch->data[data->index];
1554 }
1555
1556
1557
1558 /* Keep a registry of swapped data required by GDB modules. */
1559
1560 struct gdbarch_swap
1561 {
1562   void *swap;
1563   struct gdbarch_swap_registration *source;
1564   struct gdbarch_swap *next;
1565 };
1566
1567 struct gdbarch_swap_registration
1568 {
1569   void *data;
1570   unsigned long sizeof_data;
1571   gdbarch_swap_ftype *init;
1572   struct gdbarch_swap_registration *next;
1573 };
1574
1575 struct gdbarch_swap_registry
1576 {
1577   int nr;
1578   struct gdbarch_swap_registration *registrations;
1579 };
1580
1581 struct gdbarch_swap_registry gdbarch_swap_registry =
1582 {
1583   0, NULL,
1584 };
1585
1586 void
1587 register_gdbarch_swap (void *data,
1588                        unsigned long sizeof_data,
1589                        gdbarch_swap_ftype *init)
1590 {
1591   struct gdbarch_swap_registration **rego;
1592   for (rego = &gdbarch_swap_registry.registrations;
1593        (*rego) != NULL;
1594        rego = &(*rego)->next);
1595   (*rego) = XMALLOC (struct gdbarch_swap_registration);
1596   (*rego)->next = NULL;
1597   (*rego)->init = init;
1598   (*rego)->data = data;
1599   (*rego)->sizeof_data = sizeof_data;
1600 }
1601
1602
1603 static void
1604 init_gdbarch_swap (struct gdbarch *gdbarch)
1605 {
1606   struct gdbarch_swap_registration *rego;
1607   struct gdbarch_swap **curr = &gdbarch->swap;
1608   for (rego = gdbarch_swap_registry.registrations;
1609        rego != NULL;
1610        rego = rego->next)
1611     {
1612       if (rego->data != NULL)
1613         {
1614           (*curr) = XMALLOC (struct gdbarch_swap);
1615           (*curr)->source = rego;
1616           (*curr)->swap = xmalloc (rego->sizeof_data);
1617           (*curr)->next = NULL;
1618           memset (rego->data, 0, rego->sizeof_data);
1619           curr = &(*curr)->next;
1620         }
1621       if (rego->init != NULL)
1622         rego->init ();
1623     }
1624 }
1625
1626 static void
1627 swapout_gdbarch_swap (struct gdbarch *gdbarch)
1628 {
1629   struct gdbarch_swap *curr;
1630   for (curr = gdbarch->swap;
1631        curr != NULL;
1632        curr = curr->next)
1633     memcpy (curr->swap, curr->source->data, curr->source->sizeof_data);
1634 }
1635
1636 static void
1637 swapin_gdbarch_swap (struct gdbarch *gdbarch)
1638 {
1639   struct gdbarch_swap *curr;
1640   for (curr = gdbarch->swap;
1641        curr != NULL;
1642        curr = curr->next)
1643     memcpy (curr->source->data, curr->swap, curr->source->sizeof_data);
1644 }
1645
1646
1647 /* Keep a registry of the architectures known by GDB. */
1648
1649 struct gdbarch_registration
1650 {
1651   enum bfd_architecture bfd_architecture;
1652   gdbarch_init_ftype *init;
1653   gdbarch_dump_tdep_ftype *dump_tdep;
1654   struct gdbarch_list *arches;
1655   struct gdbarch_registration *next;
1656 };
1657
1658 static struct gdbarch_registration *gdbarch_registry = NULL;
1659
1660 static void
1661 append_name (const char ***buf, int *nr, const char *name)
1662 {
1663   *buf = xrealloc (*buf, sizeof (char**) * (*nr + 1));
1664   (*buf)[*nr] = name;
1665   *nr += 1;
1666 }
1667
1668 const char **
1669 gdbarch_printable_names (void)
1670 {
1671   if (GDB_MULTI_ARCH)
1672     {
1673       /* Accumulate a list of names based on the registed list of
1674          architectures. */
1675       enum bfd_architecture a;
1676       int nr_arches = 0;
1677       const char **arches = NULL;
1678       struct gdbarch_registration *rego;
1679       for (rego = gdbarch_registry;
1680            rego != NULL;
1681            rego = rego->next)
1682         {
1683           const struct bfd_arch_info *ap;
1684           ap = bfd_lookup_arch (rego->bfd_architecture, 0);
1685           if (ap == NULL)
1686             internal_error ("gdbarch_architecture_names: multi-arch unknown");
1687           do
1688             {
1689               append_name (&arches, &nr_arches, ap->printable_name);
1690               ap = ap->next;
1691             }
1692           while (ap != NULL);
1693         }
1694       append_name (&arches, &nr_arches, NULL);
1695       return arches;
1696     }
1697   else
1698     /* Just return all the architectures that BFD knows.  Assume that
1699        the legacy architecture framework supports them. */
1700     return bfd_arch_list ();
1701 }
1702
1703
1704 void
1705 gdbarch_register (enum bfd_architecture bfd_architecture,
1706                   gdbarch_init_ftype *init,
1707                   gdbarch_dump_tdep_ftype *dump_tdep)
1708 {
1709   struct gdbarch_registration **curr;
1710   const struct bfd_arch_info *bfd_arch_info;
1711   /* Check that BFD recognizes this architecture */
1712   bfd_arch_info = bfd_lookup_arch (bfd_architecture, 0);
1713   if (bfd_arch_info == NULL)
1714     {
1715       internal_error ("gdbarch: Attempt to register unknown architecture (%d)", bfd_architecture);
1716     }
1717   /* Check that we haven't seen this architecture before */
1718   for (curr = &gdbarch_registry;
1719        (*curr) != NULL;
1720        curr = &(*curr)->next)
1721     {
1722       if (bfd_architecture == (*curr)->bfd_architecture)
1723         internal_error ("gdbarch: Duplicate registraration of architecture (%s)",
1724                bfd_arch_info->printable_name);
1725     }
1726   /* log it */
1727   if (gdbarch_debug)
1728     fprintf_unfiltered (gdb_stdlog, "register_gdbarch_init (%s, 0x%08lx)\n",
1729                         bfd_arch_info->printable_name,
1730                         (long) init);
1731   /* Append it */
1732   (*curr) = XMALLOC (struct gdbarch_registration);
1733   (*curr)->bfd_architecture = bfd_architecture;
1734   (*curr)->init = init;
1735   (*curr)->dump_tdep = dump_tdep;
1736   (*curr)->arches = NULL;
1737   (*curr)->next = NULL;
1738   /* When non- multi-arch, install whatever target dump routine we've
1739      been provided - hopefully that routine has been written correctly
1740      and works regardless of multi-arch. */
1741   if (!GDB_MULTI_ARCH && dump_tdep != NULL
1742       && startup_gdbarch.dump_tdep == NULL)
1743     startup_gdbarch.dump_tdep = dump_tdep;
1744 }
1745
1746 void
1747 register_gdbarch_init (enum bfd_architecture bfd_architecture,
1748                        gdbarch_init_ftype *init)
1749 {
1750   gdbarch_register (bfd_architecture, init, NULL);
1751 }
1752
1753
1754 /* Look for an architecture using gdbarch_info.  Base search on only
1755    BFD_ARCH_INFO and BYTE_ORDER. */
1756
1757 struct gdbarch_list *
1758 gdbarch_list_lookup_by_info (struct gdbarch_list *arches,
1759                              const struct gdbarch_info *info)
1760 {
1761   for (; arches != NULL; arches = arches->next)
1762     {
1763       if (info->bfd_arch_info != arches->gdbarch->bfd_arch_info)
1764         continue;
1765       if (info->byte_order != arches->gdbarch->byte_order)
1766         continue;
1767       return arches;
1768     }
1769   return NULL;
1770 }
1771
1772
1773 /* Update the current architecture. Return ZERO if the update request
1774    failed. */
1775
1776 int
1777 gdbarch_update_p (struct gdbarch_info info)
1778 {
1779   struct gdbarch *new_gdbarch;
1780   struct gdbarch_list **list;
1781   struct gdbarch_registration *rego;
1782
1783   /* Fill in any missing bits. Most important is the bfd_architecture
1784      which is used to select the target architecture. */
1785   if (info.bfd_architecture == bfd_arch_unknown)
1786     {
1787       if (info.bfd_arch_info != NULL)
1788         info.bfd_architecture = info.bfd_arch_info->arch;
1789       else if (info.abfd != NULL)
1790         info.bfd_architecture = bfd_get_arch (info.abfd);
1791       /* FIXME - should query BFD for its default architecture. */
1792       else
1793         info.bfd_architecture = current_gdbarch->bfd_arch_info->arch;
1794     }
1795   if (info.bfd_arch_info == NULL)
1796     {
1797       if (target_architecture_auto && info.abfd != NULL)
1798         info.bfd_arch_info = bfd_get_arch_info (info.abfd);
1799       else
1800         info.bfd_arch_info = current_gdbarch->bfd_arch_info;
1801     }
1802   if (info.byte_order == 0)
1803     {
1804       if (target_byte_order_auto && info.abfd != NULL)
1805         info.byte_order = (bfd_big_endian (info.abfd) ? BIG_ENDIAN
1806                            : bfd_little_endian (info.abfd) ? LITTLE_ENDIAN
1807                            : 0);
1808       else
1809         info.byte_order = current_gdbarch->byte_order;
1810       /* FIXME - should query BFD for its default byte-order. */
1811     }
1812   /* A default for abfd? */
1813
1814   /* Find the target that knows about this architecture. */
1815   for (rego = gdbarch_registry;
1816        rego != NULL;
1817        rego = rego->next)
1818     if (rego->bfd_architecture == info.bfd_architecture)
1819       break;
1820   if (rego == NULL)
1821     {
1822       if (gdbarch_debug)
1823         fprintf_unfiltered (gdb_stdlog, "gdbarch_update: No matching architecture\\n");
1824       return 0;
1825     }
1826
1827   if (gdbarch_debug)
1828     {
1829       fprintf_unfiltered (gdb_stdlog,
1830                           "gdbarch_update: info.bfd_architecture %d (%s)\\n",
1831                           info.bfd_architecture,
1832                           bfd_lookup_arch (info.bfd_architecture, 0)->printable_name);
1833       fprintf_unfiltered (gdb_stdlog,
1834                           "gdbarch_update: info.bfd_arch_info %s\\n",
1835                           (info.bfd_arch_info != NULL
1836                            ? info.bfd_arch_info->printable_name
1837                            : "(null)"));
1838       fprintf_unfiltered (gdb_stdlog,
1839                           "gdbarch_update: info.byte_order %d (%s)\\n",
1840                           info.byte_order,
1841                           (info.byte_order == BIG_ENDIAN ? "big"
1842                            : info.byte_order == LITTLE_ENDIAN ? "little"
1843                            : "default"));
1844       fprintf_unfiltered (gdb_stdlog,
1845                           "gdbarch_update: info.abfd 0x%lx\\n",
1846                           (long) info.abfd);
1847       fprintf_unfiltered (gdb_stdlog,
1848                           "gdbarch_update: info.tdep_info 0x%lx\\n",
1849                           (long) info.tdep_info);
1850     }
1851
1852   /* Ask the target for a replacement architecture. */
1853   new_gdbarch = rego->init (info, rego->arches);
1854
1855   /* Did the target like it?  No. Reject the change. */
1856   if (new_gdbarch == NULL)
1857     {
1858       if (gdbarch_debug)
1859         fprintf_unfiltered (gdb_stdlog, "gdbarch_update: Target rejected architecture\\n");
1860       return 0;
1861     }
1862
1863   /* Did the architecture change?  No. Do nothing. */
1864   if (current_gdbarch == new_gdbarch)
1865     {
1866       if (gdbarch_debug)
1867         fprintf_unfiltered (gdb_stdlog, "gdbarch_update: Architecture 0x%08lx (%s) unchanged\\n",
1868                             (long) new_gdbarch,
1869                             new_gdbarch->bfd_arch_info->printable_name);
1870       return 1;
1871     }
1872
1873   /* Swap all data belonging to the old target out */
1874   swapout_gdbarch_swap (current_gdbarch);
1875
1876   /* Is this a pre-existing architecture?  Yes. Swap it in.  */
1877   for (list = &rego->arches;
1878        (*list) != NULL;
1879        list = &(*list)->next)
1880     {
1881       if ((*list)->gdbarch == new_gdbarch)
1882         {
1883           if (gdbarch_debug)
1884             fprintf_unfiltered (gdb_stdlog,
1885                                 "gdbarch_update: Previous architecture 0x%08lx (%s) selected\\n",
1886                                 (long) new_gdbarch,
1887                                 new_gdbarch->bfd_arch_info->printable_name);
1888           current_gdbarch = new_gdbarch;
1889           swapin_gdbarch_swap (new_gdbarch);
1890           return 1;
1891         }
1892     }
1893
1894   /* Append this new architecture to this targets list. */
1895   (*list) = XMALLOC (struct gdbarch_list);
1896   (*list)->next = NULL;
1897   (*list)->gdbarch = new_gdbarch;
1898
1899   /* Switch to this new architecture.  Dump it out. */
1900   current_gdbarch = new_gdbarch;
1901   if (gdbarch_debug)
1902     {
1903       fprintf_unfiltered (gdb_stdlog,
1904                           "gdbarch_update: New architecture 0x%08lx (%s) selected\\n",
1905                           (long) new_gdbarch,
1906                           new_gdbarch->bfd_arch_info->printable_name);
1907     }
1908
1909   /* Check that the newly installed architecture is valid.  Plug in
1910      any post init values.  */
1911   new_gdbarch->dump_tdep = rego->dump_tdep;
1912   verify_gdbarch (new_gdbarch);
1913
1914   /* Initialize the per-architecture memory (swap) areas.
1915      CURRENT_GDBARCH must be update before these modules are
1916      called. */
1917   init_gdbarch_swap (new_gdbarch);
1918
1919   /* Initialize the per-architecture data-pointer of all parties that
1920      registered an interest in this architecture.  CURRENT_GDBARCH
1921      must be updated before these modules are called. */
1922   init_gdbarch_data (new_gdbarch);
1923
1924   if (gdbarch_debug)
1925     gdbarch_dump (current_gdbarch, gdb_stdlog);
1926
1927   return 1;
1928 }
1929
1930
1931 /* Disassembler */
1932
1933 /* Pointer to the target-dependent disassembly function.  */
1934 int (*tm_print_insn) (bfd_vma, disassemble_info *);
1935 disassemble_info tm_print_insn_info;
1936
1937
1938 extern void _initialize_gdbarch (void);
1939
1940 void
1941 _initialize_gdbarch (void)
1942 {
1943   struct cmd_list_element *c;
1944
1945   INIT_DISASSEMBLE_INFO_NO_ARCH (tm_print_insn_info, gdb_stdout, (fprintf_ftype)fprintf_filtered);
1946   tm_print_insn_info.flavour = bfd_target_unknown_flavour;
1947   tm_print_insn_info.read_memory_func = dis_asm_read_memory;
1948   tm_print_insn_info.memory_error_func = dis_asm_memory_error;
1949   tm_print_insn_info.print_address_func = dis_asm_print_address;
1950
1951   add_show_from_set (add_set_cmd ("arch",
1952                                   class_maintenance,
1953                                   var_zinteger,
1954                                   (char *)&gdbarch_debug,
1955                                   "Set architecture debugging.\\n\\
1956 When non-zero, architecture debugging is enabled.", &setdebuglist),
1957                      &showdebuglist);
1958   c = add_set_cmd ("archdebug",
1959                    class_maintenance,
1960                    var_zinteger,
1961                    (char *)&gdbarch_debug,
1962                    "Set architecture debugging.\\n\\
1963 When non-zero, architecture debugging is enabled.", &setlist);
1964
1965   deprecate_cmd (c, "set debug arch");
1966   deprecate_cmd (add_show_from_set (c, &showlist), "show debug arch");
1967 }
1968 EOF
1969
1970 # close things off
1971 exec 1>&2
1972 #../move-if-change new-gdbarch.c gdbarch.c
1973 compare_new gdbarch.c