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