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