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 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 true if any prefix has been found, false 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 true if S points to a register prefix, false otherwise. For
506 a 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 true if S points to a register indirection prefix, false
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 true if S points to an integer prefix, false otherwise. For
531 a 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. */
552 return isdigit (*s
) > 0;
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 true if a suffix has
580 been found, false 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 true if S points to an integer suffix, false otherwise. For
615 a 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 true if S points to a register suffix, false otherwise. For
628 a 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 true if S points to a register indirection suffix, false
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
677 bool got_minus
= false;
678 /* Flags to indicate whether this register access is being displaced and/or
681 bool indirect_p
= false;
682 struct gdbarch
*gdbarch
= p
->gdbarch
;
683 /* Needed to generate the register name as a part of an expression. */
685 /* Variables used to extract the register name from the probe's
690 const char *gdb_reg_prefix
= gdbarch_stap_gdb_register_prefix (gdbarch
);
691 int gdb_reg_prefix_len
= gdb_reg_prefix
? strlen (gdb_reg_prefix
) : 0;
692 const char *gdb_reg_suffix
= gdbarch_stap_gdb_register_suffix (gdbarch
);
693 int gdb_reg_suffix_len
= gdb_reg_suffix
? strlen (gdb_reg_suffix
) : 0;
694 const char *reg_prefix
;
695 const char *reg_ind_prefix
;
696 const char *reg_suffix
;
697 const char *reg_ind_suffix
;
699 /* Checking for a displacement argument. */
702 /* If it's a plus sign, we don't need to do anything, just advance the
713 if (isdigit (*p
->arg
))
715 /* The value of the displacement. */
720 displacement
= strtol (p
->arg
, &endp
, 10);
723 /* Generating the expression for the displacement. */
724 write_exp_elt_opcode (&p
->pstate
, OP_LONG
);
725 write_exp_elt_type (&p
->pstate
, builtin_type (gdbarch
)->builtin_long
);
726 write_exp_elt_longcst (&p
->pstate
, displacement
);
727 write_exp_elt_opcode (&p
->pstate
, OP_LONG
);
729 write_exp_elt_opcode (&p
->pstate
, UNOP_NEG
);
732 /* Getting rid of register indirection prefix. */
733 if (stap_is_register_indirection_prefix (gdbarch
, p
->arg
, ®_ind_prefix
))
736 p
->arg
+= strlen (reg_ind_prefix
);
739 if (disp_p
&& !indirect_p
)
740 error (_("Invalid register displacement syntax on expression `%s'."),
743 /* Getting rid of register prefix. */
744 if (stap_is_register_prefix (gdbarch
, p
->arg
, ®_prefix
))
745 p
->arg
+= strlen (reg_prefix
);
747 /* Now we should have only the register name. Let's extract it and get
748 the associated number. */
751 /* We assume the register name is composed by letters and numbers. */
752 while (isalnum (*p
->arg
))
755 len
= p
->arg
- start
;
757 regname
= (char *) alloca (len
+ gdb_reg_prefix_len
+ gdb_reg_suffix_len
+ 1);
760 /* We only add the GDB's register prefix/suffix if we are dealing with
761 a numeric register. */
762 if (gdb_reg_prefix
&& isdigit (*start
))
764 strncpy (regname
, gdb_reg_prefix
, gdb_reg_prefix_len
);
765 strncpy (regname
+ gdb_reg_prefix_len
, start
, len
);
768 strncpy (regname
+ gdb_reg_prefix_len
+ len
,
769 gdb_reg_suffix
, gdb_reg_suffix_len
);
771 len
+= gdb_reg_prefix_len
+ gdb_reg_suffix_len
;
774 strncpy (regname
, start
, len
);
778 /* Is this a valid register name? */
779 if (user_reg_map_name_to_regnum (gdbarch
, regname
, len
) == -1)
780 error (_("Invalid register name `%s' on expression `%s'."),
781 regname
, p
->saved_arg
);
783 write_exp_elt_opcode (&p
->pstate
, OP_REGISTER
);
786 write_exp_string (&p
->pstate
, str
);
787 write_exp_elt_opcode (&p
->pstate
, OP_REGISTER
);
792 write_exp_elt_opcode (&p
->pstate
, BINOP_ADD
);
794 /* Casting to the expected type. */
795 write_exp_elt_opcode (&p
->pstate
, UNOP_CAST
);
796 write_exp_elt_type (&p
->pstate
, lookup_pointer_type (p
->arg_type
));
797 write_exp_elt_opcode (&p
->pstate
, UNOP_CAST
);
799 write_exp_elt_opcode (&p
->pstate
, UNOP_IND
);
802 /* Getting rid of the register name suffix. */
803 if (stap_check_register_suffix (gdbarch
, p
->arg
, ®_suffix
))
804 p
->arg
+= strlen (reg_suffix
);
806 error (_("Missing register name suffix on expression `%s'."),
809 /* Getting rid of the register indirection suffix. */
812 if (stap_check_register_indirection_suffix (gdbarch
, p
->arg
,
814 p
->arg
+= strlen (reg_ind_suffix
);
816 error (_("Missing indirection suffix on expression `%s'."),
821 /* This function is responsible for parsing a single operand.
823 A single operand can be:
825 - an unary operation (e.g., `-5', `~2', or even with subexpressions
827 - a register displacement, which will be treated as a register
828 operand (e.g., `-4(%eax)' on x86)
829 - a numeric constant, or
830 - a register operand (see function `stap_parse_register_operand')
832 The function also calls special-handling functions to deal with
833 unrecognized operands, allowing arch-specific parsers to be
837 stap_parse_single_operand (struct stap_parse_info
*p
)
839 struct gdbarch
*gdbarch
= p
->gdbarch
;
840 const char *int_prefix
= NULL
;
842 /* We first try to parse this token as a "special token". */
843 if (gdbarch_stap_parse_special_token_p (gdbarch
))
844 if (gdbarch_stap_parse_special_token (gdbarch
, p
) != 0)
846 /* If the return value of the above function is not zero,
847 it means it successfully parsed the special token.
849 If it is NULL, we try to parse it using our method. */
853 if (*p
->arg
== '-' || *p
->arg
== '~' || *p
->arg
== '+')
856 /* We use this variable to do a lookahead. */
857 const char *tmp
= p
->arg
;
858 bool has_digit
= false;
860 /* Skipping signal. */
863 /* This is an unary operation. Here is a list of allowed tokens
867 - number (from register displacement)
868 - subexpression (beginning with `(')
870 We handle the register displacement here, and the other cases
872 if (p
->inside_paren_p
)
873 tmp
= skip_spaces (tmp
);
875 while (isdigit (*tmp
))
877 /* We skip the digit here because we are only interested in
878 knowing what kind of unary operation this is. The digit
879 will be handled by one of the functions that will be
880 called below ('stap_parse_argument_conditionally' or
881 'stap_parse_register_operand'). */
886 if (has_digit
&& stap_is_register_indirection_prefix (gdbarch
, tmp
,
889 /* If we are here, it means it is a displacement. The only
890 operations allowed here are `-' and `+'. */
892 error (_("Invalid operator `%c' for register displacement "
893 "on expression `%s'."), c
, p
->saved_arg
);
895 stap_parse_register_operand (p
);
899 /* This is not a displacement. We skip the operator, and
900 deal with it when the recursion returns. */
902 stap_parse_argument_conditionally (p
);
904 write_exp_elt_opcode (&p
->pstate
, UNOP_NEG
);
906 write_exp_elt_opcode (&p
->pstate
, UNOP_COMPLEMENT
);
909 else if (isdigit (*p
->arg
))
911 /* A temporary variable, needed for lookahead. */
912 const char *tmp
= p
->arg
;
916 /* We can be dealing with a numeric constant, or with a register
918 number
= strtol (tmp
, &endp
, 10);
921 if (p
->inside_paren_p
)
922 tmp
= skip_spaces (tmp
);
924 /* If "stap_is_integer_prefix" returns true, it means we can
925 accept integers without a prefix here. But we also need to
926 check whether the next token (i.e., "tmp") is not a register
927 indirection prefix. */
928 if (stap_is_integer_prefix (gdbarch
, p
->arg
, NULL
)
929 && !stap_is_register_indirection_prefix (gdbarch
, tmp
, NULL
))
931 const char *int_suffix
;
933 /* We are dealing with a numeric constant. */
934 write_exp_elt_opcode (&p
->pstate
, OP_LONG
);
935 write_exp_elt_type (&p
->pstate
,
936 builtin_type (gdbarch
)->builtin_long
);
937 write_exp_elt_longcst (&p
->pstate
, number
);
938 write_exp_elt_opcode (&p
->pstate
, OP_LONG
);
942 if (stap_check_integer_suffix (gdbarch
, p
->arg
, &int_suffix
))
943 p
->arg
+= strlen (int_suffix
);
945 error (_("Invalid constant suffix on expression `%s'."),
948 else if (stap_is_register_indirection_prefix (gdbarch
, tmp
, NULL
))
949 stap_parse_register_operand (p
);
951 error (_("Unknown numeric token on expression `%s'."),
954 else if (stap_is_integer_prefix (gdbarch
, p
->arg
, &int_prefix
))
956 /* We are dealing with a numeric constant. */
959 const char *int_suffix
;
961 p
->arg
+= strlen (int_prefix
);
962 number
= strtol (p
->arg
, &endp
, 10);
965 write_exp_elt_opcode (&p
->pstate
, OP_LONG
);
966 write_exp_elt_type (&p
->pstate
, builtin_type (gdbarch
)->builtin_long
);
967 write_exp_elt_longcst (&p
->pstate
, number
);
968 write_exp_elt_opcode (&p
->pstate
, OP_LONG
);
970 if (stap_check_integer_suffix (gdbarch
, p
->arg
, &int_suffix
))
971 p
->arg
+= strlen (int_suffix
);
973 error (_("Invalid constant suffix on expression `%s'."),
976 else if (stap_is_register_prefix (gdbarch
, p
->arg
, NULL
)
977 || stap_is_register_indirection_prefix (gdbarch
, p
->arg
, NULL
))
978 stap_parse_register_operand (p
);
980 error (_("Operator `%c' not recognized on expression `%s'."),
981 *p
->arg
, p
->saved_arg
);
984 /* This function parses an argument conditionally, based on single or
985 non-single operands. A non-single operand would be a parenthesized
986 expression (e.g., `(2 + 1)'), and a single operand is anything that
987 starts with `-', `~', `+' (i.e., unary operators), a digit, or
988 something recognized by `gdbarch_stap_is_single_operand'. */
991 stap_parse_argument_conditionally (struct stap_parse_info
*p
)
993 gdb_assert (gdbarch_stap_is_single_operand_p (p
->gdbarch
));
995 if (*p
->arg
== '-' || *p
->arg
== '~' || *p
->arg
== '+' /* Unary. */
997 || gdbarch_stap_is_single_operand (p
->gdbarch
, p
->arg
))
998 stap_parse_single_operand (p
);
999 else if (*p
->arg
== '(')
1001 /* We are dealing with a parenthesized operand. It means we
1002 have to parse it as it was a separate expression, without
1003 left-side or precedence. */
1005 p
->arg
= skip_spaces (p
->arg
);
1006 ++p
->inside_paren_p
;
1008 stap_parse_argument_1 (p
, 0, STAP_OPERAND_PREC_NONE
);
1010 --p
->inside_paren_p
;
1012 error (_("Missign close-paren on expression `%s'."),
1016 if (p
->inside_paren_p
)
1017 p
->arg
= skip_spaces (p
->arg
);
1020 error (_("Cannot parse expression `%s'."), p
->saved_arg
);
1023 /* Helper function for `stap_parse_argument'. Please, see its comments to
1024 better understand what this function does. */
1027 stap_parse_argument_1 (struct stap_parse_info
*p
, bool has_lhs
,
1028 enum stap_operand_prec prec
)
1030 /* This is an operator-precedence parser.
1032 We work with left- and right-sides of expressions, and
1033 parse them depending on the precedence of the operators
1036 gdb_assert (p
->arg
!= NULL
);
1038 if (p
->inside_paren_p
)
1039 p
->arg
= skip_spaces (p
->arg
);
1043 /* We were called without a left-side, either because this is the
1044 first call, or because we were called to parse a parenthesized
1045 expression. It doesn't really matter; we have to parse the
1046 left-side in order to continue the process. */
1047 stap_parse_argument_conditionally (p
);
1050 /* Start to parse the right-side, and to "join" left and right sides
1051 depending on the operation specified.
1053 This loop shall continue until we run out of characters in the input,
1054 or until we find a close-parenthesis, which means that we've reached
1055 the end of a sub-expression. */
1056 while (*p
->arg
!= '\0' && *p
->arg
!= ')' && !isspace (*p
->arg
))
1058 const char *tmp_exp_buf
;
1059 enum exp_opcode opcode
;
1060 enum stap_operand_prec cur_prec
;
1062 if (!stap_is_operator (p
->arg
))
1063 error (_("Invalid operator `%c' on expression `%s'."), *p
->arg
,
1066 /* We have to save the current value of the expression buffer because
1067 the `stap_get_opcode' modifies it in order to get the current
1068 operator. If this operator's precedence is lower than PREC, we
1069 should return and not advance the expression buffer pointer. */
1070 tmp_exp_buf
= p
->arg
;
1071 opcode
= stap_get_opcode (&tmp_exp_buf
);
1073 cur_prec
= stap_get_operator_prec (opcode
);
1074 if (cur_prec
< prec
)
1076 /* If the precedence of the operator that we are seeing now is
1077 lower than the precedence of the first operator seen before
1078 this parsing process began, it means we should stop parsing
1083 p
->arg
= tmp_exp_buf
;
1084 if (p
->inside_paren_p
)
1085 p
->arg
= skip_spaces (p
->arg
);
1087 /* Parse the right-side of the expression. */
1088 stap_parse_argument_conditionally (p
);
1090 /* While we still have operators, try to parse another
1091 right-side, but using the current right-side as a left-side. */
1092 while (*p
->arg
!= '\0' && stap_is_operator (p
->arg
))
1094 enum exp_opcode lookahead_opcode
;
1095 enum stap_operand_prec lookahead_prec
;
1097 /* Saving the current expression buffer position. The explanation
1098 is the same as above. */
1099 tmp_exp_buf
= p
->arg
;
1100 lookahead_opcode
= stap_get_opcode (&tmp_exp_buf
);
1101 lookahead_prec
= stap_get_operator_prec (lookahead_opcode
);
1103 if (lookahead_prec
<= prec
)
1105 /* If we are dealing with an operator whose precedence is lower
1106 than the first one, just abandon the attempt. */
1110 /* Parse the right-side of the expression, but since we already
1111 have a left-side at this point, set `has_lhs' to 1. */
1112 stap_parse_argument_1 (p
, 1, lookahead_prec
);
1115 write_exp_elt_opcode (&p
->pstate
, opcode
);
1119 /* Parse a probe's argument.
1123 LP = literal integer prefix
1124 LS = literal integer suffix
1126 RP = register prefix
1127 RS = register suffix
1129 RIP = register indirection prefix
1130 RIS = register indirection suffix
1132 This routine assumes that arguments' tokens are of the form:
1135 - [RP] REGISTER [RS]
1136 - [RIP] [RP] REGISTER [RS] [RIS]
1137 - If we find a number without LP, we try to parse it as a literal integer
1138 constant (if LP == NULL), or as a register displacement.
1139 - We count parenthesis, and only skip whitespaces if we are inside them.
1140 - If we find an operator, we skip it.
1142 This function can also call a special function that will try to match
1143 unknown tokens. It will return the expression_up generated from
1144 parsing the argument. */
1146 static expression_up
1147 stap_parse_argument (const char **arg
, struct type
*atype
,
1148 struct gdbarch
*gdbarch
)
1150 /* We need to initialize the expression buffer, in order to begin
1151 our parsing efforts. We use language_c here because we may need
1152 to do pointer arithmetics. */
1153 struct stap_parse_info
p (*arg
, atype
, language_def (language_c
),
1156 stap_parse_argument_1 (&p
, 0, STAP_OPERAND_PREC_NONE
);
1158 gdb_assert (p
.inside_paren_p
== 0);
1160 /* Casting the final expression to the appropriate type. */
1161 write_exp_elt_opcode (&p
.pstate
, UNOP_CAST
);
1162 write_exp_elt_type (&p
.pstate
, atype
);
1163 write_exp_elt_opcode (&p
.pstate
, UNOP_CAST
);
1165 p
.arg
= skip_spaces (p
.arg
);
1168 return p
.pstate
.release ();
1171 /* Implementation of 'parse_arguments' method. */
1174 stap_probe::parse_arguments (struct gdbarch
*gdbarch
)
1178 gdb_assert (!m_have_parsed_args
);
1179 cur
= m_unparsed_args_text
;
1180 m_have_parsed_args
= true;
1182 if (cur
== NULL
|| *cur
== '\0' || *cur
== ':')
1185 while (*cur
!= '\0')
1187 enum stap_arg_bitness bitness
;
1188 bool got_minus
= false;
1190 /* We expect to find something like:
1194 Where `N' can be [+,-][1,2,4,8]. This is not mandatory, so
1195 we check it here. If we don't find it, go to the next
1197 if ((cur
[0] == '-' && isdigit (cur
[1]) && cur
[2] == '@')
1198 || (isdigit (cur
[0]) && cur
[1] == '@'))
1202 /* Discard the `-'. */
1207 /* Defining the bitness. */
1211 bitness
= (got_minus
? STAP_ARG_BITNESS_8BIT_SIGNED
1212 : STAP_ARG_BITNESS_8BIT_UNSIGNED
);
1216 bitness
= (got_minus
? STAP_ARG_BITNESS_16BIT_SIGNED
1217 : STAP_ARG_BITNESS_16BIT_UNSIGNED
);
1221 bitness
= (got_minus
? STAP_ARG_BITNESS_32BIT_SIGNED
1222 : STAP_ARG_BITNESS_32BIT_UNSIGNED
);
1226 bitness
= (got_minus
? STAP_ARG_BITNESS_64BIT_SIGNED
1227 : STAP_ARG_BITNESS_64BIT_UNSIGNED
);
1232 /* We have an error, because we don't expect anything
1233 except 1, 2, 4 and 8. */
1234 warning (_("unrecognized bitness %s%c' for probe `%s'"),
1235 got_minus
? "`-" : "`", *cur
,
1236 this->get_name ().c_str ());
1240 /* Discard the number and the `@' sign. */
1244 bitness
= STAP_ARG_BITNESS_UNDEFINED
;
1247 = stap_get_expected_argument_type (gdbarch
, bitness
,
1248 this->get_name ().c_str ());
1250 expression_up expr
= stap_parse_argument (&cur
, atype
, gdbarch
);
1252 if (stap_expression_debug
)
1253 dump_raw_expression (expr
.get (), gdb_stdlog
,
1254 "before conversion to prefix form");
1256 prefixify_expression (expr
.get ());
1258 if (stap_expression_debug
)
1259 dump_prefix_expression (expr
.get (), gdb_stdlog
);
1261 m_parsed_args
.emplace_back (bitness
, atype
, std::move (expr
));
1263 /* Start it over again. */
1264 cur
= skip_spaces (cur
);
1268 /* Helper function to relocate an address. */
1271 relocate_address (CORE_ADDR address
, struct objfile
*objfile
)
1273 return address
+ ANOFFSET (objfile
->section_offsets
,
1274 SECT_OFF_DATA (objfile
));
1277 /* Implementation of the get_relocated_address method. */
1280 stap_probe::get_relocated_address (struct objfile
*objfile
)
1282 return relocate_address (this->get_address (), objfile
);
1285 /* Given PROBE, returns the number of arguments present in that probe's
1289 stap_probe::get_argument_count (struct frame_info
*frame
)
1291 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1293 if (!m_have_parsed_args
)
1295 if (this->can_evaluate_arguments ())
1296 this->parse_arguments (gdbarch
);
1299 static bool have_warned_stap_incomplete
= false;
1301 if (!have_warned_stap_incomplete
)
1304 "The SystemTap SDT probe support is not fully implemented on this target;\n"
1305 "you will not be able to inspect the arguments of the probes.\n"
1306 "Please report a bug against GDB requesting a port to this target."));
1307 have_warned_stap_incomplete
= true;
1310 /* Marking the arguments as "already parsed". */
1311 m_have_parsed_args
= true;
1315 gdb_assert (m_have_parsed_args
);
1316 return m_parsed_args
.size ();
1319 /* Return true if OP is a valid operator inside a probe argument, or
1323 stap_is_operator (const char *op
)
1348 /* We didn't find any operator. */
1355 /* Implement the `can_evaluate_arguments' method. */
1358 stap_probe::can_evaluate_arguments () const
1360 struct gdbarch
*gdbarch
= this->get_gdbarch ();
1362 /* For SystemTap probes, we have to guarantee that the method
1363 stap_is_single_operand is defined on gdbarch. If it is not, then it
1364 means that argument evaluation is not implemented on this target. */
1365 return gdbarch_stap_is_single_operand_p (gdbarch
);
1368 /* Evaluate the probe's argument N (indexed from 0), returning a value
1369 corresponding to it. Assertion is thrown if N does not exist. */
1372 stap_probe::evaluate_argument (unsigned n
, struct frame_info
*frame
)
1374 struct stap_probe_arg
*arg
;
1376 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1378 arg
= this->get_arg_by_number (n
, gdbarch
);
1379 return evaluate_subexp_standard (arg
->atype
, arg
->aexpr
.get (), &pos
,
1383 /* Compile the probe's argument N (indexed from 0) to agent expression.
1384 Assertion is thrown if N does not exist. */
1387 stap_probe::compile_to_ax (struct agent_expr
*expr
, struct axs_value
*value
,
1390 struct stap_probe_arg
*arg
;
1391 union exp_element
*pc
;
1393 arg
= this->get_arg_by_number (n
, expr
->gdbarch
);
1395 pc
= arg
->aexpr
->elts
;
1396 gen_expr (arg
->aexpr
.get (), &pc
, expr
, value
);
1398 require_rvalue (expr
, value
);
1399 value
->type
= arg
->atype
;
1403 /* Set or clear a SystemTap semaphore. ADDRESS is the semaphore's
1404 address. SET is zero if the semaphore should be cleared, or one if
1405 it should be set. This is a helper function for
1406 'stap_probe::set_semaphore' and 'stap_probe::clear_semaphore'. */
1409 stap_modify_semaphore (CORE_ADDR address
, int set
, struct gdbarch
*gdbarch
)
1411 gdb_byte bytes
[sizeof (LONGEST
)];
1412 /* The ABI specifies "unsigned short". */
1413 struct type
*type
= builtin_type (gdbarch
)->builtin_unsigned_short
;
1419 /* Swallow errors. */
1420 if (target_read_memory (address
, bytes
, TYPE_LENGTH (type
)) != 0)
1422 warning (_("Could not read the value of a SystemTap semaphore."));
1426 value
= extract_unsigned_integer (bytes
, TYPE_LENGTH (type
),
1427 gdbarch_byte_order (gdbarch
));
1428 /* Note that we explicitly don't worry about overflow or
1435 store_unsigned_integer (bytes
, TYPE_LENGTH (type
),
1436 gdbarch_byte_order (gdbarch
), value
);
1438 if (target_write_memory (address
, bytes
, TYPE_LENGTH (type
)) != 0)
1439 warning (_("Could not write the value of a SystemTap semaphore."));
1442 /* Implementation of the 'set_semaphore' method.
1444 SystemTap semaphores act as reference counters, so calls to this
1445 function must be paired with calls to 'clear_semaphore'.
1447 This function and 'clear_semaphore' race with another tool
1448 changing the probes, but that is too rare to care. */
1451 stap_probe::set_semaphore (struct objfile
*objfile
, struct gdbarch
*gdbarch
)
1453 stap_modify_semaphore (relocate_address (m_sem_addr
, objfile
), 1, gdbarch
);
1456 /* Implementation of the 'clear_semaphore' method. */
1459 stap_probe::clear_semaphore (struct objfile
*objfile
, struct gdbarch
*gdbarch
)
1461 stap_modify_semaphore (relocate_address (m_sem_addr
, objfile
), 0, gdbarch
);
1464 /* Implementation of the 'get_static_ops' method. */
1466 const static_probe_ops
*
1467 stap_probe::get_static_ops () const
1469 return &stap_static_probe_ops
;
1472 /* Implementation of the 'gen_info_probes_table_values' method. */
1474 std::vector
<const char *>
1475 stap_probe::gen_info_probes_table_values () const
1477 const char *val
= NULL
;
1479 if (m_sem_addr
!= 0)
1480 val
= print_core_address (this->get_gdbarch (), m_sem_addr
);
1482 return std::vector
<const char *> { val
};
1485 /* Helper function that parses the information contained in a
1486 SystemTap's probe. Basically, the information consists in:
1488 - Probe's PC address;
1489 - Link-time section address of `.stapsdt.base' section;
1490 - Link-time address of the semaphore variable, or ZERO if the
1491 probe doesn't have an associated semaphore;
1492 - Probe's provider name;
1494 - Probe's argument format
1496 This function returns 1 if the handling was successful, and zero
1500 handle_stap_probe (struct objfile
*objfile
, struct sdt_note
*el
,
1501 std::vector
<std::unique_ptr
<probe
>> *probesp
,
1504 bfd
*abfd
= objfile
->obfd
;
1505 int size
= bfd_get_arch_size (abfd
) / 8;
1506 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
1507 struct type
*ptr_type
= builtin_type (gdbarch
)->builtin_data_ptr
;
1509 /* Provider and the name of the probe. */
1510 const char *provider
= (const char *) &el
->data
[3 * size
];
1511 const char *name
= ((const char *)
1512 memchr (provider
, '\0',
1513 (char *) el
->data
+ el
->size
- provider
));
1514 /* Making sure there is a name. */
1517 complaint (_("corrupt probe name when "
1519 objfile_name (objfile
));
1521 /* There is no way to use a probe without a name or a provider, so
1522 returning zero here makes sense. */
1528 /* Retrieving the probe's address. */
1529 CORE_ADDR address
= extract_typed_address (&el
->data
[0], ptr_type
);
1531 /* Link-time sh_addr of `.stapsdt.base' section. */
1532 CORE_ADDR base_ref
= extract_typed_address (&el
->data
[size
], ptr_type
);
1534 /* Semaphore address. */
1535 CORE_ADDR sem_addr
= extract_typed_address (&el
->data
[2 * size
], ptr_type
);
1537 address
+= base
- base_ref
;
1539 sem_addr
+= base
- base_ref
;
1541 /* Arguments. We can only extract the argument format if there is a valid
1542 name for this probe. */
1543 const char *probe_args
= ((const char*)
1545 (char *) el
->data
+ el
->size
- name
));
1547 if (probe_args
!= NULL
)
1550 if (probe_args
== NULL
1551 || (memchr (probe_args
, '\0', (char *) el
->data
+ el
->size
- name
)
1552 != el
->data
+ el
->size
- 1))
1554 complaint (_("corrupt probe argument when "
1556 objfile_name (objfile
));
1557 /* If the argument string is NULL, it means some problem happened with
1558 it. So we return 0. */
1562 stap_probe
*ret
= new stap_probe (std::string (name
), std::string (provider
),
1563 address
, gdbarch
, sem_addr
, probe_args
);
1565 /* Successfully created probe. */
1566 probesp
->emplace_back (ret
);
1569 /* Helper function which tries to find the base address of the SystemTap
1570 base section named STAP_BASE_SECTION_NAME. */
1573 get_stap_base_address_1 (bfd
*abfd
, asection
*sect
, void *obj
)
1575 asection
**ret
= (asection
**) obj
;
1577 if ((sect
->flags
& (SEC_DATA
| SEC_ALLOC
| SEC_HAS_CONTENTS
))
1578 && sect
->name
&& !strcmp (sect
->name
, STAP_BASE_SECTION_NAME
))
1582 /* Helper function which iterates over every section in the BFD file,
1583 trying to find the base address of the SystemTap base section.
1584 Returns 1 if found (setting BASE to the proper value), zero otherwise. */
1587 get_stap_base_address (bfd
*obfd
, bfd_vma
*base
)
1589 asection
*ret
= NULL
;
1591 bfd_map_over_sections (obfd
, get_stap_base_address_1
, (void *) &ret
);
1595 complaint (_("could not obtain base address for "
1596 "SystemTap section on objfile `%s'."),
1607 /* Implementation of the 'is_linespec' method. */
1610 stap_static_probe_ops::is_linespec (const char **linespecp
) const
1612 static const char *const keywords
[] = { "-pstap", "-probe-stap", NULL
};
1614 return probe_is_linespec_by_keyword (linespecp
, keywords
);
1617 /* Implementation of the 'get_probes' method. */
1620 stap_static_probe_ops::get_probes
1621 (std::vector
<std::unique_ptr
<probe
>> *probesp
,
1622 struct objfile
*objfile
) const
1624 /* If we are here, then this is the first time we are parsing the
1625 SystemTap probe's information. We basically have to count how many
1626 probes the objfile has, and then fill in the necessary information
1628 bfd
*obfd
= objfile
->obfd
;
1630 struct sdt_note
*iter
;
1631 unsigned save_probesp_len
= probesp
->size ();
1633 if (objfile
->separate_debug_objfile_backlink
!= NULL
)
1635 /* This is a .debug file, not the objfile itself. */
1639 if (elf_tdata (obfd
)->sdt_note_head
== NULL
)
1641 /* There isn't any probe here. */
1645 if (!get_stap_base_address (obfd
, &base
))
1647 /* There was an error finding the base address for the section.
1648 Just return NULL. */
1652 /* Parsing each probe's information. */
1653 for (iter
= elf_tdata (obfd
)->sdt_note_head
;
1657 /* We first have to handle all the information about the
1658 probe which is present in the section. */
1659 handle_stap_probe (objfile
, iter
, probesp
, base
);
1662 if (save_probesp_len
== probesp
->size ())
1664 /* If we are here, it means we have failed to parse every known
1666 complaint (_("could not parse SystemTap probe(s) "
1672 /* Implementation of the type_name method. */
1675 stap_static_probe_ops::type_name () const
1680 /* Implementation of the 'gen_info_probes_table_header' method. */
1682 std::vector
<struct info_probe_column
>
1683 stap_static_probe_ops::gen_info_probes_table_header () const
1685 struct info_probe_column stap_probe_column
;
1687 stap_probe_column
.field_name
= "semaphore";
1688 stap_probe_column
.print_name
= _("Semaphore");
1690 return std::vector
<struct info_probe_column
> { stap_probe_column
};
1693 /* Implementation of the `info probes stap' command. */
1696 info_probes_stap_command (const char *arg
, int from_tty
)
1698 info_probes_for_spops (arg
, from_tty
, &stap_static_probe_ops
);
1702 _initialize_stap_probe (void)
1704 all_static_probe_ops
.push_back (&stap_static_probe_ops
);
1706 add_setshow_zuinteger_cmd ("stap-expression", class_maintenance
,
1707 &stap_expression_debug
,
1708 _("Set SystemTap expression debugging."),
1709 _("Show SystemTap expression debugging."),
1710 _("When non-zero, the internal representation "
1711 "of SystemTap expressions will be printed."),
1713 show_stapexpressiondebug
,
1714 &setdebuglist
, &showdebuglist
);
1716 add_cmd ("stap", class_info
, info_probes_stap_command
,
1718 Show information about SystemTap static probes.\n\
1719 Usage: info probes stap [PROVIDER [NAME [OBJECT]]]\n\
1720 Each argument is a regular expression, used to select probes.\n\
1721 PROVIDER matches probe provider names.\n\
1722 NAME matches the probe names.\n\
1723 OBJECT matches the executable or shared library name."),
1724 info_probes_cmdlist_get ());