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