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