#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation; either version 2 of the License, or
+# the Free Software Foundation; either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
-# along with this program; if not, write to the Free Software
-# Foundation, Inc., 51 Franklin Street, Fifth Floor,
-# Boston, MA 02110-1301, USA.
+# along with this program. If not, see <http://www.gnu.org/licenses/>.
# Make certain that the script is not running in an internationalized
# environment.
{
# See below (DOCO) for description of each field
cat <<EOF
-i:TARGET_ARCHITECTURE:const struct bfd_arch_info *:bfd_arch_info:::&bfd_default_arch_struct::::TARGET_ARCHITECTURE->printable_name
+i::const struct bfd_arch_info *:bfd_arch_info:::&bfd_default_arch_struct::::gdbarch_bfd_arch_info (current_gdbarch)->printable_name
#
-i:TARGET_BYTE_ORDER:int:byte_order:::BFD_ENDIAN_BIG
+i::int:byte_order:::BFD_ENDIAN_BIG
#
-i:TARGET_OSABI:enum gdb_osabi:osabi:::GDB_OSABI_UNKNOWN
+i::enum gdb_osabi:osabi:::GDB_OSABI_UNKNOWN
#
i::const struct target_desc *:target_desc:::::::paddr_d ((long) current_gdbarch->target_desc)
# Number of bits in a char or unsigned char for the target machine.
# v:TARGET_CHAR_BIT:int:char_bit::::8 * sizeof (char):8::0:
#
# Number of bits in a short or unsigned short for the target machine.
-v:TARGET_SHORT_BIT:int:short_bit:::8 * sizeof (short):2*TARGET_CHAR_BIT::0
+v::int:short_bit:::8 * sizeof (short):2*TARGET_CHAR_BIT::0
# Number of bits in an int or unsigned int for the target machine.
-v:TARGET_INT_BIT:int:int_bit:::8 * sizeof (int):4*TARGET_CHAR_BIT::0
+v::int:int_bit:::8 * sizeof (int):4*TARGET_CHAR_BIT::0
# Number of bits in a long or unsigned long for the target machine.
-v:TARGET_LONG_BIT:int:long_bit:::8 * sizeof (long):4*TARGET_CHAR_BIT::0
+v::int:long_bit:::8 * sizeof (long):4*TARGET_CHAR_BIT::0
# Number of bits in a long long or unsigned long long for the target
# machine.
-v:TARGET_LONG_LONG_BIT:int:long_long_bit:::8 * sizeof (LONGEST):2*TARGET_LONG_BIT::0
+v::int:long_long_bit:::8 * sizeof (LONGEST):2*current_gdbarch->long_bit::0
# The ABI default bit-size and format for "float", "double", and "long
# double". These bit/format pairs should eventually be combined into
# a single object. For the moment, just initialize them as a pair.
+# Each format describes both the big and little endian layouts (if
+# useful).
-v:TARGET_FLOAT_BIT:int:float_bit:::8 * sizeof (float):4*TARGET_CHAR_BIT::0
-v:TARGET_FLOAT_FORMAT:const struct floatformat *:float_format:::::default_float_format (current_gdbarch)::pformat (current_gdbarch->float_format)
-v:TARGET_DOUBLE_BIT:int:double_bit:::8 * sizeof (double):8*TARGET_CHAR_BIT::0
-v:TARGET_DOUBLE_FORMAT:const struct floatformat *:double_format:::::default_double_format (current_gdbarch)::pformat (current_gdbarch->double_format)
-v:TARGET_LONG_DOUBLE_BIT:int:long_double_bit:::8 * sizeof (long double):8*TARGET_CHAR_BIT::0
-v:TARGET_LONG_DOUBLE_FORMAT:const struct floatformat *:long_double_format:::::default_double_format (current_gdbarch)::pformat (current_gdbarch->long_double_format)
+v::int:float_bit:::8 * sizeof (float):4*TARGET_CHAR_BIT::0
+v::const struct floatformat **:float_format:::::floatformats_ieee_single::pformat (current_gdbarch->float_format)
+v::int:double_bit:::8 * sizeof (double):8*TARGET_CHAR_BIT::0
+v::const struct floatformat **:double_format:::::floatformats_ieee_double::pformat (current_gdbarch->double_format)
+v::int:long_double_bit:::8 * sizeof (long double):8*TARGET_CHAR_BIT::0
+v::const struct floatformat **:long_double_format:::::floatformats_ieee_double::pformat (current_gdbarch->long_double_format)
# 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
+# target, you need only set gdbarch_ptr_bit and gdbarch_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.
+# If gdbarch_ptr_bit and gdbarch_addr_bit are different, you'll probably
+# also need to set gdbarch_pointer_to_address and gdbarch_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
+v::int:ptr_bit:::8 * sizeof (void*):current_gdbarch->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::int:addr_bit:::8 * sizeof (void*):0:gdbarch_ptr_bit (current_gdbarch):
#
# One if \`char' acts like \`signed char', zero if \`unsigned char'.
-v:TARGET_CHAR_SIGNED:int:char_signed:::1:-1:1
+v::int:char_signed:::1:-1:1
#
-F:TARGET_READ_PC:CORE_ADDR:read_pc:ptid_t ptid:ptid
-f:TARGET_WRITE_PC:void:write_pc:CORE_ADDR val, ptid_t ptid:val, ptid:0:generic_target_write_pc::0
-# UNWIND_SP is a direct replacement for TARGET_READ_SP.
-F:TARGET_READ_SP:CORE_ADDR:read_sp:void
+F::CORE_ADDR:read_pc:struct regcache *regcache:regcache
+F::void:write_pc:struct regcache *regcache, CORE_ADDR val:regcache, val
# 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
+f::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:pseudo_register_read:struct regcache *regcache, int cookednum, gdb_byte *buf:regcache, cookednum, buf
M::void:pseudo_register_write:struct regcache *regcache, int cookednum, const gdb_byte *buf:regcache, cookednum, buf
#
-v:=:int:num_regs:::0:-1
+v::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.
-v:=:int:num_pseudo_regs:::0:0::0
+v::int:num_pseudo_regs:::0:0::0
# 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).
-# SP_REGNUM will hopefully be replaced by UNWIND_SP.
-v:=:int:sp_regnum:::-1:-1::0
-v:=:int:pc_regnum:::-1:-1::0
-v:=:int:ps_regnum:::-1:-1::0
-v:=:int:fp0_regnum:::0:-1::0
+# gdbarch_sp_regnum will hopefully be replaced by UNWIND_SP.
+v::int:sp_regnum:::-1:-1::0
+v::int:pc_regnum:::-1:-1::0
+v::int:ps_regnum:::-1:-1::0
+v::int:fp0_regnum:::0:-1::0
# Convert stab register number (from \`r\' declaration) to a gdb REGNUM.
-f:=:int:stab_reg_to_regnum:int stab_regnr:stab_regnr::no_op_reg_to_regnum::0
+f::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:=:int:ecoff_reg_to_regnum:int ecoff_regnr:ecoff_regnr::no_op_reg_to_regnum::0
+f::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:=:int:dwarf_reg_to_regnum:int dwarf_regnr:dwarf_regnr::no_op_reg_to_regnum::0
+f::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.
-f:=:int:sdb_reg_to_regnum:int sdb_regnr:sdb_regnr::no_op_reg_to_regnum::0
-f:=:int:dwarf2_reg_to_regnum:int dwarf2_regnr:dwarf2_regnr::no_op_reg_to_regnum::0
-f:=:const char *:register_name:int regnr:regnr
+f::int:sdb_reg_to_regnum:int sdb_regnr:sdb_regnr::no_op_reg_to_regnum::0
+f::int:dwarf2_reg_to_regnum:int dwarf2_regnr:dwarf2_regnr::no_op_reg_to_regnum::0
+f::const char *:register_name:int regnr:regnr
-# REGISTER_TYPE is a direct replacement for DEPRECATED_REGISTER_VIRTUAL_TYPE.
+# Return the type of a register specified by the architecture. Only
+# the register cache should call this function directly; others should
+# use "register_type".
M::struct type *:register_type:int reg_nr:reg_nr
-# If the value returned by DEPRECATED_REGISTER_BYTE agrees with the
-# register offsets computed using just REGISTER_TYPE, this can be
-# deleted. See: maint print registers. NOTE: cagney/2002-05-02: This
-# function with predicate has a valid (callable) initial value. As a
-# consequence, even when the predicate is false, the corresponding
-# function works. This simplifies the migration process - old code,
-# calling DEPRECATED_REGISTER_BYTE, doesn't need to be modified.
-F:=:int:deprecated_register_byte:int reg_nr:reg_nr:generic_register_byte:generic_register_byte
# See gdbint.texinfo, and PUSH_DUMMY_CALL.
M::struct frame_id:unwind_dummy_id:struct frame_info *info:info
# Implement UNWIND_DUMMY_ID and PUSH_DUMMY_CALL, then delete
-# DEPRECATED_FP_REGNUM.
-v:=:int:deprecated_fp_regnum:::-1:-1::0
+# deprecated_fp_regnum.
+v::int:deprecated_fp_regnum:::-1:-1::0
# See gdbint.texinfo. See infcall.c.
M::CORE_ADDR:push_dummy_call:struct value *function, struct regcache *regcache, CORE_ADDR bp_addr, int nargs, struct value **args, CORE_ADDR sp, int struct_return, CORE_ADDR struct_addr:function, regcache, bp_addr, nargs, args, sp, struct_return, struct_addr
-# DEPRECATED_REGISTER_SIZE can be deleted.
-v:=:int:deprecated_register_size
-v:=:int:call_dummy_location::::AT_ENTRY_POINT::0
-M::CORE_ADDR:push_dummy_code:CORE_ADDR sp, CORE_ADDR funaddr, int using_gcc, struct value **args, int nargs, struct type *value_type, CORE_ADDR *real_pc, CORE_ADDR *bp_addr:sp, funaddr, using_gcc, args, nargs, value_type, real_pc, bp_addr
+v::int:call_dummy_location::::AT_ENTRY_POINT::0
+M::CORE_ADDR:push_dummy_code:CORE_ADDR sp, CORE_ADDR funaddr, struct value **args, int nargs, struct type *value_type, CORE_ADDR *real_pc, CORE_ADDR *bp_addr, struct regcache *regcache:sp, funaddr, args, nargs, value_type, real_pc, bp_addr, regcache
m::void:print_registers_info:struct ui_file *file, struct frame_info *frame, int regnum, int all:file, frame, regnum, all::default_print_registers_info::0
M::void:print_float_info:struct ui_file *file, struct frame_info *frame, const char *args:file, frame, args
M::void:print_vector_info:struct ui_file *file, struct frame_info *frame, const char *args:file, frame, args
# MAP a GDB RAW register number onto a simulator register number. See
# also include/...-sim.h.
-f:=:int:register_sim_regno:int reg_nr:reg_nr::legacy_register_sim_regno::0
-F:=:int:register_bytes_ok:long nr_bytes:nr_bytes
-f:=:int:cannot_fetch_register:int regnum:regnum::cannot_register_not::0
-f:=:int:cannot_store_register:int regnum:regnum::cannot_register_not::0
+f::int:register_sim_regno:int reg_nr:reg_nr::legacy_register_sim_regno::0
+f::int:cannot_fetch_register:int regnum:regnum::cannot_register_not::0
+f::int:cannot_store_register:int regnum:regnum::cannot_register_not::0
# setjmp/longjmp support.
-F:=:int:get_longjmp_target:CORE_ADDR *pc:pc
+F::int:get_longjmp_target:struct frame_info *frame, CORE_ADDR *pc:frame, pc
#
-v:=:int:believe_pcc_promotion:::::::
+v::int:believe_pcc_promotion:::::::
#
-f:=:int:convert_register_p:int regnum, struct type *type:regnum, type:0:generic_convert_register_p::0
-f:=:void:register_to_value:struct frame_info *frame, int regnum, struct type *type, gdb_byte *buf:frame, regnum, type, buf:0
-f:=:void:value_to_register:struct frame_info *frame, int regnum, struct type *type, const gdb_byte *buf:frame, regnum, type, buf:0
+f::int:convert_register_p:int regnum, struct type *type:regnum, type:0:generic_convert_register_p::0
+f::void:register_to_value:struct frame_info *frame, int regnum, struct type *type, gdb_byte *buf:frame, regnum, type, buf:0
+f::void:value_to_register:struct frame_info *frame, int regnum, struct type *type, const gdb_byte *buf:frame, regnum, type, buf:0
# Construct a value representing the contents of register REGNUM in
# frame FRAME, interpreted as type TYPE. The routine needs to
# allocate and return a struct value with all value attributes
# (but not the value contents) filled in.
f::struct value *:value_from_register:struct type *type, int regnum, struct frame_info *frame:type, regnum, frame::default_value_from_register::0
#
-f:=:CORE_ADDR:pointer_to_address:struct type *type, const gdb_byte *buf:type, buf::unsigned_pointer_to_address::0
-f:=:void:address_to_pointer:struct type *type, gdb_byte *buf, CORE_ADDR addr:type, buf, addr::unsigned_address_to_pointer::0
+f::CORE_ADDR:pointer_to_address:struct type *type, const gdb_byte *buf:type, buf::unsigned_pointer_to_address::0
+f::void:address_to_pointer:struct type *type, gdb_byte *buf, CORE_ADDR addr:type, buf, addr::unsigned_address_to_pointer::0
M::CORE_ADDR:integer_to_address:struct type *type, const gdb_byte *buf:type, buf
-#
-# NOTE: kettenis/2005-09-01: Replaced by PUSH_DUMMY_CALL.
-F:=:void:deprecated_store_struct_return:CORE_ADDR addr, CORE_ADDR sp:addr, sp
# It has been suggested that this, well actually its predecessor,
# should take the type/value of the function to be called and not the
# return type. This is left as an exercise for the reader.
-# NOTE: cagney/2004-06-13: The function stack.c:return_command uses
-# the predicate with default hack to avoid calling STORE_RETURN_VALUE
-# (via legacy_return_value), when a small struct is involved.
-
-M::enum return_value_convention:return_value:struct type *valtype, struct regcache *regcache, gdb_byte *readbuf, const gdb_byte *writebuf:valtype, regcache, readbuf, writebuf::legacy_return_value
-
-# The deprecated methods EXTRACT_RETURN_VALUE, STORE_RETURN_VALUE,
-# DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS and
-# DEPRECATED_USE_STRUCT_CONVENTION have all been folded into
-# RETURN_VALUE.
-
-f:=:void:extract_return_value:struct type *type, struct regcache *regcache, gdb_byte *valbuf:type, regcache, valbuf::legacy_extract_return_value::0
-f:=:void:store_return_value:struct type *type, struct regcache *regcache, const gdb_byte *valbuf:type, regcache, valbuf::legacy_store_return_value::0
-f:=:void:deprecated_extract_return_value:struct type *type, gdb_byte *regbuf, gdb_byte *valbuf:type, regbuf, valbuf
-f:=:void:deprecated_store_return_value:struct type *type, gdb_byte *valbuf:type, valbuf
-f:=:int:deprecated_use_struct_convention:int gcc_p, struct type *value_type:gcc_p, value_type::generic_use_struct_convention::0
-
-# As of 2004-01-17 only the 32-bit SPARC ABI has been identified as an
-# ABI suitable for the implementation of a robust extract
-# struct-convention return-value address method (the sparc saves the
-# address in the callers frame). All the other cases so far examined,
-# the DEPRECATED_EXTRACT_STRUCT_VALUE implementation has been
-# erreneous - the code was incorrectly assuming that the return-value
-# address, stored in a register, was preserved across the entire
-# function call.
-
-# For the moment retain DEPRECATED_EXTRACT_STRUCT_VALUE as a marker of
-# the ABIs that are still to be analyzed - perhaps this should simply
-# be deleted. The commented out extract_returned_value_address method
-# is provided as a starting point for the 32-bit SPARC. It, or
-# something like it, along with changes to both infcmd.c and stack.c
-# will be needed for that case to work. NB: It is passed the callers
-# frame since it is only after the callee has returned that this
-# function is used.
-
-#M::CORE_ADDR:extract_returned_value_address:struct frame_info *caller_frame:caller_frame
-F:=:CORE_ADDR:deprecated_extract_struct_value_address:struct regcache *regcache:regcache
+M::enum return_value_convention:return_value:struct type *valtype, struct regcache *regcache, gdb_byte *readbuf, const gdb_byte *writebuf:valtype, regcache, readbuf, writebuf
-#
-f:=:CORE_ADDR:skip_prologue:CORE_ADDR ip:ip:0:0
-f:=:int:inner_than:CORE_ADDR lhs, CORE_ADDR rhs:lhs, rhs:0:0
-f:=:const gdb_byte *:breakpoint_from_pc:CORE_ADDR *pcptr, int *lenptr:pcptr, lenptr::0:
+f::CORE_ADDR:skip_prologue:CORE_ADDR ip:ip:0:0
+f::int:inner_than:CORE_ADDR lhs, CORE_ADDR rhs:lhs, rhs:0:0
+f::const gdb_byte *:breakpoint_from_pc:CORE_ADDR *pcptr, int *lenptr:pcptr, lenptr::0:
M::CORE_ADDR:adjust_breakpoint_address:CORE_ADDR bpaddr:bpaddr
-f:=:int:memory_insert_breakpoint:struct bp_target_info *bp_tgt:bp_tgt:0:default_memory_insert_breakpoint::0
-f:=:int:memory_remove_breakpoint:struct bp_target_info *bp_tgt:bp_tgt:0:default_memory_remove_breakpoint::0
-v:=:CORE_ADDR:decr_pc_after_break:::0:::0
+f::int:memory_insert_breakpoint:struct bp_target_info *bp_tgt:bp_tgt:0:default_memory_insert_breakpoint::0
+f::int:memory_remove_breakpoint:struct bp_target_info *bp_tgt:bp_tgt:0:default_memory_remove_breakpoint::0
+v::CORE_ADDR:decr_pc_after_break:::0:::0
# A function can be addressed by either it's "pointer" (possibly a
# descriptor address) or "entry point" (first executable instruction).
# The method "convert_from_func_ptr_addr" converting the former to the
-# latter. DEPRECATED_FUNCTION_START_OFFSET is being used to implement
+# latter. gdbarch_deprecated_function_start_offset is being used to implement
# a simplified subset of that functionality - the function's address
# corresponds to the "function pointer" and the function's start
# corresponds to the "function entry point" - and hence is redundant.
-v:=:CORE_ADDR:deprecated_function_start_offset:::0:::0
+v::CORE_ADDR:deprecated_function_start_offset:::0:::0
-m::void:remote_translate_xfer_address:struct regcache *regcache, CORE_ADDR gdb_addr, int gdb_len, CORE_ADDR *rem_addr, int *rem_len:regcache, gdb_addr, gdb_len, rem_addr, rem_len::generic_remote_translate_xfer_address::0
+# Return the remote protocol register number associated with this
+# register. Normally the identity mapping.
+m::int:remote_register_number:int regno:regno::default_remote_register_number::0
# Fetch the target specific address used to represent a load module.
-F:=:CORE_ADDR:fetch_tls_load_module_address:struct objfile *objfile:objfile
+F::CORE_ADDR:fetch_tls_load_module_address:struct objfile *objfile:objfile
#
-v:=:CORE_ADDR:frame_args_skip:::0:::0
+v::CORE_ADDR:frame_args_skip:::0:::0
M::CORE_ADDR:unwind_pc:struct frame_info *next_frame:next_frame
M::CORE_ADDR:unwind_sp:struct frame_info *next_frame:next_frame
# DEPRECATED_FRAME_LOCALS_ADDRESS as been replaced by the per-frame
# frame-base. Enable frame-base before frame-unwind.
-F:=:int:frame_num_args:struct frame_info *frame:frame
+F::int:frame_num_args:struct frame_info *frame:frame
#
-# DEPRECATED_STACK_ALIGN has been replaced by an initial aligning call
-# to frame_align and the requirement that methods such as
-# push_dummy_call and frame_red_zone_size maintain correct stack/frame
-# alignment.
-F:=:CORE_ADDR:deprecated_stack_align:CORE_ADDR sp:sp
M::CORE_ADDR:frame_align:CORE_ADDR address:address
-# DEPRECATED_REG_STRUCT_HAS_ADDR has been replaced by
-# stabs_argument_has_addr.
-F:=:int:deprecated_reg_struct_has_addr:int gcc_p, struct type *type:gcc_p, type
m::int:stabs_argument_has_addr:struct type *type:type::default_stabs_argument_has_addr::0
-v:=:int:frame_red_zone_size
+v::int:frame_red_zone_size
#
m::CORE_ADDR:convert_from_func_ptr_addr:CORE_ADDR addr, struct target_ops *targ:addr, targ::convert_from_func_ptr_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
+# for special purposes. gdbarch_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:=: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:=: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.
+f::CORE_ADDR:addr_bits_remove:CORE_ADDR addr:addr::core_addr_identity::0
+# It is not at all clear why gdbarch_smash_text_address is not folded into
+# gdbarch_addr_bits_remove.
+f::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: 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.
#
-# 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:=:void:software_single_step:enum target_signal sig, int insert_breakpoints_p:sig, insert_breakpoints_p
+# A return value of 1 means that the software_single_step breakpoints
+# were inserted; 0 means they were not.
+F::int:software_single_step:struct frame_info *frame:frame
+
# Return non-zero if the processor is executing a delay slot and a
# further single-step is needed before the instruction finishes.
M::int:single_step_through_delay:struct frame_info *frame:frame
# FIXME: cagney/2003-08-28: Need to find a better way of selecting the
# disassembler. Perhaps objdump can handle it?
-f:TARGET_PRINT_INSN:int:print_insn:bfd_vma vma, struct disassemble_info *info:vma, info::0:
-f:=:CORE_ADDR:skip_trampoline_code:CORE_ADDR pc:pc::generic_skip_trampoline_code::0
+f::int:print_insn:bfd_vma vma, struct disassemble_info *info:vma, info::0:
+f::CORE_ADDR:skip_trampoline_code:struct frame_info *frame, CORE_ADDR pc:frame, pc::generic_skip_trampoline_code::0
# If IN_SOLIB_DYNSYM_RESOLVE_CODE returns true, and SKIP_SOLIB_RESOLVER
# a step-resume breakpoint to get us past the dynamic linker.
m::CORE_ADDR:skip_solib_resolver:CORE_ADDR pc:pc::generic_skip_solib_resolver::0
# Some systems also have trampoline code for returning from shared libs.
-f:=:int:in_solib_return_trampoline:CORE_ADDR pc, char *name:pc, name::generic_in_solib_return_trampoline::0
+f::int:in_solib_return_trampoline:CORE_ADDR pc, char *name:pc, name::generic_in_solib_return_trampoline::0
# A target might have problems with watchpoints as soon as the stack
# frame of the current function has been destroyed. This mostly happens
# ARGC is the number of elements in the vector.
# ARGV is an array of strings, one per argument.
m::char *:construct_inferior_arguments:int argc, char **argv:argc, argv::construct_inferior_arguments::0
-f:=:void:elf_make_msymbol_special:asymbol *sym, struct minimal_symbol *msym:sym, msym::default_elf_make_msymbol_special::0
-f:=:void:coff_make_msymbol_special:int val, struct minimal_symbol *msym:val, msym::default_coff_make_msymbol_special::0
-v:=:const char *:name_of_malloc:::"malloc":"malloc"::0:NAME_OF_MALLOC
-v:=:int:cannot_step_breakpoint:::0:0::0
-v:=:int:have_nonsteppable_watchpoint:::0:0::0
-F:=:int:address_class_type_flags:int byte_size, int dwarf2_addr_class:byte_size, dwarf2_addr_class
+f::void:elf_make_msymbol_special:asymbol *sym, struct minimal_symbol *msym:sym, msym::default_elf_make_msymbol_special::0
+f::void:coff_make_msymbol_special:int val, struct minimal_symbol *msym:val, msym::default_coff_make_msymbol_special::0
+v::const char *:name_of_malloc:::"malloc":"malloc"::0:current_gdbarch->name_of_malloc
+v::int:cannot_step_breakpoint:::0:0::0
+v::int:have_nonsteppable_watchpoint:::0:0::0
+F::int:address_class_type_flags:int byte_size, int dwarf2_addr_class:byte_size, dwarf2_addr_class
M::const char *:address_class_type_flags_to_name:int type_flags:type_flags
M::int:address_class_name_to_type_flags:const char *name, int *type_flags_ptr:name, type_flags_ptr
# Is a register in a group
m::int:register_reggroup_p:int regnum, struct reggroup *reggroup:regnum, reggroup::default_register_reggroup_p::0
# Fetch the pointer to the ith function argument.
-F:=:CORE_ADDR:fetch_pointer_argument:struct frame_info *frame, int argi, struct type *type:frame, argi, type
+F::CORE_ADDR:fetch_pointer_argument:struct frame_info *frame, int argi, struct type *type:frame, argi, type
# Return the appropriate register set for a core file section with
# name SECT_NAME and size SECT_SIZE.
M::const struct regset *:regset_from_core_section:const char *sect_name, size_t sect_size:sect_name, sect_size
+# Read offset OFFSET of TARGET_OBJECT_LIBRARIES formatted shared libraries list from
+# core file into buffer READBUF with length LEN.
+M::LONGEST:core_xfer_shared_libraries:gdb_byte *readbuf, ULONGEST offset, LONGEST len:readbuf, offset, len
+
# If the elements of C++ vtables are in-place function descriptors rather
# than normal function pointers (which may point to code or a descriptor),
# set this to one.
# Set if the least significant bit of the delta is used instead of the least
# significant bit of the pfn for pointers to virtual member functions.
v::int:vbit_in_delta:::0:0::0
+
+# Advance PC to next instruction in order to skip a permanent breakpoint.
+F::void:skip_permanent_breakpoint:struct regcache *regcache:regcache
+
+# Refresh overlay mapped state for section OSECT.
+F::void:overlay_update:struct obj_section *osect:osect
+
+M::const struct target_desc *:core_read_description:struct target_ops *target, bfd *abfd:target, abfd
+
+# Handle special encoding of static variables in stabs debug info.
+F::char *:static_transform_name:char *name:name
+# Set if the address in N_SO or N_FUN stabs may be zero.
+v::int:sofun_address_maybe_missing:::0:0::0
EOF
}
/* Dynamic architecture support for GDB, the GNU debugger.
- Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006
+ Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007
Free Software Foundation, Inc.
This file is part of GDB.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2 of the License, or
+ the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.
-
+
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
-
+
You should have received a copy of the GNU General Public License
- along with this program; if not, write to the Free Software
- Foundation, Inc., 51 Franklin Street, Fifth Floor,
- Boston, MA 02110-1301, USA. */
+ along with this program. If not, see <http://www.gnu.org/licenses/>. */
/* This file was created with the aid of \`\`gdbarch.sh''.
struct frame_info;
struct value;
struct objfile;
+struct obj_section;
struct minimal_symbol;
struct regcache;
struct reggroup;
extern void *gdbarch_data (struct gdbarch *gdbarch, struct gdbarch_data *);
-
-/* Register per-architecture memory region.
-
- Provide a memory-region swap mechanism. Per-architecture memory
- region are created. These memory regions are swapped whenever the
- architecture is changed. For a new architecture, the memory region
- is initialized with zero (0) and the INIT function is called.
-
- Memory regions are swapped / initialized in the order that they are
- registered. NULL DATA and/or INIT values can be specified.
-
- New code should use gdbarch_data_register_*(). */
-
-typedef void (gdbarch_swap_ftype) (void);
-extern void deprecated_register_gdbarch_swap (void *data, unsigned long size, gdbarch_swap_ftype *init);
-#define DEPRECATED_REGISTER_GDBARCH_SWAP(VAR) deprecated_register_gdbarch_swap (&(VAR), sizeof ((VAR)), NULL)
-
-
-
/* Set the dynamic target-system-dependent parameters (architecture,
byte-order, ...) using information found in the BFD */
#include "arch-utils.h"
#include "gdbcmd.h"
-#include "inferior.h" /* enum CALL_DUMMY_LOCATION et.al. */
+#include "inferior.h"
#include "symcat.h"
#include "floatformat.h"
}
static const char *
-pformat (const struct floatformat *format)
+pformat (const struct floatformat **format)
{
if (format == NULL)
return "(null)";
else
- return format->name;
+ /* Just print out one of them - this is only for diagnostics. */
+ return format[0]->name;
}
EOF
struct gdbarch_tdep *tdep)
{
/* NOTE: The new architecture variable is named \`\`current_gdbarch''
- so that macros such as TARGET_DOUBLE_BIT, when expanded, refer to
+ so that macros such as TARGET_ARCHITECTURE, 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
}
-
-/* Keep a registry of swapped data required by GDB modules. */
-
-struct gdbarch_swap
-{
- void *swap;
- struct gdbarch_swap_registration *source;
- struct gdbarch_swap *next;
-};
-
-struct gdbarch_swap_registration
-{
- void *data;
- unsigned long sizeof_data;
- gdbarch_swap_ftype *init;
- struct gdbarch_swap_registration *next;
-};
-
-struct gdbarch_swap_registry
-{
- int nr;
- struct gdbarch_swap_registration *registrations;
-};
-
-struct gdbarch_swap_registry gdbarch_swap_registry =
-{
- 0, NULL,
-};
-
-void
-deprecated_register_gdbarch_swap (void *data,
- unsigned long sizeof_data,
- gdbarch_swap_ftype *init)
-{
- struct gdbarch_swap_registration **rego;
- for (rego = &gdbarch_swap_registry.registrations;
- (*rego) != NULL;
- rego = &(*rego)->next);
- (*rego) = XMALLOC (struct gdbarch_swap_registration);
- (*rego)->next = NULL;
- (*rego)->init = init;
- (*rego)->data = data;
- (*rego)->sizeof_data = sizeof_data;
-}
-
-static void
-current_gdbarch_swap_init_hack (void)
-{
- struct gdbarch_swap_registration *rego;
- struct gdbarch_swap **curr = ¤t_gdbarch->swap;
- for (rego = gdbarch_swap_registry.registrations;
- rego != NULL;
- rego = rego->next)
- {
- if (rego->data != NULL)
- {
- (*curr) = GDBARCH_OBSTACK_ZALLOC (current_gdbarch,
- struct gdbarch_swap);
- (*curr)->source = rego;
- (*curr)->swap = gdbarch_obstack_zalloc (current_gdbarch,
- rego->sizeof_data);
- (*curr)->next = NULL;
- curr = &(*curr)->next;
- }
- if (rego->init != NULL)
- rego->init ();
- }
-}
-
-static struct gdbarch *
-current_gdbarch_swap_out_hack (void)
-{
- struct gdbarch *old_gdbarch = current_gdbarch;
- struct gdbarch_swap *curr;
-
- gdb_assert (old_gdbarch != NULL);
- for (curr = old_gdbarch->swap;
- curr != NULL;
- curr = curr->next)
- {
- memcpy (curr->swap, curr->source->data, curr->source->sizeof_data);
- memset (curr->source->data, 0, curr->source->sizeof_data);
- }
- current_gdbarch = NULL;
- return old_gdbarch;
-}
-
-static void
-current_gdbarch_swap_in_hack (struct gdbarch *new_gdbarch)
-{
- struct gdbarch_swap *curr;
-
- gdb_assert (current_gdbarch == NULL);
- for (curr = new_gdbarch->swap;
- curr != NULL;
- curr = curr->next)
- memcpy (curr->source->data, curr->swap, curr->source->sizeof_data);
- current_gdbarch = new_gdbarch;
-}
-
-
/* Keep a registry of the architectures known by GDB. */
struct gdbarch_registration
verify_gdbarch (new_gdbarch);
new_gdbarch->initialized_p = 1;
- /* Initialize any per-architecture swap areas. This phase requires
- a valid global CURRENT_GDBARCH. Set it momentarially, and then
- swap the entire architecture out. */
- current_gdbarch = new_gdbarch;
- current_gdbarch_swap_init_hack ();
- current_gdbarch_swap_out_hack ();
-
if (gdbarch_debug)
gdbarch_dump (new_gdbarch, gdb_stdlog);
struct gdbarch *
gdbarch_find_by_info (struct gdbarch_info info)
{
+ struct gdbarch *new_gdbarch;
+
/* Save the previously selected architecture, setting the global to
NULL. This stops things like gdbarch->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. */
- struct gdbarch *old_gdbarch = current_gdbarch_swap_out_hack ();
+ struct gdbarch *old_gdbarch = current_gdbarch;
+ current_gdbarch = NULL;
/* Find the specified architecture. */
- struct gdbarch *new_gdbarch = find_arch_by_info (info);
+ new_gdbarch = find_arch_by_info (info);
/* Restore the existing architecture. */
gdb_assert (current_gdbarch == NULL);
- current_gdbarch_swap_in_hack (old_gdbarch);
+ current_gdbarch = old_gdbarch;
return new_gdbarch;
}
-/* Make the specified architecture current, swapping the existing one
- out. */
+/* Make the specified architecture current. */
void
deprecated_current_gdbarch_select_hack (struct gdbarch *new_gdbarch)
gdb_assert (new_gdbarch != NULL);
gdb_assert (current_gdbarch != NULL);
gdb_assert (new_gdbarch->initialized_p);
- current_gdbarch_swap_out_hack ();
- current_gdbarch_swap_in_hack (new_gdbarch);
+ current_gdbarch = new_gdbarch;
architecture_changed_event ();
- flush_cached_frames ();
+ reinit_frame_cache ();
}
extern void _initialize_gdbarch (void);
projects / deliverable / binutils-gdb.git / blobdiff