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