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() is
 793    called.  gdbarch_update() shall initialize any \`\`default'' fields
 794    using information obtained from the previous architecture or
 795    INFO.ABFD (if specified) before calling the corresponding
 796    architectures INIT function. */
 797
 798 extern int gdbarch_update (struct gdbarch_info info);
 799
 800
 801
 802 /* Register per-architecture data-pointer.
 803
 804    Reserve space for a per-architecture data-pointer.  An identifier
 805    for the reserved data-pointer is returned.  That identifer should
 806    be saved in a local static.
 807
 808    When a new architecture is selected, INIT() is called.  When a
 809    previous architecture is re-selected, the per-architecture
 810    data-pointer for that previous architecture is restored (INIT() is
 811    not called).
 812
 813    INIT() shall return the initial value for the per-architecture
 814    data-pointer for the current architecture.
 815
 816    Multiple registrarants for any architecture are allowed (and
 817    strongly encouraged).  */
 818
 819 typedef void *(gdbarch_data_ftype) (void);
 820 extern struct gdbarch_data *register_gdbarch_data (gdbarch_data_ftype *init);
 821
 822 /* Return the value of the per-architecture data-pointer for the
 823    current architecture. */
 824
 825 extern void *gdbarch_data (struct gdbarch_data*);
 826
 827
 828
 829 /* Register per-architecture memory region.
 830
 831    Provide a memory-region swap mechanism.  Per-architecture memory
 832    region are created.  These memory regions are swapped whenever the
 833    architecture is changed.  For a new architecture, the memory region
 834    is initialized with zero (0) and the INIT function is called.
 835
 836    Memory regions are swapped / initialized in the order that they are
 837    registered.  NULL DATA and/or INIT values can be specified.
 838
 839    New code should use register_gdbarch_data(). */
 840
 841 typedef void (gdbarch_swap_ftype) (void);
 842 extern void register_gdbarch_swap (void *data, unsigned long size, gdbarch_swap_ftype *init);
 843 #define REGISTER_GDBARCH_SWAP(VAR) register_gdbarch_swap (&(VAR), sizeof ((VAR)), NULL)
 844
 845
 846
 847 /* The target-system-dependant byte order is dynamic */
 848
 849 /* TARGET_BYTE_ORDER_SELECTABLE_P determines if the target endianness
 850    is selectable at runtime.  The user can use the \`\`set endian''
 851    command to change it.  TARGET_BYTE_ORDER_AUTO is nonzero when
 852    target_byte_order should be auto-detected (from the program image
 853    say). */
 854
 855 #if GDB_MULTI_ARCH
 856 /* Multi-arch GDB is always bi-endian. */
 857 #define TARGET_BYTE_ORDER_SELECTABLE_P 1
 858 #endif
 859
 860 #ifndef TARGET_BYTE_ORDER_SELECTABLE_P
 861 /* compat - Catch old targets that define TARGET_BYTE_ORDER_SLECTABLE
 862    when they should have defined TARGET_BYTE_ORDER_SELECTABLE_P 1 */
 863 #ifdef TARGET_BYTE_ORDER_SELECTABLE
 864 #define TARGET_BYTE_ORDER_SELECTABLE_P 1
 865 #else
 866 #define TARGET_BYTE_ORDER_SELECTABLE_P 0
 867 #endif
 868 #endif
 869
 870 extern int target_byte_order;
 871 #ifdef TARGET_BYTE_ORDER_SELECTABLE
 872 /* compat - Catch old targets that define TARGET_BYTE_ORDER_SELECTABLE
 873    and expect defs.h to re-define TARGET_BYTE_ORDER. */
 874 #undef TARGET_BYTE_ORDER
 875 #endif
 876 #ifndef TARGET_BYTE_ORDER
 877 #define TARGET_BYTE_ORDER (target_byte_order + 0)
 878 #endif
 879
 880 extern int target_byte_order_auto;
 881 #ifndef TARGET_BYTE_ORDER_AUTO
 882 #define TARGET_BYTE_ORDER_AUTO (target_byte_order_auto + 0)
 883 #endif
 884
 885
 886
 887 /* The target-system-dependant BFD architecture is dynamic */
 888
 889 extern int target_architecture_auto;
 890 #ifndef TARGET_ARCHITECTURE_AUTO
 891 #define TARGET_ARCHITECTURE_AUTO (target_architecture_auto + 0)
 892 #endif
 893
 894 extern const struct bfd_arch_info *target_architecture;
 895 #ifndef TARGET_ARCHITECTURE
 896 #define TARGET_ARCHITECTURE (target_architecture + 0)
 897 #endif
 898
 899
 900 /* The target-system-dependant disassembler is semi-dynamic */
 901
 902 #include "dis-asm.h"            /* Get defs for disassemble_info */
 903
 904 extern int dis_asm_read_memory (bfd_vma memaddr, bfd_byte *myaddr,
 905                                 unsigned int len, disassemble_info *info);
 906
 907 extern void dis_asm_memory_error (int status, bfd_vma memaddr,
 908                                   disassemble_info *info);
 909
 910 extern void dis_asm_print_address (bfd_vma addr,
 911                                    disassemble_info *info);
 912
 913 extern int (*tm_print_insn) (bfd_vma, disassemble_info*);
 914 extern disassemble_info tm_print_insn_info;
 915 #ifndef TARGET_PRINT_INSN
 916 #define TARGET_PRINT_INSN(vma, info) (*tm_print_insn) (vma, info)
 917 #endif
 918 #ifndef TARGET_PRINT_INSN_INFO
 919 #define TARGET_PRINT_INSN_INFO (&tm_print_insn_info)
 920 #endif
 921
 922
 923
 924 /* Explicit test for D10V architecture.
 925    USE of these macro's is *STRONGLY* discouraged. */
 926
 927 #define GDB_TARGET_IS_D10V (TARGET_ARCHITECTURE->arch == bfd_arch_d10v)
 928
 929
 930 /* Fallback definition for EXTRACT_STRUCT_VALUE_ADDRESS */
 931 #ifndef EXTRACT_STRUCT_VALUE_ADDRESS
 932 #define EXTRACT_STRUCT_VALUE_ADDRESS_P (0)
 933 #define EXTRACT_STRUCT_VALUE_ADDRESS(X) (internal_error ("gdbarch: EXTRACT_STRUCT_VALUE_ADDRESS"), 0)
 934 #else
 935 #ifndef EXTRACT_STRUCT_VALUE_ADDRESS_P
 936 #define EXTRACT_STRUCT_VALUE_ADDRESS_P (1)
 937 #endif
 938 #endif
 939
 940
 941 /* Set the dynamic target-system-dependant parameters (architecture,
 942    byte-order, ...) using information found in the BFD */
 943
 944 extern void set_gdbarch_from_file (bfd *);
 945
 946
 947 /* Initialize the current architecture to the "first" one we find on
 948    our list.  */
 949
 950 extern void initialize_current_architecture (void);
 951
 952
 953 /* gdbarch trace variable */
 954 extern int gdbarch_debug;
 955
 956 extern void gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file);
 957
 958 #endif
 959 EOF
 960 exec 1>&2
 961 #../move-if-change new-gdbarch.h gdbarch.h
 962 compare_new gdbarch.h
 963
 964
 965 #
 966 # C file
 967 #
 968
 969 exec > new-gdbarch.c
 970 copyright
 971 cat <<EOF
 972
 973 #include "defs.h"
 974 #include "arch-utils.h"
 975
 976 #if GDB_MULTI_ARCH
 977 #include "gdbcmd.h"
 978 #include "inferior.h" /* enum CALL_DUMMY_LOCATION et.al. */
 979 #else
 980 /* Just include everything in sight so that the every old definition
 981    of macro is visible. */
 982 #include "gdb_string.h"
 983 #include <ctype.h>
 984 #include "symtab.h"
 985 #include "frame.h"
 986 #include "inferior.h"
 987 #include "breakpoint.h"
 988 #include "gdb_wait.h"
 989 #include "gdbcore.h"
 990 #include "gdbcmd.h"
 991 #include "target.h"
 992 #include "gdbthread.h"
 993 #include "annotate.h"
 994 #include "symfile.h"            /* for overlay functions */
 995 #endif
 996 #include "symcat.h"
 997
 998 #include "floatformat.h"
 999
1000 /* Static function declarations */
1001
1002 static void verify_gdbarch (struct gdbarch *gdbarch);
1003 static void init_gdbarch_data (struct gdbarch *);
1004 static void init_gdbarch_swap (struct gdbarch *);
1005 static void swapout_gdbarch_swap (struct gdbarch *);
1006 static void swapin_gdbarch_swap (struct gdbarch *);
1007
1008 /* Convenience macro for allocting typesafe memory. */
1009
1010 #ifndef XMALLOC
1011 #define XMALLOC(TYPE) (TYPE*) xmalloc (sizeof (TYPE))
1012 #endif
1013
1014
1015 /* Non-zero if we want to trace architecture code.  */
1016
1017 #ifndef GDBARCH_DEBUG
1018 #define GDBARCH_DEBUG 0
1019 #endif
1020 int gdbarch_debug = GDBARCH_DEBUG;
1021
1022 EOF
1023
1024 # gdbarch open the gdbarch object
1025 echo ""
1026 echo "/* Maintain the struct gdbarch object */"
1027 echo ""
1028 echo "struct gdbarch"
1029 echo "{"
1030 echo "  /* basic architectural information */"
1031 function_list | while do_read
1032 do
1033     if class_is_info_p
1034     then
1035         echo "  ${returntype} ${function};"
1036     fi
1037 done
1038 echo ""
1039 echo "  /* target specific vector. */"
1040 echo "  struct gdbarch_tdep *tdep;"
1041 echo "  gdbarch_dump_tdep_ftype *dump_tdep;"
1042 echo ""
1043 echo "  /* per-architecture data-pointers */"
1044 echo "  int nr_data;"
1045 echo "  void **data;"
1046 echo ""
1047 echo "  /* per-architecture swap-regions */"
1048 echo "  struct gdbarch_swap *swap;"
1049 echo ""
1050 cat <<EOF
1051   /* Multi-arch values.
1052
1053      When extending this structure you must:
1054
1055      Add the field below.
1056
1057      Declare set/get functions and define the corresponding
1058      macro in gdbarch.h.
1059
1060      gdbarch_alloc(): If zero/NULL is not a suitable default,
1061      initialize the new field.
1062
1063      verify_gdbarch(): Confirm that the target updated the field
1064      correctly.
1065
1066      gdbarch_dump(): Add a fprintf_unfiltered call to so that the new
1067      field is dumped out
1068
1069      \`\`startup_gdbarch()'': Append an initial value to the static
1070      variable (base values on the host's c-type system).
1071
1072      get_gdbarch(): Implement the set/get functions (probably using
1073      the macro's as shortcuts).
1074
1075      */
1076
1077 EOF
1078 function_list | while do_read
1079 do
1080     if class_is_variable_p
1081     then
1082         echo "  ${returntype} ${function};"
1083     elif class_is_function_p
1084     then
1085         echo "  gdbarch_${function}_ftype *${function}${attrib};"
1086     fi
1087 done
1088 echo "};"
1089
1090 # A pre-initialized vector
1091 echo ""
1092 echo ""
1093 cat <<EOF
1094 /* The default architecture uses host values (for want of a better
1095    choice). */
1096 EOF
1097 echo ""
1098 echo "extern const struct bfd_arch_info bfd_default_arch_struct;"
1099 echo ""
1100 echo "struct gdbarch startup_gdbarch ="
1101 echo "{"
1102 echo "  /* basic architecture information */"
1103 function_list | while do_read
1104 do
1105     if class_is_info_p
1106     then
1107         echo "  ${staticdefault},"
1108     fi
1109 done
1110 cat <<EOF
1111   /* target specific vector and its dump routine */
1112   NULL, NULL,
1113   /*per-architecture data-pointers and swap regions */
1114   0, NULL, NULL,
1115   /* Multi-arch values */
1116 EOF
1117 function_list | while do_read
1118 do
1119     if class_is_function_p || class_is_variable_p
1120     then
1121         echo "  ${staticdefault},"
1122     fi
1123 done
1124 cat <<EOF
1125   /* startup_gdbarch() */
1126 };
1127
1128 struct gdbarch *current_gdbarch = &startup_gdbarch;
1129 EOF
1130
1131 # Create a new gdbarch struct
1132 echo ""
1133 echo ""
1134 cat <<EOF
1135 /* Create a new \`\`struct gdbarch'' based in information provided by
1136    \`\`struct gdbarch_info''. */
1137 EOF
1138 echo ""
1139 cat <<EOF
1140 struct gdbarch *
1141 gdbarch_alloc (const struct gdbarch_info *info,
1142                struct gdbarch_tdep *tdep)
1143 {
1144   struct gdbarch *gdbarch = XMALLOC (struct gdbarch);
1145   memset (gdbarch, 0, sizeof (*gdbarch));
1146
1147   gdbarch->tdep = tdep;
1148 EOF
1149 echo ""
1150 function_list | while do_read
1151 do
1152     if class_is_info_p
1153     then
1154         echo "  gdbarch->${function} = info->${function};"
1155     fi
1156 done
1157 echo ""
1158 echo "  /* Force the explicit initialization of these. */"
1159 function_list | while do_read
1160 do
1161     if class_is_function_p || class_is_variable_p
1162     then
1163         if [ "${predefault}" != "" -a "${predefault}" != "0" ]
1164         then
1165           echo "  gdbarch->${function} = ${predefault};"
1166         fi
1167     fi
1168 done
1169 cat <<EOF
1170   /* gdbarch_alloc() */
1171
1172   return gdbarch;
1173 }
1174 EOF
1175
1176 # Free a gdbarch struct.
1177 echo ""
1178 echo ""
1179 cat <<EOF
1180 /* Free a gdbarch struct.  This should never happen in normal
1181    operation --- once you've created a gdbarch, you keep it around.
1182    However, if an architecture's init function encounters an error
1183    building the structure, it may need to clean up a partially
1184    constructed gdbarch.  */
1185
1186 void
1187 gdbarch_free (struct gdbarch *arch)
1188 {
1189   /* At the moment, this is trivial.  */
1190   free (arch);
1191 }
1192 EOF
1193
1194 # verify a new architecture
1195 echo ""
1196 echo ""
1197 echo "/* Ensure that all values in a GDBARCH are reasonable. */"
1198 echo ""
1199 cat <<EOF
1200 static void
1201 verify_gdbarch (struct gdbarch *gdbarch)
1202 {
1203   /* Only perform sanity checks on a multi-arch target. */
1204   if (!GDB_MULTI_ARCH)
1205     return;
1206   /* fundamental */
1207   if (gdbarch->byte_order == 0)
1208     internal_error ("verify_gdbarch: byte-order unset");
1209   if (gdbarch->bfd_arch_info == NULL)
1210     internal_error ("verify_gdbarch: bfd_arch_info unset");
1211   /* Check those that need to be defined for the given multi-arch level. */
1212 EOF
1213 function_list | while do_read
1214 do
1215     if class_is_function_p || class_is_variable_p
1216     then
1217         if [ "${invalid_p}" = "0" ]
1218         then
1219             echo "  /* Skip verify of ${function}, invalid_p == 0 */"
1220         elif class_is_predicate_p
1221         then
1222             echo "  /* Skip verify of ${function}, has predicate */"
1223         # FIXME: See do_read for potential simplification
1224         elif [ "${invalid_p}" -a "${postdefault}" ]
1225         then
1226             echo "  if (${invalid_p})"
1227             echo "    gdbarch->${function} = ${postdefault};"
1228         elif [ "${predefault}" -a "${postdefault}" ]
1229         then
1230             echo "  if (gdbarch->${function} == ${predefault})"
1231             echo "    gdbarch->${function} = ${postdefault};"
1232         elif [ "${postdefault}" ]
1233         then
1234             echo "  if (gdbarch->${function} == 0)"
1235             echo "    gdbarch->${function} = ${postdefault};"
1236         elif [ "${invalid_p}" ]
1237         then
1238             echo "  if ((GDB_MULTI_ARCH >= ${level})"
1239             echo "      && (${invalid_p}))"
1240             echo "    internal_error (\"gdbarch: verify_gdbarch: ${function} invalid\");"
1241         elif [ "${predefault}" ]
1242         then
1243             echo "  if ((GDB_MULTI_ARCH >= ${level})"
1244             echo "      && (gdbarch->${function} == ${predefault}))"
1245             echo "    internal_error (\"gdbarch: verify_gdbarch: ${function} invalid\");"
1246         fi
1247     fi
1248 done
1249 cat <<EOF
1250 }
1251 EOF
1252
1253 # dump the structure
1254 echo ""
1255 echo ""
1256 cat <<EOF
1257 /* Print out the details of the current architecture. */
1258
1259 /* NOTE/WARNING: The parameter is called \`\`current_gdbarch'' so that it
1260    just happens to match the global variable \`\`current_gdbarch''.  That
1261    way macros refering to that variable get the local and not the global
1262    version - ulgh.  Once everything is parameterised with gdbarch, this
1263    will go away. */
1264
1265 void
1266 gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file)
1267 {
1268   fprintf_unfiltered (file,
1269                       "gdbarch_dump: GDB_MULTI_ARCH = %d\\n",
1270                       GDB_MULTI_ARCH);
1271 EOF
1272 function_list | while do_read
1273 do
1274     if [ "${returntype}" == "void" ]
1275     then
1276         echo "#if defined (${macro}) && GDB_MULTI_ARCH"
1277         echo "  /* Macro might contain \`[{}]' when not multi-arch */"
1278     else
1279         echo "#ifdef ${macro}"
1280     fi
1281     if class_is_function_p
1282     then
1283         echo "  fprintf_unfiltered (file,"
1284         echo "                      \"gdbarch_dump: %s # %s\\n\","
1285         echo "                      \"${macro}(${actual})\","
1286         echo "                      XSTRING (${macro} (${actual})));"
1287     else
1288         echo "  fprintf_unfiltered (file,"
1289         echo "                      \"gdbarch_dump: ${macro} # %s\\n\","
1290         echo "                      XSTRING (${macro}));"
1291     fi
1292     echo "#endif"
1293 done
1294 function_list | while do_read
1295 do
1296     echo "#ifdef ${macro}"
1297     if [ "${print_p}" = "()" ]
1298     then
1299         echo "  gdbarch_dump_${function} (current_gdbarch);"
1300     elif [ "${print_p}" = "0" ]
1301     then
1302         echo "  /* skip print of ${macro}, print_p == 0. */"
1303     elif [ "${print_p}" ]
1304     then
1305         echo "  if (${print_p})"
1306         echo "    fprintf_unfiltered (file,"
1307         echo "                        \"gdbarch_dump: ${macro} = ${fmt}\\n\","
1308         echo "                        ${print});"
1309     elif class_is_function_p
1310     then
1311         echo "  if (GDB_MULTI_ARCH)"
1312         echo "    fprintf_unfiltered (file,"
1313         echo "                        \"gdbarch_dump: ${macro} = 0x%08lx\\n\","
1314         echo "                        (long) current_gdbarch->${function}"
1315         echo "                        /*${macro} ()*/);"
1316     else
1317         echo "  fprintf_unfiltered (file,"
1318         echo "                      \"gdbarch_dump: ${macro} = ${fmt}\\n\","
1319         echo "                      ${print});"
1320     fi
1321     echo "#endif"
1322 done
1323 cat <<EOF
1324   if (current_gdbarch->dump_tdep != NULL)
1325     current_gdbarch->dump_tdep (current_gdbarch, file);
1326 }
1327 EOF
1328
1329
1330 # GET/SET
1331 echo ""
1332 cat <<EOF
1333 struct gdbarch_tdep *
1334 gdbarch_tdep (struct gdbarch *gdbarch)
1335 {
1336   if (gdbarch_debug >= 2)
1337     fprintf_unfiltered (gdb_stdlog, "gdbarch_tdep called\n");
1338   return gdbarch->tdep;
1339 }
1340 EOF
1341 echo ""
1342 function_list | while do_read
1343 do
1344     if class_is_predicate_p
1345     then
1346         echo ""
1347         echo "int"
1348         echo "gdbarch_${function}_p (struct gdbarch *gdbarch)"
1349         echo "{"
1350         if [ "${valid_p}" ]
1351         then
1352             echo "  return ${valid_p};"
1353         else
1354             echo "#error \"gdbarch_${function}_p: not defined\""
1355         fi
1356         echo "}"
1357     fi
1358     if class_is_function_p
1359     then
1360         echo ""
1361         echo "${returntype}"
1362         if [ "${formal}" = "void" ]
1363         then
1364           echo "gdbarch_${function} (struct gdbarch *gdbarch)"
1365         else
1366           echo "gdbarch_${function} (struct gdbarch *gdbarch, ${formal})"
1367         fi
1368         echo "{"
1369         echo "  if (gdbarch->${function} == 0)"
1370         echo "    internal_error (\"gdbarch: gdbarch_${function} invalid\");"
1371         echo "  if (gdbarch_debug >= 2)"
1372         echo "    fprintf_unfiltered (gdb_stdlog, \"gdbarch_${function} called\n\");"
1373         test "${actual}" = "-" && actual=""
1374         if [ "${returntype}" = "void" ]
1375         then
1376           echo "  gdbarch->${function} (${actual});"
1377         else
1378           echo "  return gdbarch->${function} (${actual});"
1379         fi
1380         echo "}"
1381         echo ""
1382         echo "void"
1383         echo "set_gdbarch_${function} (struct gdbarch *gdbarch,"
1384         echo "            `echo ${function} | sed -e 's/./ /g'`  gdbarch_${function}_ftype ${function})"
1385         echo "{"
1386         echo "  gdbarch->${function} = ${function};"
1387         echo "}"
1388     elif class_is_variable_p
1389     then
1390         echo ""
1391         echo "${returntype}"
1392         echo "gdbarch_${function} (struct gdbarch *gdbarch)"
1393         echo "{"
1394         if [ "${invalid_p}" = "0" ]
1395         then
1396             echo "  /* Skip verify of ${function}, invalid_p == 0 */"
1397         elif [ "${invalid_p}" ]
1398         then
1399           echo "  if (${invalid_p})"
1400           echo "    internal_error (\"gdbarch: gdbarch_${function} invalid\");"
1401         elif [ "${predefault}" ]
1402         then
1403           echo "  if (gdbarch->${function} == ${predefault})"
1404           echo "    internal_error (\"gdbarch: gdbarch_${function} invalid\");"
1405         fi
1406         echo "  if (gdbarch_debug >= 2)"
1407         echo "    fprintf_unfiltered (gdb_stdlog, \"gdbarch_${function} called\n\");"
1408         echo "  return gdbarch->${function};"
1409         echo "}"
1410         echo ""
1411         echo "void"
1412         echo "set_gdbarch_${function} (struct gdbarch *gdbarch,"
1413         echo "            `echo ${function} | sed -e 's/./ /g'`  ${returntype} ${function})"
1414         echo "{"
1415         echo "  gdbarch->${function} = ${function};"
1416         echo "}"
1417     elif class_is_info_p
1418     then
1419         echo ""
1420         echo "${returntype}"
1421         echo "gdbarch_${function} (struct gdbarch *gdbarch)"
1422         echo "{"
1423         echo "  if (gdbarch_debug >= 2)"
1424         echo "    fprintf_unfiltered (gdb_stdlog, \"gdbarch_${function} called\n\");"
1425         echo "  return gdbarch->${function};"
1426         echo "}"
1427     fi
1428 done
1429
1430 # All the trailing guff
1431 cat <<EOF
1432
1433
1434 /* Keep a registrary of per-architecture data-pointers required by GDB
1435    modules. */
1436
1437 struct gdbarch_data
1438 {
1439   int index;
1440 };
1441
1442 struct gdbarch_data_registration
1443 {
1444   gdbarch_data_ftype *init;
1445   struct gdbarch_data *data;
1446   struct gdbarch_data_registration *next;
1447 };
1448
1449 struct gdbarch_data_registrary
1450 {
1451   int nr;
1452   struct gdbarch_data_registration *registrations;
1453 };
1454
1455 struct gdbarch_data_registrary gdbarch_data_registrary =
1456 {
1457   0, NULL,
1458 };
1459
1460 struct gdbarch_data *
1461 register_gdbarch_data (gdbarch_data_ftype *init)
1462 {
1463   struct gdbarch_data_registration **curr;
1464   for (curr = &gdbarch_data_registrary.registrations;
1465        (*curr) != NULL;
1466        curr = &(*curr)->next);
1467   (*curr) = XMALLOC (struct gdbarch_data_registration);
1468   (*curr)->next = NULL;
1469   (*curr)->init = init;
1470   (*curr)->data = XMALLOC (struct gdbarch_data);
1471   (*curr)->data->index = gdbarch_data_registrary.nr++;
1472   return (*curr)->data;
1473 }
1474
1475
1476 /* Walk through all the registered users initializing each in turn. */
1477
1478 static void
1479 init_gdbarch_data (struct gdbarch *gdbarch)
1480 {
1481   struct gdbarch_data_registration *rego;
1482   gdbarch->nr_data = gdbarch_data_registrary.nr + 1;
1483   gdbarch->data = xmalloc (sizeof (void*) * gdbarch->nr_data);
1484   for (rego = gdbarch_data_registrary.registrations;
1485        rego != NULL;
1486        rego = rego->next)
1487     {
1488       if (rego->data->index < gdbarch->nr_data)
1489         gdbarch->data[rego->data->index] = rego->init ();
1490     }
1491 }
1492
1493
1494 /* Return the current value of the specified per-architecture
1495    data-pointer. */
1496
1497 void *
1498 gdbarch_data (struct gdbarch_data *data)
1499 {
1500   if (data->index >= current_gdbarch->nr_data)
1501     internal_error ("gdbarch_data: request for non-existant data.");
1502   return current_gdbarch->data[data->index];
1503 }
1504
1505
1506
1507 /* Keep a registrary of swaped data required by GDB modules. */
1508
1509 struct gdbarch_swap
1510 {
1511   void *swap;
1512   struct gdbarch_swap_registration *source;
1513   struct gdbarch_swap *next;
1514 };
1515
1516 struct gdbarch_swap_registration
1517 {
1518   void *data;
1519   unsigned long sizeof_data;
1520   gdbarch_swap_ftype *init;
1521   struct gdbarch_swap_registration *next;
1522 };
1523
1524 struct gdbarch_swap_registrary
1525 {
1526   int nr;
1527   struct gdbarch_swap_registration *registrations;
1528 };
1529
1530 struct gdbarch_swap_registrary gdbarch_swap_registrary =
1531 {
1532   0, NULL,
1533 };
1534
1535 void
1536 register_gdbarch_swap (void *data,
1537                        unsigned long sizeof_data,
1538                        gdbarch_swap_ftype *init)
1539 {
1540   struct gdbarch_swap_registration **rego;
1541   for (rego = &gdbarch_swap_registrary.registrations;
1542        (*rego) != NULL;
1543        rego = &(*rego)->next);
1544   (*rego) = XMALLOC (struct gdbarch_swap_registration);
1545   (*rego)->next = NULL;
1546   (*rego)->init = init;
1547   (*rego)->data = data;
1548   (*rego)->sizeof_data = sizeof_data;
1549 }
1550
1551
1552 static void
1553 init_gdbarch_swap (struct gdbarch *gdbarch)
1554 {
1555   struct gdbarch_swap_registration *rego;
1556   struct gdbarch_swap **curr = &gdbarch->swap;
1557   for (rego = gdbarch_swap_registrary.registrations;
1558        rego != NULL;
1559        rego = rego->next)
1560     {
1561       if (rego->data != NULL)
1562         {
1563           (*curr) = XMALLOC (struct gdbarch_swap);
1564           (*curr)->source = rego;
1565           (*curr)->swap = xmalloc (rego->sizeof_data);
1566           (*curr)->next = NULL;
1567           memset (rego->data, 0, rego->sizeof_data);
1568           curr = &(*curr)->next;
1569         }
1570       if (rego->init != NULL)
1571         rego->init ();
1572     }
1573 }
1574
1575 static void
1576 swapout_gdbarch_swap (struct gdbarch *gdbarch)
1577 {
1578   struct gdbarch_swap *curr;
1579   for (curr = gdbarch->swap;
1580        curr != NULL;
1581        curr = curr->next)
1582     memcpy (curr->swap, curr->source->data, curr->source->sizeof_data);
1583 }
1584
1585 static void
1586 swapin_gdbarch_swap (struct gdbarch *gdbarch)
1587 {
1588   struct gdbarch_swap *curr;
1589   for (curr = gdbarch->swap;
1590        curr != NULL;
1591        curr = curr->next)
1592     memcpy (curr->source->data, curr->swap, curr->source->sizeof_data);
1593 }
1594
1595
1596 /* Keep a registrary of the architectures known by GDB. */
1597
1598 struct gdbarch_registration
1599 {
1600   enum bfd_architecture bfd_architecture;
1601   gdbarch_init_ftype *init;
1602   gdbarch_dump_tdep_ftype *dump_tdep;
1603   struct gdbarch_list *arches;
1604   struct gdbarch_registration *next;
1605 };
1606
1607 static struct gdbarch_registration *gdbarch_registrary = NULL;
1608
1609 static void
1610 append_name (const char ***buf, int *nr, const char *name)
1611 {
1612   *buf = xrealloc (*buf, sizeof (char**) * (*nr + 1));
1613   (*buf)[*nr] = name;
1614   *nr += 1;
1615 }
1616
1617 const char **
1618 gdbarch_printable_names (void)
1619 {
1620   if (GDB_MULTI_ARCH)
1621     {
1622       /* Accumulate a list of names based on the registed list of
1623          architectures. */
1624       enum bfd_architecture a;
1625       int nr_arches = 0;
1626       const char **arches = NULL;
1627       struct gdbarch_registration *rego;
1628       for (rego = gdbarch_registrary;
1629            rego != NULL;
1630            rego = rego->next)
1631         {
1632           const struct bfd_arch_info *ap;
1633           ap = bfd_lookup_arch (rego->bfd_architecture, 0);
1634           if (ap == NULL)
1635             internal_error ("gdbarch_architecture_names: multi-arch unknown");
1636           do
1637             {
1638               append_name (&arches, &nr_arches, ap->printable_name);
1639               ap = ap->next;
1640             }
1641           while (ap != NULL);
1642         }
1643       append_name (&arches, &nr_arches, NULL);
1644       return arches;
1645     }
1646   else
1647     /* Just return all the architectures that BFD knows.  Assume that
1648        the legacy architecture framework supports them. */
1649     return bfd_arch_list ();
1650 }
1651
1652
1653 void
1654 gdbarch_register (enum bfd_architecture bfd_architecture,
1655                   gdbarch_init_ftype *init,
1656                   gdbarch_dump_tdep_ftype *dump_tdep)
1657 {
1658   struct gdbarch_registration **curr;
1659   const struct bfd_arch_info *bfd_arch_info;
1660   /* Check that BFD reconizes this architecture */
1661   bfd_arch_info = bfd_lookup_arch (bfd_architecture, 0);
1662   if (bfd_arch_info == NULL)
1663     {
1664       internal_error ("gdbarch: Attempt to register unknown architecture (%d)", bfd_architecture);
1665     }
1666   /* Check that we haven't seen this architecture before */
1667   for (curr = &gdbarch_registrary;
1668        (*curr) != NULL;
1669        curr = &(*curr)->next)
1670     {
1671       if (bfd_architecture == (*curr)->bfd_architecture)
1672         internal_error ("gdbarch: Duplicate registraration of architecture (%s)",
1673                bfd_arch_info->printable_name);
1674     }
1675   /* log it */
1676   if (gdbarch_debug)
1677     fprintf_unfiltered (gdb_stdlog, "register_gdbarch_init (%s, 0x%08lx)\n",
1678                         bfd_arch_info->printable_name,
1679                         (long) init);
1680   /* Append it */
1681   (*curr) = XMALLOC (struct gdbarch_registration);
1682   (*curr)->bfd_architecture = bfd_architecture;
1683   (*curr)->init = init;
1684   (*curr)->dump_tdep = dump_tdep;
1685   (*curr)->arches = NULL;
1686   (*curr)->next = NULL;
1687   /* When non- multi-arch, install what ever target dump routine we've
1688      been provided - hopefully that routine has been writen correct
1689      and works regardless of multi-arch. */
1690   if (!GDB_MULTI_ARCH && dump_tdep != NULL
1691       && startup_gdbarch.dump_tdep == NULL)
1692     startup_gdbarch.dump_tdep = dump_tdep;
1693 }
1694
1695 void
1696 register_gdbarch_init (enum bfd_architecture bfd_architecture,
1697                        gdbarch_init_ftype *init)
1698 {
1699   gdbarch_register (bfd_architecture, init, NULL);
1700 }
1701
1702
1703 /* Look for an architecture using gdbarch_info.  Base search on only
1704    BFD_ARCH_INFO and BYTE_ORDER. */
1705
1706 struct gdbarch_list *
1707 gdbarch_list_lookup_by_info (struct gdbarch_list *arches,
1708                              const struct gdbarch_info *info)
1709 {
1710   for (; arches != NULL; arches = arches->next)
1711     {
1712       if (info->bfd_arch_info != arches->gdbarch->bfd_arch_info)
1713         continue;
1714       if (info->byte_order != arches->gdbarch->byte_order)
1715         continue;
1716       return arches;
1717     }
1718   return NULL;
1719 }
1720
1721
1722 /* Update the current architecture. Return ZERO if the update request
1723    failed. */
1724
1725 int
1726 gdbarch_update (struct gdbarch_info info)
1727 {
1728   struct gdbarch *new_gdbarch;
1729   struct gdbarch_list **list;
1730   struct gdbarch_registration *rego;
1731
1732   /* Fill in any missing bits. Most important is the bfd_architecture
1733      which is used to select the target architecture. */
1734   if (info.bfd_architecture == bfd_arch_unknown)
1735     {
1736       if (info.bfd_arch_info != NULL)
1737         info.bfd_architecture = info.bfd_arch_info->arch;
1738       else if (info.abfd != NULL)
1739         info.bfd_architecture = bfd_get_arch (info.abfd);
1740       /* FIXME - should query BFD for its default architecture. */
1741       else
1742         info.bfd_architecture = current_gdbarch->bfd_arch_info->arch;
1743     }
1744   if (info.bfd_arch_info == NULL)
1745     {
1746       if (target_architecture_auto && info.abfd != NULL)
1747         info.bfd_arch_info = bfd_get_arch_info (info.abfd);
1748       else
1749         info.bfd_arch_info = current_gdbarch->bfd_arch_info;
1750     }
1751   if (info.byte_order == 0)
1752     {
1753       if (target_byte_order_auto && info.abfd != NULL)
1754         info.byte_order = (bfd_big_endian (info.abfd) ? BIG_ENDIAN
1755                            : bfd_little_endian (info.abfd) ? LITTLE_ENDIAN
1756                            : 0);
1757       else
1758         info.byte_order = current_gdbarch->byte_order;
1759       /* FIXME - should query BFD for its default byte-order. */
1760     }
1761   /* A default for abfd? */
1762
1763   /* Find the target that knows about this architecture. */
1764   for (rego = gdbarch_registrary;
1765        rego != NULL;
1766        rego = rego->next)
1767     if (rego->bfd_architecture == info.bfd_architecture)
1768       break;
1769   if (rego == NULL)
1770     {
1771       if (gdbarch_debug)
1772         fprintf_unfiltered (gdb_stdlog, "gdbarch_update: No matching architecture\n");
1773       return 0;
1774     }
1775
1776   if (gdbarch_debug)
1777     {
1778       fprintf_unfiltered (gdb_stdlog,
1779                           "gdbarch_update: info.bfd_architecture %d (%s)\n",
1780                           info.bfd_architecture,
1781                           bfd_lookup_arch (info.bfd_architecture, 0)->printable_name);
1782       fprintf_unfiltered (gdb_stdlog,
1783                           "gdbarch_update: info.bfd_arch_info %s\n",
1784                           (info.bfd_arch_info != NULL
1785                            ? info.bfd_arch_info->printable_name
1786                            : "(null)"));
1787       fprintf_unfiltered (gdb_stdlog,
1788                           "gdbarch_update: info.byte_order %d (%s)\n",
1789                           info.byte_order,
1790                           (info.byte_order == BIG_ENDIAN ? "big"
1791                            : info.byte_order == LITTLE_ENDIAN ? "little"
1792                            : "default"));
1793       fprintf_unfiltered (gdb_stdlog,
1794                           "gdbarch_update: info.abfd 0x%lx\n",
1795                           (long) info.abfd);
1796       fprintf_unfiltered (gdb_stdlog,
1797                           "gdbarch_update: info.tdep_info 0x%lx\n",
1798                           (long) info.tdep_info);
1799     }
1800
1801   /* Ask the target for a replacement architecture. */
1802   new_gdbarch = rego->init (info, rego->arches);
1803
1804   /* Did the target like it?  No. Reject the change. */
1805   if (new_gdbarch == NULL)
1806     {
1807       if (gdbarch_debug)
1808         fprintf_unfiltered (gdb_stdlog, "gdbarch_update: Target rejected architecture\n");
1809       return 0;
1810     }
1811
1812   /* Did the architecture change?  No. Do nothing. */
1813   if (current_gdbarch == new_gdbarch)
1814     {
1815       if (gdbarch_debug)
1816         fprintf_unfiltered (gdb_stdlog, "gdbarch_update: Architecture 0x%08lx (%s) unchanged\n",
1817                             (long) new_gdbarch,
1818                             new_gdbarch->bfd_arch_info->printable_name);
1819       return 1;
1820     }
1821
1822   /* Swap all data belonging to the old target out */
1823   swapout_gdbarch_swap (current_gdbarch);
1824
1825   /* Is this a pre-existing architecture?  Yes. Swap it in.  */
1826   for (list = &rego->arches;
1827        (*list) != NULL;
1828        list = &(*list)->next)
1829     {
1830       if ((*list)->gdbarch == new_gdbarch)
1831         {
1832           if (gdbarch_debug)
1833             fprintf_unfiltered (gdb_stdlog,
1834                                 "gdbarch_update: Previous architecture 0x%08lx (%s) selected\n",
1835                                 (long) new_gdbarch,
1836                                 new_gdbarch->bfd_arch_info->printable_name);
1837           current_gdbarch = new_gdbarch;
1838           swapin_gdbarch_swap (new_gdbarch);
1839           return 1;
1840         }
1841     }
1842
1843   /* Append this new architecture to this targets list. */
1844   (*list) = XMALLOC (struct gdbarch_list);
1845   (*list)->next = NULL;
1846   (*list)->gdbarch = new_gdbarch;
1847
1848   /* Switch to this new architecture.  Dump it out. */
1849   current_gdbarch = new_gdbarch;
1850   if (gdbarch_debug)
1851     {
1852       fprintf_unfiltered (gdb_stdlog,
1853                           "gdbarch_update: New architecture 0x%08lx (%s) selected\n",
1854                           (long) new_gdbarch,
1855                           new_gdbarch->bfd_arch_info->printable_name);
1856     }
1857
1858   /* Check that the newly installed architecture is valid.  Plug in
1859      any post init values.  */
1860   new_gdbarch->dump_tdep = rego->dump_tdep;
1861   verify_gdbarch (new_gdbarch);
1862
1863   /* Initialize the per-architecture memory (swap) areas.
1864      CURRENT_GDBARCH must be update before these modules are
1865      called. */
1866   init_gdbarch_swap (new_gdbarch);
1867
1868   /* Initialize the per-architecture data-pointer of all parties that
1869      registered an interest in this architecture.  CURRENT_GDBARCH
1870      must be updated before these modules are called. */
1871   init_gdbarch_data (new_gdbarch);
1872
1873   if (gdbarch_debug)
1874     gdbarch_dump (current_gdbarch, gdb_stdlog);
1875
1876   return 1;
1877 }
1878
1879
1880 /* Disassembler */
1881
1882 /* Pointer to the target-dependent disassembly function.  */
1883 int (*tm_print_insn) (bfd_vma, disassemble_info *);
1884 disassemble_info tm_print_insn_info;
1885
1886
1887 extern void _initialize_gdbarch (void);
1888
1889 void
1890 _initialize_gdbarch (void)
1891 {
1892   struct cmd_list_element *c;
1893
1894   INIT_DISASSEMBLE_INFO_NO_ARCH (tm_print_insn_info, gdb_stdout, (fprintf_ftype)fprintf_filtered);
1895   tm_print_insn_info.flavour = bfd_target_unknown_flavour;
1896   tm_print_insn_info.read_memory_func = dis_asm_read_memory;
1897   tm_print_insn_info.memory_error_func = dis_asm_memory_error;
1898   tm_print_insn_info.print_address_func = dis_asm_print_address;
1899
1900   add_show_from_set (add_set_cmd ("arch",
1901                                   class_maintenance,
1902                                   var_zinteger,
1903                                   (char *)&gdbarch_debug,
1904                                   "Set architecture debugging.\n\\
1905 When non-zero, architecture debugging is enabled.", &setdebuglist),
1906                      &showdebuglist);
1907   c = add_set_cmd ("archdebug",
1908                    class_maintenance,
1909                    var_zinteger,
1910                    (char *)&gdbarch_debug,
1911                    "Set architecture debugging.\n\\
1912 When non-zero, architecture debugging is enabled.", &setlist);
1913
1914   deprecate_cmd (c, "set debug arch");
1915   deprecate_cmd (add_show_from_set (c, &showlist), "show debug arch");
1916 }
1917 EOF
1918
1919 # close things off
1920 exec 1>&2
1921 #../move-if-change new-gdbarch.c gdbarch.c
1922 compare_new gdbarch.c