3 # Architecture commands for GDB, the GNU debugger.
4 # Copyright 1998, 1999, 2000, 2001, 2002 Free Software Foundation, Inc.
6 # This file is part of GDB.
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.
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.
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.
27 echo "${file} missing? cp new-${file} ${file}" 1>&2
28 elif diff -c ${file} new-
${file}
30 echo "${file} unchanged" 1>&2
32 echo "${file} has changed? cp new-${file} ${file}" 1>&2
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"
46 if test "${line}" = ""
49 elif test "${line}" = "#" -a "${comment}" = ""
52 elif expr "${line}" : "#" > /dev
/null
58 # The semantics of IFS varies between different SH's. Some
59 # treat ``::' as three fields while some treat it as just too.
60 # Work around this by eliminating ``::'' ....
61 line
="`echo "${line}" | sed -e 's/::/: :/g' -e 's/::/: :/g'`"
63 OFS
="${IFS}" ; IFS
="[:]"
64 eval read ${read} <<EOF
69 # .... and then going back through each field and strip out those
70 # that ended up with just that space character.
73 if eval test \"\
${${r}}\" = \"\
\"
80 m
) staticdefault
="${predefault}" ;;
81 M
) staticdefault
="0" ;;
82 * ) test "${staticdefault}" || staticdefault
=0 ;;
84 # NOT YET: Breaks BELIEVE_PCC_PROMOTION and confuses non-
85 # multi-arch defaults.
86 # test "${predefault}" || predefault=0
88 # come up with a format, use a few guesses for variables
89 case ":${class}:${fmt}:${print}:" in
91 if [ "${returntype}" = int
]
95 elif [ "${returntype}" = long
]
102 test "${fmt}" ||
fmt="%ld"
103 test "${print}" || print
="(long) ${macro}"
105 case "${invalid_p}" in
108 if [ -n "${predefault}" ]
110 #invalid_p="gdbarch->${function} == ${predefault}"
111 valid_p
="gdbarch->${function} != ${predefault}"
113 #invalid_p="gdbarch->${function} == 0"
114 valid_p
="gdbarch->${function} != 0"
117 * ) valid_p
="!(${invalid_p})"
120 # PREDEFAULT is a valid fallback definition of MEMBER when
121 # multi-arch is not enabled. This ensures that the
122 # default value, when multi-arch is the same as the
123 # default value when not multi-arch. POSTDEFAULT is
124 # always a valid definition of MEMBER as this again
125 # ensures consistency.
127 if [ -n "${postdefault}" ]
129 fallbackdefault
="${postdefault}"
130 elif [ -n "${predefault}" ]
132 fallbackdefault
="${predefault}"
137 #NOT YET: See gdbarch.log for basic verification of
152 fallback_default_p
()
154 [ -n "${postdefault}" -a "x${invalid_p}" != "x0" ] \
155 ||
[ -n "${predefault}" -a "x${invalid_p}" = "x0" ]
158 class_is_variable_p
()
166 class_is_function_p
()
169 *f
* |
*F
* |
*m
* |
*M
* ) true
;;
174 class_is_multiarch_p
()
182 class_is_predicate_p
()
185 *F
* |
*V
* |
*M
* ) true
;;
199 # dump out/verify the doco
209 # F -> function + predicate
210 # hiding a function + predicate to test function validity
213 # V -> variable + predicate
214 # hiding a variable + predicate to test variables validity
216 # hiding something from the ``struct info'' object
217 # m -> multi-arch function
218 # hiding a multi-arch function (parameterised with the architecture)
219 # M -> multi-arch function + predicate
220 # hiding a multi-arch function + predicate to test function validity
224 # See GDB_MULTI_ARCH description. Having GDB_MULTI_ARCH >=
225 # LEVEL is a predicate on checking that a given method is
226 # initialized (using INVALID_P).
230 # The name of the MACRO that this method is to be accessed by.
234 # For functions, the return type; for variables, the data type
238 # For functions, the member function name; for variables, the
239 # variable name. Member function names are always prefixed with
240 # ``gdbarch_'' for name-space purity.
244 # The formal argument list. It is assumed that the formal
245 # argument list includes the actual name of each list element.
246 # A function with no arguments shall have ``void'' as the
247 # formal argument list.
251 # The list of actual arguments. The arguments specified shall
252 # match the FORMAL list given above. Functions with out
253 # arguments leave this blank.
257 # Any GCC attributes that should be attached to the function
258 # declaration. At present this field is unused.
262 # To help with the GDB startup a static gdbarch object is
263 # created. STATICDEFAULT is the value to insert into that
264 # static gdbarch object. Since this a static object only
265 # simple expressions can be used.
267 # If STATICDEFAULT is empty, zero is used.
271 # An initial value to assign to MEMBER of the freshly
272 # malloc()ed gdbarch object. After initialization, the
273 # freshly malloc()ed object is passed to the target
274 # architecture code for further updates.
276 # If PREDEFAULT is empty, zero is used.
278 # A non-empty PREDEFAULT, an empty POSTDEFAULT and a zero
279 # INVALID_P are specified, PREDEFAULT will be used as the
280 # default for the non- multi-arch target.
282 # A zero PREDEFAULT function will force the fallback to call
285 # Variable declarations can refer to ``gdbarch'' which will
286 # contain the current architecture. Care should be taken.
290 # A value to assign to MEMBER of the new gdbarch object should
291 # the target architecture code fail to change the PREDEFAULT
294 # If POSTDEFAULT is empty, no post update is performed.
296 # If both INVALID_P and POSTDEFAULT are non-empty then
297 # INVALID_P will be used to determine if MEMBER should be
298 # changed to POSTDEFAULT.
300 # If a non-empty POSTDEFAULT and a zero INVALID_P are
301 # specified, POSTDEFAULT will be used as the default for the
302 # non- multi-arch target (regardless of the value of
305 # You cannot specify both a zero INVALID_P and a POSTDEFAULT.
307 # Variable declarations can refer to ``gdbarch'' which will
308 # contain the current architecture. Care should be taken.
312 # A predicate equation that validates MEMBER. Non-zero is
313 # returned if the code creating the new architecture failed to
314 # initialize MEMBER or the initialized the member is invalid.
315 # If POSTDEFAULT is non-empty then MEMBER will be updated to
316 # that value. If POSTDEFAULT is empty then internal_error()
319 # If INVALID_P is empty, a check that MEMBER is no longer
320 # equal to PREDEFAULT is used.
322 # The expression ``0'' disables the INVALID_P check making
323 # PREDEFAULT a legitimate value.
325 # See also PREDEFAULT and POSTDEFAULT.
329 # printf style format string that can be used to print out the
330 # MEMBER. Sometimes "%s" is useful. For functions, this is
331 # ignored and the function address is printed.
333 # If FMT is empty, ``%ld'' is used.
337 # An optional equation that casts MEMBER to a value suitable
338 # for formatting by FMT.
340 # If PRINT is empty, ``(long)'' is used.
344 # An optional indicator for any predicte to wrap around the
347 # () -> Call a custom function to do the dump.
348 # exp -> Wrap print up in ``if (${print_p}) ...
349 # ``'' -> No predicate
351 # If PRINT_P is empty, ``1'' is always used.
364 # See below (DOCO) for description of each field
366 i:2:TARGET_ARCHITECTURE:const struct bfd_arch_info *:bfd_arch_info::::&bfd_default_arch_struct::::%s:TARGET_ARCHITECTURE->printable_name:TARGET_ARCHITECTURE != NULL
368 i:2:TARGET_BYTE_ORDER:int:byte_order::::BFD_ENDIAN_BIG
369 # Number of bits in a char or unsigned char for the target machine.
370 # Just like CHAR_BIT in <limits.h> but describes the target machine.
371 # v::TARGET_CHAR_BIT:int:char_bit::::8 * sizeof (char):8::0:
373 # Number of bits in a short or unsigned short for the target machine.
374 v::TARGET_SHORT_BIT:int:short_bit::::8 * sizeof (short):2*TARGET_CHAR_BIT::0
375 # Number of bits in an int or unsigned int for the target machine.
376 v::TARGET_INT_BIT:int:int_bit::::8 * sizeof (int):4*TARGET_CHAR_BIT::0
377 # Number of bits in a long or unsigned long for the target machine.
378 v::TARGET_LONG_BIT:int:long_bit::::8 * sizeof (long):4*TARGET_CHAR_BIT::0
379 # Number of bits in a long long or unsigned long long for the target
381 v::TARGET_LONG_LONG_BIT:int:long_long_bit::::8 * sizeof (LONGEST):2*TARGET_LONG_BIT::0
382 # Number of bits in a float for the target machine.
383 v::TARGET_FLOAT_BIT:int:float_bit::::8 * sizeof (float):4*TARGET_CHAR_BIT::0
384 # Number of bits in a double for the target machine.
385 v::TARGET_DOUBLE_BIT:int:double_bit::::8 * sizeof (double):8*TARGET_CHAR_BIT::0
386 # Number of bits in a long double for the target machine.
387 v::TARGET_LONG_DOUBLE_BIT:int:long_double_bit::::8 * sizeof (long double):2*TARGET_DOUBLE_BIT::0
388 # For most targets, a pointer on the target and its representation as an
389 # address in GDB have the same size and "look the same". For such a
390 # target, you need only set TARGET_PTR_BIT / ptr_bit and TARGET_ADDR_BIT
391 # / addr_bit will be set from it.
393 # If TARGET_PTR_BIT and TARGET_ADDR_BIT are different, you'll probably
394 # also need to set POINTER_TO_ADDRESS and ADDRESS_TO_POINTER as well.
396 # ptr_bit is the size of a pointer on the target
397 v::TARGET_PTR_BIT:int:ptr_bit::::8 * sizeof (void*):TARGET_INT_BIT::0
398 # addr_bit is the size of a target address as represented in gdb
399 v::TARGET_ADDR_BIT:int:addr_bit::::8 * sizeof (void*):0:TARGET_PTR_BIT:
400 # Number of bits in a BFD_VMA for the target object file format.
401 v::TARGET_BFD_VMA_BIT:int:bfd_vma_bit::::8 * sizeof (void*):TARGET_ARCHITECTURE->bits_per_address::0
403 # One if \`char' acts like \`signed char', zero if \`unsigned char'.
404 v::TARGET_CHAR_SIGNED:int:char_signed::::1:-1:1::::
406 f::TARGET_READ_PC:CORE_ADDR:read_pc:ptid_t ptid:ptid::0:generic_target_read_pc::0
407 f::TARGET_WRITE_PC:void:write_pc:CORE_ADDR val, ptid_t ptid:val, ptid::0:generic_target_write_pc::0
408 f::TARGET_READ_FP:CORE_ADDR:read_fp:void:::0:generic_target_read_fp::0
409 f::TARGET_WRITE_FP:void:write_fp:CORE_ADDR val:val::0:generic_target_write_fp::0
410 f::TARGET_READ_SP:CORE_ADDR:read_sp:void:::0:generic_target_read_sp::0
411 f::TARGET_WRITE_SP:void:write_sp:CORE_ADDR val:val::0:generic_target_write_sp::0
412 # Function for getting target's idea of a frame pointer. FIXME: GDB's
413 # whole scheme for dealing with "frames" and "frame pointers" needs a
415 f::TARGET_VIRTUAL_FRAME_POINTER:void:virtual_frame_pointer:CORE_ADDR pc, int *frame_regnum, LONGEST *frame_offset:pc, frame_regnum, frame_offset::0:legacy_virtual_frame_pointer::0
417 M:::void:register_read:int regnum, char *buf:regnum, buf:
418 M:::void:register_write:int regnum, char *buf:regnum, buf:
420 v:2:NUM_REGS:int:num_regs::::0:-1
421 # This macro gives the number of pseudo-registers that live in the
422 # register namespace but do not get fetched or stored on the target.
423 # These pseudo-registers may be aliases for other registers,
424 # combinations of other registers, or they may be computed by GDB.
425 v:2:NUM_PSEUDO_REGS:int:num_pseudo_regs::::0:0::0:::
426 v:2:SP_REGNUM:int:sp_regnum::::0:-1
427 v:2:FP_REGNUM:int:fp_regnum::::0:-1
428 v:2:PC_REGNUM:int:pc_regnum::::0:-1
429 v:2:FP0_REGNUM:int:fp0_regnum::::0:-1::0
430 v:2:NPC_REGNUM:int:npc_regnum::::0:-1::0
431 v:2:NNPC_REGNUM:int:nnpc_regnum::::0:-1::0
432 # Convert stab register number (from \`r\' declaration) to a gdb REGNUM.
433 f:2:STAB_REG_TO_REGNUM:int:stab_reg_to_regnum:int stab_regnr:stab_regnr:::no_op_reg_to_regnum::0
434 # Provide a default mapping from a ecoff register number to a gdb REGNUM.
435 f:2:ECOFF_REG_TO_REGNUM:int:ecoff_reg_to_regnum:int ecoff_regnr:ecoff_regnr:::no_op_reg_to_regnum::0
436 # Provide a default mapping from a DWARF register number to a gdb REGNUM.
437 f:2:DWARF_REG_TO_REGNUM:int:dwarf_reg_to_regnum:int dwarf_regnr:dwarf_regnr:::no_op_reg_to_regnum::0
438 # Convert from an sdb register number to an internal gdb register number.
439 # This should be defined in tm.h, if REGISTER_NAMES is not set up
440 # to map one to one onto the sdb register numbers.
441 f:2:SDB_REG_TO_REGNUM:int:sdb_reg_to_regnum:int sdb_regnr:sdb_regnr:::no_op_reg_to_regnum::0
442 f:2:DWARF2_REG_TO_REGNUM:int:dwarf2_reg_to_regnum:int dwarf2_regnr:dwarf2_regnr:::no_op_reg_to_regnum::0
443 f:2:REGISTER_NAME:char *:register_name:int regnr:regnr:::legacy_register_name::0
444 v:2:REGISTER_SIZE:int:register_size::::0:-1
445 v:2:REGISTER_BYTES:int:register_bytes::::0:-1
446 f:2:REGISTER_BYTE:int:register_byte:int reg_nr:reg_nr::0:0
447 f:2:REGISTER_RAW_SIZE:int:register_raw_size:int reg_nr:reg_nr::generic_register_raw_size:0
448 v:2:MAX_REGISTER_RAW_SIZE:int:max_register_raw_size::::0:-1
449 f:2:REGISTER_VIRTUAL_SIZE:int:register_virtual_size:int reg_nr:reg_nr::generic_register_virtual_size:0
450 v:2:MAX_REGISTER_VIRTUAL_SIZE:int:max_register_virtual_size::::0:-1
451 f:2:REGISTER_VIRTUAL_TYPE:struct type *:register_virtual_type:int reg_nr:reg_nr::0:0
452 f:2:DO_REGISTERS_INFO:void:do_registers_info:int reg_nr, int fpregs:reg_nr, fpregs:::do_registers_info::0
453 # MAP a GDB RAW register number onto a simulator register number. See
454 # also include/...-sim.h.
455 f:2:REGISTER_SIM_REGNO:int:register_sim_regno:int reg_nr:reg_nr:::default_register_sim_regno::0
456 F:2:REGISTER_BYTES_OK:int:register_bytes_ok:long nr_bytes:nr_bytes::0:0
457 f:2:CANNOT_FETCH_REGISTER:int:cannot_fetch_register:int regnum:regnum:::cannot_register_not::0
458 f:2:CANNOT_STORE_REGISTER:int:cannot_store_register:int regnum:regnum:::cannot_register_not::0
460 v:1:USE_GENERIC_DUMMY_FRAMES:int:use_generic_dummy_frames::::0:-1
461 v:1:CALL_DUMMY_LOCATION:int:call_dummy_location::::0:0
462 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
463 v:2:CALL_DUMMY_START_OFFSET:CORE_ADDR:call_dummy_start_offset::::0:-1:::0x%08lx
464 v:2:CALL_DUMMY_BREAKPOINT_OFFSET:CORE_ADDR:call_dummy_breakpoint_offset::::0:-1::gdbarch->call_dummy_breakpoint_offset_p && gdbarch->call_dummy_breakpoint_offset == -1:0x%08lx::CALL_DUMMY_BREAKPOINT_OFFSET_P
465 v:1:CALL_DUMMY_BREAKPOINT_OFFSET_P:int:call_dummy_breakpoint_offset_p::::0:-1
466 v:2:CALL_DUMMY_LENGTH:int:call_dummy_length::::0:-1:::::CALL_DUMMY_LOCATION == BEFORE_TEXT_END || CALL_DUMMY_LOCATION == AFTER_TEXT_END
467 f:1: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
468 v:1:CALL_DUMMY_P:int:call_dummy_p::::0:-1
469 v:2:CALL_DUMMY_WORDS:LONGEST *:call_dummy_words::::0:legacy_call_dummy_words::0:0x%08lx
470 v:2:SIZEOF_CALL_DUMMY_WORDS:int:sizeof_call_dummy_words::::0:legacy_sizeof_call_dummy_words::0:0x%08lx
471 v:1:CALL_DUMMY_STACK_ADJUST_P:int:call_dummy_stack_adjust_p::::0:-1:::0x%08lx
472 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
473 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
474 f:2:INIT_FRAME_PC_FIRST:void:init_frame_pc_first:int fromleaf, struct frame_info *prev:fromleaf, prev:::init_frame_pc_noop::0
475 f:2:INIT_FRAME_PC:void:init_frame_pc:int fromleaf, struct frame_info *prev:fromleaf, prev:::init_frame_pc_default::0
477 v:2:BELIEVE_PCC_PROMOTION:int:believe_pcc_promotion:::::::
478 v:2:BELIEVE_PCC_PROMOTION_TYPE:int:believe_pcc_promotion_type:::::::
479 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
480 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
482 f:1:REGISTER_CONVERTIBLE:int:register_convertible:int nr:nr:::generic_register_convertible_not::0
483 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
484 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
485 # This function is called when the value of a pseudo-register needs to
486 # be updated. Typically it will be defined on a per-architecture
488 F:2:FETCH_PSEUDO_REGISTER:void:fetch_pseudo_register:int regnum:regnum:
489 # This function is called when the value of a pseudo-register needs to
490 # be set or stored. Typically it will be defined on a
491 # per-architecture basis.
492 F:2:STORE_PSEUDO_REGISTER:void:store_pseudo_register:int regnum:regnum:
494 f:2:POINTER_TO_ADDRESS:CORE_ADDR:pointer_to_address:struct type *type, void *buf:type, buf:::unsigned_pointer_to_address::0
495 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
496 F:2:INTEGER_TO_ADDRESS:CORE_ADDR:integer_to_address:struct type *type, void *buf:type, buf
498 f:2:RETURN_VALUE_ON_STACK:int:return_value_on_stack:struct type *type:type:::generic_return_value_on_stack_not::0
499 f:2:EXTRACT_RETURN_VALUE:void:extract_return_value:struct type *type, char *regbuf, char *valbuf:type, regbuf, valbuf::0:0
500 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
501 f:2:PUSH_DUMMY_FRAME:void:push_dummy_frame:void:-:::0
502 F:1:PUSH_RETURN_ADDRESS:CORE_ADDR:push_return_address:CORE_ADDR pc, CORE_ADDR sp:pc, sp:::0
503 f:2:POP_FRAME:void:pop_frame:void:-:::0
505 f:2:STORE_STRUCT_RETURN:void:store_struct_return:CORE_ADDR addr, CORE_ADDR sp:addr, sp:::0
506 f:2:STORE_RETURN_VALUE:void:store_return_value:struct type *type, char *valbuf:type, valbuf:::0
507 F:2:EXTRACT_STRUCT_VALUE_ADDRESS:CORE_ADDR:extract_struct_value_address:char *regbuf:regbuf:::0
508 f:2:USE_STRUCT_CONVENTION:int:use_struct_convention:int gcc_p, struct type *value_type:gcc_p, value_type:::generic_use_struct_convention::0
510 f:2:FRAME_INIT_SAVED_REGS:void:frame_init_saved_regs:struct frame_info *frame:frame::0:0
511 F:2:INIT_EXTRA_FRAME_INFO:void:init_extra_frame_info:int fromleaf, struct frame_info *frame:fromleaf, frame:::0
513 f:2:SKIP_PROLOGUE:CORE_ADDR:skip_prologue:CORE_ADDR ip:ip::0:0
514 f:2:PROLOGUE_FRAMELESS_P:int:prologue_frameless_p:CORE_ADDR ip:ip::0:generic_prologue_frameless_p::0
515 f:2:INNER_THAN:int:inner_than:CORE_ADDR lhs, CORE_ADDR rhs:lhs, rhs::0:0
516 f:2:BREAKPOINT_FROM_PC:unsigned char *:breakpoint_from_pc:CORE_ADDR *pcptr, int *lenptr:pcptr, lenptr:::legacy_breakpoint_from_pc::0
517 f:2:MEMORY_INSERT_BREAKPOINT:int:memory_insert_breakpoint:CORE_ADDR addr, char *contents_cache:addr, contents_cache::0:default_memory_insert_breakpoint::0
518 f:2:MEMORY_REMOVE_BREAKPOINT:int:memory_remove_breakpoint:CORE_ADDR addr, char *contents_cache:addr, contents_cache::0:default_memory_remove_breakpoint::0
519 v:2:DECR_PC_AFTER_BREAK:CORE_ADDR:decr_pc_after_break::::0:-1
520 f::PREPARE_TO_PROCEED:int:prepare_to_proceed:int select_it:select_it::0:default_prepare_to_proceed::0
521 v:2:FUNCTION_START_OFFSET:CORE_ADDR:function_start_offset::::0:-1
523 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
525 v:2:FRAME_ARGS_SKIP:CORE_ADDR:frame_args_skip::::0:-1
526 f:2:FRAMELESS_FUNCTION_INVOCATION:int:frameless_function_invocation:struct frame_info *fi:fi:::generic_frameless_function_invocation_not::0
527 f:2:FRAME_CHAIN:CORE_ADDR:frame_chain:struct frame_info *frame:frame::0:0
528 f:1:FRAME_CHAIN_VALID:int:frame_chain_valid:CORE_ADDR chain, struct frame_info *thisframe:chain, thisframe::0:0
529 f:2:FRAME_SAVED_PC:CORE_ADDR:frame_saved_pc:struct frame_info *fi:fi::0:0
530 f:2:FRAME_ARGS_ADDRESS:CORE_ADDR:frame_args_address:struct frame_info *fi:fi::0:0
531 f:2:FRAME_LOCALS_ADDRESS:CORE_ADDR:frame_locals_address:struct frame_info *fi:fi::0:0
532 f:2:SAVED_PC_AFTER_CALL:CORE_ADDR:saved_pc_after_call:struct frame_info *frame:frame::0:0
533 f:2:FRAME_NUM_ARGS:int:frame_num_args:struct frame_info *frame:frame::0:0
535 F:2:STACK_ALIGN:CORE_ADDR:stack_align:CORE_ADDR sp:sp::0:0
536 v:1:EXTRA_STACK_ALIGNMENT_NEEDED:int:extra_stack_alignment_needed::::0:1::0:::
537 F:2:REG_STRUCT_HAS_ADDR:int:reg_struct_has_addr:int gcc_p, struct type *type:gcc_p, type::0:0
538 F:2:SAVE_DUMMY_FRAME_TOS:void:save_dummy_frame_tos:CORE_ADDR sp:sp::0:0
539 v:2:PARM_BOUNDARY:int:parm_boundary
541 v:2:TARGET_FLOAT_FORMAT:const struct floatformat *:float_format::::::default_float_format (gdbarch)
542 v:2:TARGET_DOUBLE_FORMAT:const struct floatformat *:double_format::::::default_double_format (gdbarch)
543 v:2:TARGET_LONG_DOUBLE_FORMAT:const struct floatformat *:long_double_format::::::&floatformat_unknown
544 f:2:CONVERT_FROM_FUNC_PTR_ADDR:CORE_ADDR:convert_from_func_ptr_addr:CORE_ADDR addr:addr:::core_addr_identity::0
545 # On some machines there are bits in addresses which are not really
546 # part of the address, but are used by the kernel, the hardware, etc.
547 # for special purposes. ADDR_BITS_REMOVE takes out any such bits so
548 # we get a "real" address such as one would find in a symbol table.
549 # This is used only for addresses of instructions, and even then I'm
550 # not sure it's used in all contexts. It exists to deal with there
551 # being a few stray bits in the PC which would mislead us, not as some
552 # sort of generic thing to handle alignment or segmentation (it's
553 # possible it should be in TARGET_READ_PC instead).
554 f:2:ADDR_BITS_REMOVE:CORE_ADDR:addr_bits_remove:CORE_ADDR addr:addr:::core_addr_identity::0
555 # It is not at all clear why SMASH_TEXT_ADDRESS is not folded into
557 f:2:SMASH_TEXT_ADDRESS:CORE_ADDR:smash_text_address:CORE_ADDR addr:addr:::core_addr_identity::0
558 # FIXME/cagney/2001-01-18: This should be split in two. A target method that indicates if
559 # the target needs software single step. An ISA method to implement it.
561 # FIXME/cagney/2001-01-18: This should be replaced with something that inserts breakpoints
562 # using the breakpoint system instead of blatting memory directly (as with rs6000).
564 # FIXME/cagney/2001-01-18: The logic is backwards. It should be asking if the target can
565 # single step. If not, then implement single step using breakpoints.
566 F:2:SOFTWARE_SINGLE_STEP:void:software_single_step:enum target_signal sig, int insert_breakpoints_p:sig, insert_breakpoints_p::0:0
567 f:2:TARGET_PRINT_INSN:int:print_insn:bfd_vma vma, disassemble_info *info:vma, info:::legacy_print_insn::0
568 f:2:SKIP_TRAMPOLINE_CODE:CORE_ADDR:skip_trampoline_code:CORE_ADDR pc:pc:::generic_skip_trampoline_code::0
569 # For SVR4 shared libraries, each call goes through a small piece of
570 # trampoline code in the ".plt" section. IN_SOLIB_CALL_TRAMPOLINE evaluates
571 # to nonzero if we are current stopped in one of these.
572 f:2:IN_SOLIB_CALL_TRAMPOLINE:int:in_solib_call_trampoline:CORE_ADDR pc, char *name:pc, name:::generic_in_solib_call_trampoline::0
573 # A target might have problems with watchpoints as soon as the stack
574 # frame of the current function has been destroyed. This mostly happens
575 # as the first action in a funtion's epilogue. in_function_epilogue_p()
576 # is defined to return a non-zero value if either the given addr is one
577 # instruction after the stack destroying instruction up to the trailing
578 # return instruction or if we can figure out that the stack frame has
579 # already been invalidated regardless of the value of addr. Targets
580 # which don't suffer from that problem could just let this functionality
582 m:::int:in_function_epilogue_p:CORE_ADDR addr:addr::0:generic_in_function_epilogue_p::0
583 # Given a vector of command-line arguments, return a newly allocated
584 # string which, when passed to the create_inferior function, will be
585 # parsed (on Unix systems, by the shell) to yield the same vector.
586 # This function should call error() if the argument vector is not
587 # representable for this target or if this target does not support
588 # command-line arguments.
589 # ARGC is the number of elements in the vector.
590 # ARGV is an array of strings, one per argument.
591 m::CONSTRUCT_INFERIOR_ARGUMENTS:char *:construct_inferior_arguments:int argc, char **argv:argc, argv:::construct_inferior_arguments::0
592 F:2:DWARF2_BUILD_FRAME_INFO:void:dwarf2_build_frame_info:struct objfile *objfile:objfile:::0
599 exec > new-gdbarch.log
600 function_list |
while do_read
603 ${class} ${macro}(${actual})
604 ${returntype} ${function} ($formal)${attrib}
608 eval echo \"\ \ \ \
${r}=\
${${r}}\"
610 # #fallbackdefault=${fallbackdefault}
611 # #valid_p=${valid_p}
613 if class_is_predicate_p
&& fallback_default_p
615 echo "Error: predicate function ${macro} can not have a non- multi-arch default" 1>&2
619 if [ "x${invalid_p}" = "x0" -a -n "${postdefault}" ]
621 echo "Error: postdefault is useless when invalid_p=0" 1>&2
625 if class_is_multiarch_p
627 if class_is_predicate_p
; then :
628 elif test "x${predefault}" = "x"
630 echo "Error: pure multi-arch function must have a predefault" 1>&2
639 compare_new gdbarch.log
645 /* *INDENT-OFF* */ /* THIS FILE IS GENERATED */
647 /* Dynamic architecture support for GDB, the GNU debugger.
648 Copyright 1998, 1999, 2000, 2001, 2002 Free Software Foundation, Inc.
650 This file is part of GDB.
652 This program is free software; you can redistribute it and/or modify
653 it under the terms of the GNU General Public License as published by
654 the Free Software Foundation; either version 2 of the License, or
655 (at your option) any later version.
657 This program is distributed in the hope that it will be useful,
658 but WITHOUT ANY WARRANTY; without even the implied warranty of
659 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
660 GNU General Public License for more details.
662 You should have received a copy of the GNU General Public License
663 along with this program; if not, write to the Free Software
664 Foundation, Inc., 59 Temple Place - Suite 330,
665 Boston, MA 02111-1307, USA. */
667 /* This file was created with the aid of \`\`gdbarch.sh''.
669 The Bourne shell script \`\`gdbarch.sh'' creates the files
670 \`\`new-gdbarch.c'' and \`\`new-gdbarch.h and then compares them
671 against the existing \`\`gdbarch.[hc]''. Any differences found
674 If editing this file, please also run gdbarch.sh and merge any
675 changes into that script. Conversely, when making sweeping changes
676 to this file, modifying gdbarch.sh and using its output may prove
692 #include "dis-asm.h" /* Get defs for disassemble_info, which unfortunately is a typedef. */
694 #include "value.h" /* For default_coerce_float_to_double which is referenced by a macro. */
701 extern struct gdbarch *current_gdbarch;
704 /* If any of the following are defined, the target wasn't correctly
708 #if defined (EXTRA_FRAME_INFO)
709 #error "EXTRA_FRAME_INFO: replaced by struct frame_extra_info"
714 #if defined (FRAME_FIND_SAVED_REGS)
715 #error "FRAME_FIND_SAVED_REGS: replaced by FRAME_INIT_SAVED_REGS"
719 #if (GDB_MULTI_ARCH >= GDB_MULTI_ARCH_PURE) && defined (GDB_TM_FILE)
720 #error "GDB_TM_FILE: Pure multi-arch targets do not have a tm.h file."
727 printf "/* The following are pre-initialized by GDBARCH. */\n"
728 function_list |
while do_read
733 printf "extern ${returntype} gdbarch_${function} (struct gdbarch *gdbarch);\n"
734 printf "/* set_gdbarch_${function}() - not applicable - pre-initialized. */\n"
735 printf "#if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (${macro})\n"
736 printf "#error \"Non multi-arch definition of ${macro}\"\n"
738 printf "#if GDB_MULTI_ARCH\n"
739 printf "#if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (${macro})\n"
740 printf "#define ${macro} (gdbarch_${function} (current_gdbarch))\n"
749 printf "/* The following are initialized by the target dependent code. */\n"
750 function_list |
while do_read
752 if [ -n "${comment}" ]
754 echo "${comment}" |
sed \
759 if class_is_multiarch_p
761 if class_is_predicate_p
764 printf "extern int gdbarch_${function}_p (struct gdbarch *gdbarch);\n"
767 if class_is_predicate_p
770 printf "#if defined (${macro})\n"
771 printf "/* Legacy for systems yet to multi-arch ${macro} */\n"
772 #printf "#if (GDB_MULTI_ARCH <= GDB_MULTI_ARCH_PARTIAL) && defined (${macro})\n"
773 printf "#if !defined (${macro}_P)\n"
774 printf "#define ${macro}_P() (1)\n"
778 printf "/* Default predicate for non- multi-arch targets. */\n"
779 printf "#if (!GDB_MULTI_ARCH) && !defined (${macro}_P)\n"
780 printf "#define ${macro}_P() (0)\n"
783 printf "extern int gdbarch_${function}_p (struct gdbarch *gdbarch);\n"
784 printf "#if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (${macro}_P)\n"
785 printf "#error \"Non multi-arch definition of ${macro}\"\n"
787 printf "#if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (${macro}_P)\n"
788 printf "#define ${macro}_P() (gdbarch_${function}_p (current_gdbarch))\n"
792 if class_is_variable_p
794 if fallback_default_p || class_is_predicate_p
797 printf "/* Default (value) for non- multi-arch platforms. */\n"
798 printf "#if (!GDB_MULTI_ARCH) && !defined (${macro})\n"
799 echo "#define ${macro} (${fallbackdefault})" \
800 |
sed -e 's/\([^a-z_]\)\(gdbarch[^a-z_]\)/\1current_\2/g'
804 printf "extern ${returntype} gdbarch_${function} (struct gdbarch *gdbarch);\n"
805 printf "extern void set_gdbarch_${function} (struct gdbarch *gdbarch, ${returntype} ${function});\n"
806 printf "#if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (${macro})\n"
807 printf "#error \"Non multi-arch definition of ${macro}\"\n"
809 printf "#if GDB_MULTI_ARCH\n"
810 printf "#if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (${macro})\n"
811 printf "#define ${macro} (gdbarch_${function} (current_gdbarch))\n"
815 if class_is_function_p
817 if class_is_multiarch_p
; then :
818 elif fallback_default_p || class_is_predicate_p
821 printf "/* Default (function) for non- multi-arch platforms. */\n"
822 printf "#if (!GDB_MULTI_ARCH) && !defined (${macro})\n"
823 if [ "x${fallbackdefault}" = "x0" ]
825 printf "#define ${macro}(${actual}) (internal_error (__FILE__, __LINE__, \"${macro}\"), 0)\n"
827 # FIXME: Should be passing current_gdbarch through!
828 echo "#define ${macro}(${actual}) (${fallbackdefault} (${actual}))" \
829 |
sed -e 's/\([^a-z_]\)\(gdbarch[^a-z_]\)/\1current_\2/g'
834 if [ "x${formal}" = "xvoid" ] && class_is_multiarch_p
836 printf "typedef ${returntype} (gdbarch_${function}_ftype) (struct gdbarch *gdbarch);\n"
837 elif class_is_multiarch_p
839 printf "typedef ${returntype} (gdbarch_${function}_ftype) (struct gdbarch *gdbarch, ${formal});\n"
841 printf "typedef ${returntype} (gdbarch_${function}_ftype) (${formal});\n"
843 if [ "x${formal}" = "xvoid" ]
845 printf "extern ${returntype} gdbarch_${function} (struct gdbarch *gdbarch);\n"
847 printf "extern ${returntype} gdbarch_${function} (struct gdbarch *gdbarch, ${formal});\n"
849 printf "extern void set_gdbarch_${function} (struct gdbarch *gdbarch, gdbarch_${function}_ftype *${function});\n"
850 if class_is_multiarch_p
; then :
852 printf "#if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (${macro})\n"
853 printf "#error \"Non multi-arch definition of ${macro}\"\n"
855 printf "#if GDB_MULTI_ARCH\n"
856 printf "#if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (${macro})\n"
857 if [ "x${actual}" = "x" ]
859 printf "#define ${macro}() (gdbarch_${function} (current_gdbarch))\n"
860 elif [ "x${actual}" = "x-" ]
862 printf "#define ${macro} (gdbarch_${function} (current_gdbarch))\n"
864 printf "#define ${macro}(${actual}) (gdbarch_${function} (current_gdbarch, ${actual}))\n"
875 extern struct gdbarch_tdep *gdbarch_tdep (struct gdbarch *gdbarch);
878 /* Mechanism for co-ordinating the selection of a specific
881 GDB targets (*-tdep.c) can register an interest in a specific
882 architecture. Other GDB components can register a need to maintain
883 per-architecture data.
885 The mechanisms below ensures that there is only a loose connection
886 between the set-architecture command and the various GDB
887 components. Each component can independently register their need
888 to maintain architecture specific data with gdbarch.
892 Previously, a single TARGET_ARCHITECTURE_HOOK was provided. It
895 The more traditional mega-struct containing architecture specific
896 data for all the various GDB components was also considered. Since
897 GDB is built from a variable number of (fairly independent)
898 components it was determined that the global aproach was not
902 /* Register a new architectural family with GDB.
904 Register support for the specified ARCHITECTURE with GDB. When
905 gdbarch determines that the specified architecture has been
906 selected, the corresponding INIT function is called.
910 The INIT function takes two parameters: INFO which contains the
911 information available to gdbarch about the (possibly new)
912 architecture; ARCHES which is a list of the previously created
913 \`\`struct gdbarch'' for this architecture.
915 The INIT function parameter INFO shall, as far as possible, be
916 pre-initialized with information obtained from INFO.ABFD or
917 previously selected architecture (if similar).
919 The INIT function shall return any of: NULL - indicating that it
920 doesn't recognize the selected architecture; an existing \`\`struct
921 gdbarch'' from the ARCHES list - indicating that the new
922 architecture is just a synonym for an earlier architecture (see
923 gdbarch_list_lookup_by_info()); a newly created \`\`struct gdbarch''
924 - that describes the selected architecture (see gdbarch_alloc()).
926 The DUMP_TDEP function shall print out all target specific values.
927 Care should be taken to ensure that the function works in both the
928 multi-arch and non- multi-arch cases. */
932 struct gdbarch *gdbarch;
933 struct gdbarch_list *next;
938 /* Use default: NULL (ZERO). */
939 const struct bfd_arch_info *bfd_arch_info;
941 /* Use default: BFD_ENDIAN_UNKNOWN (NB: is not ZERO). */
944 /* Use default: NULL (ZERO). */
947 /* Use default: NULL (ZERO). */
948 struct gdbarch_tdep_info *tdep_info;
951 typedef struct gdbarch *(gdbarch_init_ftype) (struct gdbarch_info info, struct gdbarch_list *arches);
952 typedef void (gdbarch_dump_tdep_ftype) (struct gdbarch *gdbarch, struct ui_file *file);
954 /* DEPRECATED - use gdbarch_register() */
955 extern void register_gdbarch_init (enum bfd_architecture architecture, gdbarch_init_ftype *);
957 extern void gdbarch_register (enum bfd_architecture architecture,
958 gdbarch_init_ftype *,
959 gdbarch_dump_tdep_ftype *);
962 /* Return a freshly allocated, NULL terminated, array of the valid
963 architecture names. Since architectures are registered during the
964 _initialize phase this function only returns useful information
965 once initialization has been completed. */
967 extern const char **gdbarch_printable_names (void);
970 /* Helper function. Search the list of ARCHES for a GDBARCH that
971 matches the information provided by INFO. */
973 extern struct gdbarch_list *gdbarch_list_lookup_by_info (struct gdbarch_list *arches, const struct gdbarch_info *info);
976 /* Helper function. Create a preliminary \`\`struct gdbarch''. Perform
977 basic initialization using values obtained from the INFO andTDEP
978 parameters. set_gdbarch_*() functions are called to complete the
979 initialization of the object. */
981 extern struct gdbarch *gdbarch_alloc (const struct gdbarch_info *info, struct gdbarch_tdep *tdep);
984 /* Helper function. Free a partially-constructed \`\`struct gdbarch''.
985 It is assumed that the caller freeds the \`\`struct
988 extern void gdbarch_free (struct gdbarch *);
991 /* Helper function. Force an update of the current architecture.
993 The actual architecture selected is determined by INFO, \`\`(gdb) set
994 architecture'' et.al., the existing architecture and BFD's default
995 architecture. INFO should be initialized to zero and then selected
996 fields should be updated.
998 Returns non-zero if the update succeeds */
1000 extern int gdbarch_update_p (struct gdbarch_info info);
1004 /* Register per-architecture data-pointer.
1006 Reserve space for a per-architecture data-pointer. An identifier
1007 for the reserved data-pointer is returned. That identifer should
1008 be saved in a local static variable.
1010 The per-architecture data-pointer can be initialized in one of two
1011 ways: The value can be set explicitly using a call to
1012 set_gdbarch_data(); the value can be set implicitly using the value
1013 returned by a non-NULL INIT() callback. INIT(), when non-NULL is
1014 called after the basic architecture vector has been created.
1016 When a previously created architecture is re-selected, the
1017 per-architecture data-pointer for that previous architecture is
1018 restored. INIT() is not called.
1020 During initialization, multiple assignments of the data-pointer are
1021 allowed, non-NULL values are deleted by calling FREE(). If the
1022 architecture is deleted using gdbarch_free() all non-NULL data
1023 pointers are also deleted using FREE().
1025 Multiple registrarants for any architecture are allowed (and
1026 strongly encouraged). */
1028 struct gdbarch_data;
1030 typedef void *(gdbarch_data_init_ftype) (struct gdbarch *gdbarch);
1031 typedef void (gdbarch_data_free_ftype) (struct gdbarch *gdbarch,
1033 extern struct gdbarch_data *register_gdbarch_data (gdbarch_data_init_ftype *init,
1034 gdbarch_data_free_ftype *free);
1035 extern void set_gdbarch_data (struct gdbarch *gdbarch,
1036 struct gdbarch_data *data,
1039 extern void *gdbarch_data (struct gdbarch_data*);
1042 /* Register per-architecture memory region.
1044 Provide a memory-region swap mechanism. Per-architecture memory
1045 region are created. These memory regions are swapped whenever the
1046 architecture is changed. For a new architecture, the memory region
1047 is initialized with zero (0) and the INIT function is called.
1049 Memory regions are swapped / initialized in the order that they are
1050 registered. NULL DATA and/or INIT values can be specified.
1052 New code should use register_gdbarch_data(). */
1054 typedef void (gdbarch_swap_ftype) (void);
1055 extern void register_gdbarch_swap (void *data, unsigned long size, gdbarch_swap_ftype *init);
1056 #define REGISTER_GDBARCH_SWAP(VAR) register_gdbarch_swap (&(VAR), sizeof ((VAR)), NULL)
1060 /* The target-system-dependent byte order is dynamic */
1062 extern int target_byte_order;
1063 #ifndef TARGET_BYTE_ORDER
1064 #define TARGET_BYTE_ORDER (target_byte_order + 0)
1067 extern int target_byte_order_auto;
1068 #ifndef TARGET_BYTE_ORDER_AUTO
1069 #define TARGET_BYTE_ORDER_AUTO (target_byte_order_auto + 0)
1074 /* The target-system-dependent BFD architecture is dynamic */
1076 extern int target_architecture_auto;
1077 #ifndef TARGET_ARCHITECTURE_AUTO
1078 #define TARGET_ARCHITECTURE_AUTO (target_architecture_auto + 0)
1081 extern const struct bfd_arch_info *target_architecture;
1082 #ifndef TARGET_ARCHITECTURE
1083 #define TARGET_ARCHITECTURE (target_architecture + 0)
1087 /* The target-system-dependent disassembler is semi-dynamic */
1089 extern int dis_asm_read_memory (bfd_vma memaddr, bfd_byte *myaddr,
1090 unsigned int len, disassemble_info *info);
1092 extern void dis_asm_memory_error (int status, bfd_vma memaddr,
1093 disassemble_info *info);
1095 extern void dis_asm_print_address (bfd_vma addr,
1096 disassemble_info *info);
1098 extern int (*tm_print_insn) (bfd_vma, disassemble_info*);
1099 extern disassemble_info tm_print_insn_info;
1100 #ifndef TARGET_PRINT_INSN_INFO
1101 #define TARGET_PRINT_INSN_INFO (&tm_print_insn_info)
1106 /* Set the dynamic target-system-dependent parameters (architecture,
1107 byte-order, ...) using information found in the BFD */
1109 extern void set_gdbarch_from_file (bfd *);
1112 /* Initialize the current architecture to the "first" one we find on
1115 extern void initialize_current_architecture (void);
1117 /* For non-multiarched targets, do any initialization of the default
1118 gdbarch object necessary after the _initialize_MODULE functions
1120 extern void initialize_non_multiarch ();
1122 /* gdbarch trace variable */
1123 extern int gdbarch_debug;
1125 extern void gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file);
1130 #../move-if-change new-gdbarch.h gdbarch.h
1131 compare_new gdbarch.h
1138 exec > new-gdbarch.c
1143 #include "arch-utils.h"
1147 #include "inferior.h" /* enum CALL_DUMMY_LOCATION et.al. */
1149 /* Just include everything in sight so that the every old definition
1150 of macro is visible. */
1151 #include "gdb_string.h"
1155 #include "inferior.h"
1156 #include "breakpoint.h"
1157 #include "gdb_wait.h"
1158 #include "gdbcore.h"
1161 #include "gdbthread.h"
1162 #include "annotate.h"
1163 #include "symfile.h" /* for overlay functions */
1164 #include "value.h" /* For old tm.h/nm.h macros. */
1168 #include "floatformat.h"
1170 #include "gdb_assert.h"
1171 #include "gdb-events.h"
1173 /* Static function declarations */
1175 static void verify_gdbarch (struct gdbarch *gdbarch);
1176 static void alloc_gdbarch_data (struct gdbarch *);
1177 static void init_gdbarch_data (struct gdbarch *);
1178 static void free_gdbarch_data (struct gdbarch *);
1179 static void init_gdbarch_swap (struct gdbarch *);
1180 static void swapout_gdbarch_swap (struct gdbarch *);
1181 static void swapin_gdbarch_swap (struct gdbarch *);
1183 /* Convenience macro for allocting typesafe memory. */
1186 #define XMALLOC(TYPE) (TYPE*) xmalloc (sizeof (TYPE))
1190 /* Non-zero if we want to trace architecture code. */
1192 #ifndef GDBARCH_DEBUG
1193 #define GDBARCH_DEBUG 0
1195 int gdbarch_debug = GDBARCH_DEBUG;
1199 # gdbarch open the gdbarch object
1201 printf "/* Maintain the struct gdbarch object */\n"
1203 printf "struct gdbarch\n"
1205 printf " /* basic architectural information */\n"
1206 function_list |
while do_read
1210 printf " ${returntype} ${function};\n"
1214 printf " /* target specific vector. */\n"
1215 printf " struct gdbarch_tdep *tdep;\n"
1216 printf " gdbarch_dump_tdep_ftype *dump_tdep;\n"
1218 printf " /* per-architecture data-pointers */\n"
1219 printf " unsigned nr_data;\n"
1220 printf " void **data;\n"
1222 printf " /* per-architecture swap-regions */\n"
1223 printf " struct gdbarch_swap *swap;\n"
1226 /* Multi-arch values.
1228 When extending this structure you must:
1230 Add the field below.
1232 Declare set/get functions and define the corresponding
1235 gdbarch_alloc(): If zero/NULL is not a suitable default,
1236 initialize the new field.
1238 verify_gdbarch(): Confirm that the target updated the field
1241 gdbarch_dump(): Add a fprintf_unfiltered call so that the new
1244 \`\`startup_gdbarch()'': Append an initial value to the static
1245 variable (base values on the host's c-type system).
1247 get_gdbarch(): Implement the set/get functions (probably using
1248 the macro's as shortcuts).
1253 function_list |
while do_read
1255 if class_is_variable_p
1257 printf " ${returntype} ${function};\n"
1258 elif class_is_function_p
1260 printf " gdbarch_${function}_ftype *${function}${attrib};\n"
1265 # A pre-initialized vector
1269 /* The default architecture uses host values (for want of a better
1273 printf "extern const struct bfd_arch_info bfd_default_arch_struct;\n"
1275 printf "struct gdbarch startup_gdbarch =\n"
1277 printf " /* basic architecture information */\n"
1278 function_list |
while do_read
1282 printf " ${staticdefault},\n"
1286 /* target specific vector and its dump routine */
1288 /*per-architecture data-pointers and swap regions */
1290 /* Multi-arch values */
1292 function_list |
while do_read
1294 if class_is_function_p || class_is_variable_p
1296 printf " ${staticdefault},\n"
1300 /* startup_gdbarch() */
1303 struct gdbarch *current_gdbarch = &startup_gdbarch;
1305 /* Do any initialization needed for a non-multiarch configuration
1306 after the _initialize_MODULE functions have been run. */
1308 initialize_non_multiarch ()
1310 alloc_gdbarch_data (&startup_gdbarch);
1311 init_gdbarch_data (&startup_gdbarch);
1315 # Create a new gdbarch struct
1319 /* Create a new \`\`struct gdbarch'' based on information provided by
1320 \`\`struct gdbarch_info''. */
1325 gdbarch_alloc (const struct gdbarch_info *info,
1326 struct gdbarch_tdep *tdep)
1328 /* NOTE: The new architecture variable is named \`\`current_gdbarch''
1329 so that macros such as TARGET_DOUBLE_BIT, when expanded, refer to
1330 the current local architecture and not the previous global
1331 architecture. This ensures that the new architectures initial
1332 values are not influenced by the previous architecture. Once
1333 everything is parameterised with gdbarch, this will go away. */
1334 struct gdbarch *current_gdbarch = XMALLOC (struct gdbarch);
1335 memset (current_gdbarch, 0, sizeof (*current_gdbarch));
1337 alloc_gdbarch_data (current_gdbarch);
1339 current_gdbarch->tdep = tdep;
1342 function_list |
while do_read
1346 printf " current_gdbarch->${function} = info->${function};\n"
1350 printf " /* Force the explicit initialization of these. */\n"
1351 function_list |
while do_read
1353 if class_is_function_p || class_is_variable_p
1355 if [ -n "${predefault}" -a "x${predefault}" != "x0" ]
1357 printf " current_gdbarch->${function} = ${predefault};\n"
1362 /* gdbarch_alloc() */
1364 return current_gdbarch;
1368 # Free a gdbarch struct.
1372 /* Free a gdbarch struct. This should never happen in normal
1373 operation --- once you've created a gdbarch, you keep it around.
1374 However, if an architecture's init function encounters an error
1375 building the structure, it may need to clean up a partially
1376 constructed gdbarch. */
1379 gdbarch_free (struct gdbarch *arch)
1381 gdb_assert (arch != NULL);
1382 free_gdbarch_data (arch);
1387 # verify a new architecture
1390 printf "/* Ensure that all values in a GDBARCH are reasonable. */\n"
1394 verify_gdbarch (struct gdbarch *gdbarch)
1396 struct ui_file *log;
1397 struct cleanup *cleanups;
1400 /* Only perform sanity checks on a multi-arch target. */
1401 if (!GDB_MULTI_ARCH)
1403 log = mem_fileopen ();
1404 cleanups = make_cleanup_ui_file_delete (log);
1406 if (gdbarch->byte_order == BFD_ENDIAN_UNKNOWN)
1407 fprintf_unfiltered (log, "\n\tbyte-order");
1408 if (gdbarch->bfd_arch_info == NULL)
1409 fprintf_unfiltered (log, "\n\tbfd_arch_info");
1410 /* Check those that need to be defined for the given multi-arch level. */
1412 function_list |
while do_read
1414 if class_is_function_p || class_is_variable_p
1416 if [ "x${invalid_p}" = "x0" ]
1418 printf " /* Skip verify of ${function}, invalid_p == 0 */\n"
1419 elif class_is_predicate_p
1421 printf " /* Skip verify of ${function}, has predicate */\n"
1422 # FIXME: See do_read for potential simplification
1423 elif [ -n "${invalid_p}" -a -n "${postdefault}" ]
1425 printf " if (${invalid_p})\n"
1426 printf " gdbarch->${function} = ${postdefault};\n"
1427 elif [ -n "${predefault}" -a -n "${postdefault}" ]
1429 printf " if (gdbarch->${function} == ${predefault})\n"
1430 printf " gdbarch->${function} = ${postdefault};\n"
1431 elif [ -n "${postdefault}" ]
1433 printf " if (gdbarch->${function} == 0)\n"
1434 printf " gdbarch->${function} = ${postdefault};\n"
1435 elif [ -n "${invalid_p}" ]
1437 printf " if ((GDB_MULTI_ARCH >= ${level})\n"
1438 printf " && (${invalid_p}))\n"
1439 printf " fprintf_unfiltered (log, \"\\\\n\\\\t${function}\");\n"
1440 elif [ -n "${predefault}" ]
1442 printf " if ((GDB_MULTI_ARCH >= ${level})\n"
1443 printf " && (gdbarch->${function} == ${predefault}))\n"
1444 printf " fprintf_unfiltered (log, \"\\\\n\\\\t${function}\");\n"
1449 buf = ui_file_xstrdup (log, &dummy);
1450 make_cleanup (xfree, buf);
1451 if (strlen (buf) > 0)
1452 internal_error (__FILE__, __LINE__,
1453 "verify_gdbarch: the following are invalid ...%s",
1455 do_cleanups (cleanups);
1459 # dump the structure
1463 /* Print out the details of the current architecture. */
1465 /* NOTE/WARNING: The parameter is called \`\`current_gdbarch'' so that it
1466 just happens to match the global variable \`\`current_gdbarch''. That
1467 way macros refering to that variable get the local and not the global
1468 version - ulgh. Once everything is parameterised with gdbarch, this
1472 gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file)
1474 fprintf_unfiltered (file,
1475 "gdbarch_dump: GDB_MULTI_ARCH = %d\\n",
1478 function_list |
sort -t: +2 |
while do_read
1480 # multiarch functions don't have macros.
1481 if class_is_multiarch_p
1483 printf " if (GDB_MULTI_ARCH)\n"
1484 printf " fprintf_unfiltered (file,\n"
1485 printf " \"gdbarch_dump: ${function} = 0x%%08lx\\\\n\",\n"
1486 printf " (long) current_gdbarch->${function});\n"
1489 # Print the macro definition.
1490 printf "#ifdef ${macro}\n"
1491 if [ "x${returntype}" = "xvoid" ]
1493 printf "#if GDB_MULTI_ARCH\n"
1494 printf " /* Macro might contain \`[{}]' when not multi-arch */\n"
1496 if class_is_function_p
1498 printf " fprintf_unfiltered (file,\n"
1499 printf " \"gdbarch_dump: %%s # %%s\\\\n\",\n"
1500 printf " \"${macro}(${actual})\",\n"
1501 printf " XSTRING (${macro} (${actual})));\n"
1503 printf " fprintf_unfiltered (file,\n"
1504 printf " \"gdbarch_dump: ${macro} # %%s\\\\n\",\n"
1505 printf " XSTRING (${macro}));\n"
1507 # Print the architecture vector value
1508 if [ "x${returntype}" = "xvoid" ]
1512 if [ "x${print_p}" = "x()" ]
1514 printf " gdbarch_dump_${function} (current_gdbarch);\n"
1515 elif [ "x${print_p}" = "x0" ]
1517 printf " /* skip print of ${macro}, print_p == 0. */\n"
1518 elif [ -n "${print_p}" ]
1520 printf " if (${print_p})\n"
1521 printf " fprintf_unfiltered (file,\n"
1522 printf " \"gdbarch_dump: ${macro} = %s\\\\n\",\n" "${fmt}"
1523 printf " ${print});\n"
1524 elif class_is_function_p
1526 printf " if (GDB_MULTI_ARCH)\n"
1527 printf " fprintf_unfiltered (file,\n"
1528 printf " \"gdbarch_dump: ${macro} = 0x%%08lx\\\\n\",\n"
1529 printf " (long) current_gdbarch->${function}\n"
1530 printf " /*${macro} ()*/);\n"
1532 printf " fprintf_unfiltered (file,\n"
1533 printf " \"gdbarch_dump: ${macro} = %s\\\\n\",\n" "${fmt}"
1534 printf " ${print});\n"
1539 if (current_gdbarch->dump_tdep != NULL)
1540 current_gdbarch->dump_tdep (current_gdbarch, file);
1548 struct gdbarch_tdep *
1549 gdbarch_tdep (struct gdbarch *gdbarch)
1551 if (gdbarch_debug >= 2)
1552 fprintf_unfiltered (gdb_stdlog, "gdbarch_tdep called\\n");
1553 return gdbarch->tdep;
1557 function_list |
while do_read
1559 if class_is_predicate_p
1563 printf "gdbarch_${function}_p (struct gdbarch *gdbarch)\n"
1565 if [ -n "${valid_p}" ]
1567 printf " return ${valid_p};\n"
1569 printf "#error \"gdbarch_${function}_p: not defined\"\n"
1573 if class_is_function_p
1576 printf "${returntype}\n"
1577 if [ "x${formal}" = "xvoid" ]
1579 printf "gdbarch_${function} (struct gdbarch *gdbarch)\n"
1581 printf "gdbarch_${function} (struct gdbarch *gdbarch, ${formal})\n"
1584 printf " if (gdbarch->${function} == 0)\n"
1585 printf " internal_error (__FILE__, __LINE__,\n"
1586 printf " \"gdbarch: gdbarch_${function} invalid\");\n"
1587 printf " if (gdbarch_debug >= 2)\n"
1588 printf " fprintf_unfiltered (gdb_stdlog, \"gdbarch_${function} called\\\\n\");\n"
1589 if [ "x${actual}" = "x-" -o "x${actual}" = "x" ]
1591 if class_is_multiarch_p
1598 if class_is_multiarch_p
1600 params
="gdbarch, ${actual}"
1605 if [ "x${returntype}" = "xvoid" ]
1607 printf " gdbarch->${function} (${params});\n"
1609 printf " return gdbarch->${function} (${params});\n"
1614 printf "set_gdbarch_${function} (struct gdbarch *gdbarch,\n"
1615 printf " `echo ${function} | sed -e 's/./ /g'` gdbarch_${function}_ftype ${function})\n"
1617 printf " gdbarch->${function} = ${function};\n"
1619 elif class_is_variable_p
1622 printf "${returntype}\n"
1623 printf "gdbarch_${function} (struct gdbarch *gdbarch)\n"
1625 if [ "x${invalid_p}" = "x0" ]
1627 printf " /* Skip verify of ${function}, invalid_p == 0 */\n"
1628 elif [ -n "${invalid_p}" ]
1630 printf " if (${invalid_p})\n"
1631 printf " internal_error (__FILE__, __LINE__,\n"
1632 printf " \"gdbarch: gdbarch_${function} invalid\");\n"
1633 elif [ -n "${predefault}" ]
1635 printf " if (gdbarch->${function} == ${predefault})\n"
1636 printf " internal_error (__FILE__, __LINE__,\n"
1637 printf " \"gdbarch: gdbarch_${function} invalid\");\n"
1639 printf " if (gdbarch_debug >= 2)\n"
1640 printf " fprintf_unfiltered (gdb_stdlog, \"gdbarch_${function} called\\\\n\");\n"
1641 printf " return gdbarch->${function};\n"
1645 printf "set_gdbarch_${function} (struct gdbarch *gdbarch,\n"
1646 printf " `echo ${function} | sed -e 's/./ /g'` ${returntype} ${function})\n"
1648 printf " gdbarch->${function} = ${function};\n"
1650 elif class_is_info_p
1653 printf "${returntype}\n"
1654 printf "gdbarch_${function} (struct gdbarch *gdbarch)\n"
1656 printf " if (gdbarch_debug >= 2)\n"
1657 printf " fprintf_unfiltered (gdb_stdlog, \"gdbarch_${function} called\\\\n\");\n"
1658 printf " return gdbarch->${function};\n"
1663 # All the trailing guff
1667 /* Keep a registry of per-architecture data-pointers required by GDB
1673 gdbarch_data_init_ftype *init;
1674 gdbarch_data_free_ftype *free;
1677 struct gdbarch_data_registration
1679 struct gdbarch_data *data;
1680 struct gdbarch_data_registration *next;
1683 struct gdbarch_data_registry
1686 struct gdbarch_data_registration *registrations;
1689 struct gdbarch_data_registry gdbarch_data_registry =
1694 struct gdbarch_data *
1695 register_gdbarch_data (gdbarch_data_init_ftype *init,
1696 gdbarch_data_free_ftype *free)
1698 struct gdbarch_data_registration **curr;
1699 for (curr = &gdbarch_data_registry.registrations;
1701 curr = &(*curr)->next);
1702 (*curr) = XMALLOC (struct gdbarch_data_registration);
1703 (*curr)->next = NULL;
1704 (*curr)->data = XMALLOC (struct gdbarch_data);
1705 (*curr)->data->index = gdbarch_data_registry.nr++;
1706 (*curr)->data->init = init;
1707 (*curr)->data->free = free;
1708 return (*curr)->data;
1712 /* Walk through all the registered users initializing each in turn. */
1715 init_gdbarch_data (struct gdbarch *gdbarch)
1717 struct gdbarch_data_registration *rego;
1718 for (rego = gdbarch_data_registry.registrations;
1722 struct gdbarch_data *data = rego->data;
1723 gdb_assert (data->index < gdbarch->nr_data);
1724 if (data->init != NULL)
1726 void *pointer = data->init (gdbarch);
1727 set_gdbarch_data (gdbarch, data, pointer);
1732 /* Create/delete the gdbarch data vector. */
1735 alloc_gdbarch_data (struct gdbarch *gdbarch)
1737 gdb_assert (gdbarch->data == NULL);
1738 gdbarch->nr_data = gdbarch_data_registry.nr;
1739 gdbarch->data = xcalloc (gdbarch->nr_data, sizeof (void*));
1743 free_gdbarch_data (struct gdbarch *gdbarch)
1745 struct gdbarch_data_registration *rego;
1746 gdb_assert (gdbarch->data != NULL);
1747 for (rego = gdbarch_data_registry.registrations;
1751 struct gdbarch_data *data = rego->data;
1752 gdb_assert (data->index < gdbarch->nr_data);
1753 if (data->free != NULL && gdbarch->data[data->index] != NULL)
1755 data->free (gdbarch, gdbarch->data[data->index]);
1756 gdbarch->data[data->index] = NULL;
1759 xfree (gdbarch->data);
1760 gdbarch->data = NULL;
1764 /* Initialize the current value of thee specified per-architecture
1768 set_gdbarch_data (struct gdbarch *gdbarch,
1769 struct gdbarch_data *data,
1772 gdb_assert (data->index < gdbarch->nr_data);
1773 if (data->free != NULL && gdbarch->data[data->index] != NULL)
1774 data->free (gdbarch, gdbarch->data[data->index]);
1775 gdbarch->data[data->index] = pointer;
1778 /* Return the current value of the specified per-architecture
1782 gdbarch_data (struct gdbarch_data *data)
1784 gdb_assert (data->index < current_gdbarch->nr_data);
1785 return current_gdbarch->data[data->index];
1790 /* Keep a registry of swapped data required by GDB modules. */
1795 struct gdbarch_swap_registration *source;
1796 struct gdbarch_swap *next;
1799 struct gdbarch_swap_registration
1802 unsigned long sizeof_data;
1803 gdbarch_swap_ftype *init;
1804 struct gdbarch_swap_registration *next;
1807 struct gdbarch_swap_registry
1810 struct gdbarch_swap_registration *registrations;
1813 struct gdbarch_swap_registry gdbarch_swap_registry =
1819 register_gdbarch_swap (void *data,
1820 unsigned long sizeof_data,
1821 gdbarch_swap_ftype *init)
1823 struct gdbarch_swap_registration **rego;
1824 for (rego = &gdbarch_swap_registry.registrations;
1826 rego = &(*rego)->next);
1827 (*rego) = XMALLOC (struct gdbarch_swap_registration);
1828 (*rego)->next = NULL;
1829 (*rego)->init = init;
1830 (*rego)->data = data;
1831 (*rego)->sizeof_data = sizeof_data;
1836 init_gdbarch_swap (struct gdbarch *gdbarch)
1838 struct gdbarch_swap_registration *rego;
1839 struct gdbarch_swap **curr = &gdbarch->swap;
1840 for (rego = gdbarch_swap_registry.registrations;
1844 if (rego->data != NULL)
1846 (*curr) = XMALLOC (struct gdbarch_swap);
1847 (*curr)->source = rego;
1848 (*curr)->swap = xmalloc (rego->sizeof_data);
1849 (*curr)->next = NULL;
1850 memset (rego->data, 0, rego->sizeof_data);
1851 curr = &(*curr)->next;
1853 if (rego->init != NULL)
1859 swapout_gdbarch_swap (struct gdbarch *gdbarch)
1861 struct gdbarch_swap *curr;
1862 for (curr = gdbarch->swap;
1865 memcpy (curr->swap, curr->source->data, curr->source->sizeof_data);
1869 swapin_gdbarch_swap (struct gdbarch *gdbarch)
1871 struct gdbarch_swap *curr;
1872 for (curr = gdbarch->swap;
1875 memcpy (curr->source->data, curr->swap, curr->source->sizeof_data);
1879 /* Keep a registry of the architectures known by GDB. */
1881 struct gdbarch_registration
1883 enum bfd_architecture bfd_architecture;
1884 gdbarch_init_ftype *init;
1885 gdbarch_dump_tdep_ftype *dump_tdep;
1886 struct gdbarch_list *arches;
1887 struct gdbarch_registration *next;
1890 static struct gdbarch_registration *gdbarch_registry = NULL;
1893 append_name (const char ***buf, int *nr, const char *name)
1895 *buf = xrealloc (*buf, sizeof (char**) * (*nr + 1));
1901 gdbarch_printable_names (void)
1905 /* Accumulate a list of names based on the registed list of
1907 enum bfd_architecture a;
1909 const char **arches = NULL;
1910 struct gdbarch_registration *rego;
1911 for (rego = gdbarch_registry;
1915 const struct bfd_arch_info *ap;
1916 ap = bfd_lookup_arch (rego->bfd_architecture, 0);
1918 internal_error (__FILE__, __LINE__,
1919 "gdbarch_architecture_names: multi-arch unknown");
1922 append_name (&arches, &nr_arches, ap->printable_name);
1927 append_name (&arches, &nr_arches, NULL);
1931 /* Just return all the architectures that BFD knows. Assume that
1932 the legacy architecture framework supports them. */
1933 return bfd_arch_list ();
1938 gdbarch_register (enum bfd_architecture bfd_architecture,
1939 gdbarch_init_ftype *init,
1940 gdbarch_dump_tdep_ftype *dump_tdep)
1942 struct gdbarch_registration **curr;
1943 const struct bfd_arch_info *bfd_arch_info;
1944 /* Check that BFD recognizes this architecture */
1945 bfd_arch_info = bfd_lookup_arch (bfd_architecture, 0);
1946 if (bfd_arch_info == NULL)
1948 internal_error (__FILE__, __LINE__,
1949 "gdbarch: Attempt to register unknown architecture (%d)",
1952 /* Check that we haven't seen this architecture before */
1953 for (curr = &gdbarch_registry;
1955 curr = &(*curr)->next)
1957 if (bfd_architecture == (*curr)->bfd_architecture)
1958 internal_error (__FILE__, __LINE__,
1959 "gdbarch: Duplicate registraration of architecture (%s)",
1960 bfd_arch_info->printable_name);
1964 fprintf_unfiltered (gdb_stdlog, "register_gdbarch_init (%s, 0x%08lx)\n",
1965 bfd_arch_info->printable_name,
1968 (*curr) = XMALLOC (struct gdbarch_registration);
1969 (*curr)->bfd_architecture = bfd_architecture;
1970 (*curr)->init = init;
1971 (*curr)->dump_tdep = dump_tdep;
1972 (*curr)->arches = NULL;
1973 (*curr)->next = NULL;
1974 /* When non- multi-arch, install whatever target dump routine we've
1975 been provided - hopefully that routine has been written correctly
1976 and works regardless of multi-arch. */
1977 if (!GDB_MULTI_ARCH && dump_tdep != NULL
1978 && startup_gdbarch.dump_tdep == NULL)
1979 startup_gdbarch.dump_tdep = dump_tdep;
1983 register_gdbarch_init (enum bfd_architecture bfd_architecture,
1984 gdbarch_init_ftype *init)
1986 gdbarch_register (bfd_architecture, init, NULL);
1990 /* Look for an architecture using gdbarch_info. Base search on only
1991 BFD_ARCH_INFO and BYTE_ORDER. */
1993 struct gdbarch_list *
1994 gdbarch_list_lookup_by_info (struct gdbarch_list *arches,
1995 const struct gdbarch_info *info)
1997 for (; arches != NULL; arches = arches->next)
1999 if (info->bfd_arch_info != arches->gdbarch->bfd_arch_info)
2001 if (info->byte_order != arches->gdbarch->byte_order)
2009 /* Update the current architecture. Return ZERO if the update request
2013 gdbarch_update_p (struct gdbarch_info info)
2015 struct gdbarch *new_gdbarch;
2016 struct gdbarch_list **list;
2017 struct gdbarch_registration *rego;
2019 /* Fill in missing parts of the INFO struct using a number of
2020 sources: \`\`set ...''; INFOabfd supplied; existing target. */
2022 /* \`\`(gdb) set architecture ...'' */
2023 if (info.bfd_arch_info == NULL
2024 && !TARGET_ARCHITECTURE_AUTO)
2025 info.bfd_arch_info = TARGET_ARCHITECTURE;
2026 if (info.bfd_arch_info == NULL
2027 && info.abfd != NULL
2028 && bfd_get_arch (info.abfd) != bfd_arch_unknown
2029 && bfd_get_arch (info.abfd) != bfd_arch_obscure)
2030 info.bfd_arch_info = bfd_get_arch_info (info.abfd);
2031 if (info.bfd_arch_info == NULL)
2032 info.bfd_arch_info = TARGET_ARCHITECTURE;
2034 /* \`\`(gdb) set byte-order ...'' */
2035 if (info.byte_order == BFD_ENDIAN_UNKNOWN
2036 && !TARGET_BYTE_ORDER_AUTO)
2037 info.byte_order = TARGET_BYTE_ORDER;
2038 /* From the INFO struct. */
2039 if (info.byte_order == BFD_ENDIAN_UNKNOWN
2040 && info.abfd != NULL)
2041 info.byte_order = (bfd_big_endian (info.abfd) ? BFD_ENDIAN_BIG
2042 : bfd_little_endian (info.abfd) ? BFD_ENDIAN_LITTLE
2043 : BFD_ENDIAN_UNKNOWN);
2044 /* From the current target. */
2045 if (info.byte_order == BFD_ENDIAN_UNKNOWN)
2046 info.byte_order = TARGET_BYTE_ORDER;
2048 /* Must have found some sort of architecture. */
2049 gdb_assert (info.bfd_arch_info != NULL);
2053 fprintf_unfiltered (gdb_stdlog,
2054 "gdbarch_update: info.bfd_arch_info %s\n",
2055 (info.bfd_arch_info != NULL
2056 ? info.bfd_arch_info->printable_name
2058 fprintf_unfiltered (gdb_stdlog,
2059 "gdbarch_update: info.byte_order %d (%s)\n",
2061 (info.byte_order == BFD_ENDIAN_BIG ? "big"
2062 : info.byte_order == BFD_ENDIAN_LITTLE ? "little"
2064 fprintf_unfiltered (gdb_stdlog,
2065 "gdbarch_update: info.abfd 0x%lx\n",
2067 fprintf_unfiltered (gdb_stdlog,
2068 "gdbarch_update: info.tdep_info 0x%lx\n",
2069 (long) info.tdep_info);
2072 /* Find the target that knows about this architecture. */
2073 for (rego = gdbarch_registry;
2076 if (rego->bfd_architecture == info.bfd_arch_info->arch)
2081 fprintf_unfiltered (gdb_stdlog, "gdbarch_update: No matching architecture\\n");
2085 /* Ask the target for a replacement architecture. */
2086 new_gdbarch = rego->init (info, rego->arches);
2088 /* Did the target like it? No. Reject the change. */
2089 if (new_gdbarch == NULL)
2092 fprintf_unfiltered (gdb_stdlog, "gdbarch_update: Target rejected architecture\\n");
2096 /* Did the architecture change? No. Do nothing. */
2097 if (current_gdbarch == new_gdbarch)
2100 fprintf_unfiltered (gdb_stdlog, "gdbarch_update: Architecture 0x%08lx (%s) unchanged\\n",
2102 new_gdbarch->bfd_arch_info->printable_name);
2106 /* Swap all data belonging to the old target out */
2107 swapout_gdbarch_swap (current_gdbarch);
2109 /* Is this a pre-existing architecture? Yes. Swap it in. */
2110 for (list = ®o->arches;
2112 list = &(*list)->next)
2114 if ((*list)->gdbarch == new_gdbarch)
2117 fprintf_unfiltered (gdb_stdlog,
2118 "gdbarch_update: Previous architecture 0x%08lx (%s) selected\\n",
2120 new_gdbarch->bfd_arch_info->printable_name);
2121 current_gdbarch = new_gdbarch;
2122 swapin_gdbarch_swap (new_gdbarch);
2123 architecture_changed_event ();
2128 /* Append this new architecture to this targets list. */
2129 (*list) = XMALLOC (struct gdbarch_list);
2130 (*list)->next = NULL;
2131 (*list)->gdbarch = new_gdbarch;
2133 /* Switch to this new architecture. Dump it out. */
2134 current_gdbarch = new_gdbarch;
2137 fprintf_unfiltered (gdb_stdlog,
2138 "gdbarch_update: New architecture 0x%08lx (%s) selected\\n",
2140 new_gdbarch->bfd_arch_info->printable_name);
2143 /* Check that the newly installed architecture is valid. Plug in
2144 any post init values. */
2145 new_gdbarch->dump_tdep = rego->dump_tdep;
2146 verify_gdbarch (new_gdbarch);
2148 /* Initialize the per-architecture memory (swap) areas.
2149 CURRENT_GDBARCH must be update before these modules are
2151 init_gdbarch_swap (new_gdbarch);
2153 /* Initialize the per-architecture data-pointer of all parties that
2154 registered an interest in this architecture. CURRENT_GDBARCH
2155 must be updated before these modules are called. */
2156 init_gdbarch_data (new_gdbarch);
2157 architecture_changed_event ();
2160 gdbarch_dump (current_gdbarch, gdb_stdlog);
2168 /* Pointer to the target-dependent disassembly function. */
2169 int (*tm_print_insn) (bfd_vma, disassemble_info *);
2170 disassemble_info tm_print_insn_info;
2173 extern void _initialize_gdbarch (void);
2176 _initialize_gdbarch (void)
2178 struct cmd_list_element *c;
2180 INIT_DISASSEMBLE_INFO_NO_ARCH (tm_print_insn_info, gdb_stdout, (fprintf_ftype)fprintf_filtered);
2181 tm_print_insn_info.flavour = bfd_target_unknown_flavour;
2182 tm_print_insn_info.read_memory_func = dis_asm_read_memory;
2183 tm_print_insn_info.memory_error_func = dis_asm_memory_error;
2184 tm_print_insn_info.print_address_func = dis_asm_print_address;
2186 add_show_from_set (add_set_cmd ("arch",
2189 (char *)&gdbarch_debug,
2190 "Set architecture debugging.\\n\\
2191 When non-zero, architecture debugging is enabled.", &setdebuglist),
2193 c = add_set_cmd ("archdebug",
2196 (char *)&gdbarch_debug,
2197 "Set architecture debugging.\\n\\
2198 When non-zero, architecture debugging is enabled.", &setlist);
2200 deprecate_cmd (c, "set debug arch");
2201 deprecate_cmd (add_show_from_set (c, &showlist), "show debug arch");
2207 #../move-if-change new-gdbarch.c gdbarch.c
2208 compare_new gdbarch.c