gdb/gdbarch.sh

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