gdb/gdbarch.sh

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