X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=gdb%2Fgdbarch.sh;h=0be3e88bb24701ddef03b59b9086dc11d504495b;hb=153d79c451fd852e97cdfecf2205781e3a13dd55;hp=753819f321c5a9b8f513bc83ad83a19a7ee094b5;hpb=35837774a77d641ba3ae75930a7b08ed853759ad;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/gdbarch.sh b/gdb/gdbarch.sh index 753819f321..0be3e88bb2 100755 --- a/gdb/gdbarch.sh +++ b/gdb/gdbarch.sh @@ -2,7 +2,7 @@ # Architecture commands for GDB, the GNU debugger. # -# Copyright (C) 1998-2017 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 @@ -422,19 +415,19 @@ v;int;dwarf2_addr_size;;;sizeof (void*);0;gdbarch_ptr_bit (gdbarch) / TARGET_CHA # One if \`char' acts like \`signed char', zero if \`unsigned char'. v;int;char_signed;;;1;-1;1 # -F;CORE_ADDR;read_pc;struct regcache *regcache;regcache +F;CORE_ADDR;read_pc;readable_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. m;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;enum register_status;pseudo_register_read;struct regcache *regcache, int cookednum, gdb_byte *buf;regcache, cookednum, buf +M;enum register_status;pseudo_register_read;readable_regcache *regcache, int cookednum, gdb_byte *buf;regcache, cookednum, buf # Read a register into a new struct value. If the register is wholly # or partly unavailable, this should call mark_value_bytes_unavailable # as appropriate. If this is defined, then pseudo_register_read will # never be called. -M;struct value *;pseudo_register_read_value;struct regcache *regcache, int cookednum;regcache, cookednum +M;struct value *;pseudo_register_read_value;readable_regcache *regcache, int cookednum;regcache, cookednum M;void;pseudo_register_write;struct regcache *regcache, int cookednum, const gdb_byte *buf;regcache, cookednum, buf # v;int;num_regs;;;0;-1 @@ -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 @@ -621,6 +630,12 @@ m;CORE_ADDR;convert_from_func_ptr_addr;CORE_ADDR addr, struct target_ops *targ;a # possible it should be in TARGET_READ_PC instead). m;CORE_ADDR;addr_bits_remove;CORE_ADDR addr;addr;;core_addr_identity;;0 +# On some machines, not all bits of an address word are significant. +# 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;;;;;;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. @@ -643,7 +658,7 @@ F;std::vector;software_single_step;struct regcache *regcache;regcache 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;int;print_insn;bfd_vma vma, struct disassemble_info *info;vma, info;;0; +f;int;print_insn;bfd_vma vma, struct disassemble_info *info;vma, info;;default_print_insn;;0 f;CORE_ADDR;skip_trampoline_code;struct frame_info *frame, CORE_ADDR pc;frame, pc;;generic_skip_trampoline_code;;0 @@ -654,6 +669,9 @@ 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. m;int;in_solib_return_trampoline;CORE_ADDR pc, const char *name;pc, name;;generic_in_solib_return_trampoline;;0 +# Return true if PC lies inside an indirect branch thunk. +m;bool;in_indirect_branch_thunk;CORE_ADDR pc;pc;;default_in_indirect_branch_thunk;;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 function's epilogue. stack_frame_destroyed_p() @@ -701,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 @@ -728,13 +748,6 @@ M;void;iterate_over_regset_sections;iterate_over_regset_sections_cb *cb, void *c # Create core file notes M;char *;make_corefile_notes;bfd *obfd, int *note_size;obfd, note_size -# The elfcore writer hook to use to write Linux prpsinfo notes to core -# files. Most Linux architectures use the same prpsinfo32 or -# prpsinfo64 layouts, and so won't need to provide this hook, as we -# call the Linux generic routines in bfd to write prpsinfo notes by -# default. -F;char *;elfcore_write_linux_prpsinfo;bfd *obfd, char *note_data, int *note_size, const struct elf_internal_linux_prpsinfo *info;obfd, note_data, note_size, info - # Find core file memory regions M;int;find_memory_regions;find_memory_region_ftype func, void *data;func, data @@ -750,11 +763,16 @@ 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 +# Read offset OFFSET of TARGET_OBJECT_SIGNAL_INFO signal information +# from core file into buffer READBUF with length LEN. Return the number +# of bytes read (zero indicates EOF, a negative value indicates failure). +M;LONGEST;core_xfer_siginfo;gdb_byte *readbuf, ULONGEST offset, ULONGEST len; readbuf, offset, len + # BFD target to use when generating a core file. V;const char *;gcore_bfd_target;;;0;0;;;pstring (gdbarch->gcore_bfd_target) @@ -795,10 +813,6 @@ V;ULONGEST;max_insn_length;;;0;0 # If you do not provide this function, GDB assumes that the # architecture does not support displaced stepping. # -# If your architecture doesn't need to adjust instructions before -# single-stepping them, consider using simple_displaced_step_copy_insn -# here. -# # If the instruction cannot execute out of line, return NULL. The # core falls back to stepping past the instruction in-line instead in # that case. @@ -833,18 +847,6 @@ m;int;displaced_step_hw_singlestep;struct displaced_step_closure *closure;closur # see the comments in infrun.c. M;void;displaced_step_fixup;struct displaced_step_closure *closure, CORE_ADDR from, CORE_ADDR to, struct regcache *regs;closure, from, to, regs;;NULL -# Free a closure returned by gdbarch_displaced_step_copy_insn. -# -# If you provide gdbarch_displaced_step_copy_insn, you must provide -# this function as well. -# -# If your architecture uses closures that don't need to be freed, then -# you can use simple_displaced_step_free_closure here. -# -# For a general explanation of displaced stepping and how GDB uses it, -# see the comments in infrun.c. -m;void;displaced_step_free_closure;struct displaced_step_closure *closure;closure;;NULL;;(! gdbarch->displaced_step_free_closure) != (! gdbarch->displaced_step_copy_insn) - # Return the address of an appropriate place to put displaced # instructions while we step over them. There need only be one such # place, since we're only stepping one thread over a breakpoint at a @@ -916,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) @@ -1024,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. @@ -1057,7 +1084,7 @@ v;int;has_global_breakpoints;;;0;0;;0 m;int;has_shared_address_space;void;;;default_has_shared_address_space;;0 # True if a fast tracepoint can be set at an address. -m;int;fast_tracepoint_valid_at;CORE_ADDR addr, char **msg;addr, msg;;default_fast_tracepoint_valid_at;;0 +m;int;fast_tracepoint_valid_at;CORE_ADDR addr, std::string *msg;addr, msg;;default_fast_tracepoint_valid_at;;0 # Guess register state based on tracepoint location. Used for tracepoints # where no registers have been collected, but there's only one location, @@ -1153,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 @@ -1169,8 +1196,18 @@ 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 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 } @@ -1225,7 +1262,7 @@ cat < #include "frame.h" #include "dis-asm.h" +#include "gdb_obstack.h" struct floatformat; struct ui_file; @@ -1285,16 +1323,14 @@ struct target_ops; struct obstack; struct bp_target_info; struct target_desc; -struct objfile; struct symbol; struct displaced_step_closure; struct syscall; struct agent_expr; struct axs_value; struct stap_parse_info; -struct parser_state; +struct expr_builder; struct ravenscar_arch_ops; -struct elf_internal_linux_prpsinfo; struct mem_range; struct syscalls_info; struct thread_info; @@ -1325,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 @@ -1398,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 @@ -1618,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 @@ -1644,10 +1729,12 @@ cat <obstack, size); - - memset (data, 0, size); - return data; + return arch->obstack; } /* See gdbarch.h. */ @@ -2506,7 +2588,7 @@ set_target_gdbarch (struct gdbarch *new_gdbarch) gdb_assert (new_gdbarch != NULL); gdb_assert (new_gdbarch->initialized_p); current_inferior ()->gdbarch = new_gdbarch; - observer_notify_architecture_changed (new_gdbarch); + gdb::observers::architecture_changed.notify (new_gdbarch); registers_changed (); } @@ -2518,8 +2600,6 @@ target_gdbarch (void) return current_inferior ()->gdbarch; } -extern void _initialize_gdbarch (void); - void _initialize_gdbarch (void) {