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