#!/bin/sh -u
# Architecture commands for GDB, the GNU debugger.
-# Copyright 1998-2000 Free Software Foundation, Inc.
+# Copyright 1998, 1999, 2000, 2001, 2002 Free Software Foundation, Inc.
#
# This file is part of GDB.
#
# along with this program; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+# Make certain that the script is running in an internationalized
+# environment.
+LANG=c ; export LANG
+LC_ALL=c ; export LC_ALL
+
+
compare_new ()
{
file=$1
if test ! -r ${file}
then
echo "${file} missing? cp new-${file} ${file}" 1>&2
- elif diff -c ${file} new-${file}
+ elif diff -u ${file} new-${file}
then
echo "${file} unchanged" 1>&2
else
comment="${comment}
${line}"
else
- OFS="${IFS}" ; IFS=":"
+
+ # The semantics of IFS varies between different SH's. Some
+ # treat ``::' as three fields while some treat it as just too.
+ # Work around this by eliminating ``::'' ....
+ line="`echo "${line}" | sed -e 's/::/: :/g' -e 's/::/: :/g'`"
+
+ OFS="${IFS}" ; IFS="[:]"
eval read ${read} <<EOF
${line}
EOF
IFS="${OFS}"
- test "${staticdefault}" || staticdefault=0
+ # .... and then going back through each field and strip out those
+ # that ended up with just that space character.
+ for r in ${read}
+ do
+ if eval test \"\${${r}}\" = \"\ \"
+ then
+ eval ${r}=""
+ fi
+ done
+
+ case "${level}" in
+ 1 ) gt_level=">= GDB_MULTI_ARCH_PARTIAL" ;;
+ 2 ) gt_level="> GDB_MULTI_ARCH_PARTIAL" ;;
+ "" ) ;;
+ * ) error "Error: bad level for ${function}" 1>&2 ; kill $$ ; exit 1 ;;
+ esac
+
+ case "${class}" in
+ m ) staticdefault="${predefault}" ;;
+ M ) staticdefault="0" ;;
+ * ) test "${staticdefault}" || staticdefault=0 ;;
+ esac
# NOT YET: Breaks BELIEVE_PCC_PROMOTION and confuses non-
# multi-arch defaults.
# test "${predefault}" || predefault=0
+
+ # come up with a format, use a few guesses for variables
+ case ":${class}:${fmt}:${print}:" in
+ :[vV]::: )
+ if [ "${returntype}" = int ]
+ then
+ fmt="%d"
+ print="${macro}"
+ elif [ "${returntype}" = long ]
+ then
+ fmt="%ld"
+ print="${macro}"
+ fi
+ ;;
+ esac
test "${fmt}" || fmt="%ld"
test "${print}" || print="(long) ${macro}"
+
case "${invalid_p}" in
0 ) valid_p=1 ;;
"" )
- if [ "${predefault}" ]
+ if [ -n "${predefault}" ]
then
#invalid_p="gdbarch->${function} == ${predefault}"
valid_p="gdbarch->${function} != ${predefault}"
# always a valid definition of MEMBER as this again
# ensures consistency.
- if [ "${postdefault}" != "" ]
+ if [ -n "${postdefault}" ]
then
fallbackdefault="${postdefault}"
- elif [ "${predefault}" != "" ]
+ elif [ -n "${predefault}" ]
then
fallbackdefault="${predefault}"
else
- fallbackdefault=""
+ fallbackdefault="0"
fi
#NOT YET: See gdbarch.log for basic verification of
break
fi
done
- if [ "${class}" ]
+ if [ -n "${class}" ]
then
true
else
fallback_default_p ()
{
- [ "${postdefault}" != "" -a "${invalid_p}" != "0" ] \
- || [ "${predefault}" != "" -a "${invalid_p}" = "0" ]
+ [ -n "${postdefault}" -a "x${invalid_p}" != "x0" ] \
+ || [ -n "${predefault}" -a "x${invalid_p}" = "x0" ]
}
class_is_variable_p ()
{
- [ "${class}" = "v" -o "${class}" = "V" ]
+ case "${class}" in
+ *v* | *V* ) true ;;
+ * ) false ;;
+ esac
}
class_is_function_p ()
{
- [ "${class}" = "f" -o "${class}" = "F" ]
+ case "${class}" in
+ *f* | *F* | *m* | *M* ) true ;;
+ * ) false ;;
+ esac
+}
+
+class_is_multiarch_p ()
+{
+ case "${class}" in
+ *m* | *M* ) true ;;
+ * ) false ;;
+ esac
}
class_is_predicate_p ()
{
- [ "${class}" = "F" -o "${class}" = "V" ]
+ case "${class}" in
+ *F* | *V* | *M* ) true ;;
+ * ) false ;;
+ esac
}
class_is_info_p ()
{
- [ "${class}" = "i" ]
+ case "${class}" in
+ *i* ) true ;;
+ * ) false ;;
+ esac
}
# hiding a variable + predicate to test variables validity
# i -> set from info
# hiding something from the ``struct info'' object
+ # m -> multi-arch function
+ # hiding a multi-arch function (parameterised with the architecture)
+ # M -> multi-arch function + predicate
+ # hiding a multi-arch function + predicate to test function validity
level ) : ;;
predefault ) : ;;
- # A initial value to assign to MEMBER of the freshly
- # malloc()ed gdbarch object. After the gdbarch object has
- # been initialized using PREDEFAULT, it is passed to the
- # target code for further updates.
+ # An initial value to assign to MEMBER of the freshly
+ # malloc()ed gdbarch object. After initialization, the
+ # freshly malloc()ed object is passed to the target
+ # architecture code for further updates.
# If PREDEFAULT is empty, zero is used.
- # When POSTDEFAULT is empty, a non-empty PREDEFAULT and a zero
- # INVALID_P will be used as default values when when
- # multi-arch is disabled. Specify a zero PREDEFAULT function
- # to make that fallback call internal_error().
+ # A non-empty PREDEFAULT, an empty POSTDEFAULT and a zero
+ # INVALID_P are specified, PREDEFAULT will be used as the
+ # default for the non- multi-arch target.
+
+ # A zero PREDEFAULT function will force the fallback to call
+ # internal_error().
# Variable declarations can refer to ``gdbarch'' which will
# contain the current architecture. Care should be taken.
postdefault ) : ;;
# A value to assign to MEMBER of the new gdbarch object should
- # the target code fail to change the PREDEFAULT value. Also
- # use POSTDEFAULT as the fallback value for the non-
- # multi-arch case.
+ # the target architecture code fail to change the PREDEFAULT
+ # value.
# If POSTDEFAULT is empty, no post update is performed.
# INVALID_P will be used to determine if MEMBER should be
# changed to POSTDEFAULT.
+ # If a non-empty POSTDEFAULT and a zero INVALID_P are
+ # specified, POSTDEFAULT will be used as the default for the
+ # non- multi-arch target (regardless of the value of
+ # PREDEFAULT).
+
# You cannot specify both a zero INVALID_P and a POSTDEFAULT.
# Variable declarations can refer to ``gdbarch'' which will
# Currently unused.
- *) exit 1;;
+ *)
+ echo "Bad field ${field}"
+ exit 1;;
esac
done
cat <<EOF
i:2:TARGET_ARCHITECTURE:const struct bfd_arch_info *:bfd_arch_info::::&bfd_default_arch_struct::::%s:TARGET_ARCHITECTURE->printable_name:TARGET_ARCHITECTURE != NULL
#
-i:2:TARGET_BYTE_ORDER:int:byte_order::::BIG_ENDIAN
+i:2:TARGET_BYTE_ORDER:int:byte_order::::BFD_ENDIAN_BIG
# Number of bits in a char or unsigned char for the target machine.
# Just like CHAR_BIT in <limits.h> but describes the target machine.
# v::TARGET_CHAR_BIT:int:char_bit::::8 * sizeof (char):8::0:
# Number of bits in a double for the target machine.
v::TARGET_DOUBLE_BIT:int:double_bit::::8 * sizeof (double):8*TARGET_CHAR_BIT::0
# Number of bits in a long double for the target machine.
-v::TARGET_LONG_DOUBLE_BIT:int:long_double_bit::::8 * sizeof (long double):2*TARGET_DOUBLE_BIT::0
-# Number of bits in a pointer for the target machine
+v::TARGET_LONG_DOUBLE_BIT:int:long_double_bit::::8 * sizeof (long double):8*TARGET_CHAR_BIT::0
+# For most targets, a pointer on the target and its representation as an
+# address in GDB have the same size and "look the same". For such a
+# target, you need only set TARGET_PTR_BIT / ptr_bit and TARGET_ADDR_BIT
+# / addr_bit will be set from it.
+#
+# If TARGET_PTR_BIT and TARGET_ADDR_BIT are different, you'll probably
+# also need to set POINTER_TO_ADDRESS and ADDRESS_TO_POINTER as well.
+#
+# ptr_bit is the size of a pointer on the target
v::TARGET_PTR_BIT:int:ptr_bit::::8 * sizeof (void*):TARGET_INT_BIT::0
+# addr_bit is the size of a target address as represented in gdb
+v::TARGET_ADDR_BIT:int:addr_bit::::8 * sizeof (void*):0:TARGET_PTR_BIT:
# Number of bits in a BFD_VMA for the target object file format.
v::TARGET_BFD_VMA_BIT:int:bfd_vma_bit::::8 * sizeof (void*):TARGET_ARCHITECTURE->bits_per_address::0
#
-v:1:IEEE_FLOAT:int:ieee_float::::0:0::0:::
+# One if \`char' acts like \`signed char', zero if \`unsigned char'.
+v::TARGET_CHAR_SIGNED:int:char_signed::::1:-1:1::::
#
-f:1:TARGET_READ_PC:CORE_ADDR:read_pc:int pid:pid::0:0
-f:1:TARGET_WRITE_PC:void:write_pc:CORE_ADDR val, int pid:val, pid::0:0
-f:1:TARGET_READ_FP:CORE_ADDR:read_fp:void:::0:0
-f:1:TARGET_WRITE_FP:void:write_fp:CORE_ADDR val:val::0:0
-f:1:TARGET_READ_SP:CORE_ADDR:read_sp:void:::0:0
-f:1:TARGET_WRITE_SP:void:write_sp:CORE_ADDR val:val::0:0
+f::TARGET_READ_PC:CORE_ADDR:read_pc:ptid_t ptid:ptid::0:generic_target_read_pc::0
+f::TARGET_WRITE_PC:void:write_pc:CORE_ADDR val, ptid_t ptid:val, ptid::0:generic_target_write_pc::0
+f::TARGET_READ_FP:CORE_ADDR:read_fp:void:::0:generic_target_read_fp::0
+f::TARGET_READ_SP:CORE_ADDR:read_sp:void:::0:generic_target_read_sp::0
+f::TARGET_WRITE_SP:void:write_sp:CORE_ADDR val:val::0:generic_target_write_sp::0
+# Function for getting target's idea of a frame pointer. FIXME: GDB's
+# whole scheme for dealing with "frames" and "frame pointers" needs a
+# serious shakedown.
+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
#
+M:::void:register_read:int regnum, char *buf:regnum, buf:
+M:::void:register_write:int regnum, char *buf:regnum, buf:
#
v:2:NUM_REGS:int:num_regs::::0:-1
# This macro gives the number of pseudo-registers that live in the
# register namespace but do not get fetched or stored on the target.
-# These pseudo-registers may be aliases for other registers,
-# combinations of other registers, or they may be computed by GDB.
+# These pseudo-registers may be aliases for other registers,
+# combinations of other registers, or they may be computed by GDB.
v:2:NUM_PSEUDO_REGS:int:num_pseudo_regs::::0:0::0:::
-v:2:SP_REGNUM:int:sp_regnum::::0:-1
-v:2:FP_REGNUM:int:fp_regnum::::0:-1
-v:2:PC_REGNUM:int:pc_regnum::::0:-1
+
+# GDB's standard (or well known) register numbers. These can map onto
+# a real register or a pseudo (computed) register or not be defined at
+# all (-1).
+v:2:SP_REGNUM:int:sp_regnum::::-1:-1::0
+v:2:FP_REGNUM:int:fp_regnum::::-1:-1::0
+v:2:PC_REGNUM:int:pc_regnum::::-1:-1::0
+v:2:PS_REGNUM:int:ps_regnum::::-1:-1::0
v:2:FP0_REGNUM:int:fp0_regnum::::0:-1::0
v:2:NPC_REGNUM:int:npc_regnum::::0:-1::0
v:2:NNPC_REGNUM:int:nnpc_regnum::::0:-1::0
+# Convert stab register number (from \`r\' declaration) to a gdb REGNUM.
+f:2:STAB_REG_TO_REGNUM:int:stab_reg_to_regnum:int stab_regnr:stab_regnr:::no_op_reg_to_regnum::0
+# Provide a default mapping from a ecoff register number to a gdb REGNUM.
+f:2:ECOFF_REG_TO_REGNUM:int:ecoff_reg_to_regnum:int ecoff_regnr:ecoff_regnr:::no_op_reg_to_regnum::0
+# Provide a default mapping from a DWARF register number to a gdb REGNUM.
+f:2:DWARF_REG_TO_REGNUM:int:dwarf_reg_to_regnum:int dwarf_regnr:dwarf_regnr:::no_op_reg_to_regnum::0
+# Convert from an sdb register number to an internal gdb register number.
+# This should be defined in tm.h, if REGISTER_NAMES is not set up
+# to map one to one onto the sdb register numbers.
+f:2:SDB_REG_TO_REGNUM:int:sdb_reg_to_regnum:int sdb_regnr:sdb_regnr:::no_op_reg_to_regnum::0
+f:2:DWARF2_REG_TO_REGNUM:int:dwarf2_reg_to_regnum:int dwarf2_regnr:dwarf2_regnr:::no_op_reg_to_regnum::0
f:2:REGISTER_NAME:char *:register_name:int regnr:regnr:::legacy_register_name::0
v:2:REGISTER_SIZE:int:register_size::::0:-1
v:2:REGISTER_BYTES:int:register_bytes::::0:-1
f:2:REGISTER_BYTE:int:register_byte:int reg_nr:reg_nr::0:0
-f:2:REGISTER_RAW_SIZE:int:register_raw_size:int reg_nr:reg_nr::0:0
+f:2:REGISTER_RAW_SIZE:int:register_raw_size:int reg_nr:reg_nr::generic_register_raw_size:0
v:2:MAX_REGISTER_RAW_SIZE:int:max_register_raw_size::::0:-1
-f:2:REGISTER_VIRTUAL_SIZE:int:register_virtual_size:int reg_nr:reg_nr::0:0
+f:2:REGISTER_VIRTUAL_SIZE:int:register_virtual_size:int reg_nr:reg_nr::generic_register_virtual_size:0
v:2:MAX_REGISTER_VIRTUAL_SIZE:int:max_register_virtual_size::::0:-1
f:2:REGISTER_VIRTUAL_TYPE:struct type *:register_virtual_type:int reg_nr:reg_nr::0:0
f:2:DO_REGISTERS_INFO:void:do_registers_info:int reg_nr, int fpregs:reg_nr, fpregs:::do_registers_info::0
+f:2:PRINT_FLOAT_INFO:void:print_float_info:void::::default_print_float_info::0
# MAP a GDB RAW register number onto a simulator register number. See
# also include/...-sim.h.
f:2:REGISTER_SIM_REGNO:int:register_sim_regno:int reg_nr:reg_nr:::default_register_sim_regno::0
+F:2:REGISTER_BYTES_OK:int:register_bytes_ok:long nr_bytes:nr_bytes::0:0
+f:2:CANNOT_FETCH_REGISTER:int:cannot_fetch_register:int regnum:regnum:::cannot_register_not::0
+f:2:CANNOT_STORE_REGISTER:int:cannot_store_register:int regnum:regnum:::cannot_register_not::0
+# setjmp/longjmp support.
+F:2:GET_LONGJMP_TARGET:int:get_longjmp_target:CORE_ADDR *pc:pc::0:0
#
+# Non multi-arch DUMMY_FRAMES are a mess (multi-arch ones are not that
+# much better but at least they are vaguely consistent). The headers
+# and body contain convoluted #if/#else sequences for determine how
+# things should be compiled. Instead of trying to mimic that
+# behaviour here (and hence entrench it further) gdbarch simply
+# reqires that these methods be set up from the word go. This also
+# avoids any potential problems with moving beyond multi-arch partial.
v:1:USE_GENERIC_DUMMY_FRAMES:int:use_generic_dummy_frames::::0:-1
-v:2:CALL_DUMMY_LOCATION:int:call_dummy_location::::0:0
+v:1:CALL_DUMMY_LOCATION:int:call_dummy_location::::0:0
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
v:2:CALL_DUMMY_START_OFFSET:CORE_ADDR:call_dummy_start_offset::::0:-1:::0x%08lx
-v:2:CALL_DUMMY_BREAKPOINT_OFFSET:CORE_ADDR:call_dummy_breakpoint_offset::::0:-1:::0x%08lx::CALL_DUMMY_BREAKPOINT_OFFSET_P
+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
v:1:CALL_DUMMY_BREAKPOINT_OFFSET_P:int:call_dummy_breakpoint_offset_p::::0:-1
v:2:CALL_DUMMY_LENGTH:int:call_dummy_length::::0:-1:::::CALL_DUMMY_LOCATION == BEFORE_TEXT_END || CALL_DUMMY_LOCATION == AFTER_TEXT_END
-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
+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
v:1:CALL_DUMMY_P:int:call_dummy_p::::0:-1
v:2:CALL_DUMMY_WORDS:LONGEST *:call_dummy_words::::0:legacy_call_dummy_words::0:0x%08lx
v:2:SIZEOF_CALL_DUMMY_WORDS:int:sizeof_call_dummy_words::::0:legacy_sizeof_call_dummy_words::0:0x%08lx
v:1:CALL_DUMMY_STACK_ADJUST_P:int:call_dummy_stack_adjust_p::::0:-1:::0x%08lx
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
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
+f:2:INIT_FRAME_PC_FIRST:void:init_frame_pc_first:int fromleaf, struct frame_info *prev:fromleaf, prev:::init_frame_pc_noop::0
+f:2:INIT_FRAME_PC:void:init_frame_pc:int fromleaf, struct frame_info *prev:fromleaf, prev:::init_frame_pc_default::0
#
v:2:BELIEVE_PCC_PROMOTION:int:believe_pcc_promotion:::::::
v:2:BELIEVE_PCC_PROMOTION_TYPE:int:believe_pcc_promotion_type:::::::
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
+# GET_SAVED_REGISTER is like DUMMY_FRAMES. It is at level one as the
+# old code has strange #ifdef interaction. So far no one has found
+# that default_get_saved_register() is the default they are after.
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
#
-f:1:REGISTER_CONVERTIBLE:int:register_convertible:int nr:nr:::generic_register_convertible_not::0
+f:2:REGISTER_CONVERTIBLE:int:register_convertible:int nr:nr:::generic_register_convertible_not::0
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
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
# This function is called when the value of a pseudo-register needs to
# be updated. Typically it will be defined on a per-architecture
# basis.
-f:2:FETCH_PSEUDO_REGISTER:void:fetch_pseudo_register:int regnum:regnum:::0::0
+F:2:FETCH_PSEUDO_REGISTER:void:fetch_pseudo_register:int regnum:regnum:
# This function is called when the value of a pseudo-register needs to
# be set or stored. Typically it will be defined on a
# per-architecture basis.
-f:2:STORE_PSEUDO_REGISTER:void:store_pseudo_register:int regnum:regnum:::0::0
+F:2:STORE_PSEUDO_REGISTER:void:store_pseudo_register:int regnum:regnum:
#
f:2:POINTER_TO_ADDRESS:CORE_ADDR:pointer_to_address:struct type *type, void *buf:type, buf:::unsigned_pointer_to_address::0
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
+F:2:INTEGER_TO_ADDRESS:CORE_ADDR:integer_to_address:struct type *type, void *buf:type, buf
#
f:2:RETURN_VALUE_ON_STACK:int:return_value_on_stack:struct type *type:type:::generic_return_value_on_stack_not::0
f:2:EXTRACT_RETURN_VALUE:void:extract_return_value:struct type *type, char *regbuf, char *valbuf:type, regbuf, valbuf::0:0
-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
+f:2: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:::default_push_arguments::0
f:2:PUSH_DUMMY_FRAME:void:push_dummy_frame:void:-:::0
-f:1:PUSH_RETURN_ADDRESS:CORE_ADDR:push_return_address:CORE_ADDR pc, CORE_ADDR sp:pc, sp:::0
+F:2:PUSH_RETURN_ADDRESS:CORE_ADDR:push_return_address:CORE_ADDR pc, CORE_ADDR sp:pc, sp:::0
f:2:POP_FRAME:void:pop_frame:void:-:::0
#
-# I wish that these would just go away....
-f:2:D10V_MAKE_DADDR:CORE_ADDR:d10v_make_daddr:CORE_ADDR x:x:::0::0
-f:2:D10V_MAKE_IADDR:CORE_ADDR:d10v_make_iaddr:CORE_ADDR x:x:::0::0
-f:2:D10V_DADDR_P:int:d10v_daddr_p:CORE_ADDR x:x:::0::0
-f:2:D10V_IADDR_P:int:d10v_iaddr_p:CORE_ADDR x:x:::0::0
-f:2:D10V_CONVERT_DADDR_TO_RAW:CORE_ADDR:d10v_convert_daddr_to_raw:CORE_ADDR x:x:::0::0
-f:2:D10V_CONVERT_IADDR_TO_RAW:CORE_ADDR:d10v_convert_iaddr_to_raw:CORE_ADDR x:x:::0::0
-#
f:2:STORE_STRUCT_RETURN:void:store_struct_return:CORE_ADDR addr, CORE_ADDR sp:addr, sp:::0
f:2:STORE_RETURN_VALUE:void:store_return_value:struct type *type, char *valbuf:type, valbuf:::0
-f:2:EXTRACT_STRUCT_VALUE_ADDRESS:CORE_ADDR:extract_struct_value_address:char *regbuf:regbuf:::0
-f:2:USE_STRUCT_CONVENTION:int:use_struct_convention:int gcc_p, struct type *value_type:gcc_p, value_type:::0
+F:2:EXTRACT_STRUCT_VALUE_ADDRESS:CORE_ADDR:extract_struct_value_address:char *regbuf:regbuf:::0
+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
#
f:2:FRAME_INIT_SAVED_REGS:void:frame_init_saved_regs:struct frame_info *frame:frame::0:0
-f:2:INIT_EXTRA_FRAME_INFO:void:init_extra_frame_info:int fromleaf, struct frame_info *frame:fromleaf, frame:::0
+F:2:INIT_EXTRA_FRAME_INFO:void:init_extra_frame_info:int fromleaf, struct frame_info *frame:fromleaf, frame:::0
#
f:2:SKIP_PROLOGUE:CORE_ADDR:skip_prologue:CORE_ADDR ip:ip::0:0
f:2:PROLOGUE_FRAMELESS_P:int:prologue_frameless_p:CORE_ADDR ip:ip::0:generic_prologue_frameless_p::0
f:2:INNER_THAN:int:inner_than:CORE_ADDR lhs, CORE_ADDR rhs:lhs, rhs::0:0
-f:2:BREAKPOINT_FROM_PC:unsigned char *:breakpoint_from_pc:CORE_ADDR *pcptr, int *lenptr:pcptr, lenptr:::legacy_breakpoint_from_pc::0
+f:2:BREAKPOINT_FROM_PC:const unsigned char *:breakpoint_from_pc:CORE_ADDR *pcptr, int *lenptr:pcptr, lenptr:::legacy_breakpoint_from_pc::0
f:2:MEMORY_INSERT_BREAKPOINT:int:memory_insert_breakpoint:CORE_ADDR addr, char *contents_cache:addr, contents_cache::0:default_memory_insert_breakpoint::0
f:2:MEMORY_REMOVE_BREAKPOINT:int:memory_remove_breakpoint:CORE_ADDR addr, char *contents_cache:addr, contents_cache::0:default_memory_remove_breakpoint::0
v:2:DECR_PC_AFTER_BREAK:CORE_ADDR:decr_pc_after_break::::0:-1
+f::PREPARE_TO_PROCEED:int:prepare_to_proceed:int select_it:select_it::0:default_prepare_to_proceed::0
v:2:FUNCTION_START_OFFSET:CORE_ADDR:function_start_offset::::0:-1
#
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
v:2:FRAME_ARGS_SKIP:CORE_ADDR:frame_args_skip::::0:-1
f:2:FRAMELESS_FUNCTION_INVOCATION:int:frameless_function_invocation:struct frame_info *fi:fi:::generic_frameless_function_invocation_not::0
f:2:FRAME_CHAIN:CORE_ADDR:frame_chain:struct frame_info *frame:frame::0:0
-f:1:FRAME_CHAIN_VALID:int:frame_chain_valid:CORE_ADDR chain, struct frame_info *thisframe:chain, thisframe::0:0
+# Define a default FRAME_CHAIN_VALID, in the form that is suitable for
+# most targets. If FRAME_CHAIN_VALID returns zero it means that the
+# given frame is the outermost one and has no caller.
+#
+# XXXX - both default and alternate frame_chain_valid functions are
+# deprecated. New code should use dummy frames and one of the generic
+# functions.
+f:2:FRAME_CHAIN_VALID:int:frame_chain_valid:CORE_ADDR chain, struct frame_info *thisframe:chain, thisframe:::func_frame_chain_valid::0
f:2:FRAME_SAVED_PC:CORE_ADDR:frame_saved_pc:struct frame_info *fi:fi::0:0
f:2:FRAME_ARGS_ADDRESS:CORE_ADDR:frame_args_address:struct frame_info *fi:fi::0:0
f:2:FRAME_LOCALS_ADDRESS:CORE_ADDR:frame_locals_address:struct frame_info *fi:fi::0:0
f:2:FRAME_NUM_ARGS:int:frame_num_args:struct frame_info *frame:frame::0:0
#
F:2:STACK_ALIGN:CORE_ADDR:stack_align:CORE_ADDR sp:sp::0:0
-v:1:EXTRA_STACK_ALIGNMENT_NEEDED:int:extra_stack_alignment_needed::::0:1::0:::
+v:2:EXTRA_STACK_ALIGNMENT_NEEDED:int:extra_stack_alignment_needed::::0:1::0:::
F:2:REG_STRUCT_HAS_ADDR:int:reg_struct_has_addr:int gcc_p, struct type *type:gcc_p, type::0:0
F:2:SAVE_DUMMY_FRAME_TOS:void:save_dummy_frame_tos:CORE_ADDR sp:sp::0:0
+v:2:PARM_BOUNDARY:int:parm_boundary
#
v:2:TARGET_FLOAT_FORMAT:const struct floatformat *:float_format::::::default_float_format (gdbarch)
v:2:TARGET_DOUBLE_FORMAT:const struct floatformat *:double_format::::::default_double_format (gdbarch)
-v:2:TARGET_LONG_DOUBLE_FORMAT:const struct floatformat *:long_double_format::::::&floatformat_unknown
+v:2:TARGET_LONG_DOUBLE_FORMAT:const struct floatformat *:long_double_format::::::default_double_format (gdbarch)
+f:2:CONVERT_FROM_FUNC_PTR_ADDR:CORE_ADDR:convert_from_func_ptr_addr:CORE_ADDR addr:addr:::core_addr_identity::0
+# On some machines there are bits in addresses which are not really
+# part of the address, but are used by the kernel, the hardware, etc.
+# for special purposes. ADDR_BITS_REMOVE takes out any such bits so
+# we get a "real" address such as one would find in a symbol table.
+# This is used only for addresses of instructions, and even then I'm
+# not sure it's used in all contexts. It exists to deal with there
+# being a few stray bits in the PC which would mislead us, not as some
+# sort of generic thing to handle alignment or segmentation (it's
+# possible it should be in TARGET_READ_PC instead).
+f:2:ADDR_BITS_REMOVE:CORE_ADDR:addr_bits_remove:CORE_ADDR addr:addr:::core_addr_identity::0
+# It is not at all clear why SMASH_TEXT_ADDRESS is not folded into
+# ADDR_BITS_REMOVE.
+f:2:SMASH_TEXT_ADDRESS:CORE_ADDR:smash_text_address:CORE_ADDR addr:addr:::core_addr_identity::0
+# FIXME/cagney/2001-01-18: This should be split in two. A target method that indicates if
+# the target needs software single step. An ISA method to implement it.
+#
+# FIXME/cagney/2001-01-18: This should be replaced with something that inserts breakpoints
+# using the breakpoint system instead of blatting memory directly (as with rs6000).
+#
+# FIXME/cagney/2001-01-18: The logic is backwards. It should be asking if the target can
+# single step. If not, then implement single step using breakpoints.
+F:2:SOFTWARE_SINGLE_STEP:void:software_single_step:enum target_signal sig, int insert_breakpoints_p:sig, insert_breakpoints_p::0:0
+f:2:TARGET_PRINT_INSN:int:print_insn:bfd_vma vma, disassemble_info *info:vma, info:::legacy_print_insn::0
+f:2:SKIP_TRAMPOLINE_CODE:CORE_ADDR:skip_trampoline_code:CORE_ADDR pc:pc:::generic_skip_trampoline_code::0
+# For SVR4 shared libraries, each call goes through a small piece of
+# trampoline code in the ".plt" section. IN_SOLIB_CALL_TRAMPOLINE evaluates
+# to nonzero if we are current stopped in one of these.
+f:2:IN_SOLIB_CALL_TRAMPOLINE:int:in_solib_call_trampoline:CORE_ADDR pc, char *name:pc, name:::generic_in_solib_call_trampoline::0
+# Sigtramp is a routine that the kernel calls (which then calls the
+# signal handler). On most machines it is a library routine that is
+# linked into the executable.
+#
+# This macro, given a program counter value and the name of the
+# function in which that PC resides (which can be null if the name is
+# not known), returns nonzero if the PC and name show that we are in
+# sigtramp.
+#
+# On most machines just see if the name is sigtramp (and if we have
+# no name, assume we are not in sigtramp).
+#
+# FIXME: cagney/2002-04-21: The function find_pc_partial_function
+# calls find_pc_sect_partial_function() which calls PC_IN_SIGTRAMP.
+# This means PC_IN_SIGTRAMP function can't be implemented by doing its
+# own local NAME lookup.
+#
+# FIXME: cagney/2002-04-21: PC_IN_SIGTRAMP is something of a mess.
+# Some code also depends on SIGTRAMP_START and SIGTRAMP_END but other
+# does not.
+f:2:PC_IN_SIGTRAMP:int:pc_in_sigtramp:CORE_ADDR pc, char *name:pc, name:::legacy_pc_in_sigtramp::0
+# A target might have problems with watchpoints as soon as the stack
+# frame of the current function has been destroyed. This mostly happens
+# as the first action in a funtion's epilogue. in_function_epilogue_p()
+# is defined to return a non-zero value if either the given addr is one
+# instruction after the stack destroying instruction up to the trailing
+# return instruction or if we can figure out that the stack frame has
+# already been invalidated regardless of the value of addr. Targets
+# which don't suffer from that problem could just let this functionality
+# untouched.
+m:::int:in_function_epilogue_p:CORE_ADDR addr:addr::0:generic_in_function_epilogue_p::0
+# Given a vector of command-line arguments, return a newly allocated
+# string which, when passed to the create_inferior function, will be
+# parsed (on Unix systems, by the shell) to yield the same vector.
+# This function should call error() if the argument vector is not
+# representable for this target or if this target does not support
+# command-line arguments.
+# ARGC is the number of elements in the vector.
+# ARGV is an array of strings, one per argument.
+m::CONSTRUCT_INFERIOR_ARGUMENTS:char *:construct_inferior_arguments:int argc, char **argv:argc, argv:::construct_inferior_arguments::0
+F:2:DWARF2_BUILD_FRAME_INFO:void:dwarf2_build_frame_info:struct objfile *objfile:objfile:::0
+f:2:ELF_MAKE_MSYMBOL_SPECIAL:void:elf_make_msymbol_special:asymbol *sym, struct minimal_symbol *msym:sym, msym:::default_elf_make_msymbol_special::0
+f:2:COFF_MAKE_MSYMBOL_SPECIAL:void:coff_make_msymbol_special:int val, struct minimal_symbol *msym:val, msym:::default_coff_make_msymbol_special::0
EOF
}
cat <<EOF
${class} ${macro}(${actual})
${returntype} ${function} ($formal)${attrib}
- level=${level}
- staticdefault=${staticdefault}
- predefault=${predefault}
- postdefault=${postdefault}
- #fallbackdefault=${fallbackdefault}
- invalid_p=${invalid_p}
- #valid_p=${valid_p}
- fmt=${fmt}
- print=${print}
- print_p=${print_p}
- description=${description}
EOF
+ for r in ${read}
+ do
+ eval echo \"\ \ \ \ ${r}=\${${r}}\"
+ done
+# #fallbackdefault=${fallbackdefault}
+# #valid_p=${valid_p}
+#EOF
if class_is_predicate_p && fallback_default_p
then
echo "Error: predicate function ${macro} can not have a non- multi-arch default" 1>&2
kill $$
exit 1
fi
- if [ "${invalid_p}" = "0" -a "${postdefault}" != "" ]
+ if [ "x${invalid_p}" = "x0" -a -n "${postdefault}" ]
then
echo "Error: postdefault is useless when invalid_p=0" 1>&2
kill $$
exit 1
fi
+ if class_is_multiarch_p
+ then
+ if class_is_predicate_p ; then :
+ elif test "x${predefault}" = "x"
+ then
+ echo "Error: pure multi-arch function must have a predefault" 1>&2
+ kill $$
+ exit 1
+ fi
+ fi
+ echo ""
done
exec 1>&2
/* *INDENT-OFF* */ /* THIS FILE IS GENERATED */
/* Dynamic architecture support for GDB, the GNU debugger.
- Copyright 1998-1999, Free Software Foundation, Inc.
+ Copyright 1998, 1999, 2000, 2001, 2002 Free Software Foundation, Inc.
This file is part of GDB.
/* This file was created with the aid of \`\`gdbarch.sh''.
- The bourn shell script \`\`gdbarch.sh'' creates the files
+ The Bourne shell script \`\`gdbarch.sh'' creates the files
\`\`new-gdbarch.c'' and \`\`new-gdbarch.h and then compares them
against the existing \`\`gdbarch.[hc]''. Any differences found
being reported.
If editing this file, please also run gdbarch.sh and merge any
- changes into that script. Conversely, when makeing sweeping changes
+ changes into that script. Conversely, when making sweeping changes
to this file, modifying gdbarch.sh and using its output may prove
easier. */
#ifndef GDBARCH_H
#define GDBARCH_H
+#include "dis-asm.h" /* Get defs for disassemble_info, which unfortunately is a typedef. */
+#if !GDB_MULTI_ARCH
+/* Pull in function declarations refered to, indirectly, via macros. */
+#include "value.h" /* For default_coerce_float_to_double which is referenced by a macro. */
+#include "inferior.h" /* For unsigned_address_to_pointer(). */
+#endif
+
struct frame_info;
struct value;
-
+struct objfile;
+struct minimal_symbol;
extern struct gdbarch *current_gdbarch;
#error "FRAME_FIND_SAVED_REGS: replaced by FRAME_INIT_SAVED_REGS"
#endif
#endif
+
+#if (GDB_MULTI_ARCH >= GDB_MULTI_ARCH_PURE) && defined (GDB_TM_FILE)
+#error "GDB_TM_FILE: Pure multi-arch targets do not have a tm.h file."
+#endif
EOF
# function typedef's
-echo ""
-echo ""
-echo "/* The following are pre-initialized by GDBARCH. */"
+printf "\n"
+printf "\n"
+printf "/* The following are pre-initialized by GDBARCH. */\n"
function_list | while do_read
do
if class_is_info_p
then
- echo ""
- echo "extern ${returntype} gdbarch_${function} (struct gdbarch *gdbarch);"
- echo "/* set_gdbarch_${function}() - not applicable - pre-initialized. */"
- echo "#if GDB_MULTI_ARCH"
- echo "#if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (${macro})"
- echo "#define ${macro} (gdbarch_${function} (current_gdbarch))"
- echo "#endif"
- echo "#endif"
+ printf "\n"
+ printf "extern ${returntype} gdbarch_${function} (struct gdbarch *gdbarch);\n"
+ printf "/* set_gdbarch_${function}() - not applicable - pre-initialized. */\n"
+ printf "#if (GDB_MULTI_ARCH ${gt_level}) && defined (${macro})\n"
+ printf "#error \"Non multi-arch definition of ${macro}\"\n"
+ printf "#endif\n"
+ printf "#if GDB_MULTI_ARCH\n"
+ printf "#if (GDB_MULTI_ARCH ${gt_level}) || !defined (${macro})\n"
+ printf "#define ${macro} (gdbarch_${function} (current_gdbarch))\n"
+ printf "#endif\n"
+ printf "#endif\n"
fi
done
# function typedef's
-echo ""
-echo ""
-echo "/* The following are initialized by the target dependant code. */"
+printf "\n"
+printf "\n"
+printf "/* The following are initialized by the target dependent code. */\n"
function_list | while do_read
do
- if [ "${comment}" ]
+ if [ -n "${comment}" ]
then
echo "${comment}" | sed \
-e '2 s,#,/*,' \
-e '3,$ s,#, ,' \
-e '$ s,$, */,'
fi
- if class_is_predicate_p
+ if class_is_multiarch_p
then
- echo ""
- echo "#if defined (${macro})"
- echo "/* Legacy for systems yet to multi-arch ${macro} */"
-# echo "#if (GDB_MULTI_ARCH <= GDB_MULTI_ARCH_PARTIAL) && defined (${macro})"
- echo "#define ${macro}_P() (1)"
- echo "#endif"
- echo ""
- echo "/* Default predicate for non- multi-arch targets. */"
- echo "#if (!GDB_MULTI_ARCH) && !defined (${macro}_P)"
- echo "#define ${macro}_P() (0)"
- echo "#endif"
- echo ""
- echo "extern int gdbarch_${function}_p (struct gdbarch *gdbarch);"
- echo "#if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (${macro}_P)"
- echo "#define ${macro}_P() (gdbarch_${function}_p (current_gdbarch))"
- echo "#endif"
+ if class_is_predicate_p
+ then
+ printf "\n"
+ printf "extern int gdbarch_${function}_p (struct gdbarch *gdbarch);\n"
+ fi
+ else
+ if class_is_predicate_p
+ then
+ printf "\n"
+ printf "#if defined (${macro})\n"
+ printf "/* Legacy for systems yet to multi-arch ${macro} */\n"
+ #printf "#if (GDB_MULTI_ARCH <= GDB_MULTI_ARCH_PARTIAL) && defined (${macro})\n"
+ printf "#if !defined (${macro}_P)\n"
+ printf "#define ${macro}_P() (1)\n"
+ printf "#endif\n"
+ printf "#endif\n"
+ printf "\n"
+ printf "/* Default predicate for non- multi-arch targets. */\n"
+ printf "#if (!GDB_MULTI_ARCH) && !defined (${macro}_P)\n"
+ printf "#define ${macro}_P() (0)\n"
+ printf "#endif\n"
+ printf "\n"
+ printf "extern int gdbarch_${function}_p (struct gdbarch *gdbarch);\n"
+ printf "#if (GDB_MULTI_ARCH ${gt_level}) && defined (${macro}_P)\n"
+ printf "#error \"Non multi-arch definition of ${macro}\"\n"
+ printf "#endif\n"
+ printf "#if (GDB_MULTI_ARCH ${gt_level}) || !defined (${macro}_P)\n"
+ printf "#define ${macro}_P() (gdbarch_${function}_p (current_gdbarch))\n"
+ printf "#endif\n"
+ fi
fi
if class_is_variable_p
then
if fallback_default_p || class_is_predicate_p
then
- echo ""
- echo "/* Default (value) for non- multi-arch platforms. */"
- echo "#if (!GDB_MULTI_ARCH) && !defined (${macro})"
+ printf "\n"
+ printf "/* Default (value) for non- multi-arch platforms. */\n"
+ printf "#if (!GDB_MULTI_ARCH) && !defined (${macro})\n"
echo "#define ${macro} (${fallbackdefault})" \
| sed -e 's/\([^a-z_]\)\(gdbarch[^a-z_]\)/\1current_\2/g'
- echo "#endif"
+ printf "#endif\n"
fi
- echo ""
- echo "extern ${returntype} gdbarch_${function} (struct gdbarch *gdbarch);"
- echo "extern void set_gdbarch_${function} (struct gdbarch *gdbarch, ${returntype} ${function});"
- echo "#if GDB_MULTI_ARCH"
- echo "#if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (${macro})"
- echo "#define ${macro} (gdbarch_${function} (current_gdbarch))"
- echo "#endif"
- echo "#endif"
+ printf "\n"
+ printf "extern ${returntype} gdbarch_${function} (struct gdbarch *gdbarch);\n"
+ printf "extern void set_gdbarch_${function} (struct gdbarch *gdbarch, ${returntype} ${function});\n"
+ printf "#if (GDB_MULTI_ARCH ${gt_level}) && defined (${macro})\n"
+ printf "#error \"Non multi-arch definition of ${macro}\"\n"
+ printf "#endif\n"
+ printf "#if GDB_MULTI_ARCH\n"
+ printf "#if (GDB_MULTI_ARCH ${gt_level}) || !defined (${macro})\n"
+ printf "#define ${macro} (gdbarch_${function} (current_gdbarch))\n"
+ printf "#endif\n"
+ printf "#endif\n"
fi
if class_is_function_p
then
- if fallback_default_p || class_is_predicate_p
+ if class_is_multiarch_p ; then :
+ elif fallback_default_p || class_is_predicate_p
then
- echo ""
- echo "/* Default (function) for non- multi-arch platforms. */"
- echo "#if (!GDB_MULTI_ARCH) && !defined (${macro})"
- if [ "${fallbackdefault}" = "0" ]
+ printf "\n"
+ printf "/* Default (function) for non- multi-arch platforms. */\n"
+ printf "#if (!GDB_MULTI_ARCH) && !defined (${macro})\n"
+ if [ "x${fallbackdefault}" = "x0" ]
then
- echo "#define ${macro}(${actual}) (internal_error (\"${macro}\"), 0)"
+ printf "#define ${macro}(${actual}) (internal_error (__FILE__, __LINE__, \"${macro}\"), 0)\n"
else
# FIXME: Should be passing current_gdbarch through!
echo "#define ${macro}(${actual}) (${fallbackdefault} (${actual}))" \
| sed -e 's/\([^a-z_]\)\(gdbarch[^a-z_]\)/\1current_\2/g'
fi
- echo "#endif"
+ printf "#endif\n"
fi
- echo ""
- echo "typedef ${returntype} (gdbarch_${function}_ftype) (${formal});"
- if [ "${formal}" = "void" ]
+ printf "\n"
+ if [ "x${formal}" = "xvoid" ] && class_is_multiarch_p
then
- echo "extern ${returntype} gdbarch_${function} (struct gdbarch *gdbarch);"
+ printf "typedef ${returntype} (gdbarch_${function}_ftype) (struct gdbarch *gdbarch);\n"
+ elif class_is_multiarch_p
+ then
+ printf "typedef ${returntype} (gdbarch_${function}_ftype) (struct gdbarch *gdbarch, ${formal});\n"
else
- echo "extern ${returntype} gdbarch_${function} (struct gdbarch *gdbarch, ${formal});"
+ printf "typedef ${returntype} (gdbarch_${function}_ftype) (${formal});\n"
fi
- echo "extern void set_gdbarch_${function} (struct gdbarch *gdbarch, gdbarch_${function}_ftype *${function});"
- echo "#if GDB_MULTI_ARCH"
- echo "#if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (${macro})"
- if [ "${actual}" = "" ]
- then
- echo "#define ${macro}() (gdbarch_${function} (current_gdbarch))"
- elif [ "${actual}" = "-" ]
+ if [ "x${formal}" = "xvoid" ]
then
- echo "#define ${macro} (gdbarch_${function} (current_gdbarch))"
+ printf "extern ${returntype} gdbarch_${function} (struct gdbarch *gdbarch);\n"
else
- echo "#define ${macro}(${actual}) (gdbarch_${function} (current_gdbarch, ${actual}))"
+ printf "extern ${returntype} gdbarch_${function} (struct gdbarch *gdbarch, ${formal});\n"
+ fi
+ printf "extern void set_gdbarch_${function} (struct gdbarch *gdbarch, gdbarch_${function}_ftype *${function});\n"
+ if class_is_multiarch_p ; then :
+ else
+ printf "#if (GDB_MULTI_ARCH ${gt_level}) && defined (${macro})\n"
+ printf "#error \"Non multi-arch definition of ${macro}\"\n"
+ printf "#endif\n"
+ printf "#if GDB_MULTI_ARCH\n"
+ printf "#if (GDB_MULTI_ARCH ${gt_level}) || !defined (${macro})\n"
+ if [ "x${actual}" = "x" ]
+ then
+ printf "#define ${macro}() (gdbarch_${function} (current_gdbarch))\n"
+ elif [ "x${actual}" = "x-" ]
+ then
+ printf "#define ${macro} (gdbarch_${function} (current_gdbarch))\n"
+ else
+ printf "#define ${macro}(${actual}) (gdbarch_${function} (current_gdbarch, ${actual}))\n"
+ fi
+ printf "#endif\n"
+ printf "#endif\n"
fi
- echo "#endif"
- echo "#endif"
fi
done
The mechanisms below ensures that there is only a loose connection
between the set-architecture command and the various GDB
- components. Each component can independantly register their need
+ components. Each component can independently register their need
to maintain architecture specific data with gdbarch.
Pragmatics:
The more traditional mega-struct containing architecture specific
data for all the various GDB components was also considered. Since
- GDB is built from a variable number of (fairly independant)
+ GDB is built from a variable number of (fairly independent)
components it was determined that the global aproach was not
applicable. */
architecture; ARCHES which is a list of the previously created
\`\`struct gdbarch'' for this architecture.
- The INIT function parameter INFO shall, as far as possible, be
- pre-initialized with information obtained from INFO.ABFD or
- previously selected architecture (if similar). INIT shall ensure
- that the INFO.BYTE_ORDER is non-zero.
+ The INFO parameter is, as far as possible, be pre-initialized with
+ information obtained from INFO.ABFD or the previously selected
+ architecture.
+
+ The ARCHES parameter is a linked list (sorted most recently used)
+ of all the previously created architures for this architecture
+ family. The (possibly NULL) ARCHES->gdbarch can used to access
+ values from the previously selected architecture for this
+ architecture family. The global \`\`current_gdbarch'' shall not be
+ used.
The INIT function shall return any of: NULL - indicating that it
- doesn't reconize the selected architecture; an existing \`\`struct
+ doesn't recognize the selected architecture; an existing \`\`struct
gdbarch'' from the ARCHES list - indicating that the new
architecture is just a synonym for an earlier architecture (see
gdbarch_list_lookup_by_info()); a newly created \`\`struct gdbarch''
struct gdbarch_info
{
- /* Use default: bfd_arch_unknown (ZERO). */
- enum bfd_architecture bfd_architecture;
-
/* Use default: NULL (ZERO). */
const struct bfd_arch_info *bfd_arch_info;
- /* Use default: 0 (ZERO). */
+ /* Use default: BFD_ENDIAN_UNKNOWN (NB: is not ZERO). */
int byte_order;
/* Use default: NULL (ZERO). */
extern void gdbarch_free (struct gdbarch *);
-/* Helper function. Force an update of the current architecture. Used
- by legacy targets that have added their own target specific
- architecture manipulation commands.
+/* Helper function. Force an update of the current architecture.
- The INFO parameter shall be fully initialized (\`\`memset (&INFO,
- sizeof (info), 0)'' set relevant fields) before gdbarch_update_p()
- is called. gdbarch_update_p() shall initialize any \`\`default''
- fields using information obtained from the previous architecture or
- INFO.ABFD (if specified) before calling the corresponding
- architectures INIT function.
+ The actual architecture selected is determined by INFO, \`\`(gdb) set
+ architecture'' et.al., the existing architecture and BFD's default
+ architecture. INFO should be initialized to zero and then selected
+ fields should be updated.
Returns non-zero if the update succeeds */
Reserve space for a per-architecture data-pointer. An identifier
for the reserved data-pointer is returned. That identifer should
- be saved in a local static.
+ be saved in a local static variable.
+
+ The per-architecture data-pointer can be initialized in one of two
+ ways: The value can be set explicitly using a call to
+ set_gdbarch_data(); the value can be set implicitly using the value
+ returned by a non-NULL INIT() callback. INIT(), when non-NULL is
+ called after the basic architecture vector has been created.
- When a new architecture is selected, INIT() is called. When a
- previous architecture is re-selected, the per-architecture
- data-pointer for that previous architecture is restored (INIT() is
- not called).
+ When a previously created architecture is re-selected, the
+ per-architecture data-pointer for that previous architecture is
+ restored. INIT() is not called.
- INIT() shall return the initial value for the per-architecture
- data-pointer for the current architecture.
+ During initialization, multiple assignments of the data-pointer are
+ allowed, non-NULL values are deleted by calling FREE(). If the
+ architecture is deleted using gdbarch_free() all non-NULL data
+ pointers are also deleted using FREE().
Multiple registrarants for any architecture are allowed (and
strongly encouraged). */
-typedef void *(gdbarch_data_ftype) (void);
-extern struct gdbarch_data *register_gdbarch_data (gdbarch_data_ftype *init);
-
-/* Return the value of the per-architecture data-pointer for the
- current architecture. */
+struct gdbarch_data;
-extern void *gdbarch_data (struct gdbarch_data*);
+typedef void *(gdbarch_data_init_ftype) (struct gdbarch *gdbarch);
+typedef void (gdbarch_data_free_ftype) (struct gdbarch *gdbarch,
+ void *pointer);
+extern struct gdbarch_data *register_gdbarch_data (gdbarch_data_init_ftype *init,
+ gdbarch_data_free_ftype *free);
+extern void set_gdbarch_data (struct gdbarch *gdbarch,
+ struct gdbarch_data *data,
+ void *pointer);
+extern void *gdbarch_data (struct gdbarch *gdbarch, struct gdbarch_data *);
/* Register per-architecture memory region.
-/* The target-system-dependant byte order is dynamic */
-
-/* TARGET_BYTE_ORDER_SELECTABLE_P determines if the target endianness
- is selectable at runtime. The user can use the \`\`set endian''
- command to change it. TARGET_BYTE_ORDER_AUTO is nonzero when
- target_byte_order should be auto-detected (from the program image
- say). */
-
-#if GDB_MULTI_ARCH
-/* Multi-arch GDB is always bi-endian. */
-#define TARGET_BYTE_ORDER_SELECTABLE_P 1
-#endif
-
-#ifndef TARGET_BYTE_ORDER_SELECTABLE_P
-/* compat - Catch old targets that define TARGET_BYTE_ORDER_SLECTABLE
- when they should have defined TARGET_BYTE_ORDER_SELECTABLE_P 1 */
-#ifdef TARGET_BYTE_ORDER_SELECTABLE
-#define TARGET_BYTE_ORDER_SELECTABLE_P 1
-#else
-#define TARGET_BYTE_ORDER_SELECTABLE_P 0
-#endif
-#endif
+/* The target-system-dependent byte order is dynamic */
extern int target_byte_order;
-#ifdef TARGET_BYTE_ORDER_SELECTABLE
-/* compat - Catch old targets that define TARGET_BYTE_ORDER_SELECTABLE
- and expect defs.h to re-define TARGET_BYTE_ORDER. */
-#undef TARGET_BYTE_ORDER
-#endif
#ifndef TARGET_BYTE_ORDER
#define TARGET_BYTE_ORDER (target_byte_order + 0)
#endif
-/* The target-system-dependant BFD architecture is dynamic */
+/* The target-system-dependent BFD architecture is dynamic */
extern int target_architecture_auto;
#ifndef TARGET_ARCHITECTURE_AUTO
#endif
-/* The target-system-dependant disassembler is semi-dynamic */
-
-#include "dis-asm.h" /* Get defs for disassemble_info */
+/* The target-system-dependent disassembler is semi-dynamic */
extern int dis_asm_read_memory (bfd_vma memaddr, bfd_byte *myaddr,
unsigned int len, disassemble_info *info);
extern int (*tm_print_insn) (bfd_vma, disassemble_info*);
extern disassemble_info tm_print_insn_info;
-#ifndef TARGET_PRINT_INSN
-#define TARGET_PRINT_INSN(vma, info) (*tm_print_insn) (vma, info)
-#endif
#ifndef TARGET_PRINT_INSN_INFO
#define TARGET_PRINT_INSN_INFO (&tm_print_insn_info)
#endif
-/* Explicit test for D10V architecture.
- USE of these macro's is *STRONGLY* discouraged. */
-
-#define GDB_TARGET_IS_D10V (TARGET_ARCHITECTURE->arch == bfd_arch_d10v)
-
-
-/* Fallback definition for EXTRACT_STRUCT_VALUE_ADDRESS */
-#ifndef EXTRACT_STRUCT_VALUE_ADDRESS
-#define EXTRACT_STRUCT_VALUE_ADDRESS_P (0)
-#define EXTRACT_STRUCT_VALUE_ADDRESS(X) (internal_error ("gdbarch: EXTRACT_STRUCT_VALUE_ADDRESS"), 0)
-#else
-#ifndef EXTRACT_STRUCT_VALUE_ADDRESS_P
-#define EXTRACT_STRUCT_VALUE_ADDRESS_P (1)
-#endif
-#endif
-
-
-/* Set the dynamic target-system-dependant parameters (architecture,
+/* Set the dynamic target-system-dependent parameters (architecture,
byte-order, ...) using information found in the BFD */
extern void set_gdbarch_from_file (bfd *);
extern void initialize_current_architecture (void);
+/* For non-multiarched targets, do any initialization of the default
+ gdbarch object necessary after the _initialize_MODULE functions
+ have run. */
+extern void initialize_non_multiarch ();
/* gdbarch trace variable */
extern int gdbarch_debug;
#include "gdbthread.h"
#include "annotate.h"
#include "symfile.h" /* for overlay functions */
+#include "value.h" /* For old tm.h/nm.h macros. */
#endif
#include "symcat.h"
#include "floatformat.h"
+#include "gdb_assert.h"
+#include "gdb-events.h"
+
/* Static function declarations */
static void verify_gdbarch (struct gdbarch *gdbarch);
+static void alloc_gdbarch_data (struct gdbarch *);
static void init_gdbarch_data (struct gdbarch *);
+static void free_gdbarch_data (struct gdbarch *);
static void init_gdbarch_swap (struct gdbarch *);
+static void clear_gdbarch_swap (struct gdbarch *);
static void swapout_gdbarch_swap (struct gdbarch *);
static void swapin_gdbarch_swap (struct gdbarch *);
-/* Convenience macro for allocting typesafe memory. */
-
-#ifndef XMALLOC
-#define XMALLOC(TYPE) (TYPE*) xmalloc (sizeof (TYPE))
-#endif
-
-
/* Non-zero if we want to trace architecture code. */
#ifndef GDBARCH_DEBUG
EOF
# gdbarch open the gdbarch object
-echo ""
-echo "/* Maintain the struct gdbarch object */"
-echo ""
-echo "struct gdbarch"
-echo "{"
-echo " /* basic architectural information */"
+printf "\n"
+printf "/* Maintain the struct gdbarch object */\n"
+printf "\n"
+printf "struct gdbarch\n"
+printf "{\n"
+printf " /* basic architectural information */\n"
function_list | while do_read
do
if class_is_info_p
then
- echo " ${returntype} ${function};"
+ printf " ${returntype} ${function};\n"
fi
done
-echo ""
-echo " /* target specific vector. */"
-echo " struct gdbarch_tdep *tdep;"
-echo " gdbarch_dump_tdep_ftype *dump_tdep;"
-echo ""
-echo " /* per-architecture data-pointers */"
-echo " int nr_data;"
-echo " void **data;"
-echo ""
-echo " /* per-architecture swap-regions */"
-echo " struct gdbarch_swap *swap;"
-echo ""
+printf "\n"
+printf " /* target specific vector. */\n"
+printf " struct gdbarch_tdep *tdep;\n"
+printf " gdbarch_dump_tdep_ftype *dump_tdep;\n"
+printf "\n"
+printf " /* per-architecture data-pointers */\n"
+printf " unsigned nr_data;\n"
+printf " void **data;\n"
+printf "\n"
+printf " /* per-architecture swap-regions */\n"
+printf " struct gdbarch_swap *swap;\n"
+printf "\n"
cat <<EOF
/* Multi-arch values.
verify_gdbarch(): Confirm that the target updated the field
correctly.
- gdbarch_dump(): Add a fprintf_unfiltered call to so that the new
+ gdbarch_dump(): Add a fprintf_unfiltered call so that the new
field is dumped out
\`\`startup_gdbarch()'': Append an initial value to the static
do
if class_is_variable_p
then
- echo " ${returntype} ${function};"
+ printf " ${returntype} ${function};\n"
elif class_is_function_p
then
- echo " gdbarch_${function}_ftype *${function}${attrib};"
+ printf " gdbarch_${function}_ftype *${function}${attrib};\n"
fi
done
-echo "};"
+printf "};\n"
# A pre-initialized vector
-echo ""
-echo ""
+printf "\n"
+printf "\n"
cat <<EOF
/* The default architecture uses host values (for want of a better
choice). */
EOF
-echo ""
-echo "extern const struct bfd_arch_info bfd_default_arch_struct;"
-echo ""
-echo "struct gdbarch startup_gdbarch ="
-echo "{"
-echo " /* basic architecture information */"
+printf "\n"
+printf "extern const struct bfd_arch_info bfd_default_arch_struct;\n"
+printf "\n"
+printf "struct gdbarch startup_gdbarch =\n"
+printf "{\n"
+printf " /* basic architecture information */\n"
function_list | while do_read
do
if class_is_info_p
then
- echo " ${staticdefault},"
+ printf " ${staticdefault},\n"
fi
done
cat <<EOF
do
if class_is_function_p || class_is_variable_p
then
- echo " ${staticdefault},"
+ printf " ${staticdefault},\n"
fi
done
cat <<EOF
};
struct gdbarch *current_gdbarch = &startup_gdbarch;
+
+/* Do any initialization needed for a non-multiarch configuration
+ after the _initialize_MODULE functions have been run. */
+void
+initialize_non_multiarch ()
+{
+ alloc_gdbarch_data (&startup_gdbarch);
+ /* Ensure that all swap areas are zeroed so that they again think
+ they are starting from scratch. */
+ clear_gdbarch_swap (&startup_gdbarch);
+ init_gdbarch_swap (&startup_gdbarch);
+ init_gdbarch_data (&startup_gdbarch);
+}
EOF
# Create a new gdbarch struct
-echo ""
-echo ""
+printf "\n"
+printf "\n"
cat <<EOF
/* Create a new \`\`struct gdbarch'' based on information provided by
\`\`struct gdbarch_info''. */
EOF
-echo ""
+printf "\n"
cat <<EOF
struct gdbarch *
gdbarch_alloc (const struct gdbarch_info *info,
struct gdbarch_tdep *tdep)
{
- struct gdbarch *gdbarch = XMALLOC (struct gdbarch);
- memset (gdbarch, 0, sizeof (*gdbarch));
-
- gdbarch->tdep = tdep;
+ /* NOTE: The new architecture variable is named \`\`current_gdbarch''
+ so that macros such as TARGET_DOUBLE_BIT, when expanded, refer to
+ the current local architecture and not the previous global
+ architecture. This ensures that the new architectures initial
+ values are not influenced by the previous architecture. Once
+ everything is parameterised with gdbarch, this will go away. */
+ struct gdbarch *current_gdbarch = XMALLOC (struct gdbarch);
+ memset (current_gdbarch, 0, sizeof (*current_gdbarch));
+
+ alloc_gdbarch_data (current_gdbarch);
+
+ current_gdbarch->tdep = tdep;
EOF
-echo ""
+printf "\n"
function_list | while do_read
do
if class_is_info_p
then
- echo " gdbarch->${function} = info->${function};"
+ printf " current_gdbarch->${function} = info->${function};\n"
fi
done
-echo ""
-echo " /* Force the explicit initialization of these. */"
+printf "\n"
+printf " /* Force the explicit initialization of these. */\n"
function_list | while do_read
do
if class_is_function_p || class_is_variable_p
then
- if [ "${predefault}" != "" -a "${predefault}" != "0" ]
+ if [ -n "${predefault}" -a "x${predefault}" != "x0" ]
then
- echo " gdbarch->${function} = ${predefault};"
+ printf " current_gdbarch->${function} = ${predefault};\n"
fi
fi
done
cat <<EOF
/* gdbarch_alloc() */
- return gdbarch;
+ return current_gdbarch;
}
EOF
# Free a gdbarch struct.
-echo ""
-echo ""
+printf "\n"
+printf "\n"
cat <<EOF
/* Free a gdbarch struct. This should never happen in normal
operation --- once you've created a gdbarch, you keep it around.
void
gdbarch_free (struct gdbarch *arch)
{
- /* At the moment, this is trivial. */
- free (arch);
+ gdb_assert (arch != NULL);
+ free_gdbarch_data (arch);
+ xfree (arch);
}
EOF
# verify a new architecture
-echo ""
-echo ""
-echo "/* Ensure that all values in a GDBARCH are reasonable. */"
-echo ""
+printf "\n"
+printf "\n"
+printf "/* Ensure that all values in a GDBARCH are reasonable. */\n"
+printf "\n"
cat <<EOF
static void
verify_gdbarch (struct gdbarch *gdbarch)
{
+ struct ui_file *log;
+ struct cleanup *cleanups;
+ long dummy;
+ char *buf;
/* Only perform sanity checks on a multi-arch target. */
if (!GDB_MULTI_ARCH)
return;
+ log = mem_fileopen ();
+ cleanups = make_cleanup_ui_file_delete (log);
/* fundamental */
- if (gdbarch->byte_order == 0)
- internal_error ("verify_gdbarch: byte-order unset");
+ if (gdbarch->byte_order == BFD_ENDIAN_UNKNOWN)
+ fprintf_unfiltered (log, "\n\tbyte-order");
if (gdbarch->bfd_arch_info == NULL)
- internal_error ("verify_gdbarch: bfd_arch_info unset");
+ fprintf_unfiltered (log, "\n\tbfd_arch_info");
/* Check those that need to be defined for the given multi-arch level. */
EOF
function_list | while do_read
do
if class_is_function_p || class_is_variable_p
then
- if [ "${invalid_p}" = "0" ]
+ if [ "x${invalid_p}" = "x0" ]
then
- echo " /* Skip verify of ${function}, invalid_p == 0 */"
+ printf " /* Skip verify of ${function}, invalid_p == 0 */\n"
elif class_is_predicate_p
then
- echo " /* Skip verify of ${function}, has predicate */"
+ printf " /* Skip verify of ${function}, has predicate */\n"
# FIXME: See do_read for potential simplification
- elif [ "${invalid_p}" -a "${postdefault}" ]
+ elif [ -n "${invalid_p}" -a -n "${postdefault}" ]
then
- echo " if (${invalid_p})"
- echo " gdbarch->${function} = ${postdefault};"
- elif [ "${predefault}" -a "${postdefault}" ]
+ printf " if (${invalid_p})\n"
+ printf " gdbarch->${function} = ${postdefault};\n"
+ elif [ -n "${predefault}" -a -n "${postdefault}" ]
then
- echo " if (gdbarch->${function} == ${predefault})"
- echo " gdbarch->${function} = ${postdefault};"
- elif [ "${postdefault}" ]
+ printf " if (gdbarch->${function} == ${predefault})\n"
+ printf " gdbarch->${function} = ${postdefault};\n"
+ elif [ -n "${postdefault}" ]
then
- echo " if (gdbarch->${function} == 0)"
- echo " gdbarch->${function} = ${postdefault};"
- elif [ "${invalid_p}" ]
+ printf " if (gdbarch->${function} == 0)\n"
+ printf " gdbarch->${function} = ${postdefault};\n"
+ elif [ -n "${invalid_p}" ]
then
- echo " if ((GDB_MULTI_ARCH >= ${level})"
- echo " && (${invalid_p}))"
- echo " internal_error (\"gdbarch: verify_gdbarch: ${function} invalid\");"
- elif [ "${predefault}" ]
+ printf " if ((GDB_MULTI_ARCH ${gt_level})\n"
+ printf " && (${invalid_p}))\n"
+ printf " fprintf_unfiltered (log, \"\\\\n\\\\t${function}\");\n"
+ elif [ -n "${predefault}" ]
then
- echo " if ((GDB_MULTI_ARCH >= ${level})"
- echo " && (gdbarch->${function} == ${predefault}))"
- echo " internal_error (\"gdbarch: verify_gdbarch: ${function} invalid\");"
+ printf " if ((GDB_MULTI_ARCH ${gt_level})\n"
+ printf " && (gdbarch->${function} == ${predefault}))\n"
+ printf " fprintf_unfiltered (log, \"\\\\n\\\\t${function}\");\n"
fi
fi
done
cat <<EOF
+ buf = ui_file_xstrdup (log, &dummy);
+ make_cleanup (xfree, buf);
+ if (strlen (buf) > 0)
+ internal_error (__FILE__, __LINE__,
+ "verify_gdbarch: the following are invalid ...%s",
+ buf);
+ do_cleanups (cleanups);
}
EOF
# dump the structure
-echo ""
-echo ""
+printf "\n"
+printf "\n"
cat <<EOF
/* Print out the details of the current architecture. */
"gdbarch_dump: GDB_MULTI_ARCH = %d\\n",
GDB_MULTI_ARCH);
EOF
-function_list | while do_read
+function_list | sort -t: +2 | while do_read
do
- if [ "${returntype}" = "void" ]
+ # multiarch functions don't have macros.
+ if class_is_multiarch_p
then
- echo "#if defined (${macro}) && GDB_MULTI_ARCH"
- echo " /* Macro might contain \`[{}]' when not multi-arch */"
- else
- echo "#ifdef ${macro}"
+ printf " if (GDB_MULTI_ARCH)\n"
+ printf " fprintf_unfiltered (file,\n"
+ printf " \"gdbarch_dump: ${function} = 0x%%08lx\\\\n\",\n"
+ printf " (long) current_gdbarch->${function});\n"
+ continue
+ fi
+ # Print the macro definition.
+ printf "#ifdef ${macro}\n"
+ if [ "x${returntype}" = "xvoid" ]
+ then
+ printf "#if GDB_MULTI_ARCH\n"
+ printf " /* Macro might contain \`[{}]' when not multi-arch */\n"
fi
if class_is_function_p
then
- echo " fprintf_unfiltered (file,"
- echo " \"gdbarch_dump: %s # %s\\n\","
- echo " \"${macro}(${actual})\","
- echo " XSTRING (${macro} (${actual})));"
+ printf " fprintf_unfiltered (file,\n"
+ printf " \"gdbarch_dump: %%s # %%s\\\\n\",\n"
+ printf " \"${macro}(${actual})\",\n"
+ printf " XSTRING (${macro} (${actual})));\n"
else
- echo " fprintf_unfiltered (file,"
- echo " \"gdbarch_dump: ${macro} # %s\\n\","
- echo " XSTRING (${macro}));"
+ printf " fprintf_unfiltered (file,\n"
+ printf " \"gdbarch_dump: ${macro} # %%s\\\\n\",\n"
+ printf " XSTRING (${macro}));\n"
fi
- echo "#endif"
-done
-function_list | while do_read
-do
- echo "#ifdef ${macro}"
- if [ "${print_p}" = "()" ]
+ # Print the architecture vector value
+ if [ "x${returntype}" = "xvoid" ]
then
- echo " gdbarch_dump_${function} (current_gdbarch);"
- elif [ "${print_p}" = "0" ]
+ printf "#endif\n"
+ fi
+ if [ "x${print_p}" = "x()" ]
+ then
+ printf " gdbarch_dump_${function} (current_gdbarch);\n"
+ elif [ "x${print_p}" = "x0" ]
then
- echo " /* skip print of ${macro}, print_p == 0. */"
- elif [ "${print_p}" ]
+ printf " /* skip print of ${macro}, print_p == 0. */\n"
+ elif [ -n "${print_p}" ]
then
- echo " if (${print_p})"
- echo " fprintf_unfiltered (file,"
- echo " \"gdbarch_dump: ${macro} = ${fmt}\\n\","
- echo " ${print});"
+ printf " if (${print_p})\n"
+ printf " fprintf_unfiltered (file,\n"
+ printf " \"gdbarch_dump: ${macro} = %s\\\\n\",\n" "${fmt}"
+ printf " ${print});\n"
elif class_is_function_p
then
- echo " if (GDB_MULTI_ARCH)"
- echo " fprintf_unfiltered (file,"
- echo " \"gdbarch_dump: ${macro} = 0x%08lx\\n\","
- echo " (long) current_gdbarch->${function}"
- echo " /*${macro} ()*/);"
+ printf " if (GDB_MULTI_ARCH)\n"
+ printf " fprintf_unfiltered (file,\n"
+ printf " \"gdbarch_dump: ${macro} = 0x%%08lx\\\\n\",\n"
+ printf " (long) current_gdbarch->${function}\n"
+ printf " /*${macro} ()*/);\n"
else
- echo " fprintf_unfiltered (file,"
- echo " \"gdbarch_dump: ${macro} = ${fmt}\\n\","
- echo " ${print});"
+ printf " fprintf_unfiltered (file,\n"
+ printf " \"gdbarch_dump: ${macro} = %s\\\\n\",\n" "${fmt}"
+ printf " ${print});\n"
fi
- echo "#endif"
+ printf "#endif\n"
done
cat <<EOF
if (current_gdbarch->dump_tdep != NULL)
# GET/SET
-echo ""
+printf "\n"
cat <<EOF
struct gdbarch_tdep *
gdbarch_tdep (struct gdbarch *gdbarch)
{
if (gdbarch_debug >= 2)
- fprintf_unfiltered (gdb_stdlog, "gdbarch_tdep called\n");
+ fprintf_unfiltered (gdb_stdlog, "gdbarch_tdep called\\n");
return gdbarch->tdep;
}
EOF
-echo ""
+printf "\n"
function_list | while do_read
do
if class_is_predicate_p
then
- echo ""
- echo "int"
- echo "gdbarch_${function}_p (struct gdbarch *gdbarch)"
- echo "{"
- if [ "${valid_p}" ]
+ printf "\n"
+ printf "int\n"
+ printf "gdbarch_${function}_p (struct gdbarch *gdbarch)\n"
+ printf "{\n"
+ printf " gdb_assert (gdbarch != NULL);\n"
+ if [ -n "${valid_p}" ]
then
- echo " return ${valid_p};"
+ printf " return ${valid_p};\n"
else
- echo "#error \"gdbarch_${function}_p: not defined\""
+ printf "#error \"gdbarch_${function}_p: not defined\"\n"
fi
- echo "}"
+ printf "}\n"
fi
if class_is_function_p
then
- echo ""
- echo "${returntype}"
- if [ "${formal}" = "void" ]
+ printf "\n"
+ printf "${returntype}\n"
+ if [ "x${formal}" = "xvoid" ]
then
- echo "gdbarch_${function} (struct gdbarch *gdbarch)"
+ printf "gdbarch_${function} (struct gdbarch *gdbarch)\n"
else
- echo "gdbarch_${function} (struct gdbarch *gdbarch, ${formal})"
+ printf "gdbarch_${function} (struct gdbarch *gdbarch, ${formal})\n"
fi
- echo "{"
- echo " if (gdbarch->${function} == 0)"
- echo " internal_error (\"gdbarch: gdbarch_${function} invalid\");"
- echo " if (gdbarch_debug >= 2)"
- echo " fprintf_unfiltered (gdb_stdlog, \"gdbarch_${function} called\n\");"
- test "${actual}" = "-" && actual=""
- if [ "${returntype}" = "void" ]
+ printf "{\n"
+ printf " gdb_assert (gdbarch != NULL);\n"
+ printf " if (gdbarch->${function} == 0)\n"
+ printf " internal_error (__FILE__, __LINE__,\n"
+ printf " \"gdbarch: gdbarch_${function} invalid\");\n"
+ printf " if (gdbarch_debug >= 2)\n"
+ printf " fprintf_unfiltered (gdb_stdlog, \"gdbarch_${function} called\\\\n\");\n"
+ if [ "x${actual}" = "x-" -o "x${actual}" = "x" ]
then
- echo " gdbarch->${function} (${actual});"
+ if class_is_multiarch_p
+ then
+ params="gdbarch"
+ else
+ params=""
+ fi
else
- echo " return gdbarch->${function} (${actual});"
+ if class_is_multiarch_p
+ then
+ params="gdbarch, ${actual}"
+ else
+ params="${actual}"
+ fi
+ fi
+ if [ "x${returntype}" = "xvoid" ]
+ then
+ printf " gdbarch->${function} (${params});\n"
+ else
+ printf " return gdbarch->${function} (${params});\n"
fi
- echo "}"
- echo ""
- echo "void"
- echo "set_gdbarch_${function} (struct gdbarch *gdbarch,"
- echo " `echo ${function} | sed -e 's/./ /g'` gdbarch_${function}_ftype ${function})"
- echo "{"
- echo " gdbarch->${function} = ${function};"
- echo "}"
+ printf "}\n"
+ printf "\n"
+ printf "void\n"
+ printf "set_gdbarch_${function} (struct gdbarch *gdbarch,\n"
+ printf " `echo ${function} | sed -e 's/./ /g'` gdbarch_${function}_ftype ${function})\n"
+ printf "{\n"
+ printf " gdbarch->${function} = ${function};\n"
+ printf "}\n"
elif class_is_variable_p
then
- echo ""
- echo "${returntype}"
- echo "gdbarch_${function} (struct gdbarch *gdbarch)"
- echo "{"
- if [ "${invalid_p}" = "0" ]
+ printf "\n"
+ printf "${returntype}\n"
+ printf "gdbarch_${function} (struct gdbarch *gdbarch)\n"
+ printf "{\n"
+ printf " gdb_assert (gdbarch != NULL);\n"
+ if [ "x${invalid_p}" = "x0" ]
then
- echo " /* Skip verify of ${function}, invalid_p == 0 */"
- elif [ "${invalid_p}" ]
+ printf " /* Skip verify of ${function}, invalid_p == 0 */\n"
+ elif [ -n "${invalid_p}" ]
then
- echo " if (${invalid_p})"
- echo " internal_error (\"gdbarch: gdbarch_${function} invalid\");"
- elif [ "${predefault}" ]
+ printf " if (${invalid_p})\n"
+ printf " internal_error (__FILE__, __LINE__,\n"
+ printf " \"gdbarch: gdbarch_${function} invalid\");\n"
+ elif [ -n "${predefault}" ]
then
- echo " if (gdbarch->${function} == ${predefault})"
- echo " internal_error (\"gdbarch: gdbarch_${function} invalid\");"
+ printf " if (gdbarch->${function} == ${predefault})\n"
+ printf " internal_error (__FILE__, __LINE__,\n"
+ printf " \"gdbarch: gdbarch_${function} invalid\");\n"
fi
- echo " if (gdbarch_debug >= 2)"
- echo " fprintf_unfiltered (gdb_stdlog, \"gdbarch_${function} called\n\");"
- echo " return gdbarch->${function};"
- echo "}"
- echo ""
- echo "void"
- echo "set_gdbarch_${function} (struct gdbarch *gdbarch,"
- echo " `echo ${function} | sed -e 's/./ /g'` ${returntype} ${function})"
- echo "{"
- echo " gdbarch->${function} = ${function};"
- echo "}"
+ printf " if (gdbarch_debug >= 2)\n"
+ printf " fprintf_unfiltered (gdb_stdlog, \"gdbarch_${function} called\\\\n\");\n"
+ printf " return gdbarch->${function};\n"
+ printf "}\n"
+ printf "\n"
+ printf "void\n"
+ printf "set_gdbarch_${function} (struct gdbarch *gdbarch,\n"
+ printf " `echo ${function} | sed -e 's/./ /g'` ${returntype} ${function})\n"
+ printf "{\n"
+ printf " gdbarch->${function} = ${function};\n"
+ printf "}\n"
elif class_is_info_p
then
- echo ""
- echo "${returntype}"
- echo "gdbarch_${function} (struct gdbarch *gdbarch)"
- echo "{"
- echo " if (gdbarch_debug >= 2)"
- echo " fprintf_unfiltered (gdb_stdlog, \"gdbarch_${function} called\n\");"
- echo " return gdbarch->${function};"
- echo "}"
+ printf "\n"
+ printf "${returntype}\n"
+ printf "gdbarch_${function} (struct gdbarch *gdbarch)\n"
+ printf "{\n"
+ printf " gdb_assert (gdbarch != NULL);\n"
+ printf " if (gdbarch_debug >= 2)\n"
+ printf " fprintf_unfiltered (gdb_stdlog, \"gdbarch_${function} called\\\\n\");\n"
+ printf " return gdbarch->${function};\n"
+ printf "}\n"
fi
done
cat <<EOF
-/* Keep a registrary of per-architecture data-pointers required by GDB
+/* Keep a registry of per-architecture data-pointers required by GDB
modules. */
struct gdbarch_data
{
- int index;
+ unsigned index;
+ gdbarch_data_init_ftype *init;
+ gdbarch_data_free_ftype *free;
};
struct gdbarch_data_registration
{
- gdbarch_data_ftype *init;
struct gdbarch_data *data;
struct gdbarch_data_registration *next;
};
-struct gdbarch_data_registrary
+struct gdbarch_data_registry
{
- int nr;
+ unsigned nr;
struct gdbarch_data_registration *registrations;
};
-struct gdbarch_data_registrary gdbarch_data_registrary =
+struct gdbarch_data_registry gdbarch_data_registry =
{
0, NULL,
};
struct gdbarch_data *
-register_gdbarch_data (gdbarch_data_ftype *init)
+register_gdbarch_data (gdbarch_data_init_ftype *init,
+ gdbarch_data_free_ftype *free)
{
struct gdbarch_data_registration **curr;
- for (curr = &gdbarch_data_registrary.registrations;
+ for (curr = &gdbarch_data_registry.registrations;
(*curr) != NULL;
curr = &(*curr)->next);
(*curr) = XMALLOC (struct gdbarch_data_registration);
(*curr)->next = NULL;
- (*curr)->init = init;
(*curr)->data = XMALLOC (struct gdbarch_data);
- (*curr)->data->index = gdbarch_data_registrary.nr++;
+ (*curr)->data->index = gdbarch_data_registry.nr++;
+ (*curr)->data->init = init;
+ (*curr)->data->free = free;
return (*curr)->data;
}
init_gdbarch_data (struct gdbarch *gdbarch)
{
struct gdbarch_data_registration *rego;
- gdbarch->nr_data = gdbarch_data_registrary.nr + 1;
- gdbarch->data = xmalloc (sizeof (void*) * gdbarch->nr_data);
- for (rego = gdbarch_data_registrary.registrations;
+ for (rego = gdbarch_data_registry.registrations;
rego != NULL;
rego = rego->next)
{
- if (rego->data->index < gdbarch->nr_data)
- gdbarch->data[rego->data->index] = rego->init ();
+ struct gdbarch_data *data = rego->data;
+ gdb_assert (data->index < gdbarch->nr_data);
+ if (data->init != NULL)
+ {
+ void *pointer = data->init (gdbarch);
+ set_gdbarch_data (gdbarch, data, pointer);
+ }
}
}
+/* Create/delete the gdbarch data vector. */
+
+static void
+alloc_gdbarch_data (struct gdbarch *gdbarch)
+{
+ gdb_assert (gdbarch->data == NULL);
+ gdbarch->nr_data = gdbarch_data_registry.nr;
+ gdbarch->data = xcalloc (gdbarch->nr_data, sizeof (void*));
+}
+
+static void
+free_gdbarch_data (struct gdbarch *gdbarch)
+{
+ struct gdbarch_data_registration *rego;
+ gdb_assert (gdbarch->data != NULL);
+ for (rego = gdbarch_data_registry.registrations;
+ rego != NULL;
+ rego = rego->next)
+ {
+ struct gdbarch_data *data = rego->data;
+ gdb_assert (data->index < gdbarch->nr_data);
+ if (data->free != NULL && gdbarch->data[data->index] != NULL)
+ {
+ data->free (gdbarch, gdbarch->data[data->index]);
+ gdbarch->data[data->index] = NULL;
+ }
+ }
+ xfree (gdbarch->data);
+ gdbarch->data = NULL;
+}
+
+
+/* Initialize the current value of thee specified per-architecture
+ data-pointer. */
+
+void
+set_gdbarch_data (struct gdbarch *gdbarch,
+ struct gdbarch_data *data,
+ void *pointer)
+{
+ gdb_assert (data->index < gdbarch->nr_data);
+ if (data->free != NULL && gdbarch->data[data->index] != NULL)
+ data->free (gdbarch, gdbarch->data[data->index]);
+ gdbarch->data[data->index] = pointer;
+}
/* Return the current value of the specified per-architecture
data-pointer. */
void *
-gdbarch_data (struct gdbarch_data *data)
+gdbarch_data (struct gdbarch *gdbarch, struct gdbarch_data *data)
{
- if (data->index >= current_gdbarch->nr_data)
- internal_error ("gdbarch_data: request for non-existant data.");
- return current_gdbarch->data[data->index];
+ gdb_assert (data->index < gdbarch->nr_data);
+ return gdbarch->data[data->index];
}
-/* Keep a registrary of swaped data required by GDB modules. */
+/* Keep a registry of swapped data required by GDB modules. */
struct gdbarch_swap
{
struct gdbarch_swap_registration *next;
};
-struct gdbarch_swap_registrary
+struct gdbarch_swap_registry
{
int nr;
struct gdbarch_swap_registration *registrations;
};
-struct gdbarch_swap_registrary gdbarch_swap_registrary =
+struct gdbarch_swap_registry gdbarch_swap_registry =
{
0, NULL,
};
gdbarch_swap_ftype *init)
{
struct gdbarch_swap_registration **rego;
- for (rego = &gdbarch_swap_registrary.registrations;
+ for (rego = &gdbarch_swap_registry.registrations;
(*rego) != NULL;
rego = &(*rego)->next);
(*rego) = XMALLOC (struct gdbarch_swap_registration);
(*rego)->sizeof_data = sizeof_data;
}
+static void
+clear_gdbarch_swap (struct gdbarch *gdbarch)
+{
+ struct gdbarch_swap *curr;
+ for (curr = gdbarch->swap;
+ curr != NULL;
+ curr = curr->next)
+ {
+ memset (curr->source->data, 0, curr->source->sizeof_data);
+ }
+}
static void
init_gdbarch_swap (struct gdbarch *gdbarch)
{
struct gdbarch_swap_registration *rego;
struct gdbarch_swap **curr = &gdbarch->swap;
- for (rego = gdbarch_swap_registrary.registrations;
+ for (rego = gdbarch_swap_registry.registrations;
rego != NULL;
rego = rego->next)
{
(*curr)->source = rego;
(*curr)->swap = xmalloc (rego->sizeof_data);
(*curr)->next = NULL;
- memset (rego->data, 0, rego->sizeof_data);
curr = &(*curr)->next;
}
if (rego->init != NULL)
}
-/* Keep a registrary of the architectures known by GDB. */
+/* Keep a registry of the architectures known by GDB. */
struct gdbarch_registration
{
struct gdbarch_registration *next;
};
-static struct gdbarch_registration *gdbarch_registrary = NULL;
+static struct gdbarch_registration *gdbarch_registry = NULL;
static void
append_name (const char ***buf, int *nr, const char *name)
int nr_arches = 0;
const char **arches = NULL;
struct gdbarch_registration *rego;
- for (rego = gdbarch_registrary;
+ for (rego = gdbarch_registry;
rego != NULL;
rego = rego->next)
{
const struct bfd_arch_info *ap;
ap = bfd_lookup_arch (rego->bfd_architecture, 0);
if (ap == NULL)
- internal_error ("gdbarch_architecture_names: multi-arch unknown");
+ internal_error (__FILE__, __LINE__,
+ "gdbarch_architecture_names: multi-arch unknown");
do
{
append_name (&arches, &nr_arches, ap->printable_name);
{
struct gdbarch_registration **curr;
const struct bfd_arch_info *bfd_arch_info;
- /* Check that BFD reconizes this architecture */
+ /* Check that BFD recognizes this architecture */
bfd_arch_info = bfd_lookup_arch (bfd_architecture, 0);
if (bfd_arch_info == NULL)
{
- internal_error ("gdbarch: Attempt to register unknown architecture (%d)", bfd_architecture);
+ internal_error (__FILE__, __LINE__,
+ "gdbarch: Attempt to register unknown architecture (%d)",
+ bfd_architecture);
}
/* Check that we haven't seen this architecture before */
- for (curr = &gdbarch_registrary;
+ for (curr = &gdbarch_registry;
(*curr) != NULL;
curr = &(*curr)->next)
{
if (bfd_architecture == (*curr)->bfd_architecture)
- internal_error ("gdbarch: Duplicate registraration of architecture (%s)",
- bfd_arch_info->printable_name);
+ internal_error (__FILE__, __LINE__,
+ "gdbarch: Duplicate registraration of architecture (%s)",
+ bfd_arch_info->printable_name);
}
/* log it */
if (gdbarch_debug)
(*curr)->dump_tdep = dump_tdep;
(*curr)->arches = NULL;
(*curr)->next = NULL;
- /* When non- multi-arch, install what ever target dump routine we've
- been provided - hopefully that routine has been writen correct
+ /* When non- multi-arch, install whatever target dump routine we've
+ been provided - hopefully that routine has been written correctly
and works regardless of multi-arch. */
if (!GDB_MULTI_ARCH && dump_tdep != NULL
&& startup_gdbarch.dump_tdep == NULL)
gdbarch_update_p (struct gdbarch_info info)
{
struct gdbarch *new_gdbarch;
- struct gdbarch_list **list;
+ struct gdbarch *old_gdbarch;
struct gdbarch_registration *rego;
- /* Fill in any missing bits. Most important is the bfd_architecture
- which is used to select the target architecture. */
- if (info.bfd_architecture == bfd_arch_unknown)
- {
- if (info.bfd_arch_info != NULL)
- info.bfd_architecture = info.bfd_arch_info->arch;
- else if (info.abfd != NULL)
- info.bfd_architecture = bfd_get_arch (info.abfd);
- /* FIXME - should query BFD for its default architecture. */
- else
- info.bfd_architecture = current_gdbarch->bfd_arch_info->arch;
- }
+ /* Fill in missing parts of the INFO struct using a number of
+ sources: \`\`set ...''; INFOabfd supplied; existing target. */
+
+ /* \`\`(gdb) set architecture ...'' */
+ if (info.bfd_arch_info == NULL
+ && !TARGET_ARCHITECTURE_AUTO)
+ info.bfd_arch_info = TARGET_ARCHITECTURE;
+ if (info.bfd_arch_info == NULL
+ && info.abfd != NULL
+ && bfd_get_arch (info.abfd) != bfd_arch_unknown
+ && bfd_get_arch (info.abfd) != bfd_arch_obscure)
+ info.bfd_arch_info = bfd_get_arch_info (info.abfd);
if (info.bfd_arch_info == NULL)
- {
- if (target_architecture_auto && info.abfd != NULL)
- info.bfd_arch_info = bfd_get_arch_info (info.abfd);
- else
- info.bfd_arch_info = current_gdbarch->bfd_arch_info;
- }
- if (info.byte_order == 0)
- {
- if (target_byte_order_auto && info.abfd != NULL)
- info.byte_order = (bfd_big_endian (info.abfd) ? BIG_ENDIAN
- : bfd_little_endian (info.abfd) ? LITTLE_ENDIAN
- : 0);
- else
- info.byte_order = current_gdbarch->byte_order;
- /* FIXME - should query BFD for its default byte-order. */
- }
- /* A default for abfd? */
-
- /* Find the target that knows about this architecture. */
- for (rego = gdbarch_registrary;
- rego != NULL;
- rego = rego->next)
- if (rego->bfd_architecture == info.bfd_architecture)
- break;
- if (rego == NULL)
- {
- if (gdbarch_debug)
- fprintf_unfiltered (gdb_stdlog, "gdbarch_update: No matching architecture\n");
- return 0;
- }
+ info.bfd_arch_info = TARGET_ARCHITECTURE;
+
+ /* \`\`(gdb) set byte-order ...'' */
+ if (info.byte_order == BFD_ENDIAN_UNKNOWN
+ && !TARGET_BYTE_ORDER_AUTO)
+ info.byte_order = TARGET_BYTE_ORDER;
+ /* From the INFO struct. */
+ if (info.byte_order == BFD_ENDIAN_UNKNOWN
+ && info.abfd != NULL)
+ info.byte_order = (bfd_big_endian (info.abfd) ? BFD_ENDIAN_BIG
+ : bfd_little_endian (info.abfd) ? BFD_ENDIAN_LITTLE
+ : BFD_ENDIAN_UNKNOWN);
+ /* From the current target. */
+ if (info.byte_order == BFD_ENDIAN_UNKNOWN)
+ info.byte_order = TARGET_BYTE_ORDER;
+
+ /* Must have found some sort of architecture. */
+ gdb_assert (info.bfd_arch_info != NULL);
if (gdbarch_debug)
{
- fprintf_unfiltered (gdb_stdlog,
- "gdbarch_update: info.bfd_architecture %d (%s)\n",
- info.bfd_architecture,
- bfd_lookup_arch (info.bfd_architecture, 0)->printable_name);
fprintf_unfiltered (gdb_stdlog,
"gdbarch_update: info.bfd_arch_info %s\n",
(info.bfd_arch_info != NULL
fprintf_unfiltered (gdb_stdlog,
"gdbarch_update: info.byte_order %d (%s)\n",
info.byte_order,
- (info.byte_order == BIG_ENDIAN ? "big"
- : info.byte_order == LITTLE_ENDIAN ? "little"
+ (info.byte_order == BFD_ENDIAN_BIG ? "big"
+ : info.byte_order == BFD_ENDIAN_LITTLE ? "little"
: "default"));
fprintf_unfiltered (gdb_stdlog,
"gdbarch_update: info.abfd 0x%lx\n",
(long) info.tdep_info);
}
+ /* Find the target that knows about this architecture. */
+ for (rego = gdbarch_registry;
+ rego != NULL;
+ rego = rego->next)
+ if (rego->bfd_architecture == info.bfd_arch_info->arch)
+ break;
+ if (rego == NULL)
+ {
+ if (gdbarch_debug)
+ fprintf_unfiltered (gdb_stdlog, "gdbarch_update: No matching architecture\\n");
+ return 0;
+ }
+
+ /* Swap the data belonging to the old target out setting the
+ installed data to zero. This stops the ->init() function trying
+ to refer to the previous architecture's global data structures. */
+ swapout_gdbarch_swap (current_gdbarch);
+ clear_gdbarch_swap (current_gdbarch);
+
+ /* Save the previously selected architecture, setting the global to
+ NULL. This stops ->init() trying to use the previous
+ architecture's configuration. The previous architecture may not
+ even be of the same architecture family. The most recent
+ architecture of the same family is found at the head of the
+ rego->arches list. */
+ old_gdbarch = current_gdbarch;
+ current_gdbarch = NULL;
+
/* Ask the target for a replacement architecture. */
new_gdbarch = rego->init (info, rego->arches);
- /* Did the target like it? No. Reject the change. */
+ /* Did the target like it? No. Reject the change and revert to the
+ old architecture. */
if (new_gdbarch == NULL)
{
if (gdbarch_debug)
- fprintf_unfiltered (gdb_stdlog, "gdbarch_update: Target rejected architecture\n");
+ fprintf_unfiltered (gdb_stdlog, "gdbarch_update: Target rejected architecture\\n");
+ swapin_gdbarch_swap (old_gdbarch);
+ current_gdbarch = old_gdbarch;
return 0;
}
- /* Did the architecture change? No. Do nothing. */
- if (current_gdbarch == new_gdbarch)
+ /* Did the architecture change? No. Oops, put the old architecture
+ back. */
+ if (old_gdbarch == new_gdbarch)
{
if (gdbarch_debug)
- fprintf_unfiltered (gdb_stdlog, "gdbarch_update: Architecture 0x%08lx (%s) unchanged\n",
+ fprintf_unfiltered (gdb_stdlog, "gdbarch_update: Architecture 0x%08lx (%s) unchanged\\n",
(long) new_gdbarch,
new_gdbarch->bfd_arch_info->printable_name);
+ swapin_gdbarch_swap (old_gdbarch);
+ current_gdbarch = old_gdbarch;
return 1;
}
- /* Swap all data belonging to the old target out */
- swapout_gdbarch_swap (current_gdbarch);
-
- /* Is this a pre-existing architecture? Yes. Swap it in. */
- for (list = ®o->arches;
- (*list) != NULL;
- list = &(*list)->next)
- {
- if ((*list)->gdbarch == new_gdbarch)
- {
- if (gdbarch_debug)
- fprintf_unfiltered (gdb_stdlog,
- "gdbarch_update: Previous architecture 0x%08lx (%s) selected\n",
- (long) new_gdbarch,
- new_gdbarch->bfd_arch_info->printable_name);
- current_gdbarch = new_gdbarch;
- swapin_gdbarch_swap (new_gdbarch);
- return 1;
- }
- }
-
- /* Append this new architecture to this targets list. */
- (*list) = XMALLOC (struct gdbarch_list);
- (*list)->next = NULL;
- (*list)->gdbarch = new_gdbarch;
+ /* Is this a pre-existing architecture? Yes. Move it to the front
+ of the list of architectures (keeping the list sorted Most
+ Recently Used) and then copy it in. */
+ {
+ struct gdbarch_list **list;
+ for (list = ®o->arches;
+ (*list) != NULL;
+ list = &(*list)->next)
+ {
+ if ((*list)->gdbarch == new_gdbarch)
+ {
+ struct gdbarch_list *this;
+ if (gdbarch_debug)
+ fprintf_unfiltered (gdb_stdlog,
+ "gdbarch_update: Previous architecture 0x%08lx (%s) selected\n",
+ (long) new_gdbarch,
+ new_gdbarch->bfd_arch_info->printable_name);
+ /* Unlink this. */
+ this = (*list);
+ (*list) = this->next;
+ /* Insert in the front. */
+ this->next = rego->arches;
+ rego->arches = this;
+ /* Copy the new architecture in. */
+ current_gdbarch = new_gdbarch;
+ swapin_gdbarch_swap (new_gdbarch);
+ architecture_changed_event ();
+ return 1;
+ }
+ }
+ }
+
+ /* Prepend this new architecture to the architecture list (keep the
+ list sorted Most Recently Used). */
+ {
+ struct gdbarch_list *this = XMALLOC (struct gdbarch_list);
+ this->next = rego->arches;
+ this->gdbarch = new_gdbarch;
+ rego->arches = this;
+ }
/* Switch to this new architecture. Dump it out. */
current_gdbarch = new_gdbarch;
if (gdbarch_debug)
{
fprintf_unfiltered (gdb_stdlog,
- "gdbarch_update: New architecture 0x%08lx (%s) selected\n",
+ "gdbarch_update: New architecture 0x%08lx (%s) selected\\n",
(long) new_gdbarch,
new_gdbarch->bfd_arch_info->printable_name);
}
registered an interest in this architecture. CURRENT_GDBARCH
must be updated before these modules are called. */
init_gdbarch_data (new_gdbarch);
-
+ architecture_changed_event ();
+
if (gdbarch_debug)
gdbarch_dump (current_gdbarch, gdb_stdlog);
class_maintenance,
var_zinteger,
(char *)&gdbarch_debug,
- "Set architecture debugging.\n\\
+ "Set architecture debugging.\\n\\
When non-zero, architecture debugging is enabled.", &setdebuglist),
&showdebuglist);
c = add_set_cmd ("archdebug",
class_maintenance,
var_zinteger,
(char *)&gdbarch_debug,
- "Set architecture debugging.\n\\
+ "Set architecture debugging.\\n\\
When non-zero, architecture debugging is enabled.", &setlist);
deprecate_cmd (c, "set debug arch");
projects / deliverable / binutils-gdb.git / blobdiff