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