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