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<std::unique_ptr<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, bool has_lhs,
261 enum stap_operand_prec prec);
263 static void stap_parse_argument_conditionally (struct stap_parse_info *p);
265 /* Returns true if *S is an operator, false otherwise. */
267 static bool 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. Return the EXP_OPCODE which
320 represents the operator detected, or throw an error if no operator
323 static enum exp_opcode
324 stap_get_opcode (const char **s)
379 op = BINOP_BITWISE_IOR;
383 op = BINOP_LOGICAL_OR;
388 op = BINOP_BITWISE_AND;
392 op = BINOP_LOGICAL_AND;
397 op = BINOP_BITWISE_XOR;
401 op = UNOP_LOGICAL_NOT;
413 gdb_assert (**s == '=');
418 error (_("Invalid opcode in expression `%s' for SystemTap"
425 /* Given the bitness of the argument, represented by B, return the
426 corresponding `struct type *', or throw an error if B is
430 stap_get_expected_argument_type (struct gdbarch *gdbarch,
431 enum stap_arg_bitness b,
432 const char *probe_name)
436 case STAP_ARG_BITNESS_UNDEFINED:
437 if (gdbarch_addr_bit (gdbarch) == 32)
438 return builtin_type (gdbarch)->builtin_uint32;
440 return builtin_type (gdbarch)->builtin_uint64;
442 case STAP_ARG_BITNESS_8BIT_UNSIGNED:
443 return builtin_type (gdbarch)->builtin_uint8;
445 case STAP_ARG_BITNESS_8BIT_SIGNED:
446 return builtin_type (gdbarch)->builtin_int8;
448 case STAP_ARG_BITNESS_16BIT_UNSIGNED:
449 return builtin_type (gdbarch)->builtin_uint16;
451 case STAP_ARG_BITNESS_16BIT_SIGNED:
452 return builtin_type (gdbarch)->builtin_int16;
454 case STAP_ARG_BITNESS_32BIT_SIGNED:
455 return builtin_type (gdbarch)->builtin_int32;
457 case STAP_ARG_BITNESS_32BIT_UNSIGNED:
458 return builtin_type (gdbarch)->builtin_uint32;
460 case STAP_ARG_BITNESS_64BIT_SIGNED:
461 return builtin_type (gdbarch)->builtin_int64;
463 case STAP_ARG_BITNESS_64BIT_UNSIGNED:
464 return builtin_type (gdbarch)->builtin_uint64;
467 error (_("Undefined bitness for probe '%s'."), probe_name);
472 /* Helper function to check for a generic list of prefixes. GDBARCH
473 is the current gdbarch being used. S is the expression being
474 analyzed. If R is not NULL, it will be used to return the found
475 prefix. PREFIXES is the list of expected prefixes.
477 This function does a case-insensitive match.
479 Return true if any prefix has been found, false otherwise. */
482 stap_is_generic_prefix (struct gdbarch *gdbarch, const char *s,
483 const char **r, const char *const *prefixes)
485 const char *const *p;
487 if (prefixes == NULL)
495 for (p = prefixes; *p != NULL; ++p)
496 if (strncasecmp (s, *p, strlen (*p)) == 0)
507 /* Return true if S points to a register prefix, false otherwise. For
508 a description of the arguments, look at stap_is_generic_prefix. */
511 stap_is_register_prefix (struct gdbarch *gdbarch, const char *s,
514 const char *const *t = gdbarch_stap_register_prefixes (gdbarch);
516 return stap_is_generic_prefix (gdbarch, s, r, t);
519 /* Return true if S points to a register indirection prefix, false
520 otherwise. For a description of the arguments, look at
521 stap_is_generic_prefix. */
524 stap_is_register_indirection_prefix (struct gdbarch *gdbarch, const char *s,
527 const char *const *t = gdbarch_stap_register_indirection_prefixes (gdbarch);
529 return stap_is_generic_prefix (gdbarch, s, r, t);
532 /* Return true if S points to an integer prefix, false otherwise. For
533 a description of the arguments, look at stap_is_generic_prefix.
535 This function takes care of analyzing whether we are dealing with
536 an expected integer prefix, or, if there is no integer prefix to be
537 expected, whether we are dealing with a digit. It does a
538 case-insensitive match. */
541 stap_is_integer_prefix (struct gdbarch *gdbarch, const char *s,
544 const char *const *t = gdbarch_stap_integer_prefixes (gdbarch);
545 const char *const *p;
549 /* A NULL value here means that integers do not have a prefix.
550 We just check for a digit then. */
554 return isdigit (*s) > 0;
557 for (p = t; *p != NULL; ++p)
559 size_t len = strlen (*p);
561 if ((len == 0 && isdigit (*s))
562 || (len > 0 && strncasecmp (s, *p, len) == 0))
564 /* Integers may or may not have a prefix. The "len == 0"
565 check covers the case when integers do not have a prefix
566 (therefore, we just check if we have a digit). The call
567 to "strncasecmp" covers the case when they have a
579 /* Helper function to check for a generic list of suffixes. If we are
580 not expecting any suffixes, then it just returns 1. If we are
581 expecting at least one suffix, then it returns true if a suffix has
582 been found, false otherwise. GDBARCH is the current gdbarch being
583 used. S is the expression being analyzed. If R is not NULL, it
584 will be used to return the found suffix. SUFFIXES is the list of
585 expected suffixes. This function does a case-insensitive
589 stap_generic_check_suffix (struct gdbarch *gdbarch, const char *s,
590 const char **r, const char *const *suffixes)
592 const char *const *p;
595 if (suffixes == NULL)
603 for (p = suffixes; *p != NULL; ++p)
604 if (strncasecmp (s, *p, strlen (*p)) == 0)
616 /* Return true if S points to an integer suffix, false otherwise. For
617 a description of the arguments, look at
618 stap_generic_check_suffix. */
621 stap_check_integer_suffix (struct gdbarch *gdbarch, const char *s,
624 const char *const *p = gdbarch_stap_integer_suffixes (gdbarch);
626 return stap_generic_check_suffix (gdbarch, s, r, p);
629 /* Return true if S points to a register suffix, false otherwise. For
630 a description of the arguments, look at
631 stap_generic_check_suffix. */
634 stap_check_register_suffix (struct gdbarch *gdbarch, const char *s,
637 const char *const *p = gdbarch_stap_register_suffixes (gdbarch);
639 return stap_generic_check_suffix (gdbarch, s, r, p);
642 /* Return true if S points to a register indirection suffix, false
643 otherwise. For a description of the arguments, look at
644 stap_generic_check_suffix. */
647 stap_check_register_indirection_suffix (struct gdbarch *gdbarch, const char *s,
650 const char *const *p = gdbarch_stap_register_indirection_suffixes (gdbarch);
652 return stap_generic_check_suffix (gdbarch, s, r, p);
655 /* Function responsible for parsing a register operand according to
656 SystemTap parlance. Assuming:
660 RIP = register indirection prefix
661 RIS = register indirection suffix
663 Then a register operand can be:
665 [RIP] [RP] REGISTER [RS] [RIS]
667 This function takes care of a register's indirection, displacement and
668 direct access. It also takes into consideration the fact that some
669 registers are named differently inside and outside GDB, e.g., PPC's
670 general-purpose registers are represented by integers in the assembly
671 language (e.g., `15' is the 15th general-purpose register), but inside
672 GDB they have a prefix (the letter `r') appended. */
675 stap_parse_register_operand (struct stap_parse_info *p)
677 /* Simple flag to indicate whether we have seen a minus signal before
679 bool got_minus = false;
680 /* Flags to indicate whether this register access is being displaced and/or
683 bool indirect_p = false;
684 struct gdbarch *gdbarch = p->gdbarch;
685 /* Needed to generate the register name as a part of an expression. */
687 /* Variables used to extract the register name from the probe's
692 const char *gdb_reg_prefix = gdbarch_stap_gdb_register_prefix (gdbarch);
693 int gdb_reg_prefix_len = gdb_reg_prefix ? strlen (gdb_reg_prefix) : 0;
694 const char *gdb_reg_suffix = gdbarch_stap_gdb_register_suffix (gdbarch);
695 int gdb_reg_suffix_len = gdb_reg_suffix ? strlen (gdb_reg_suffix) : 0;
696 const char *reg_prefix;
697 const char *reg_ind_prefix;
698 const char *reg_suffix;
699 const char *reg_ind_suffix;
701 /* Checking for a displacement argument. */
704 /* If it's a plus sign, we don't need to do anything, just advance the
715 if (isdigit (*p->arg))
717 /* The value of the displacement. */
722 displacement = strtol (p->arg, &endp, 10);
725 /* Generating the expression for the displacement. */
726 write_exp_elt_opcode (&p->pstate, OP_LONG);
727 write_exp_elt_type (&p->pstate, builtin_type (gdbarch)->builtin_long);
728 write_exp_elt_longcst (&p->pstate, displacement);
729 write_exp_elt_opcode (&p->pstate, OP_LONG);
731 write_exp_elt_opcode (&p->pstate, UNOP_NEG);
734 /* Getting rid of register indirection prefix. */
735 if (stap_is_register_indirection_prefix (gdbarch, p->arg, ®_ind_prefix))
738 p->arg += strlen (reg_ind_prefix);
741 if (disp_p && !indirect_p)
742 error (_("Invalid register displacement syntax on expression `%s'."),
745 /* Getting rid of register prefix. */
746 if (stap_is_register_prefix (gdbarch, p->arg, ®_prefix))
747 p->arg += strlen (reg_prefix);
749 /* Now we should have only the register name. Let's extract it and get
750 the associated number. */
753 /* We assume the register name is composed by letters and numbers. */
754 while (isalnum (*p->arg))
757 len = p->arg - start;
759 regname = (char *) alloca (len + gdb_reg_prefix_len + gdb_reg_suffix_len + 1);
762 /* We only add the GDB's register prefix/suffix if we are dealing with
763 a numeric register. */
764 if (gdb_reg_prefix && isdigit (*start))
766 strncpy (regname, gdb_reg_prefix, gdb_reg_prefix_len);
767 strncpy (regname + gdb_reg_prefix_len, start, len);
770 strncpy (regname + gdb_reg_prefix_len + len,
771 gdb_reg_suffix, gdb_reg_suffix_len);
773 len += gdb_reg_prefix_len + gdb_reg_suffix_len;
776 strncpy (regname, start, len);
780 /* Is this a valid register name? */
781 if (user_reg_map_name_to_regnum (gdbarch, regname, len) == -1)
782 error (_("Invalid register name `%s' on expression `%s'."),
783 regname, p->saved_arg);
785 write_exp_elt_opcode (&p->pstate, OP_REGISTER);
788 write_exp_string (&p->pstate, str);
789 write_exp_elt_opcode (&p->pstate, OP_REGISTER);
794 write_exp_elt_opcode (&p->pstate, BINOP_ADD);
796 /* Casting to the expected type. */
797 write_exp_elt_opcode (&p->pstate, UNOP_CAST);
798 write_exp_elt_type (&p->pstate, lookup_pointer_type (p->arg_type));
799 write_exp_elt_opcode (&p->pstate, UNOP_CAST);
801 write_exp_elt_opcode (&p->pstate, UNOP_IND);
804 /* Getting rid of the register name suffix. */
805 if (stap_check_register_suffix (gdbarch, p->arg, ®_suffix))
806 p->arg += strlen (reg_suffix);
808 error (_("Missing register name suffix on expression `%s'."),
811 /* Getting rid of the register indirection suffix. */
814 if (stap_check_register_indirection_suffix (gdbarch, p->arg,
816 p->arg += strlen (reg_ind_suffix);
818 error (_("Missing indirection suffix on expression `%s'."),
823 /* This function is responsible for parsing a single operand.
825 A single operand can be:
827 - an unary operation (e.g., `-5', `~2', or even with subexpressions
829 - a register displacement, which will be treated as a register
830 operand (e.g., `-4(%eax)' on x86)
831 - a numeric constant, or
832 - a register operand (see function `stap_parse_register_operand')
834 The function also calls special-handling functions to deal with
835 unrecognized operands, allowing arch-specific parsers to be
839 stap_parse_single_operand (struct stap_parse_info *p)
841 struct gdbarch *gdbarch = p->gdbarch;
842 const char *int_prefix = NULL;
844 /* We first try to parse this token as a "special token". */
845 if (gdbarch_stap_parse_special_token_p (gdbarch))
846 if (gdbarch_stap_parse_special_token (gdbarch, p) != 0)
848 /* If the return value of the above function is not zero,
849 it means it successfully parsed the special token.
851 If it is NULL, we try to parse it using our method. */
855 if (*p->arg == '-' || *p->arg == '~' || *p->arg == '+')
858 /* We use this variable to do a lookahead. */
859 const char *tmp = p->arg;
860 bool has_digit = false;
862 /* Skipping signal. */
865 /* This is an unary operation. Here is a list of allowed tokens
869 - number (from register displacement)
870 - subexpression (beginning with `(')
872 We handle the register displacement here, and the other cases
874 if (p->inside_paren_p)
875 tmp = skip_spaces (tmp);
877 while (isdigit (*tmp))
879 /* We skip the digit here because we are only interested in
880 knowing what kind of unary operation this is. The digit
881 will be handled by one of the functions that will be
882 called below ('stap_parse_argument_conditionally' or
883 'stap_parse_register_operand'). */
888 if (has_digit && stap_is_register_indirection_prefix (gdbarch, tmp,
891 /* If we are here, it means it is a displacement. The only
892 operations allowed here are `-' and `+'. */
894 error (_("Invalid operator `%c' for register displacement "
895 "on expression `%s'."), c, p->saved_arg);
897 stap_parse_register_operand (p);
901 /* This is not a displacement. We skip the operator, and
902 deal with it when the recursion returns. */
904 stap_parse_argument_conditionally (p);
906 write_exp_elt_opcode (&p->pstate, UNOP_NEG);
908 write_exp_elt_opcode (&p->pstate, UNOP_COMPLEMENT);
911 else if (isdigit (*p->arg))
913 /* A temporary variable, needed for lookahead. */
914 const char *tmp = p->arg;
918 /* We can be dealing with a numeric constant, or with a register
920 number = strtol (tmp, &endp, 10);
923 if (p->inside_paren_p)
924 tmp = skip_spaces (tmp);
926 /* If "stap_is_integer_prefix" returns true, it means we can
927 accept integers without a prefix here. But we also need to
928 check whether the next token (i.e., "tmp") is not a register
929 indirection prefix. */
930 if (stap_is_integer_prefix (gdbarch, p->arg, NULL)
931 && !stap_is_register_indirection_prefix (gdbarch, tmp, NULL))
933 const char *int_suffix;
935 /* We are dealing with a numeric constant. */
936 write_exp_elt_opcode (&p->pstate, OP_LONG);
937 write_exp_elt_type (&p->pstate,
938 builtin_type (gdbarch)->builtin_long);
939 write_exp_elt_longcst (&p->pstate, number);
940 write_exp_elt_opcode (&p->pstate, OP_LONG);
944 if (stap_check_integer_suffix (gdbarch, p->arg, &int_suffix))
945 p->arg += strlen (int_suffix);
947 error (_("Invalid constant suffix on expression `%s'."),
950 else if (stap_is_register_indirection_prefix (gdbarch, tmp, NULL))
951 stap_parse_register_operand (p);
953 error (_("Unknown numeric token on expression `%s'."),
956 else if (stap_is_integer_prefix (gdbarch, p->arg, &int_prefix))
958 /* We are dealing with a numeric constant. */
961 const char *int_suffix;
963 p->arg += strlen (int_prefix);
964 number = strtol (p->arg, &endp, 10);
967 write_exp_elt_opcode (&p->pstate, OP_LONG);
968 write_exp_elt_type (&p->pstate, builtin_type (gdbarch)->builtin_long);
969 write_exp_elt_longcst (&p->pstate, number);
970 write_exp_elt_opcode (&p->pstate, OP_LONG);
972 if (stap_check_integer_suffix (gdbarch, p->arg, &int_suffix))
973 p->arg += strlen (int_suffix);
975 error (_("Invalid constant suffix on expression `%s'."),
978 else if (stap_is_register_prefix (gdbarch, p->arg, NULL)
979 || stap_is_register_indirection_prefix (gdbarch, p->arg, NULL))
980 stap_parse_register_operand (p);
982 error (_("Operator `%c' not recognized on expression `%s'."),
983 *p->arg, p->saved_arg);
986 /* This function parses an argument conditionally, based on single or
987 non-single operands. A non-single operand would be a parenthesized
988 expression (e.g., `(2 + 1)'), and a single operand is anything that
989 starts with `-', `~', `+' (i.e., unary operators), a digit, or
990 something recognized by `gdbarch_stap_is_single_operand'. */
993 stap_parse_argument_conditionally (struct stap_parse_info *p)
995 gdb_assert (gdbarch_stap_is_single_operand_p (p->gdbarch));
997 if (*p->arg == '-' || *p->arg == '~' || *p->arg == '+' /* Unary. */
999 || gdbarch_stap_is_single_operand (p->gdbarch, p->arg))
1000 stap_parse_single_operand (p);
1001 else if (*p->arg == '(')
1003 /* We are dealing with a parenthesized operand. It means we
1004 have to parse it as it was a separate expression, without
1005 left-side or precedence. */
1007 p->arg = skip_spaces (p->arg);
1008 ++p->inside_paren_p;
1010 stap_parse_argument_1 (p, 0, STAP_OPERAND_PREC_NONE);
1012 --p->inside_paren_p;
1014 error (_("Missign close-paren on expression `%s'."),
1018 if (p->inside_paren_p)
1019 p->arg = skip_spaces (p->arg);
1022 error (_("Cannot parse expression `%s'."), p->saved_arg);
1025 /* Helper function for `stap_parse_argument'. Please, see its comments to
1026 better understand what this function does. */
1029 stap_parse_argument_1 (struct stap_parse_info *p, bool has_lhs,
1030 enum stap_operand_prec prec)
1032 /* This is an operator-precedence parser.
1034 We work with left- and right-sides of expressions, and
1035 parse them depending on the precedence of the operators
1038 gdb_assert (p->arg != NULL);
1040 if (p->inside_paren_p)
1041 p->arg = skip_spaces (p->arg);
1045 /* We were called without a left-side, either because this is the
1046 first call, or because we were called to parse a parenthesized
1047 expression. It doesn't really matter; we have to parse the
1048 left-side in order to continue the process. */
1049 stap_parse_argument_conditionally (p);
1052 /* Start to parse the right-side, and to "join" left and right sides
1053 depending on the operation specified.
1055 This loop shall continue until we run out of characters in the input,
1056 or until we find a close-parenthesis, which means that we've reached
1057 the end of a sub-expression. */
1058 while (*p->arg != '\0' && *p->arg != ')' && !isspace (*p->arg))
1060 const char *tmp_exp_buf;
1061 enum exp_opcode opcode;
1062 enum stap_operand_prec cur_prec;
1064 if (!stap_is_operator (p->arg))
1065 error (_("Invalid operator `%c' on expression `%s'."), *p->arg,
1068 /* We have to save the current value of the expression buffer because
1069 the `stap_get_opcode' modifies it in order to get the current
1070 operator. If this operator's precedence is lower than PREC, we
1071 should return and not advance the expression buffer pointer. */
1072 tmp_exp_buf = p->arg;
1073 opcode = stap_get_opcode (&tmp_exp_buf);
1075 cur_prec = stap_get_operator_prec (opcode);
1076 if (cur_prec < prec)
1078 /* If the precedence of the operator that we are seeing now is
1079 lower than the precedence of the first operator seen before
1080 this parsing process began, it means we should stop parsing
1085 p->arg = tmp_exp_buf;
1086 if (p->inside_paren_p)
1087 p->arg = skip_spaces (p->arg);
1089 /* Parse the right-side of the expression. */
1090 stap_parse_argument_conditionally (p);
1092 /* While we still have operators, try to parse another
1093 right-side, but using the current right-side as a left-side. */
1094 while (*p->arg != '\0' && stap_is_operator (p->arg))
1096 enum exp_opcode lookahead_opcode;
1097 enum stap_operand_prec lookahead_prec;
1099 /* Saving the current expression buffer position. The explanation
1100 is the same as above. */
1101 tmp_exp_buf = p->arg;
1102 lookahead_opcode = stap_get_opcode (&tmp_exp_buf);
1103 lookahead_prec = stap_get_operator_prec (lookahead_opcode);
1105 if (lookahead_prec <= prec)
1107 /* If we are dealing with an operator whose precedence is lower
1108 than the first one, just abandon the attempt. */
1112 /* Parse the right-side of the expression, but since we already
1113 have a left-side at this point, set `has_lhs' to 1. */
1114 stap_parse_argument_1 (p, 1, lookahead_prec);
1117 write_exp_elt_opcode (&p->pstate, opcode);
1121 /* Parse a probe's argument.
1125 LP = literal integer prefix
1126 LS = literal integer suffix
1128 RP = register prefix
1129 RS = register suffix
1131 RIP = register indirection prefix
1132 RIS = register indirection suffix
1134 This routine assumes that arguments' tokens are of the form:
1137 - [RP] REGISTER [RS]
1138 - [RIP] [RP] REGISTER [RS] [RIS]
1139 - If we find a number without LP, we try to parse it as a literal integer
1140 constant (if LP == NULL), or as a register displacement.
1141 - We count parenthesis, and only skip whitespaces if we are inside them.
1142 - If we find an operator, we skip it.
1144 This function can also call a special function that will try to match
1145 unknown tokens. It will return the expression_up generated from
1146 parsing the argument. */
1148 static expression_up
1149 stap_parse_argument (const char **arg, struct type *atype,
1150 struct gdbarch *gdbarch)
1152 /* We need to initialize the expression buffer, in order to begin
1153 our parsing efforts. We use language_c here because we may need
1154 to do pointer arithmetics. */
1155 struct stap_parse_info p (*arg, atype, language_def (language_c),
1158 stap_parse_argument_1 (&p, 0, STAP_OPERAND_PREC_NONE);
1160 gdb_assert (p.inside_paren_p == 0);
1162 /* Casting the final expression to the appropriate type. */
1163 write_exp_elt_opcode (&p.pstate, UNOP_CAST);
1164 write_exp_elt_type (&p.pstate, atype);
1165 write_exp_elt_opcode (&p.pstate, UNOP_CAST);
1167 p.arg = skip_spaces (p.arg);
1170 return p.pstate.release ();
1173 /* Implementation of 'parse_arguments' method. */
1176 stap_probe::parse_arguments (struct gdbarch *gdbarch)
1180 gdb_assert (!m_have_parsed_args);
1181 cur = m_unparsed_args_text;
1182 m_have_parsed_args = true;
1184 if (cur == NULL || *cur == '\0' || *cur == ':')
1187 while (*cur != '\0')
1189 enum stap_arg_bitness bitness;
1190 bool got_minus = false;
1192 /* We expect to find something like:
1196 Where `N' can be [+,-][1,2,4,8]. This is not mandatory, so
1197 we check it here. If we don't find it, go to the next
1199 if ((cur[0] == '-' && isdigit (cur[1]) && cur[2] == '@')
1200 || (isdigit (cur[0]) && cur[1] == '@'))
1204 /* Discard the `-'. */
1209 /* Defining the bitness. */
1213 bitness = (got_minus ? STAP_ARG_BITNESS_8BIT_SIGNED
1214 : STAP_ARG_BITNESS_8BIT_UNSIGNED);
1218 bitness = (got_minus ? STAP_ARG_BITNESS_16BIT_SIGNED
1219 : STAP_ARG_BITNESS_16BIT_UNSIGNED);
1223 bitness = (got_minus ? STAP_ARG_BITNESS_32BIT_SIGNED
1224 : STAP_ARG_BITNESS_32BIT_UNSIGNED);
1228 bitness = (got_minus ? STAP_ARG_BITNESS_64BIT_SIGNED
1229 : STAP_ARG_BITNESS_64BIT_UNSIGNED);
1234 /* We have an error, because we don't expect anything
1235 except 1, 2, 4 and 8. */
1236 warning (_("unrecognized bitness %s%c' for probe `%s'"),
1237 got_minus ? "`-" : "`", *cur,
1238 this->get_name ().c_str ());
1242 /* Discard the number and the `@' sign. */
1246 bitness = STAP_ARG_BITNESS_UNDEFINED;
1249 = stap_get_expected_argument_type (gdbarch, bitness,
1250 this->get_name ().c_str ());
1252 expression_up expr = stap_parse_argument (&cur, atype, gdbarch);
1254 if (stap_expression_debug)
1255 dump_raw_expression (expr.get (), gdb_stdlog,
1256 "before conversion to prefix form");
1258 prefixify_expression (expr.get ());
1260 if (stap_expression_debug)
1261 dump_prefix_expression (expr.get (), gdb_stdlog);
1263 m_parsed_args.emplace_back (bitness, atype, std::move (expr));
1265 /* Start it over again. */
1266 cur = skip_spaces (cur);
1270 /* Helper function to relocate an address. */
1273 relocate_address (CORE_ADDR address, struct objfile *objfile)
1275 return address + ANOFFSET (objfile->section_offsets,
1276 SECT_OFF_DATA (objfile));
1279 /* Implementation of the get_relocated_address method. */
1282 stap_probe::get_relocated_address (struct objfile *objfile)
1284 return relocate_address (this->get_address (), objfile);
1287 /* Given PROBE, returns the number of arguments present in that probe's
1291 stap_probe::get_argument_count (struct frame_info *frame)
1293 struct gdbarch *gdbarch = get_frame_arch (frame);
1295 if (!m_have_parsed_args)
1297 if (this->can_evaluate_arguments ())
1298 this->parse_arguments (gdbarch);
1301 static bool have_warned_stap_incomplete = false;
1303 if (!have_warned_stap_incomplete)
1306 "The SystemTap SDT probe support is not fully implemented on this target;\n"
1307 "you will not be able to inspect the arguments of the probes.\n"
1308 "Please report a bug against GDB requesting a port to this target."));
1309 have_warned_stap_incomplete = true;
1312 /* Marking the arguments as "already parsed". */
1313 m_have_parsed_args = true;
1317 gdb_assert (m_have_parsed_args);
1318 return m_parsed_args.size ();
1321 /* Return true if OP is a valid operator inside a probe argument, or
1325 stap_is_operator (const char *op)
1350 /* We didn't find any operator. */
1357 /* Implement the `can_evaluate_arguments' method. */
1360 stap_probe::can_evaluate_arguments () const
1362 struct gdbarch *gdbarch = this->get_gdbarch ();
1364 /* For SystemTap probes, we have to guarantee that the method
1365 stap_is_single_operand is defined on gdbarch. If it is not, then it
1366 means that argument evaluation is not implemented on this target. */
1367 return gdbarch_stap_is_single_operand_p (gdbarch);
1370 /* Evaluate the probe's argument N (indexed from 0), returning a value
1371 corresponding to it. Assertion is thrown if N does not exist. */
1374 stap_probe::evaluate_argument (unsigned n, struct frame_info *frame)
1376 struct stap_probe_arg *arg;
1378 struct gdbarch *gdbarch = get_frame_arch (frame);
1380 arg = this->get_arg_by_number (n, gdbarch);
1381 return evaluate_subexp_standard (arg->atype, arg->aexpr.get (), &pos,
1385 /* Compile the probe's argument N (indexed from 0) to agent expression.
1386 Assertion is thrown if N does not exist. */
1389 stap_probe::compile_to_ax (struct agent_expr *expr, struct axs_value *value,
1392 struct stap_probe_arg *arg;
1393 union exp_element *pc;
1395 arg = this->get_arg_by_number (n, expr->gdbarch);
1397 pc = arg->aexpr->elts;
1398 gen_expr (arg->aexpr.get (), &pc, expr, value);
1400 require_rvalue (expr, value);
1401 value->type = arg->atype;
1405 /* Set or clear a SystemTap semaphore. ADDRESS is the semaphore's
1406 address. SET is zero if the semaphore should be cleared, or one if
1407 it should be set. This is a helper function for
1408 'stap_probe::set_semaphore' and 'stap_probe::clear_semaphore'. */
1411 stap_modify_semaphore (CORE_ADDR address, int set, struct gdbarch *gdbarch)
1413 gdb_byte bytes[sizeof (LONGEST)];
1414 /* The ABI specifies "unsigned short". */
1415 struct type *type = builtin_type (gdbarch)->builtin_unsigned_short;
1421 /* Swallow errors. */
1422 if (target_read_memory (address, bytes, TYPE_LENGTH (type)) != 0)
1424 warning (_("Could not read the value of a SystemTap semaphore."));
1428 value = extract_unsigned_integer (bytes, TYPE_LENGTH (type),
1429 gdbarch_byte_order (gdbarch));
1430 /* Note that we explicitly don't worry about overflow or
1437 store_unsigned_integer (bytes, TYPE_LENGTH (type),
1438 gdbarch_byte_order (gdbarch), value);
1440 if (target_write_memory (address, bytes, TYPE_LENGTH (type)) != 0)
1441 warning (_("Could not write the value of a SystemTap semaphore."));
1444 /* Implementation of the 'set_semaphore' method.
1446 SystemTap semaphores act as reference counters, so calls to this
1447 function must be paired with calls to 'clear_semaphore'.
1449 This function and 'clear_semaphore' race with another tool
1450 changing the probes, but that is too rare to care. */
1453 stap_probe::set_semaphore (struct objfile *objfile, struct gdbarch *gdbarch)
1455 stap_modify_semaphore (relocate_address (m_sem_addr, objfile), 1, gdbarch);
1458 /* Implementation of the 'clear_semaphore' method. */
1461 stap_probe::clear_semaphore (struct objfile *objfile, struct gdbarch *gdbarch)
1463 stap_modify_semaphore (relocate_address (m_sem_addr, objfile), 0, gdbarch);
1466 /* Implementation of the 'get_static_ops' method. */
1468 const static_probe_ops *
1469 stap_probe::get_static_ops () const
1471 return &stap_static_probe_ops;
1474 /* Implementation of the 'gen_info_probes_table_values' method. */
1476 std::vector<const char *>
1477 stap_probe::gen_info_probes_table_values () const
1479 const char *val = NULL;
1481 if (m_sem_addr != 0)
1482 val = print_core_address (this->get_gdbarch (), m_sem_addr);
1484 return std::vector<const char *> { val };
1487 /* Helper function that parses the information contained in a
1488 SystemTap's probe. Basically, the information consists in:
1490 - Probe's PC address;
1491 - Link-time section address of `.stapsdt.base' section;
1492 - Link-time address of the semaphore variable, or ZERO if the
1493 probe doesn't have an associated semaphore;
1494 - Probe's provider name;
1496 - Probe's argument format. */
1499 handle_stap_probe (struct objfile *objfile, struct sdt_note *el,
1500 std::vector<std::unique_ptr<probe>> *probesp,
1503 bfd *abfd = objfile->obfd;
1504 int size = bfd_get_arch_size (abfd) / 8;
1505 struct gdbarch *gdbarch = get_objfile_arch (objfile);
1506 struct type *ptr_type = builtin_type (gdbarch)->builtin_data_ptr;
1508 /* Provider and the name of the probe. */
1509 const char *provider = (const char *) &el->data[3 * size];
1510 const char *name = ((const char *)
1511 memchr (provider, '\0',
1512 (char *) el->data + el->size - provider));
1513 /* Making sure there is a name. */
1516 complaint (_("corrupt probe name when "
1518 objfile_name (objfile));
1520 /* There is no way to use a probe without a name or a provider, so
1521 returning zero here makes sense. */
1527 /* Retrieving the probe's address. */
1528 CORE_ADDR address = extract_typed_address (&el->data[0], ptr_type);
1530 /* Link-time sh_addr of `.stapsdt.base' section. */
1531 CORE_ADDR base_ref = extract_typed_address (&el->data[size], ptr_type);
1533 /* Semaphore address. */
1534 CORE_ADDR sem_addr = extract_typed_address (&el->data[2 * size], ptr_type);
1536 address += base - base_ref;
1538 sem_addr += base - base_ref;
1540 /* Arguments. We can only extract the argument format if there is a valid
1541 name for this probe. */
1542 const char *probe_args = ((const char*)
1544 (char *) el->data + el->size - name));
1546 if (probe_args != NULL)
1549 if (probe_args == NULL
1550 || (memchr (probe_args, '\0', (char *) el->data + el->size - name)
1551 != el->data + el->size - 1))
1553 complaint (_("corrupt probe argument when "
1555 objfile_name (objfile));
1556 /* If the argument string is NULL, it means some problem happened with
1557 it. So we return 0. */
1561 stap_probe *ret = new stap_probe (std::string (name), std::string (provider),
1562 address, gdbarch, sem_addr, probe_args);
1564 /* Successfully created probe. */
1565 probesp->emplace_back (ret);
1568 /* Helper function which tries to find the base address of the SystemTap
1569 base section named STAP_BASE_SECTION_NAME. */
1572 get_stap_base_address_1 (bfd *abfd, asection *sect, void *obj)
1574 asection **ret = (asection **) obj;
1576 if ((sect->flags & (SEC_DATA | SEC_ALLOC | SEC_HAS_CONTENTS))
1577 && sect->name && !strcmp (sect->name, STAP_BASE_SECTION_NAME))
1581 /* Helper function which iterates over every section in the BFD file,
1582 trying to find the base address of the SystemTap base section.
1583 Returns 1 if found (setting BASE to the proper value), zero otherwise. */
1586 get_stap_base_address (bfd *obfd, bfd_vma *base)
1588 asection *ret = NULL;
1590 bfd_map_over_sections (obfd, get_stap_base_address_1, (void *) &ret);
1594 complaint (_("could not obtain base address for "
1595 "SystemTap section on objfile `%s'."),
1606 /* Implementation of the 'is_linespec' method. */
1609 stap_static_probe_ops::is_linespec (const char **linespecp) const
1611 static const char *const keywords[] = { "-pstap", "-probe-stap", NULL };
1613 return probe_is_linespec_by_keyword (linespecp, keywords);
1616 /* Implementation of the 'get_probes' method. */
1619 stap_static_probe_ops::get_probes
1620 (std::vector<std::unique_ptr<probe>> *probesp,
1621 struct objfile *objfile) const
1623 /* If we are here, then this is the first time we are parsing the
1624 SystemTap probe's information. We basically have to count how many
1625 probes the objfile has, and then fill in the necessary information
1627 bfd *obfd = objfile->obfd;
1629 struct sdt_note *iter;
1630 unsigned save_probesp_len = probesp->size ();
1632 if (objfile->separate_debug_objfile_backlink != NULL)
1634 /* This is a .debug file, not the objfile itself. */
1638 if (elf_tdata (obfd)->sdt_note_head == NULL)
1640 /* There isn't any probe here. */
1644 if (!get_stap_base_address (obfd, &base))
1646 /* There was an error finding the base address for the section.
1647 Just return NULL. */
1651 /* Parsing each probe's information. */
1652 for (iter = elf_tdata (obfd)->sdt_note_head;
1656 /* We first have to handle all the information about the
1657 probe which is present in the section. */
1658 handle_stap_probe (objfile, iter, probesp, base);
1661 if (save_probesp_len == probesp->size ())
1663 /* If we are here, it means we have failed to parse every known
1665 complaint (_("could not parse SystemTap probe(s) "
1671 /* Implementation of the type_name method. */
1674 stap_static_probe_ops::type_name () const
1679 /* Implementation of the 'gen_info_probes_table_header' method. */
1681 std::vector<struct info_probe_column>
1682 stap_static_probe_ops::gen_info_probes_table_header () const
1684 struct info_probe_column stap_probe_column;
1686 stap_probe_column.field_name = "semaphore";
1687 stap_probe_column.print_name = _("Semaphore");
1689 return std::vector<struct info_probe_column> { stap_probe_column };
1692 /* Implementation of the `info probes stap' command. */
1695 info_probes_stap_command (const char *arg, int from_tty)
1697 info_probes_for_spops (arg, from_tty, &stap_static_probe_ops);
1701 _initialize_stap_probe (void)
1703 all_static_probe_ops.push_back (&stap_static_probe_ops);
1705 add_setshow_zuinteger_cmd ("stap-expression", class_maintenance,
1706 &stap_expression_debug,
1707 _("Set SystemTap expression debugging."),
1708 _("Show SystemTap expression debugging."),
1709 _("When non-zero, the internal representation "
1710 "of SystemTap expressions will be printed."),
1712 show_stapexpressiondebug,
1713 &setdebuglist, &showdebuglist);
1715 add_cmd ("stap", class_info, info_probes_stap_command,
1717 Show information about SystemTap static probes.\n\
1718 Usage: info probes stap [PROVIDER [NAME [OBJECT]]]\n\
1719 Each argument is a regular expression, used to select probes.\n\
1720 PROVIDER matches probe provider names.\n\
1721 NAME matches the probe names.\n\
1722 OBJECT matches the executable or shared library name."),
1723 info_probes_cmdlist_get ());