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