X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gdb%2Fgdbarch.sh;h=0be3e88bb24701ddef03b59b9086dc11d504495b;hb=030a2e78acf66c5c12e073ec3887a167da7a7195;hp=bb62e6d6205bbc7cf36b655550a19e321ca48431;hpb=2b4424c35b9ebabaab8588b2ba6c38935a48efec;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/gdbarch.sh b/gdb/gdbarch.sh index bb62e6d620..0be3e88bb2 100755 --- a/gdb/gdbarch.sh +++ b/gdb/gdbarch.sh @@ -2,7 +2,7 @@ # Architecture commands for GDB, the GNU debugger. # -# Copyright (C) 1998-2018 Free Software Foundation, Inc. +# Copyright (C) 1998-2020 Free Software Foundation, Inc. # # This file is part of GDB. # @@ -347,10 +347,6 @@ i;enum gdb_osabi;osabi;;;GDB_OSABI_UNKNOWN # i;const struct target_desc *;target_desc;;;;;;;host_address_to_string (gdbarch->target_desc) -# The bit byte-order has to do just with numbering of bits in debugging symbols -# and such. Conceptually, it's quite separate from byte/word byte order. -v;int;bits_big_endian;;;1;(gdbarch->byte_order == BFD_ENDIAN_BIG);;0 - # Number of bits in a short or unsigned short for the target machine. 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. @@ -360,9 +356,6 @@ 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;int;long_long_bit;;;8 * sizeof (LONGEST);2*gdbarch->long_bit;;0 -# Alignment of a long long or unsigned long long for the target -# machine. -v;int;long_long_align_bit;;;8 * sizeof (LONGEST);2*gdbarch->long_bit;;0 # The ABI default bit-size and format for "half", "float", "double", and # "long double". These bit/format pairs should eventually be combined @@ -483,12 +476,20 @@ m;const char *;register_name;int regnr;regnr;;0 # use "register_type". M;struct type *;register_type;int reg_nr;reg_nr -M;struct frame_id;dummy_id;struct frame_info *this_frame;this_frame +# Generate a dummy frame_id for THIS_FRAME assuming that the frame is +# a dummy frame. A dummy frame is created before an inferior call, +# the frame_id returned here must match the frame_id that was built +# for the inferior call. Usually this means the returned frame_id's +# stack address should match the address returned by +# gdbarch_push_dummy_call, and the returned frame_id's code address +# should match the address at which the breakpoint was set in the dummy +# frame. +m;struct frame_id;dummy_id;struct frame_info *this_frame;this_frame;;default_dummy_id;;0 # Implement DUMMY_ID and PUSH_DUMMY_CALL, then delete # deprecated_fp_regnum. v;int;deprecated_fp_regnum;;;-1;-1;;0 -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 +M;CORE_ADDR;push_dummy_call;struct value *function, struct regcache *regcache, CORE_ADDR bp_addr, int nargs, struct value **args, CORE_ADDR sp, function_call_return_method return_method, CORE_ADDR struct_addr;function, regcache, bp_addr, nargs, args, sp, return_method, struct_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 @@ -597,10 +598,18 @@ 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 + +# Return the thread-local address at OFFSET in the thread-local +# storage for the thread PTID and the shared library or executable +# file given by LM_ADDR. If that block of thread-local storage hasn't +# been allocated yet, this function may throw an error. LM_ADDR may +# be zero for statically linked multithreaded inferiors. + +M;CORE_ADDR;get_thread_local_address;ptid_t ptid, CORE_ADDR lm_addr, CORE_ADDR offset;ptid, lm_addr, offset # 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 +m;CORE_ADDR;unwind_pc;struct frame_info *next_frame;next_frame;;default_unwind_pc;;0 +m;CORE_ADDR;unwind_sp;struct frame_info *next_frame;next_frame;;default_unwind_sp;;0 # 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 @@ -625,7 +634,7 @@ m;CORE_ADDR;addr_bits_remove;CORE_ADDR addr;addr;;core_addr_identity;;0 # For example, on AArch64, the top bits of an address known as the "tag" # are ignored by the kernel, the hardware, etc. and can be regarded as # additional data associated with the address. -v;int;significant_addr_bit;;;;;gdbarch_addr_bit (gdbarch); +v;int;significant_addr_bit;;;;;;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 @@ -710,6 +719,8 @@ f;CORE_ADDR;adjust_dwarf2_addr;CORE_ADDR pc;pc;;default_adjust_dwarf2_addr;;0 # stop PC. f;CORE_ADDR;adjust_dwarf2_line;CORE_ADDR addr, int rel;addr, rel;;default_adjust_dwarf2_line;;0 v;int;cannot_step_breakpoint;;;0;0;;0 +# See comment in target.h about continuable, steppable and +# non-steppable watchpoints. 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 @@ -752,7 +763,7 @@ M;ULONGEST;core_xfer_shared_libraries;gdb_byte *readbuf, ULONGEST offset, ULONGE M;ULONGEST;core_xfer_shared_libraries_aix;gdb_byte *readbuf, ULONGEST offset, ULONGEST len;readbuf, offset, len # How the core target converts a PTID from a core file to a string. -M;const char *;core_pid_to_str;ptid_t ptid;ptid +M;std::string;core_pid_to_str;ptid_t ptid;ptid # How the core target extracts the name of a thread from a core file. M;const char *;core_thread_name;struct thread_info *thr;thr @@ -907,7 +918,7 @@ M;void;record_special_symbol;struct objfile *objfile, asymbol *sym;objfile, sym # Function for the 'catch syscall' feature. # Get architecture-specific system calls information from registers. -M;LONGEST;get_syscall_number;ptid_t ptid;ptid +M;LONGEST;get_syscall_number;thread_info *thread;thread # The filename of the XML syscall for this architecture. v;const char *;xml_syscall_file;;;0;0;;0;pstring (gdbarch->xml_syscall_file) @@ -1015,11 +1026,36 @@ M;int;stap_is_single_operand;const char *s;s # parser), and should advance the buffer pointer (p->arg). M;int;stap_parse_special_token;struct stap_parse_info *p;p +# Perform arch-dependent adjustments to a register name. +# +# In very specific situations, it may be necessary for the register +# name present in a SystemTap probe's argument to be handled in a +# special way. For example, on i386, GCC may over-optimize the +# register allocation and use smaller registers than necessary. In +# such cases, the client that is reading and evaluating the SystemTap +# probe (ourselves) will need to actually fetch values from the wider +# version of the register in question. +# +# To illustrate the example, consider the following probe argument +# (i386): +# +# 4@%ax +# +# This argument says that its value can be found at the %ax register, +# which is a 16-bit register. However, the argument's prefix says +# that its type is "uint32_t", which is 32-bit in size. Therefore, in +# this case, GDB should actually fetch the probe's value from register +# %eax, not %ax. In this scenario, this function would actually +# replace the register name from %ax to %eax. +# +# The rationale for this can be found at PR breakpoints/24541. +M;std::string;stap_adjust_register;struct stap_parse_info *p, const std::string \®name, int regnum;p, regname, regnum + # DTrace related functions. # The expression to compute the NARTGth+1 argument to a DTrace USDT probe. # NARG must be >= 0. -M;void;dtrace_parse_probe_argument;struct parser_state *pstate, int narg;pstate, narg +M;void;dtrace_parse_probe_argument;struct expr_builder *builder, int narg;builder, narg # True if the given ADDR does not contain the instruction sequence # corresponding to a disabled DTrace is-enabled probe. @@ -1144,8 +1180,8 @@ f;void;infcall_munmap;CORE_ADDR addr, CORE_ADDR size;addr, size;;default_infcall # Return string (caller has to use xfree for it) with options for GCC # to produce code for this target, typically "-m64", "-m32" or "-m31". # These options are put before CU's DW_AT_producer compilation options so that -# they can override it. Method may also return NULL. -m;char *;gcc_target_options;void;;;default_gcc_target_options;;0 +# they can override it. +m;std::string;gcc_target_options;void;;;default_gcc_target_options;;0 # Return a regular expression that matches names used by this # architecture in GNU configury triplets. The result is statically @@ -1160,12 +1196,19 @@ m;const char *;gnu_triplet_regexp;void;;;default_gnu_triplet_regexp;;0 m;int;addressable_memory_unit_size;void;;;default_addressable_memory_unit_size;;0 # Functions for allowing a target to modify its disassembler options. +v;const char *;disassembler_options_implicit;;;0;0;;0;pstring (gdbarch->disassembler_options_implicit) v;char **;disassembler_options;;;0;0;;0;pstring_ptr (gdbarch->disassembler_options) -v;const disasm_options_t *;valid_disassembler_options;;;0;0;;0;host_address_to_string (gdbarch->valid_disassembler_options) +v;const disasm_options_and_args_t *;valid_disassembler_options;;;0;0;;0;host_address_to_string (gdbarch->valid_disassembler_options) -# Type alignment. +# Type alignment override method. Return the architecture specific +# alignment required for TYPE. If there is no special handling +# required for TYPE then return the value 0, GDB will then apply the +# default rules as laid out in gdbtypes.c:type_align. m;ULONGEST;type_align;struct type *type;type;;default_type_align;;0 +# Return a string containing any flags for the given PC in the given FRAME. +f;std::string;get_pc_address_flags;frame_info *frame, CORE_ADDR pc;frame, pc;;default_get_pc_address_flags;;0 + EOF } @@ -1219,7 +1262,7 @@ cat < #include "frame.h" #include "dis-asm.h" +#include "gdb_obstack.h" struct floatformat; struct ui_file; @@ -1285,7 +1329,7 @@ struct syscall; struct agent_expr; struct axs_value; struct stap_parse_info; -struct parser_state; +struct expr_builder; struct ravenscar_arch_ops; struct mem_range; struct syscalls_info; @@ -1317,13 +1361,38 @@ typedef int (iterate_over_objfiles_in_search_order_cb_ftype) /* Callback type for regset section iterators. The callback usually invokes the REGSET's supply or collect method, to which it must - pass a buffer with at least the given SIZE. SECT_NAME is a BFD - section name, and HUMAN_NAME is used for diagnostic messages. - CB_DATA should have been passed unchanged through the iterator. */ + pass a buffer - for collects this buffer will need to be created using + COLLECT_SIZE, for supply the existing buffer being read from should + be at least SUPPLY_SIZE. SECT_NAME is a BFD section name, and HUMAN_NAME + is used for diagnostic messages. CB_DATA should have been passed + unchanged through the iterator. */ typedef void (iterate_over_regset_sections_cb) - (const char *sect_name, int size, const struct regset *regset, - const char *human_name, void *cb_data); + (const char *sect_name, int supply_size, int collect_size, + const struct regset *regset, const char *human_name, void *cb_data); + +/* For a function call, does the function return a value using a + normal value return or a structure return - passing a hidden + argument pointing to storage. For the latter, there are two + cases: language-mandated structure return and target ABI + structure return. */ + +enum function_call_return_method +{ + /* Standard value return. */ + return_method_normal = 0, + + /* Language ABI structure return. This is handled + by passing the return location as the first parameter to + the function, even preceding "this". */ + return_method_hidden_param, + + /* Target ABI struct return. This is target-specific; for instance, + on ia64 the first argument is passed in out0 but the hidden + structure return pointer would normally be passed in r8. */ + return_method_struct, +}; + EOF # function typedef's @@ -1390,9 +1459,6 @@ done # close it off cat < (gdbarch_obstack ((GDBARCH)), (NR)) + +#define GDBARCH_OBSTACK_ZALLOC(GDBARCH, TYPE) \ + obstack_zalloc (gdbarch_obstack ((GDBARCH))) /* Duplicate STRING, returning an equivalent string that's allocated on the obstack associated with GDBARCH. The string is freed when the corresponding @@ -1624,6 +1695,14 @@ extern unsigned int gdbarch_debug; extern void gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file); +/* Return the number of cooked registers (raw + pseudo) for ARCH. */ + +static inline int +gdbarch_num_cooked_regs (gdbarch *arch) +{ + return gdbarch_num_regs (arch) + gdbarch_num_pseudo_regs (arch); +} + #endif EOF exec 1>&2 @@ -1654,6 +1733,8 @@ cat <obstack, size); - - memset (data, 0, size); - return data; + return arch->obstack; } /* See gdbarch.h. */