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 int regnum = user_reg_map_name_to_regnum (gdbarch, regname.c_str (),
766 /* Is this a valid register name? */
768 error (_("Invalid register name `%s' on expression `%s'."),
769 regname.c_str (), p->saved_arg);
771 /* Check if there's any special treatment that the arch-specific
772 code would like to perform on the register name. */
773 if (gdbarch_stap_adjust_register_p (gdbarch))
775 std::string oldregname = regname;
777 gdbarch_stap_adjust_register (gdbarch, p, regname, regnum);
779 if (regname != oldregname)
781 /* This is just a check we perform to make sure that the
782 arch-dependent code has provided us with a valid
784 regnum = user_reg_map_name_to_regnum (gdbarch, regname.c_str (),
788 internal_error (__FILE__, __LINE__,
789 _("Invalid register name '%s' after replacing it"
790 " (previous name was '%s')"),
791 regname.c_str (), oldregname.c_str ());
795 write_exp_elt_opcode (&p->pstate, OP_REGISTER);
796 str.ptr = regname.c_str ();
797 str.length = regname.size ();
798 write_exp_string (&p->pstate, str);
799 write_exp_elt_opcode (&p->pstate, OP_REGISTER);
804 write_exp_elt_opcode (&p->pstate, BINOP_ADD);
806 /* Casting to the expected type. */
807 write_exp_elt_opcode (&p->pstate, UNOP_CAST);
808 write_exp_elt_type (&p->pstate, lookup_pointer_type (p->arg_type));
809 write_exp_elt_opcode (&p->pstate, UNOP_CAST);
811 write_exp_elt_opcode (&p->pstate, UNOP_IND);
814 /* Getting rid of the register name suffix. */
815 if (stap_check_register_suffix (gdbarch, p->arg, ®_suffix))
816 p->arg += strlen (reg_suffix);
818 error (_("Missing register name suffix on expression `%s'."),
821 /* Getting rid of the register indirection suffix. */
824 if (stap_check_register_indirection_suffix (gdbarch, p->arg,
826 p->arg += strlen (reg_ind_suffix);
828 error (_("Missing indirection suffix on expression `%s'."),
833 /* This function is responsible for parsing a single operand.
835 A single operand can be:
837 - an unary operation (e.g., `-5', `~2', or even with subexpressions
839 - a register displacement, which will be treated as a register
840 operand (e.g., `-4(%eax)' on x86)
841 - a numeric constant, or
842 - a register operand (see function `stap_parse_register_operand')
844 The function also calls special-handling functions to deal with
845 unrecognized operands, allowing arch-specific parsers to be
849 stap_parse_single_operand (struct stap_parse_info *p)
851 struct gdbarch *gdbarch = p->gdbarch;
852 const char *int_prefix = NULL;
854 /* We first try to parse this token as a "special token". */
855 if (gdbarch_stap_parse_special_token_p (gdbarch))
856 if (gdbarch_stap_parse_special_token (gdbarch, p) != 0)
858 /* If the return value of the above function is not zero,
859 it means it successfully parsed the special token.
861 If it is NULL, we try to parse it using our method. */
865 if (*p->arg == '-' || *p->arg == '~' || *p->arg == '+')
868 /* We use this variable to do a lookahead. */
869 const char *tmp = p->arg;
872 /* Skipping signal. */
875 /* This is an unary operation. Here is a list of allowed tokens
879 - number (from register displacement)
880 - subexpression (beginning with `(')
882 We handle the register displacement here, and the other cases
884 if (p->inside_paren_p)
885 tmp = skip_spaces (tmp);
887 while (isdigit (*tmp))
889 /* We skip the digit here because we are only interested in
890 knowing what kind of unary operation this is. The digit
891 will be handled by one of the functions that will be
892 called below ('stap_parse_argument_conditionally' or
893 'stap_parse_register_operand'). */
898 if (has_digit && stap_is_register_indirection_prefix (gdbarch, tmp,
901 /* If we are here, it means it is a displacement. The only
902 operations allowed here are `-' and `+'. */
904 error (_("Invalid operator `%c' for register displacement "
905 "on expression `%s'."), c, p->saved_arg);
907 stap_parse_register_operand (p);
911 /* This is not a displacement. We skip the operator, and
912 deal with it when the recursion returns. */
914 stap_parse_argument_conditionally (p);
916 write_exp_elt_opcode (&p->pstate, UNOP_NEG);
918 write_exp_elt_opcode (&p->pstate, UNOP_COMPLEMENT);
921 else if (isdigit (*p->arg))
923 /* A temporary variable, needed for lookahead. */
924 const char *tmp = p->arg;
928 /* We can be dealing with a numeric constant, or with a register
930 number = strtol (tmp, &endp, 10);
933 if (p->inside_paren_p)
934 tmp = skip_spaces (tmp);
936 /* If "stap_is_integer_prefix" returns true, it means we can
937 accept integers without a prefix here. But we also need to
938 check whether the next token (i.e., "tmp") is not a register
939 indirection prefix. */
940 if (stap_is_integer_prefix (gdbarch, p->arg, NULL)
941 && !stap_is_register_indirection_prefix (gdbarch, tmp, NULL))
943 const char *int_suffix;
945 /* We are dealing with a numeric constant. */
946 write_exp_elt_opcode (&p->pstate, OP_LONG);
947 write_exp_elt_type (&p->pstate,
948 builtin_type (gdbarch)->builtin_long);
949 write_exp_elt_longcst (&p->pstate, number);
950 write_exp_elt_opcode (&p->pstate, OP_LONG);
954 if (stap_check_integer_suffix (gdbarch, p->arg, &int_suffix))
955 p->arg += strlen (int_suffix);
957 error (_("Invalid constant suffix on expression `%s'."),
960 else if (stap_is_register_indirection_prefix (gdbarch, tmp, NULL))
961 stap_parse_register_operand (p);
963 error (_("Unknown numeric token on expression `%s'."),
966 else if (stap_is_integer_prefix (gdbarch, p->arg, &int_prefix))
968 /* We are dealing with a numeric constant. */
971 const char *int_suffix;
973 p->arg += strlen (int_prefix);
974 number = strtol (p->arg, &endp, 10);
977 write_exp_elt_opcode (&p->pstate, OP_LONG);
978 write_exp_elt_type (&p->pstate, builtin_type (gdbarch)->builtin_long);
979 write_exp_elt_longcst (&p->pstate, number);
980 write_exp_elt_opcode (&p->pstate, OP_LONG);
982 if (stap_check_integer_suffix (gdbarch, p->arg, &int_suffix))
983 p->arg += strlen (int_suffix);
985 error (_("Invalid constant suffix on expression `%s'."),
988 else if (stap_is_register_prefix (gdbarch, p->arg, NULL)
989 || stap_is_register_indirection_prefix (gdbarch, p->arg, NULL))
990 stap_parse_register_operand (p);
992 error (_("Operator `%c' not recognized on expression `%s'."),
993 *p->arg, p->saved_arg);
996 /* This function parses an argument conditionally, based on single or
997 non-single operands. A non-single operand would be a parenthesized
998 expression (e.g., `(2 + 1)'), and a single operand is anything that
999 starts with `-', `~', `+' (i.e., unary operators), a digit, or
1000 something recognized by `gdbarch_stap_is_single_operand'. */
1003 stap_parse_argument_conditionally (struct stap_parse_info *p)
1005 gdb_assert (gdbarch_stap_is_single_operand_p (p->gdbarch));
1007 if (*p->arg == '-' || *p->arg == '~' || *p->arg == '+' /* Unary. */
1008 || isdigit (*p->arg)
1009 || gdbarch_stap_is_single_operand (p->gdbarch, p->arg))
1010 stap_parse_single_operand (p);
1011 else if (*p->arg == '(')
1013 /* We are dealing with a parenthesized operand. It means we
1014 have to parse it as it was a separate expression, without
1015 left-side or precedence. */
1017 p->arg = skip_spaces (p->arg);
1018 ++p->inside_paren_p;
1020 stap_parse_argument_1 (p, 0, STAP_OPERAND_PREC_NONE);
1022 --p->inside_paren_p;
1024 error (_("Missign close-paren on expression `%s'."),
1028 if (p->inside_paren_p)
1029 p->arg = skip_spaces (p->arg);
1032 error (_("Cannot parse expression `%s'."), p->saved_arg);
1035 /* Helper function for `stap_parse_argument'. Please, see its comments to
1036 better understand what this function does. */
1039 stap_parse_argument_1 (struct stap_parse_info *p, int has_lhs,
1040 enum stap_operand_prec prec)
1042 /* This is an operator-precedence parser.
1044 We work with left- and right-sides of expressions, and
1045 parse them depending on the precedence of the operators
1048 gdb_assert (p->arg != NULL);
1050 if (p->inside_paren_p)
1051 p->arg = skip_spaces (p->arg);
1055 /* We were called without a left-side, either because this is the
1056 first call, or because we were called to parse a parenthesized
1057 expression. It doesn't really matter; we have to parse the
1058 left-side in order to continue the process. */
1059 stap_parse_argument_conditionally (p);
1062 /* Start to parse the right-side, and to "join" left and right sides
1063 depending on the operation specified.
1065 This loop shall continue until we run out of characters in the input,
1066 or until we find a close-parenthesis, which means that we've reached
1067 the end of a sub-expression. */
1068 while (*p->arg != '\0' && *p->arg != ')' && !isspace (*p->arg))
1070 const char *tmp_exp_buf;
1071 enum exp_opcode opcode;
1072 enum stap_operand_prec cur_prec;
1074 if (!stap_is_operator (p->arg))
1075 error (_("Invalid operator `%c' on expression `%s'."), *p->arg,
1078 /* We have to save the current value of the expression buffer because
1079 the `stap_get_opcode' modifies it in order to get the current
1080 operator. If this operator's precedence is lower than PREC, we
1081 should return and not advance the expression buffer pointer. */
1082 tmp_exp_buf = p->arg;
1083 opcode = stap_get_opcode (&tmp_exp_buf);
1085 cur_prec = stap_get_operator_prec (opcode);
1086 if (cur_prec < prec)
1088 /* If the precedence of the operator that we are seeing now is
1089 lower than the precedence of the first operator seen before
1090 this parsing process began, it means we should stop parsing
1095 p->arg = tmp_exp_buf;
1096 if (p->inside_paren_p)
1097 p->arg = skip_spaces (p->arg);
1099 /* Parse the right-side of the expression. */
1100 stap_parse_argument_conditionally (p);
1102 /* While we still have operators, try to parse another
1103 right-side, but using the current right-side as a left-side. */
1104 while (*p->arg != '\0' && stap_is_operator (p->arg))
1106 enum exp_opcode lookahead_opcode;
1107 enum stap_operand_prec lookahead_prec;
1109 /* Saving the current expression buffer position. The explanation
1110 is the same as above. */
1111 tmp_exp_buf = p->arg;
1112 lookahead_opcode = stap_get_opcode (&tmp_exp_buf);
1113 lookahead_prec = stap_get_operator_prec (lookahead_opcode);
1115 if (lookahead_prec <= prec)
1117 /* If we are dealing with an operator whose precedence is lower
1118 than the first one, just abandon the attempt. */
1122 /* Parse the right-side of the expression, but since we already
1123 have a left-side at this point, set `has_lhs' to 1. */
1124 stap_parse_argument_1 (p, 1, lookahead_prec);
1127 write_exp_elt_opcode (&p->pstate, opcode);
1131 /* Parse a probe's argument.
1135 LP = literal integer prefix
1136 LS = literal integer suffix
1138 RP = register prefix
1139 RS = register suffix
1141 RIP = register indirection prefix
1142 RIS = register indirection suffix
1144 This routine assumes that arguments' tokens are of the form:
1147 - [RP] REGISTER [RS]
1148 - [RIP] [RP] REGISTER [RS] [RIS]
1149 - If we find a number without LP, we try to parse it as a literal integer
1150 constant (if LP == NULL), or as a register displacement.
1151 - We count parenthesis, and only skip whitespaces if we are inside them.
1152 - If we find an operator, we skip it.
1154 This function can also call a special function that will try to match
1155 unknown tokens. It will return the expression_up generated from
1156 parsing the argument. */
1158 static expression_up
1159 stap_parse_argument (const char **arg, struct type *atype,
1160 struct gdbarch *gdbarch)
1162 /* We need to initialize the expression buffer, in order to begin
1163 our parsing efforts. We use language_c here because we may need
1164 to do pointer arithmetics. */
1165 struct stap_parse_info p (*arg, atype, 10, language_def (language_c),
1168 stap_parse_argument_1 (&p, 0, STAP_OPERAND_PREC_NONE);
1170 gdb_assert (p.inside_paren_p == 0);
1172 /* Casting the final expression to the appropriate type. */
1173 write_exp_elt_opcode (&p.pstate, UNOP_CAST);
1174 write_exp_elt_type (&p.pstate, atype);
1175 write_exp_elt_opcode (&p.pstate, UNOP_CAST);
1177 p.arg = skip_spaces (p.arg);
1180 return p.pstate.release ();
1183 /* Implementation of 'parse_arguments' method. */
1186 stap_probe::parse_arguments (struct gdbarch *gdbarch)
1190 gdb_assert (!m_have_parsed_args);
1191 cur = m_unparsed_args_text;
1192 m_have_parsed_args = true;
1194 if (cur == NULL || *cur == '\0' || *cur == ':')
1197 while (*cur != '\0')
1199 enum stap_arg_bitness bitness;
1200 bool got_minus = false;
1202 /* We expect to find something like:
1206 Where `N' can be [+,-][1,2,4,8]. This is not mandatory, so
1207 we check it here. If we don't find it, go to the next
1209 if ((cur[0] == '-' && isdigit (cur[1]) && cur[2] == '@')
1210 || (isdigit (cur[0]) && cur[1] == '@'))
1214 /* Discard the `-'. */
1219 /* Defining the bitness. */
1223 bitness = (got_minus ? STAP_ARG_BITNESS_8BIT_SIGNED
1224 : STAP_ARG_BITNESS_8BIT_UNSIGNED);
1228 bitness = (got_minus ? STAP_ARG_BITNESS_16BIT_SIGNED
1229 : STAP_ARG_BITNESS_16BIT_UNSIGNED);
1233 bitness = (got_minus ? STAP_ARG_BITNESS_32BIT_SIGNED
1234 : STAP_ARG_BITNESS_32BIT_UNSIGNED);
1238 bitness = (got_minus ? STAP_ARG_BITNESS_64BIT_SIGNED
1239 : STAP_ARG_BITNESS_64BIT_UNSIGNED);
1244 /* We have an error, because we don't expect anything
1245 except 1, 2, 4 and 8. */
1246 warning (_("unrecognized bitness %s%c' for probe `%s'"),
1247 got_minus ? "`-" : "`", *cur,
1248 this->get_name ().c_str ());
1252 /* Discard the number and the `@' sign. */
1256 bitness = STAP_ARG_BITNESS_UNDEFINED;
1259 = stap_get_expected_argument_type (gdbarch, bitness,
1260 this->get_name ().c_str ());
1262 expression_up expr = stap_parse_argument (&cur, atype, gdbarch);
1264 if (stap_expression_debug)
1265 dump_raw_expression (expr.get (), gdb_stdlog,
1266 "before conversion to prefix form");
1268 prefixify_expression (expr.get ());
1270 if (stap_expression_debug)
1271 dump_prefix_expression (expr.get (), gdb_stdlog);
1273 m_parsed_args.emplace_back (bitness, atype, std::move (expr));
1275 /* Start it over again. */
1276 cur = skip_spaces (cur);
1280 /* Helper function to relocate an address. */
1283 relocate_address (CORE_ADDR address, struct objfile *objfile)
1285 return address + ANOFFSET (objfile->section_offsets,
1286 SECT_OFF_DATA (objfile));
1289 /* Implementation of the get_relocated_address method. */
1292 stap_probe::get_relocated_address (struct objfile *objfile)
1294 return relocate_address (this->get_address (), objfile);
1297 /* Given PROBE, returns the number of arguments present in that probe's
1301 stap_probe::get_argument_count (struct frame_info *frame)
1303 struct gdbarch *gdbarch = get_frame_arch (frame);
1305 if (!m_have_parsed_args)
1307 if (this->can_evaluate_arguments ())
1308 this->parse_arguments (gdbarch);
1311 static int have_warned_stap_incomplete = 0;
1313 if (!have_warned_stap_incomplete)
1316 "The SystemTap SDT probe support is not fully implemented on this target;\n"
1317 "you will not be able to inspect the arguments of the probes.\n"
1318 "Please report a bug against GDB requesting a port to this target."));
1319 have_warned_stap_incomplete = 1;
1322 /* Marking the arguments as "already parsed". */
1323 m_have_parsed_args = true;
1327 gdb_assert (m_have_parsed_args);
1328 return m_parsed_args.size ();
1331 /* Return 1 if OP is a valid operator inside a probe argument, or zero
1335 stap_is_operator (const char *op)
1360 /* We didn't find any operator. */
1367 /* Implement the `can_evaluate_arguments' method. */
1370 stap_probe::can_evaluate_arguments () const
1372 struct gdbarch *gdbarch = this->get_gdbarch ();
1374 /* For SystemTap probes, we have to guarantee that the method
1375 stap_is_single_operand is defined on gdbarch. If it is not, then it
1376 means that argument evaluation is not implemented on this target. */
1377 return gdbarch_stap_is_single_operand_p (gdbarch);
1380 /* Evaluate the probe's argument N (indexed from 0), returning a value
1381 corresponding to it. Assertion is thrown if N does not exist. */
1384 stap_probe::evaluate_argument (unsigned n, struct frame_info *frame)
1386 struct stap_probe_arg *arg;
1388 struct gdbarch *gdbarch = get_frame_arch (frame);
1390 arg = this->get_arg_by_number (n, gdbarch);
1391 return evaluate_subexp_standard (arg->atype, arg->aexpr.get (), &pos,
1395 /* Compile the probe's argument N (indexed from 0) to agent expression.
1396 Assertion is thrown if N does not exist. */
1399 stap_probe::compile_to_ax (struct agent_expr *expr, struct axs_value *value,
1402 struct stap_probe_arg *arg;
1403 union exp_element *pc;
1405 arg = this->get_arg_by_number (n, expr->gdbarch);
1407 pc = arg->aexpr->elts;
1408 gen_expr (arg->aexpr.get (), &pc, expr, value);
1410 require_rvalue (expr, value);
1411 value->type = arg->atype;
1415 /* Set or clear a SystemTap semaphore. ADDRESS is the semaphore's
1416 address. SET is zero if the semaphore should be cleared, or one if
1417 it should be set. This is a helper function for
1418 'stap_probe::set_semaphore' and 'stap_probe::clear_semaphore'. */
1421 stap_modify_semaphore (CORE_ADDR address, int set, struct gdbarch *gdbarch)
1423 gdb_byte bytes[sizeof (LONGEST)];
1424 /* The ABI specifies "unsigned short". */
1425 struct type *type = builtin_type (gdbarch)->builtin_unsigned_short;
1431 /* Swallow errors. */
1432 if (target_read_memory (address, bytes, TYPE_LENGTH (type)) != 0)
1434 warning (_("Could not read the value of a SystemTap semaphore."));
1438 value = extract_unsigned_integer (bytes, TYPE_LENGTH (type),
1439 gdbarch_byte_order (gdbarch));
1440 /* Note that we explicitly don't worry about overflow or
1447 store_unsigned_integer (bytes, TYPE_LENGTH (type),
1448 gdbarch_byte_order (gdbarch), value);
1450 if (target_write_memory (address, bytes, TYPE_LENGTH (type)) != 0)
1451 warning (_("Could not write the value of a SystemTap semaphore."));
1454 /* Implementation of the 'set_semaphore' method.
1456 SystemTap semaphores act as reference counters, so calls to this
1457 function must be paired with calls to 'clear_semaphore'.
1459 This function and 'clear_semaphore' race with another tool
1460 changing the probes, but that is too rare to care. */
1463 stap_probe::set_semaphore (struct objfile *objfile, struct gdbarch *gdbarch)
1465 stap_modify_semaphore (relocate_address (m_sem_addr, objfile), 1, gdbarch);
1468 /* Implementation of the 'clear_semaphore' method. */
1471 stap_probe::clear_semaphore (struct objfile *objfile, struct gdbarch *gdbarch)
1473 stap_modify_semaphore (relocate_address (m_sem_addr, objfile), 0, gdbarch);
1476 /* Implementation of the 'get_static_ops' method. */
1478 const static_probe_ops *
1479 stap_probe::get_static_ops () const
1481 return &stap_static_probe_ops;
1484 /* Implementation of the 'gen_info_probes_table_values' method. */
1486 std::vector<const char *>
1487 stap_probe::gen_info_probes_table_values () const
1489 const char *val = NULL;
1491 if (m_sem_addr != 0)
1492 val = print_core_address (this->get_gdbarch (), m_sem_addr);
1494 return std::vector<const char *> { val };
1497 /* Helper function that parses the information contained in a
1498 SystemTap's probe. Basically, the information consists in:
1500 - Probe's PC address;
1501 - Link-time section address of `.stapsdt.base' section;
1502 - Link-time address of the semaphore variable, or ZERO if the
1503 probe doesn't have an associated semaphore;
1504 - Probe's provider name;
1506 - Probe's argument format
1508 This function returns 1 if the handling was successful, and zero
1512 handle_stap_probe (struct objfile *objfile, struct sdt_note *el,
1513 std::vector<probe *> *probesp, CORE_ADDR base)
1515 bfd *abfd = objfile->obfd;
1516 int size = bfd_get_arch_size (abfd) / 8;
1517 struct gdbarch *gdbarch = get_objfile_arch (objfile);
1518 struct type *ptr_type = builtin_type (gdbarch)->builtin_data_ptr;
1520 /* Provider and the name of the probe. */
1521 const char *provider = (const char *) &el->data[3 * size];
1522 const char *name = ((const char *)
1523 memchr (provider, '\0',
1524 (char *) el->data + el->size - provider));
1525 /* Making sure there is a name. */
1528 complaint (_("corrupt probe name when "
1530 objfile_name (objfile));
1532 /* There is no way to use a probe without a name or a provider, so
1533 returning zero here makes sense. */
1539 /* Retrieving the probe's address. */
1540 CORE_ADDR address = extract_typed_address (&el->data[0], ptr_type);
1542 /* Link-time sh_addr of `.stapsdt.base' section. */
1543 CORE_ADDR base_ref = extract_typed_address (&el->data[size], ptr_type);
1545 /* Semaphore address. */
1546 CORE_ADDR sem_addr = extract_typed_address (&el->data[2 * size], ptr_type);
1548 address += base - base_ref;
1550 sem_addr += base - base_ref;
1552 /* Arguments. We can only extract the argument format if there is a valid
1553 name for this probe. */
1554 const char *probe_args = ((const char*)
1556 (char *) el->data + el->size - name));
1558 if (probe_args != NULL)
1561 if (probe_args == NULL
1562 || (memchr (probe_args, '\0', (char *) el->data + el->size - name)
1563 != el->data + el->size - 1))
1565 complaint (_("corrupt probe argument when "
1567 objfile_name (objfile));
1568 /* If the argument string is NULL, it means some problem happened with
1569 it. So we return 0. */
1573 stap_probe *ret = new stap_probe (std::string (name), std::string (provider),
1574 address, gdbarch, sem_addr, probe_args);
1576 /* Successfully created probe. */
1577 probesp->push_back (ret);
1580 /* Helper function which tries to find the base address of the SystemTap
1581 base section named STAP_BASE_SECTION_NAME. */
1584 get_stap_base_address_1 (bfd *abfd, asection *sect, void *obj)
1586 asection **ret = (asection **) obj;
1588 if ((sect->flags & (SEC_DATA | SEC_ALLOC | SEC_HAS_CONTENTS))
1589 && sect->name && !strcmp (sect->name, STAP_BASE_SECTION_NAME))
1593 /* Helper function which iterates over every section in the BFD file,
1594 trying to find the base address of the SystemTap base section.
1595 Returns 1 if found (setting BASE to the proper value), zero otherwise. */
1598 get_stap_base_address (bfd *obfd, bfd_vma *base)
1600 asection *ret = NULL;
1602 bfd_map_over_sections (obfd, get_stap_base_address_1, (void *) &ret);
1606 complaint (_("could not obtain base address for "
1607 "SystemTap section on objfile `%s'."),
1618 /* Implementation of the 'is_linespec' method. */
1621 stap_static_probe_ops::is_linespec (const char **linespecp) const
1623 static const char *const keywords[] = { "-pstap", "-probe-stap", NULL };
1625 return probe_is_linespec_by_keyword (linespecp, keywords);
1628 /* Implementation of the 'get_probes' method. */
1631 stap_static_probe_ops::get_probes (std::vector<probe *> *probesp,
1632 struct objfile *objfile) const
1634 /* If we are here, then this is the first time we are parsing the
1635 SystemTap probe's information. We basically have to count how many
1636 probes the objfile has, and then fill in the necessary information
1638 bfd *obfd = objfile->obfd;
1640 struct sdt_note *iter;
1641 unsigned save_probesp_len = probesp->size ();
1643 if (objfile->separate_debug_objfile_backlink != NULL)
1645 /* This is a .debug file, not the objfile itself. */
1649 if (elf_tdata (obfd)->sdt_note_head == NULL)
1651 /* There isn't any probe here. */
1655 if (!get_stap_base_address (obfd, &base))
1657 /* There was an error finding the base address for the section.
1658 Just return NULL. */
1662 /* Parsing each probe's information. */
1663 for (iter = elf_tdata (obfd)->sdt_note_head;
1667 /* We first have to handle all the information about the
1668 probe which is present in the section. */
1669 handle_stap_probe (objfile, iter, probesp, base);
1672 if (save_probesp_len == probesp->size ())
1674 /* If we are here, it means we have failed to parse every known
1676 complaint (_("could not parse SystemTap probe(s) "
1682 /* Implementation of the type_name method. */
1685 stap_static_probe_ops::type_name () const
1690 /* Implementation of the 'gen_info_probes_table_header' method. */
1692 std::vector<struct info_probe_column>
1693 stap_static_probe_ops::gen_info_probes_table_header () const
1695 struct info_probe_column stap_probe_column;
1697 stap_probe_column.field_name = "semaphore";
1698 stap_probe_column.print_name = _("Semaphore");
1700 return std::vector<struct info_probe_column> { stap_probe_column };
1703 /* Implementation of the `info probes stap' command. */
1706 info_probes_stap_command (const char *arg, int from_tty)
1708 info_probes_for_spops (arg, from_tty, &stap_static_probe_ops);
1712 _initialize_stap_probe (void)
1714 all_static_probe_ops.push_back (&stap_static_probe_ops);
1716 add_setshow_zuinteger_cmd ("stap-expression", class_maintenance,
1717 &stap_expression_debug,
1718 _("Set SystemTap expression debugging."),
1719 _("Show SystemTap expression debugging."),
1720 _("When non-zero, the internal representation "
1721 "of SystemTap expressions will be printed."),
1723 show_stapexpressiondebug,
1724 &setdebuglist, &showdebuglist);
1726 add_cmd ("stap", class_info, info_probes_stap_command,
1728 Show information about SystemTap static probes.\n\
1729 Usage: info probes stap [PROVIDER [NAME [OBJECT]]]\n\
1730 Each argument is a regular expression, used to select probes.\n\
1731 PROVIDER matches probe provider names.\n\
1732 NAME matches the probe names.\n\
1733 OBJECT matches the executable or shared library name."),
1734 info_probes_cmdlist_get ());