1 /* SystemTap probe support for GDB.
3 Copyright (C) 2012-2019 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
21 #include "stap-probe.h"
23 #include "common/vec.h"
26 #include "arch-utils.h"
29 #include "filenames.h"
33 #include "complaints.h"
34 #include "cli/cli-utils.h"
36 #include "user-regs.h"
37 #include "parser-defs.h"
43 /* The name of the SystemTap section where we will find information about
46 #define STAP_BASE_SECTION_NAME ".stapsdt.base"
48 /* Should we display debug information for the probe's argument expression
51 static unsigned int stap_expression_debug = 0;
53 /* The various possibilities of bitness defined for a probe's argument.
57 - STAP_ARG_BITNESS_UNDEFINED: The user hasn't specified the bitness.
58 - STAP_ARG_BITNESS_8BIT_UNSIGNED: argument string starts with `1@'.
59 - STAP_ARG_BITNESS_8BIT_SIGNED: argument string starts with `-1@'.
60 - STAP_ARG_BITNESS_16BIT_UNSIGNED: argument string starts with `2@'.
61 - STAP_ARG_BITNESS_16BIT_SIGNED: argument string starts with `-2@'.
62 - STAP_ARG_BITNESS_32BIT_UNSIGNED: argument string starts with `4@'.
63 - STAP_ARG_BITNESS_32BIT_SIGNED: argument string starts with `-4@'.
64 - STAP_ARG_BITNESS_64BIT_UNSIGNED: argument string starts with `8@'.
65 - STAP_ARG_BITNESS_64BIT_SIGNED: argument string starts with `-8@'. */
69 STAP_ARG_BITNESS_UNDEFINED,
70 STAP_ARG_BITNESS_8BIT_UNSIGNED,
71 STAP_ARG_BITNESS_8BIT_SIGNED,
72 STAP_ARG_BITNESS_16BIT_UNSIGNED,
73 STAP_ARG_BITNESS_16BIT_SIGNED,
74 STAP_ARG_BITNESS_32BIT_UNSIGNED,
75 STAP_ARG_BITNESS_32BIT_SIGNED,
76 STAP_ARG_BITNESS_64BIT_UNSIGNED,
77 STAP_ARG_BITNESS_64BIT_SIGNED,
80 /* The following structure represents a single argument for the probe. */
84 /* Constructor for stap_probe_arg. */
85 stap_probe_arg (enum stap_arg_bitness bitness_, struct type *atype_,
86 expression_up &&aexpr_)
87 : bitness (bitness_), atype (atype_), aexpr (std::move (aexpr_))
90 /* The bitness of this argument. */
91 enum stap_arg_bitness bitness;
93 /* The corresponding `struct type *' to the bitness. */
96 /* The argument converted to an internal GDB expression. */
100 /* Class that implements the static probe methods for "stap" probes. */
102 class stap_static_probe_ops : public static_probe_ops
106 bool is_linespec (const char **linespecp) const override;
109 void get_probes (std::vector<probe *> *probesp,
110 struct objfile *objfile) const override;
113 const char *type_name () const override;
116 std::vector<struct info_probe_column> gen_info_probes_table_header
120 /* SystemTap static_probe_ops. */
122 const stap_static_probe_ops stap_static_probe_ops {};
124 class stap_probe : public probe
127 /* Constructor for stap_probe. */
128 stap_probe (std::string &&name_, std::string &&provider_, CORE_ADDR address_,
129 struct gdbarch *arch_, CORE_ADDR sem_addr, const char *args_text)
130 : probe (std::move (name_), std::move (provider_), address_, arch_),
131 m_sem_addr (sem_addr),
132 m_have_parsed_args (false), m_unparsed_args_text (args_text)
136 CORE_ADDR get_relocated_address (struct objfile *objfile) override;
139 unsigned get_argument_count (struct frame_info *frame) override;
142 bool can_evaluate_arguments () const override;
145 struct value *evaluate_argument (unsigned n,
146 struct frame_info *frame) override;
149 void compile_to_ax (struct agent_expr *aexpr,
150 struct axs_value *axs_value,
151 unsigned n) override;
154 void set_semaphore (struct objfile *objfile,
155 struct gdbarch *gdbarch) override;
158 void clear_semaphore (struct objfile *objfile,
159 struct gdbarch *gdbarch) override;
162 const static_probe_ops *get_static_ops () const override;
165 std::vector<const char *> gen_info_probes_table_values () const override;
167 /* Return argument N of probe.
169 If the probe's arguments have not been parsed yet, parse them. If
170 there are no arguments, throw an exception (error). Otherwise,
171 return the requested argument. */
172 struct stap_probe_arg *get_arg_by_number (unsigned n,
173 struct gdbarch *gdbarch)
175 if (!m_have_parsed_args)
176 this->parse_arguments (gdbarch);
178 gdb_assert (m_have_parsed_args);
179 if (m_parsed_args.empty ())
180 internal_error (__FILE__, __LINE__,
181 _("Probe '%s' apparently does not have arguments, but \n"
182 "GDB is requesting its argument number %u anyway. "
183 "This should not happen. Please report this bug."),
184 this->get_name ().c_str (), n);
186 if (n > m_parsed_args.size ())
187 internal_error (__FILE__, __LINE__,
188 _("Probe '%s' has %d arguments, but GDB is requesting\n"
189 "argument %u. This should not happen. Please\n"
191 this->get_name ().c_str (),
192 (int) m_parsed_args.size (), n);
194 return &m_parsed_args[n];
197 /* Function which parses an argument string from the probe,
198 correctly splitting the arguments and storing their information
201 Consider the following argument string (x86 syntax):
205 We have two arguments, `%eax' and `$10', both with 32-bit
206 unsigned bitness. This function basically handles them, properly
207 filling some structures with this information. */
208 void parse_arguments (struct gdbarch *gdbarch);
211 /* If the probe has a semaphore associated, then this is the value of
212 it, relative to SECT_OFF_DATA. */
213 CORE_ADDR m_sem_addr;
215 /* True if the arguments have been parsed. */
216 bool m_have_parsed_args;
218 /* The text version of the probe's arguments, unparsed. */
219 const char *m_unparsed_args_text;
221 /* Information about each argument. This is an array of `stap_probe_arg',
222 with each entry representing one argument. This is only valid if
223 M_ARGS_PARSED is true. */
224 std::vector<struct stap_probe_arg> m_parsed_args;
227 /* When parsing the arguments, we have to establish different precedences
228 for the various kinds of asm operators. This enumeration represents those
231 This logic behind this is available at
232 <http://sourceware.org/binutils/docs/as/Infix-Ops.html#Infix-Ops>, or using
233 the command "info '(as)Infix Ops'". */
235 enum stap_operand_prec
237 /* Lowest precedence, used for non-recognized operands or for the beginning
238 of the parsing process. */
239 STAP_OPERAND_PREC_NONE = 0,
241 /* Precedence of logical OR. */
242 STAP_OPERAND_PREC_LOGICAL_OR,
244 /* Precedence of logical AND. */
245 STAP_OPERAND_PREC_LOGICAL_AND,
247 /* Precedence of additive (plus, minus) and comparative (equal, less,
248 greater-than, etc) operands. */
249 STAP_OPERAND_PREC_ADD_CMP,
251 /* Precedence of bitwise operands (bitwise OR, XOR, bitwise AND,
253 STAP_OPERAND_PREC_BITWISE,
255 /* Precedence of multiplicative operands (multiplication, division,
256 remainder, left shift and right shift). */
257 STAP_OPERAND_PREC_MUL
260 static void stap_parse_argument_1 (struct stap_parse_info *p, int has_lhs,
261 enum stap_operand_prec prec);
263 static void stap_parse_argument_conditionally (struct stap_parse_info *p);
265 /* Returns 1 if *S is an operator, zero otherwise. */
267 static int stap_is_operator (const char *op);
270 show_stapexpressiondebug (struct ui_file *file, int from_tty,
271 struct cmd_list_element *c, const char *value)
273 fprintf_filtered (file, _("SystemTap Probe expression debugging is %s.\n"),
277 /* Returns the operator precedence level of OP, or STAP_OPERAND_PREC_NONE
278 if the operator code was not recognized. */
280 static enum stap_operand_prec
281 stap_get_operator_prec (enum exp_opcode op)
285 case BINOP_LOGICAL_OR:
286 return STAP_OPERAND_PREC_LOGICAL_OR;
288 case BINOP_LOGICAL_AND:
289 return STAP_OPERAND_PREC_LOGICAL_AND;
299 return STAP_OPERAND_PREC_ADD_CMP;
301 case BINOP_BITWISE_IOR:
302 case BINOP_BITWISE_AND:
303 case BINOP_BITWISE_XOR:
304 case UNOP_LOGICAL_NOT:
305 return STAP_OPERAND_PREC_BITWISE;
312 return STAP_OPERAND_PREC_MUL;
315 return STAP_OPERAND_PREC_NONE;
319 /* Given S, read the operator in it and fills the OP pointer with its code.
320 Return 1 on success, zero if the operator was not recognized. */
322 static enum exp_opcode
323 stap_get_opcode (const char **s)
378 op = BINOP_BITWISE_IOR;
382 op = BINOP_LOGICAL_OR;
387 op = BINOP_BITWISE_AND;
391 op = BINOP_LOGICAL_AND;
396 op = BINOP_BITWISE_XOR;
400 op = UNOP_LOGICAL_NOT;
412 gdb_assert (**s == '=');
417 error (_("Invalid opcode in expression `%s' for SystemTap"
424 /* Given the bitness of the argument, represented by B, return the
425 corresponding `struct type *'. */
428 stap_get_expected_argument_type (struct gdbarch *gdbarch,
429 enum stap_arg_bitness b,
430 const char *probe_name)
434 case STAP_ARG_BITNESS_UNDEFINED:
435 if (gdbarch_addr_bit (gdbarch) == 32)
436 return builtin_type (gdbarch)->builtin_uint32;
438 return builtin_type (gdbarch)->builtin_uint64;
440 case STAP_ARG_BITNESS_8BIT_UNSIGNED:
441 return builtin_type (gdbarch)->builtin_uint8;
443 case STAP_ARG_BITNESS_8BIT_SIGNED:
444 return builtin_type (gdbarch)->builtin_int8;
446 case STAP_ARG_BITNESS_16BIT_UNSIGNED:
447 return builtin_type (gdbarch)->builtin_uint16;
449 case STAP_ARG_BITNESS_16BIT_SIGNED:
450 return builtin_type (gdbarch)->builtin_int16;
452 case STAP_ARG_BITNESS_32BIT_SIGNED:
453 return builtin_type (gdbarch)->builtin_int32;
455 case STAP_ARG_BITNESS_32BIT_UNSIGNED:
456 return builtin_type (gdbarch)->builtin_uint32;
458 case STAP_ARG_BITNESS_64BIT_SIGNED:
459 return builtin_type (gdbarch)->builtin_int64;
461 case STAP_ARG_BITNESS_64BIT_UNSIGNED:
462 return builtin_type (gdbarch)->builtin_uint64;
465 error (_("Undefined bitness for probe '%s'."), probe_name);
470 /* Helper function to check for a generic list of prefixes. GDBARCH
471 is the current gdbarch being used. S is the expression being
472 analyzed. If R is not NULL, it will be used to return the found
473 prefix. PREFIXES is the list of expected prefixes.
475 This function does a case-insensitive match.
477 Return 1 if any prefix has been found, zero otherwise. */
480 stap_is_generic_prefix (struct gdbarch *gdbarch, const char *s,
481 const char **r, const char *const *prefixes)
483 const char *const *p;
485 if (prefixes == NULL)
493 for (p = prefixes; *p != NULL; ++p)
494 if (strncasecmp (s, *p, strlen (*p)) == 0)
505 /* Return 1 if S points to a register prefix, zero otherwise. For a
506 description of the arguments, look at stap_is_generic_prefix. */
509 stap_is_register_prefix (struct gdbarch *gdbarch, const char *s,
512 const char *const *t = gdbarch_stap_register_prefixes (gdbarch);
514 return stap_is_generic_prefix (gdbarch, s, r, t);
517 /* Return 1 if S points to a register indirection prefix, zero
518 otherwise. For a description of the arguments, look at
519 stap_is_generic_prefix. */
522 stap_is_register_indirection_prefix (struct gdbarch *gdbarch, const char *s,
525 const char *const *t = gdbarch_stap_register_indirection_prefixes (gdbarch);
527 return stap_is_generic_prefix (gdbarch, s, r, t);
530 /* Return 1 if S points to an integer prefix, zero otherwise. For a
531 description of the arguments, look at stap_is_generic_prefix.
533 This function takes care of analyzing whether we are dealing with
534 an expected integer prefix, or, if there is no integer prefix to be
535 expected, whether we are dealing with a digit. It does a
536 case-insensitive match. */
539 stap_is_integer_prefix (struct gdbarch *gdbarch, const char *s,
542 const char *const *t = gdbarch_stap_integer_prefixes (gdbarch);
543 const char *const *p;
547 /* A NULL value here means that integers do not have a prefix.
548 We just check for a digit then. */
555 for (p = t; *p != NULL; ++p)
557 size_t len = strlen (*p);
559 if ((len == 0 && isdigit (*s))
560 || (len > 0 && strncasecmp (s, *p, len) == 0))
562 /* Integers may or may not have a prefix. The "len == 0"
563 check covers the case when integers do not have a prefix
564 (therefore, we just check if we have a digit). The call
565 to "strncasecmp" covers the case when they have a
577 /* Helper function to check for a generic list of suffixes. If we are
578 not expecting any suffixes, then it just returns 1. If we are
579 expecting at least one suffix, then it returns 1 if a suffix has
580 been found, zero otherwise. GDBARCH is the current gdbarch being
581 used. S is the expression being analyzed. If R is not NULL, it
582 will be used to return the found suffix. SUFFIXES is the list of
583 expected suffixes. This function does a case-insensitive
587 stap_generic_check_suffix (struct gdbarch *gdbarch, const char *s,
588 const char **r, const char *const *suffixes)
590 const char *const *p;
593 if (suffixes == NULL)
601 for (p = suffixes; *p != NULL; ++p)
602 if (strncasecmp (s, *p, strlen (*p)) == 0)
614 /* Return 1 if S points to an integer suffix, zero otherwise. For a
615 description of the arguments, look at
616 stap_generic_check_suffix. */
619 stap_check_integer_suffix (struct gdbarch *gdbarch, const char *s,
622 const char *const *p = gdbarch_stap_integer_suffixes (gdbarch);
624 return stap_generic_check_suffix (gdbarch, s, r, p);
627 /* Return 1 if S points to a register suffix, zero otherwise. For a
628 description of the arguments, look at
629 stap_generic_check_suffix. */
632 stap_check_register_suffix (struct gdbarch *gdbarch, const char *s,
635 const char *const *p = gdbarch_stap_register_suffixes (gdbarch);
637 return stap_generic_check_suffix (gdbarch, s, r, p);
640 /* Return 1 if S points to a register indirection suffix, zero
641 otherwise. For a description of the arguments, look at
642 stap_generic_check_suffix. */
645 stap_check_register_indirection_suffix (struct gdbarch *gdbarch, const char *s,
648 const char *const *p = gdbarch_stap_register_indirection_suffixes (gdbarch);
650 return stap_generic_check_suffix (gdbarch, s, r, p);
653 /* Function responsible for parsing a register operand according to
654 SystemTap parlance. Assuming:
658 RIP = register indirection prefix
659 RIS = register indirection suffix
661 Then a register operand can be:
663 [RIP] [RP] REGISTER [RS] [RIS]
665 This function takes care of a register's indirection, displacement and
666 direct access. It also takes into consideration the fact that some
667 registers are named differently inside and outside GDB, e.g., PPC's
668 general-purpose registers are represented by integers in the assembly
669 language (e.g., `15' is the 15th general-purpose register), but inside
670 GDB they have a prefix (the letter `r') appended. */
673 stap_parse_register_operand (struct stap_parse_info *p)
675 /* Simple flag to indicate whether we have seen a minus signal before
678 /* Flags to indicate whether this register access is being displaced and/or
680 int disp_p = 0, indirect_p = 0;
681 struct gdbarch *gdbarch = p->gdbarch;
682 /* Needed to generate the register name as a part of an expression. */
684 /* Variables used to extract the register name from the probe's
687 const char *gdb_reg_prefix = gdbarch_stap_gdb_register_prefix (gdbarch);
688 const char *gdb_reg_suffix = gdbarch_stap_gdb_register_suffix (gdbarch);
689 const char *reg_prefix;
690 const char *reg_ind_prefix;
691 const char *reg_suffix;
692 const char *reg_ind_suffix;
694 /* Checking for a displacement argument. */
697 /* If it's a plus sign, we don't need to do anything, just advance the
708 if (isdigit (*p->arg))
710 /* The value of the displacement. */
715 displacement = strtol (p->arg, &endp, 10);
718 /* Generating the expression for the displacement. */
719 write_exp_elt_opcode (&p->pstate, OP_LONG);
720 write_exp_elt_type (&p->pstate, builtin_type (gdbarch)->builtin_long);
721 write_exp_elt_longcst (&p->pstate, displacement);
722 write_exp_elt_opcode (&p->pstate, OP_LONG);
724 write_exp_elt_opcode (&p->pstate, UNOP_NEG);
727 /* Getting rid of register indirection prefix. */
728 if (stap_is_register_indirection_prefix (gdbarch, p->arg, ®_ind_prefix))
731 p->arg += strlen (reg_ind_prefix);
734 if (disp_p && !indirect_p)
735 error (_("Invalid register displacement syntax on expression `%s'."),
738 /* Getting rid of register prefix. */
739 if (stap_is_register_prefix (gdbarch, p->arg, ®_prefix))
740 p->arg += strlen (reg_prefix);
742 /* Now we should have only the register name. Let's extract it and get
743 the associated number. */
746 /* We assume the register name is composed by letters and numbers. */
747 while (isalnum (*p->arg))
750 std::string regname (start, p->arg - start);
752 /* We only add the GDB's register prefix/suffix if we are dealing with
753 a numeric register. */
754 if (isdigit (*start))
756 if (gdb_reg_prefix != NULL)
757 regname = gdb_reg_prefix + regname;
759 if (gdb_reg_suffix != NULL)
760 regname += gdb_reg_suffix;
763 /* Is this a valid register name? */
764 if (user_reg_map_name_to_regnum (gdbarch,
766 regname.size ()) == -1)
767 error (_("Invalid register name `%s' on expression `%s'."),
768 regname.c_str (), p->saved_arg);
770 write_exp_elt_opcode (&p->pstate, OP_REGISTER);
771 str.ptr = regname.c_str ();
772 str.length = regname.size ();
773 write_exp_string (&p->pstate, str);
774 write_exp_elt_opcode (&p->pstate, OP_REGISTER);
779 write_exp_elt_opcode (&p->pstate, BINOP_ADD);
781 /* Casting to the expected type. */
782 write_exp_elt_opcode (&p->pstate, UNOP_CAST);
783 write_exp_elt_type (&p->pstate, lookup_pointer_type (p->arg_type));
784 write_exp_elt_opcode (&p->pstate, UNOP_CAST);
786 write_exp_elt_opcode (&p->pstate, UNOP_IND);
789 /* Getting rid of the register name suffix. */
790 if (stap_check_register_suffix (gdbarch, p->arg, ®_suffix))
791 p->arg += strlen (reg_suffix);
793 error (_("Missing register name suffix on expression `%s'."),
796 /* Getting rid of the register indirection suffix. */
799 if (stap_check_register_indirection_suffix (gdbarch, p->arg,
801 p->arg += strlen (reg_ind_suffix);
803 error (_("Missing indirection suffix on expression `%s'."),
808 /* This function is responsible for parsing a single operand.
810 A single operand can be:
812 - an unary operation (e.g., `-5', `~2', or even with subexpressions
814 - a register displacement, which will be treated as a register
815 operand (e.g., `-4(%eax)' on x86)
816 - a numeric constant, or
817 - a register operand (see function `stap_parse_register_operand')
819 The function also calls special-handling functions to deal with
820 unrecognized operands, allowing arch-specific parsers to be
824 stap_parse_single_operand (struct stap_parse_info *p)
826 struct gdbarch *gdbarch = p->gdbarch;
827 const char *int_prefix = NULL;
829 /* We first try to parse this token as a "special token". */
830 if (gdbarch_stap_parse_special_token_p (gdbarch))
831 if (gdbarch_stap_parse_special_token (gdbarch, p) != 0)
833 /* If the return value of the above function is not zero,
834 it means it successfully parsed the special token.
836 If it is NULL, we try to parse it using our method. */
840 if (*p->arg == '-' || *p->arg == '~' || *p->arg == '+')
843 /* We use this variable to do a lookahead. */
844 const char *tmp = p->arg;
847 /* Skipping signal. */
850 /* This is an unary operation. Here is a list of allowed tokens
854 - number (from register displacement)
855 - subexpression (beginning with `(')
857 We handle the register displacement here, and the other cases
859 if (p->inside_paren_p)
860 tmp = skip_spaces (tmp);
862 while (isdigit (*tmp))
864 /* We skip the digit here because we are only interested in
865 knowing what kind of unary operation this is. The digit
866 will be handled by one of the functions that will be
867 called below ('stap_parse_argument_conditionally' or
868 'stap_parse_register_operand'). */
873 if (has_digit && stap_is_register_indirection_prefix (gdbarch, tmp,
876 /* If we are here, it means it is a displacement. The only
877 operations allowed here are `-' and `+'. */
879 error (_("Invalid operator `%c' for register displacement "
880 "on expression `%s'."), c, p->saved_arg);
882 stap_parse_register_operand (p);
886 /* This is not a displacement. We skip the operator, and
887 deal with it when the recursion returns. */
889 stap_parse_argument_conditionally (p);
891 write_exp_elt_opcode (&p->pstate, UNOP_NEG);
893 write_exp_elt_opcode (&p->pstate, UNOP_COMPLEMENT);
896 else if (isdigit (*p->arg))
898 /* A temporary variable, needed for lookahead. */
899 const char *tmp = p->arg;
903 /* We can be dealing with a numeric constant, or with a register
905 number = strtol (tmp, &endp, 10);
908 if (p->inside_paren_p)
909 tmp = skip_spaces (tmp);
911 /* If "stap_is_integer_prefix" returns true, it means we can
912 accept integers without a prefix here. But we also need to
913 check whether the next token (i.e., "tmp") is not a register
914 indirection prefix. */
915 if (stap_is_integer_prefix (gdbarch, p->arg, NULL)
916 && !stap_is_register_indirection_prefix (gdbarch, tmp, NULL))
918 const char *int_suffix;
920 /* We are dealing with a numeric constant. */
921 write_exp_elt_opcode (&p->pstate, OP_LONG);
922 write_exp_elt_type (&p->pstate,
923 builtin_type (gdbarch)->builtin_long);
924 write_exp_elt_longcst (&p->pstate, number);
925 write_exp_elt_opcode (&p->pstate, OP_LONG);
929 if (stap_check_integer_suffix (gdbarch, p->arg, &int_suffix))
930 p->arg += strlen (int_suffix);
932 error (_("Invalid constant suffix on expression `%s'."),
935 else if (stap_is_register_indirection_prefix (gdbarch, tmp, NULL))
936 stap_parse_register_operand (p);
938 error (_("Unknown numeric token on expression `%s'."),
941 else if (stap_is_integer_prefix (gdbarch, p->arg, &int_prefix))
943 /* We are dealing with a numeric constant. */
946 const char *int_suffix;
948 p->arg += strlen (int_prefix);
949 number = strtol (p->arg, &endp, 10);
952 write_exp_elt_opcode (&p->pstate, OP_LONG);
953 write_exp_elt_type (&p->pstate, builtin_type (gdbarch)->builtin_long);
954 write_exp_elt_longcst (&p->pstate, number);
955 write_exp_elt_opcode (&p->pstate, OP_LONG);
957 if (stap_check_integer_suffix (gdbarch, p->arg, &int_suffix))
958 p->arg += strlen (int_suffix);
960 error (_("Invalid constant suffix on expression `%s'."),
963 else if (stap_is_register_prefix (gdbarch, p->arg, NULL)
964 || stap_is_register_indirection_prefix (gdbarch, p->arg, NULL))
965 stap_parse_register_operand (p);
967 error (_("Operator `%c' not recognized on expression `%s'."),
968 *p->arg, p->saved_arg);
971 /* This function parses an argument conditionally, based on single or
972 non-single operands. A non-single operand would be a parenthesized
973 expression (e.g., `(2 + 1)'), and a single operand is anything that
974 starts with `-', `~', `+' (i.e., unary operators), a digit, or
975 something recognized by `gdbarch_stap_is_single_operand'. */
978 stap_parse_argument_conditionally (struct stap_parse_info *p)
980 gdb_assert (gdbarch_stap_is_single_operand_p (p->gdbarch));
982 if (*p->arg == '-' || *p->arg == '~' || *p->arg == '+' /* Unary. */
984 || gdbarch_stap_is_single_operand (p->gdbarch, p->arg))
985 stap_parse_single_operand (p);
986 else if (*p->arg == '(')
988 /* We are dealing with a parenthesized operand. It means we
989 have to parse it as it was a separate expression, without
990 left-side or precedence. */
992 p->arg = skip_spaces (p->arg);
995 stap_parse_argument_1 (p, 0, STAP_OPERAND_PREC_NONE);
999 error (_("Missign close-paren on expression `%s'."),
1003 if (p->inside_paren_p)
1004 p->arg = skip_spaces (p->arg);
1007 error (_("Cannot parse expression `%s'."), p->saved_arg);
1010 /* Helper function for `stap_parse_argument'. Please, see its comments to
1011 better understand what this function does. */
1014 stap_parse_argument_1 (struct stap_parse_info *p, int has_lhs,
1015 enum stap_operand_prec prec)
1017 /* This is an operator-precedence parser.
1019 We work with left- and right-sides of expressions, and
1020 parse them depending on the precedence of the operators
1023 gdb_assert (p->arg != NULL);
1025 if (p->inside_paren_p)
1026 p->arg = skip_spaces (p->arg);
1030 /* We were called without a left-side, either because this is the
1031 first call, or because we were called to parse a parenthesized
1032 expression. It doesn't really matter; we have to parse the
1033 left-side in order to continue the process. */
1034 stap_parse_argument_conditionally (p);
1037 /* Start to parse the right-side, and to "join" left and right sides
1038 depending on the operation specified.
1040 This loop shall continue until we run out of characters in the input,
1041 or until we find a close-parenthesis, which means that we've reached
1042 the end of a sub-expression. */
1043 while (*p->arg != '\0' && *p->arg != ')' && !isspace (*p->arg))
1045 const char *tmp_exp_buf;
1046 enum exp_opcode opcode;
1047 enum stap_operand_prec cur_prec;
1049 if (!stap_is_operator (p->arg))
1050 error (_("Invalid operator `%c' on expression `%s'."), *p->arg,
1053 /* We have to save the current value of the expression buffer because
1054 the `stap_get_opcode' modifies it in order to get the current
1055 operator. If this operator's precedence is lower than PREC, we
1056 should return and not advance the expression buffer pointer. */
1057 tmp_exp_buf = p->arg;
1058 opcode = stap_get_opcode (&tmp_exp_buf);
1060 cur_prec = stap_get_operator_prec (opcode);
1061 if (cur_prec < prec)
1063 /* If the precedence of the operator that we are seeing now is
1064 lower than the precedence of the first operator seen before
1065 this parsing process began, it means we should stop parsing
1070 p->arg = tmp_exp_buf;
1071 if (p->inside_paren_p)
1072 p->arg = skip_spaces (p->arg);
1074 /* Parse the right-side of the expression. */
1075 stap_parse_argument_conditionally (p);
1077 /* While we still have operators, try to parse another
1078 right-side, but using the current right-side as a left-side. */
1079 while (*p->arg != '\0' && stap_is_operator (p->arg))
1081 enum exp_opcode lookahead_opcode;
1082 enum stap_operand_prec lookahead_prec;
1084 /* Saving the current expression buffer position. The explanation
1085 is the same as above. */
1086 tmp_exp_buf = p->arg;
1087 lookahead_opcode = stap_get_opcode (&tmp_exp_buf);
1088 lookahead_prec = stap_get_operator_prec (lookahead_opcode);
1090 if (lookahead_prec <= prec)
1092 /* If we are dealing with an operator whose precedence is lower
1093 than the first one, just abandon the attempt. */
1097 /* Parse the right-side of the expression, but since we already
1098 have a left-side at this point, set `has_lhs' to 1. */
1099 stap_parse_argument_1 (p, 1, lookahead_prec);
1102 write_exp_elt_opcode (&p->pstate, opcode);
1106 /* Parse a probe's argument.
1110 LP = literal integer prefix
1111 LS = literal integer suffix
1113 RP = register prefix
1114 RS = register suffix
1116 RIP = register indirection prefix
1117 RIS = register indirection suffix
1119 This routine assumes that arguments' tokens are of the form:
1122 - [RP] REGISTER [RS]
1123 - [RIP] [RP] REGISTER [RS] [RIS]
1124 - If we find a number without LP, we try to parse it as a literal integer
1125 constant (if LP == NULL), or as a register displacement.
1126 - We count parenthesis, and only skip whitespaces if we are inside them.
1127 - If we find an operator, we skip it.
1129 This function can also call a special function that will try to match
1130 unknown tokens. It will return the expression_up generated from
1131 parsing the argument. */
1133 static expression_up
1134 stap_parse_argument (const char **arg, struct type *atype,
1135 struct gdbarch *gdbarch)
1137 /* We need to initialize the expression buffer, in order to begin
1138 our parsing efforts. We use language_c here because we may need
1139 to do pointer arithmetics. */
1140 struct stap_parse_info p (*arg, atype, 10, language_def (language_c),
1143 stap_parse_argument_1 (&p, 0, STAP_OPERAND_PREC_NONE);
1145 gdb_assert (p.inside_paren_p == 0);
1147 /* Casting the final expression to the appropriate type. */
1148 write_exp_elt_opcode (&p.pstate, UNOP_CAST);
1149 write_exp_elt_type (&p.pstate, atype);
1150 write_exp_elt_opcode (&p.pstate, UNOP_CAST);
1152 p.arg = skip_spaces (p.arg);
1155 return p.pstate.release ();
1158 /* Implementation of 'parse_arguments' method. */
1161 stap_probe::parse_arguments (struct gdbarch *gdbarch)
1165 gdb_assert (!m_have_parsed_args);
1166 cur = m_unparsed_args_text;
1167 m_have_parsed_args = true;
1169 if (cur == NULL || *cur == '\0' || *cur == ':')
1172 while (*cur != '\0')
1174 enum stap_arg_bitness bitness;
1175 bool got_minus = false;
1177 /* We expect to find something like:
1181 Where `N' can be [+,-][1,2,4,8]. This is not mandatory, so
1182 we check it here. If we don't find it, go to the next
1184 if ((cur[0] == '-' && isdigit (cur[1]) && cur[2] == '@')
1185 || (isdigit (cur[0]) && cur[1] == '@'))
1189 /* Discard the `-'. */
1194 /* Defining the bitness. */
1198 bitness = (got_minus ? STAP_ARG_BITNESS_8BIT_SIGNED
1199 : STAP_ARG_BITNESS_8BIT_UNSIGNED);
1203 bitness = (got_minus ? STAP_ARG_BITNESS_16BIT_SIGNED
1204 : STAP_ARG_BITNESS_16BIT_UNSIGNED);
1208 bitness = (got_minus ? STAP_ARG_BITNESS_32BIT_SIGNED
1209 : STAP_ARG_BITNESS_32BIT_UNSIGNED);
1213 bitness = (got_minus ? STAP_ARG_BITNESS_64BIT_SIGNED
1214 : STAP_ARG_BITNESS_64BIT_UNSIGNED);
1219 /* We have an error, because we don't expect anything
1220 except 1, 2, 4 and 8. */
1221 warning (_("unrecognized bitness %s%c' for probe `%s'"),
1222 got_minus ? "`-" : "`", *cur,
1223 this->get_name ().c_str ());
1227 /* Discard the number and the `@' sign. */
1231 bitness = STAP_ARG_BITNESS_UNDEFINED;
1234 = stap_get_expected_argument_type (gdbarch, bitness,
1235 this->get_name ().c_str ());
1237 expression_up expr = stap_parse_argument (&cur, atype, gdbarch);
1239 if (stap_expression_debug)
1240 dump_raw_expression (expr.get (), gdb_stdlog,
1241 "before conversion to prefix form");
1243 prefixify_expression (expr.get ());
1245 if (stap_expression_debug)
1246 dump_prefix_expression (expr.get (), gdb_stdlog);
1248 m_parsed_args.emplace_back (bitness, atype, std::move (expr));
1250 /* Start it over again. */
1251 cur = skip_spaces (cur);
1255 /* Helper function to relocate an address. */
1258 relocate_address (CORE_ADDR address, struct objfile *objfile)
1260 return address + ANOFFSET (objfile->section_offsets,
1261 SECT_OFF_DATA (objfile));
1264 /* Implementation of the get_relocated_address method. */
1267 stap_probe::get_relocated_address (struct objfile *objfile)
1269 return relocate_address (this->get_address (), objfile);
1272 /* Given PROBE, returns the number of arguments present in that probe's
1276 stap_probe::get_argument_count (struct frame_info *frame)
1278 struct gdbarch *gdbarch = get_frame_arch (frame);
1280 if (!m_have_parsed_args)
1282 if (this->can_evaluate_arguments ())
1283 this->parse_arguments (gdbarch);
1286 static int have_warned_stap_incomplete = 0;
1288 if (!have_warned_stap_incomplete)
1291 "The SystemTap SDT probe support is not fully implemented on this target;\n"
1292 "you will not be able to inspect the arguments of the probes.\n"
1293 "Please report a bug against GDB requesting a port to this target."));
1294 have_warned_stap_incomplete = 1;
1297 /* Marking the arguments as "already parsed". */
1298 m_have_parsed_args = true;
1302 gdb_assert (m_have_parsed_args);
1303 return m_parsed_args.size ();
1306 /* Return 1 if OP is a valid operator inside a probe argument, or zero
1310 stap_is_operator (const char *op)
1335 /* We didn't find any operator. */
1342 /* Implement the `can_evaluate_arguments' method. */
1345 stap_probe::can_evaluate_arguments () const
1347 struct gdbarch *gdbarch = this->get_gdbarch ();
1349 /* For SystemTap probes, we have to guarantee that the method
1350 stap_is_single_operand is defined on gdbarch. If it is not, then it
1351 means that argument evaluation is not implemented on this target. */
1352 return gdbarch_stap_is_single_operand_p (gdbarch);
1355 /* Evaluate the probe's argument N (indexed from 0), returning a value
1356 corresponding to it. Assertion is thrown if N does not exist. */
1359 stap_probe::evaluate_argument (unsigned n, struct frame_info *frame)
1361 struct stap_probe_arg *arg;
1363 struct gdbarch *gdbarch = get_frame_arch (frame);
1365 arg = this->get_arg_by_number (n, gdbarch);
1366 return evaluate_subexp_standard (arg->atype, arg->aexpr.get (), &pos,
1370 /* Compile the probe's argument N (indexed from 0) to agent expression.
1371 Assertion is thrown if N does not exist. */
1374 stap_probe::compile_to_ax (struct agent_expr *expr, struct axs_value *value,
1377 struct stap_probe_arg *arg;
1378 union exp_element *pc;
1380 arg = this->get_arg_by_number (n, expr->gdbarch);
1382 pc = arg->aexpr->elts;
1383 gen_expr (arg->aexpr.get (), &pc, expr, value);
1385 require_rvalue (expr, value);
1386 value->type = arg->atype;
1390 /* Set or clear a SystemTap semaphore. ADDRESS is the semaphore's
1391 address. SET is zero if the semaphore should be cleared, or one if
1392 it should be set. This is a helper function for
1393 'stap_probe::set_semaphore' and 'stap_probe::clear_semaphore'. */
1396 stap_modify_semaphore (CORE_ADDR address, int set, struct gdbarch *gdbarch)
1398 gdb_byte bytes[sizeof (LONGEST)];
1399 /* The ABI specifies "unsigned short". */
1400 struct type *type = builtin_type (gdbarch)->builtin_unsigned_short;
1406 /* Swallow errors. */
1407 if (target_read_memory (address, bytes, TYPE_LENGTH (type)) != 0)
1409 warning (_("Could not read the value of a SystemTap semaphore."));
1413 value = extract_unsigned_integer (bytes, TYPE_LENGTH (type),
1414 gdbarch_byte_order (gdbarch));
1415 /* Note that we explicitly don't worry about overflow or
1422 store_unsigned_integer (bytes, TYPE_LENGTH (type),
1423 gdbarch_byte_order (gdbarch), value);
1425 if (target_write_memory (address, bytes, TYPE_LENGTH (type)) != 0)
1426 warning (_("Could not write the value of a SystemTap semaphore."));
1429 /* Implementation of the 'set_semaphore' method.
1431 SystemTap semaphores act as reference counters, so calls to this
1432 function must be paired with calls to 'clear_semaphore'.
1434 This function and 'clear_semaphore' race with another tool
1435 changing the probes, but that is too rare to care. */
1438 stap_probe::set_semaphore (struct objfile *objfile, struct gdbarch *gdbarch)
1440 stap_modify_semaphore (relocate_address (m_sem_addr, objfile), 1, gdbarch);
1443 /* Implementation of the 'clear_semaphore' method. */
1446 stap_probe::clear_semaphore (struct objfile *objfile, struct gdbarch *gdbarch)
1448 stap_modify_semaphore (relocate_address (m_sem_addr, objfile), 0, gdbarch);
1451 /* Implementation of the 'get_static_ops' method. */
1453 const static_probe_ops *
1454 stap_probe::get_static_ops () const
1456 return &stap_static_probe_ops;
1459 /* Implementation of the 'gen_info_probes_table_values' method. */
1461 std::vector<const char *>
1462 stap_probe::gen_info_probes_table_values () const
1464 const char *val = NULL;
1466 if (m_sem_addr != 0)
1467 val = print_core_address (this->get_gdbarch (), m_sem_addr);
1469 return std::vector<const char *> { val };
1472 /* Helper function that parses the information contained in a
1473 SystemTap's probe. Basically, the information consists in:
1475 - Probe's PC address;
1476 - Link-time section address of `.stapsdt.base' section;
1477 - Link-time address of the semaphore variable, or ZERO if the
1478 probe doesn't have an associated semaphore;
1479 - Probe's provider name;
1481 - Probe's argument format
1483 This function returns 1 if the handling was successful, and zero
1487 handle_stap_probe (struct objfile *objfile, struct sdt_note *el,
1488 std::vector<probe *> *probesp, CORE_ADDR base)
1490 bfd *abfd = objfile->obfd;
1491 int size = bfd_get_arch_size (abfd) / 8;
1492 struct gdbarch *gdbarch = get_objfile_arch (objfile);
1493 struct type *ptr_type = builtin_type (gdbarch)->builtin_data_ptr;
1495 /* Provider and the name of the probe. */
1496 const char *provider = (const char *) &el->data[3 * size];
1497 const char *name = ((const char *)
1498 memchr (provider, '\0',
1499 (char *) el->data + el->size - provider));
1500 /* Making sure there is a name. */
1503 complaint (_("corrupt probe name when "
1505 objfile_name (objfile));
1507 /* There is no way to use a probe without a name or a provider, so
1508 returning zero here makes sense. */
1514 /* Retrieving the probe's address. */
1515 CORE_ADDR address = extract_typed_address (&el->data[0], ptr_type);
1517 /* Link-time sh_addr of `.stapsdt.base' section. */
1518 CORE_ADDR base_ref = extract_typed_address (&el->data[size], ptr_type);
1520 /* Semaphore address. */
1521 CORE_ADDR sem_addr = extract_typed_address (&el->data[2 * size], ptr_type);
1523 address += base - base_ref;
1525 sem_addr += base - base_ref;
1527 /* Arguments. We can only extract the argument format if there is a valid
1528 name for this probe. */
1529 const char *probe_args = ((const char*)
1531 (char *) el->data + el->size - name));
1533 if (probe_args != NULL)
1536 if (probe_args == NULL
1537 || (memchr (probe_args, '\0', (char *) el->data + el->size - name)
1538 != el->data + el->size - 1))
1540 complaint (_("corrupt probe argument when "
1542 objfile_name (objfile));
1543 /* If the argument string is NULL, it means some problem happened with
1544 it. So we return 0. */
1548 stap_probe *ret = new stap_probe (std::string (name), std::string (provider),
1549 address, gdbarch, sem_addr, probe_args);
1551 /* Successfully created probe. */
1552 probesp->push_back (ret);
1555 /* Helper function which tries to find the base address of the SystemTap
1556 base section named STAP_BASE_SECTION_NAME. */
1559 get_stap_base_address_1 (bfd *abfd, asection *sect, void *obj)
1561 asection **ret = (asection **) obj;
1563 if ((sect->flags & (SEC_DATA | SEC_ALLOC | SEC_HAS_CONTENTS))
1564 && sect->name && !strcmp (sect->name, STAP_BASE_SECTION_NAME))
1568 /* Helper function which iterates over every section in the BFD file,
1569 trying to find the base address of the SystemTap base section.
1570 Returns 1 if found (setting BASE to the proper value), zero otherwise. */
1573 get_stap_base_address (bfd *obfd, bfd_vma *base)
1575 asection *ret = NULL;
1577 bfd_map_over_sections (obfd, get_stap_base_address_1, (void *) &ret);
1581 complaint (_("could not obtain base address for "
1582 "SystemTap section on objfile `%s'."),
1593 /* Implementation of the 'is_linespec' method. */
1596 stap_static_probe_ops::is_linespec (const char **linespecp) const
1598 static const char *const keywords[] = { "-pstap", "-probe-stap", NULL };
1600 return probe_is_linespec_by_keyword (linespecp, keywords);
1603 /* Implementation of the 'get_probes' method. */
1606 stap_static_probe_ops::get_probes (std::vector<probe *> *probesp,
1607 struct objfile *objfile) const
1609 /* If we are here, then this is the first time we are parsing the
1610 SystemTap probe's information. We basically have to count how many
1611 probes the objfile has, and then fill in the necessary information
1613 bfd *obfd = objfile->obfd;
1615 struct sdt_note *iter;
1616 unsigned save_probesp_len = probesp->size ();
1618 if (objfile->separate_debug_objfile_backlink != NULL)
1620 /* This is a .debug file, not the objfile itself. */
1624 if (elf_tdata (obfd)->sdt_note_head == NULL)
1626 /* There isn't any probe here. */
1630 if (!get_stap_base_address (obfd, &base))
1632 /* There was an error finding the base address for the section.
1633 Just return NULL. */
1637 /* Parsing each probe's information. */
1638 for (iter = elf_tdata (obfd)->sdt_note_head;
1642 /* We first have to handle all the information about the
1643 probe which is present in the section. */
1644 handle_stap_probe (objfile, iter, probesp, base);
1647 if (save_probesp_len == probesp->size ())
1649 /* If we are here, it means we have failed to parse every known
1651 complaint (_("could not parse SystemTap probe(s) "
1657 /* Implementation of the type_name method. */
1660 stap_static_probe_ops::type_name () const
1665 /* Implementation of the 'gen_info_probes_table_header' method. */
1667 std::vector<struct info_probe_column>
1668 stap_static_probe_ops::gen_info_probes_table_header () const
1670 struct info_probe_column stap_probe_column;
1672 stap_probe_column.field_name = "semaphore";
1673 stap_probe_column.print_name = _("Semaphore");
1675 return std::vector<struct info_probe_column> { stap_probe_column };
1678 /* Implementation of the `info probes stap' command. */
1681 info_probes_stap_command (const char *arg, int from_tty)
1683 info_probes_for_spops (arg, from_tty, &stap_static_probe_ops);
1687 _initialize_stap_probe (void)
1689 all_static_probe_ops.push_back (&stap_static_probe_ops);
1691 add_setshow_zuinteger_cmd ("stap-expression", class_maintenance,
1692 &stap_expression_debug,
1693 _("Set SystemTap expression debugging."),
1694 _("Show SystemTap expression debugging."),
1695 _("When non-zero, the internal representation "
1696 "of SystemTap expressions will be printed."),
1698 show_stapexpressiondebug,
1699 &setdebuglist, &showdebuglist);
1701 add_cmd ("stap", class_info, info_probes_stap_command,
1703 Show information about SystemTap static probes.\n\
1704 Usage: info probes stap [PROVIDER [NAME [OBJECT]]]\n\
1705 Each argument is a regular expression, used to select probes.\n\
1706 PROVIDER matches probe provider names.\n\
1707 NAME matches the probe names.\n\
1708 OBJECT matches the executable or shared library name."),
1709 info_probes_cmdlist_get ());