1 /* SystemTap probe support for GDB.
3 Copyright (C) 2012-2021 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"
25 #include "arch-utils.h"
28 #include "filenames.h"
32 #include "complaints.h"
33 #include "cli/cli-utils.h"
35 #include "user-regs.h"
36 #include "parser-defs.h"
42 /* The name of the SystemTap section where we will find information about
45 #define STAP_BASE_SECTION_NAME ".stapsdt.base"
47 /* Should we display debug information for the probe's argument expression
50 static unsigned int stap_expression_debug
= 0;
52 /* The various possibilities of bitness defined for a probe's argument.
56 - STAP_ARG_BITNESS_UNDEFINED: The user hasn't specified the bitness.
57 - STAP_ARG_BITNESS_8BIT_UNSIGNED: argument string starts with `1@'.
58 - STAP_ARG_BITNESS_8BIT_SIGNED: argument string starts with `-1@'.
59 - STAP_ARG_BITNESS_16BIT_UNSIGNED: argument string starts with `2@'.
60 - STAP_ARG_BITNESS_16BIT_SIGNED: argument string starts with `-2@'.
61 - STAP_ARG_BITNESS_32BIT_UNSIGNED: argument string starts with `4@'.
62 - STAP_ARG_BITNESS_32BIT_SIGNED: argument string starts with `-4@'.
63 - STAP_ARG_BITNESS_64BIT_UNSIGNED: argument string starts with `8@'.
64 - STAP_ARG_BITNESS_64BIT_SIGNED: argument string starts with `-8@'. */
68 STAP_ARG_BITNESS_UNDEFINED
,
69 STAP_ARG_BITNESS_8BIT_UNSIGNED
,
70 STAP_ARG_BITNESS_8BIT_SIGNED
,
71 STAP_ARG_BITNESS_16BIT_UNSIGNED
,
72 STAP_ARG_BITNESS_16BIT_SIGNED
,
73 STAP_ARG_BITNESS_32BIT_UNSIGNED
,
74 STAP_ARG_BITNESS_32BIT_SIGNED
,
75 STAP_ARG_BITNESS_64BIT_UNSIGNED
,
76 STAP_ARG_BITNESS_64BIT_SIGNED
,
79 /* The following structure represents a single argument for the probe. */
83 /* Constructor for stap_probe_arg. */
84 stap_probe_arg (enum stap_arg_bitness bitness_
, struct type
*atype_
,
85 expression_up
&&aexpr_
)
86 : bitness (bitness_
), atype (atype_
), aexpr (std::move (aexpr_
))
89 /* The bitness of this argument. */
90 enum stap_arg_bitness bitness
;
92 /* The corresponding `struct type *' to the bitness. */
95 /* The argument converted to an internal GDB expression. */
99 /* Class that implements the static probe methods for "stap" probes. */
101 class stap_static_probe_ops
: public static_probe_ops
104 /* We need a user-provided constructor to placate some compilers.
105 See PR build/24937. */
106 stap_static_probe_ops ()
111 bool is_linespec (const char **linespecp
) const override
;
114 void get_probes (std::vector
<std::unique_ptr
<probe
>> *probesp
,
115 struct objfile
*objfile
) const override
;
118 const char *type_name () const override
;
121 std::vector
<struct info_probe_column
> gen_info_probes_table_header
125 /* SystemTap static_probe_ops. */
127 const stap_static_probe_ops stap_static_probe_ops
{};
129 class stap_probe
: public probe
132 /* Constructor for stap_probe. */
133 stap_probe (std::string
&&name_
, std::string
&&provider_
, CORE_ADDR address_
,
134 struct gdbarch
*arch_
, CORE_ADDR sem_addr
, const char *args_text
)
135 : probe (std::move (name_
), std::move (provider_
), address_
, arch_
),
136 m_sem_addr (sem_addr
),
137 m_have_parsed_args (false), m_unparsed_args_text (args_text
)
141 CORE_ADDR
get_relocated_address (struct objfile
*objfile
) override
;
144 unsigned get_argument_count (struct gdbarch
*gdbarch
) override
;
147 bool can_evaluate_arguments () const override
;
150 struct value
*evaluate_argument (unsigned n
,
151 struct frame_info
*frame
) override
;
154 void compile_to_ax (struct agent_expr
*aexpr
,
155 struct axs_value
*axs_value
,
156 unsigned n
) override
;
159 void set_semaphore (struct objfile
*objfile
,
160 struct gdbarch
*gdbarch
) override
;
163 void clear_semaphore (struct objfile
*objfile
,
164 struct gdbarch
*gdbarch
) override
;
167 const static_probe_ops
*get_static_ops () const override
;
170 std::vector
<const char *> gen_info_probes_table_values () const override
;
172 /* Return argument N of probe.
174 If the probe's arguments have not been parsed yet, parse them. If
175 there are no arguments, throw an exception (error). Otherwise,
176 return the requested argument. */
177 struct stap_probe_arg
*get_arg_by_number (unsigned n
,
178 struct gdbarch
*gdbarch
)
180 if (!m_have_parsed_args
)
181 this->parse_arguments (gdbarch
);
183 gdb_assert (m_have_parsed_args
);
184 if (m_parsed_args
.empty ())
185 internal_error (__FILE__
, __LINE__
,
186 _("Probe '%s' apparently does not have arguments, but \n"
187 "GDB is requesting its argument number %u anyway. "
188 "This should not happen. Please report this bug."),
189 this->get_name ().c_str (), n
);
191 if (n
> m_parsed_args
.size ())
192 internal_error (__FILE__
, __LINE__
,
193 _("Probe '%s' has %d arguments, but GDB is requesting\n"
194 "argument %u. This should not happen. Please\n"
196 this->get_name ().c_str (),
197 (int) m_parsed_args
.size (), n
);
199 return &m_parsed_args
[n
];
202 /* Function which parses an argument string from the probe,
203 correctly splitting the arguments and storing their information
206 Consider the following argument string (x86 syntax):
210 We have two arguments, `%eax' and `$10', both with 32-bit
211 unsigned bitness. This function basically handles them, properly
212 filling some structures with this information. */
213 void parse_arguments (struct gdbarch
*gdbarch
);
216 /* If the probe has a semaphore associated, then this is the value of
217 it, relative to SECT_OFF_DATA. */
218 CORE_ADDR m_sem_addr
;
220 /* True if the arguments have been parsed. */
221 bool m_have_parsed_args
;
223 /* The text version of the probe's arguments, unparsed. */
224 const char *m_unparsed_args_text
;
226 /* Information about each argument. This is an array of `stap_probe_arg',
227 with each entry representing one argument. This is only valid if
228 M_ARGS_PARSED is true. */
229 std::vector
<struct stap_probe_arg
> m_parsed_args
;
232 /* When parsing the arguments, we have to establish different precedences
233 for the various kinds of asm operators. This enumeration represents those
236 This logic behind this is available at
237 <http://sourceware.org/binutils/docs/as/Infix-Ops.html#Infix-Ops>, or using
238 the command "info '(as)Infix Ops'". */
240 enum stap_operand_prec
242 /* Lowest precedence, used for non-recognized operands or for the beginning
243 of the parsing process. */
244 STAP_OPERAND_PREC_NONE
= 0,
246 /* Precedence of logical OR. */
247 STAP_OPERAND_PREC_LOGICAL_OR
,
249 /* Precedence of logical AND. */
250 STAP_OPERAND_PREC_LOGICAL_AND
,
252 /* Precedence of additive (plus, minus) and comparative (equal, less,
253 greater-than, etc) operands. */
254 STAP_OPERAND_PREC_ADD_CMP
,
256 /* Precedence of bitwise operands (bitwise OR, XOR, bitwise AND,
258 STAP_OPERAND_PREC_BITWISE
,
260 /* Precedence of multiplicative operands (multiplication, division,
261 remainder, left shift and right shift). */
262 STAP_OPERAND_PREC_MUL
265 static void stap_parse_argument_1 (struct stap_parse_info
*p
, bool has_lhs
,
266 enum stap_operand_prec prec
);
268 static void stap_parse_argument_conditionally (struct stap_parse_info
*p
);
270 /* Returns true if *S is an operator, false otherwise. */
272 static bool stap_is_operator (const char *op
);
275 show_stapexpressiondebug (struct ui_file
*file
, int from_tty
,
276 struct cmd_list_element
*c
, const char *value
)
278 fprintf_filtered (file
, _("SystemTap Probe expression debugging is %s.\n"),
282 /* Returns the operator precedence level of OP, or STAP_OPERAND_PREC_NONE
283 if the operator code was not recognized. */
285 static enum stap_operand_prec
286 stap_get_operator_prec (enum exp_opcode op
)
290 case BINOP_LOGICAL_OR
:
291 return STAP_OPERAND_PREC_LOGICAL_OR
;
293 case BINOP_LOGICAL_AND
:
294 return STAP_OPERAND_PREC_LOGICAL_AND
;
304 return STAP_OPERAND_PREC_ADD_CMP
;
306 case BINOP_BITWISE_IOR
:
307 case BINOP_BITWISE_AND
:
308 case BINOP_BITWISE_XOR
:
309 case UNOP_LOGICAL_NOT
:
310 return STAP_OPERAND_PREC_BITWISE
;
317 return STAP_OPERAND_PREC_MUL
;
320 return STAP_OPERAND_PREC_NONE
;
324 /* Given S, read the operator in it. Return the EXP_OPCODE which
325 represents the operator detected, or throw an error if no operator
328 static enum exp_opcode
329 stap_get_opcode (const char **s
)
384 op
= BINOP_BITWISE_IOR
;
388 op
= BINOP_LOGICAL_OR
;
393 op
= BINOP_BITWISE_AND
;
397 op
= BINOP_LOGICAL_AND
;
402 op
= BINOP_BITWISE_XOR
;
406 op
= UNOP_LOGICAL_NOT
;
418 gdb_assert (**s
== '=');
423 error (_("Invalid opcode in expression `%s' for SystemTap"
430 /* Given the bitness of the argument, represented by B, return the
431 corresponding `struct type *', or throw an error if B is
435 stap_get_expected_argument_type (struct gdbarch
*gdbarch
,
436 enum stap_arg_bitness b
,
437 const char *probe_name
)
441 case STAP_ARG_BITNESS_UNDEFINED
:
442 if (gdbarch_addr_bit (gdbarch
) == 32)
443 return builtin_type (gdbarch
)->builtin_uint32
;
445 return builtin_type (gdbarch
)->builtin_uint64
;
447 case STAP_ARG_BITNESS_8BIT_UNSIGNED
:
448 return builtin_type (gdbarch
)->builtin_uint8
;
450 case STAP_ARG_BITNESS_8BIT_SIGNED
:
451 return builtin_type (gdbarch
)->builtin_int8
;
453 case STAP_ARG_BITNESS_16BIT_UNSIGNED
:
454 return builtin_type (gdbarch
)->builtin_uint16
;
456 case STAP_ARG_BITNESS_16BIT_SIGNED
:
457 return builtin_type (gdbarch
)->builtin_int16
;
459 case STAP_ARG_BITNESS_32BIT_SIGNED
:
460 return builtin_type (gdbarch
)->builtin_int32
;
462 case STAP_ARG_BITNESS_32BIT_UNSIGNED
:
463 return builtin_type (gdbarch
)->builtin_uint32
;
465 case STAP_ARG_BITNESS_64BIT_SIGNED
:
466 return builtin_type (gdbarch
)->builtin_int64
;
468 case STAP_ARG_BITNESS_64BIT_UNSIGNED
:
469 return builtin_type (gdbarch
)->builtin_uint64
;
472 error (_("Undefined bitness for probe '%s'."), probe_name
);
477 /* Helper function to check for a generic list of prefixes. GDBARCH
478 is the current gdbarch being used. S is the expression being
479 analyzed. If R is not NULL, it will be used to return the found
480 prefix. PREFIXES is the list of expected prefixes.
482 This function does a case-insensitive match.
484 Return true if any prefix has been found, false otherwise. */
487 stap_is_generic_prefix (struct gdbarch
*gdbarch
, const char *s
,
488 const char **r
, const char *const *prefixes
)
490 const char *const *p
;
492 if (prefixes
== NULL
)
500 for (p
= prefixes
; *p
!= NULL
; ++p
)
501 if (strncasecmp (s
, *p
, strlen (*p
)) == 0)
512 /* Return true if S points to a register prefix, false otherwise. For
513 a description of the arguments, look at stap_is_generic_prefix. */
516 stap_is_register_prefix (struct gdbarch
*gdbarch
, const char *s
,
519 const char *const *t
= gdbarch_stap_register_prefixes (gdbarch
);
521 return stap_is_generic_prefix (gdbarch
, s
, r
, t
);
524 /* Return true if S points to a register indirection prefix, false
525 otherwise. For a description of the arguments, look at
526 stap_is_generic_prefix. */
529 stap_is_register_indirection_prefix (struct gdbarch
*gdbarch
, const char *s
,
532 const char *const *t
= gdbarch_stap_register_indirection_prefixes (gdbarch
);
534 return stap_is_generic_prefix (gdbarch
, s
, r
, t
);
537 /* Return true if S points to an integer prefix, false otherwise. For
538 a description of the arguments, look at stap_is_generic_prefix.
540 This function takes care of analyzing whether we are dealing with
541 an expected integer prefix, or, if there is no integer prefix to be
542 expected, whether we are dealing with a digit. It does a
543 case-insensitive match. */
546 stap_is_integer_prefix (struct gdbarch
*gdbarch
, const char *s
,
549 const char *const *t
= gdbarch_stap_integer_prefixes (gdbarch
);
550 const char *const *p
;
554 /* A NULL value here means that integers do not have a prefix.
555 We just check for a digit then. */
559 return isdigit (*s
) > 0;
562 for (p
= t
; *p
!= NULL
; ++p
)
564 size_t len
= strlen (*p
);
566 if ((len
== 0 && isdigit (*s
))
567 || (len
> 0 && strncasecmp (s
, *p
, len
) == 0))
569 /* Integers may or may not have a prefix. The "len == 0"
570 check covers the case when integers do not have a prefix
571 (therefore, we just check if we have a digit). The call
572 to "strncasecmp" covers the case when they have a
584 /* Helper function to check for a generic list of suffixes. If we are
585 not expecting any suffixes, then it just returns 1. If we are
586 expecting at least one suffix, then it returns true if a suffix has
587 been found, false otherwise. GDBARCH is the current gdbarch being
588 used. S is the expression being analyzed. If R is not NULL, it
589 will be used to return the found suffix. SUFFIXES is the list of
590 expected suffixes. This function does a case-insensitive
594 stap_generic_check_suffix (struct gdbarch
*gdbarch
, const char *s
,
595 const char **r
, const char *const *suffixes
)
597 const char *const *p
;
600 if (suffixes
== NULL
)
608 for (p
= suffixes
; *p
!= NULL
; ++p
)
609 if (strncasecmp (s
, *p
, strlen (*p
)) == 0)
621 /* Return true if S points to an integer suffix, false otherwise. For
622 a description of the arguments, look at
623 stap_generic_check_suffix. */
626 stap_check_integer_suffix (struct gdbarch
*gdbarch
, const char *s
,
629 const char *const *p
= gdbarch_stap_integer_suffixes (gdbarch
);
631 return stap_generic_check_suffix (gdbarch
, s
, r
, p
);
634 /* Return true if S points to a register suffix, false otherwise. For
635 a description of the arguments, look at
636 stap_generic_check_suffix. */
639 stap_check_register_suffix (struct gdbarch
*gdbarch
, const char *s
,
642 const char *const *p
= gdbarch_stap_register_suffixes (gdbarch
);
644 return stap_generic_check_suffix (gdbarch
, s
, r
, p
);
647 /* Return true if S points to a register indirection suffix, false
648 otherwise. For a description of the arguments, look at
649 stap_generic_check_suffix. */
652 stap_check_register_indirection_suffix (struct gdbarch
*gdbarch
, const char *s
,
655 const char *const *p
= gdbarch_stap_register_indirection_suffixes (gdbarch
);
657 return stap_generic_check_suffix (gdbarch
, s
, r
, p
);
660 /* Function responsible for parsing a register operand according to
661 SystemTap parlance. Assuming:
665 RIP = register indirection prefix
666 RIS = register indirection suffix
668 Then a register operand can be:
670 [RIP] [RP] REGISTER [RS] [RIS]
672 This function takes care of a register's indirection, displacement and
673 direct access. It also takes into consideration the fact that some
674 registers are named differently inside and outside GDB, e.g., PPC's
675 general-purpose registers are represented by integers in the assembly
676 language (e.g., `15' is the 15th general-purpose register), but inside
677 GDB they have a prefix (the letter `r') appended. */
680 stap_parse_register_operand (struct stap_parse_info
*p
)
682 /* Simple flag to indicate whether we have seen a minus signal before
684 bool got_minus
= false;
685 /* Flags to indicate whether this register access is being displaced and/or
688 bool indirect_p
= false;
689 struct gdbarch
*gdbarch
= p
->gdbarch
;
690 /* Needed to generate the register name as a part of an expression. */
692 /* Variables used to extract the register name from the probe's
695 const char *gdb_reg_prefix
= gdbarch_stap_gdb_register_prefix (gdbarch
);
696 const char *gdb_reg_suffix
= gdbarch_stap_gdb_register_suffix (gdbarch
);
697 const char *reg_prefix
;
698 const char *reg_ind_prefix
;
699 const char *reg_suffix
;
700 const char *reg_ind_suffix
;
702 /* Checking for a displacement argument. */
705 /* If it's a plus sign, we don't need to do anything, just advance the
709 else if (*p
->arg
== '-')
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 std::string
regname (start
, p
->arg
- start
);
759 /* We only add the GDB's register prefix/suffix if we are dealing with
760 a numeric register. */
761 if (isdigit (*start
))
763 if (gdb_reg_prefix
!= NULL
)
764 regname
= gdb_reg_prefix
+ regname
;
766 if (gdb_reg_suffix
!= NULL
)
767 regname
+= gdb_reg_suffix
;
770 int regnum
= user_reg_map_name_to_regnum (gdbarch
, regname
.c_str (),
773 /* Is this a valid register name? */
775 error (_("Invalid register name `%s' on expression `%s'."),
776 regname
.c_str (), p
->saved_arg
);
778 /* Check if there's any special treatment that the arch-specific
779 code would like to perform on the register name. */
780 if (gdbarch_stap_adjust_register_p (gdbarch
))
782 std::string newregname
783 = gdbarch_stap_adjust_register (gdbarch
, p
, regname
, regnum
);
785 if (regname
!= newregname
)
787 /* This is just a check we perform to make sure that the
788 arch-dependent code has provided us with a valid
790 regnum
= user_reg_map_name_to_regnum (gdbarch
, newregname
.c_str (),
794 internal_error (__FILE__
, __LINE__
,
795 _("Invalid register name '%s' after replacing it"
796 " (previous name was '%s')"),
797 newregname
.c_str (), regname
.c_str ());
799 regname
= newregname
;
803 write_exp_elt_opcode (&p
->pstate
, OP_REGISTER
);
804 str
.ptr
= regname
.c_str ();
805 str
.length
= regname
.size ();
806 write_exp_string (&p
->pstate
, str
);
807 write_exp_elt_opcode (&p
->pstate
, OP_REGISTER
);
812 write_exp_elt_opcode (&p
->pstate
, BINOP_ADD
);
814 /* Casting to the expected type. */
815 write_exp_elt_opcode (&p
->pstate
, UNOP_CAST
);
816 write_exp_elt_type (&p
->pstate
, lookup_pointer_type (p
->arg_type
));
817 write_exp_elt_opcode (&p
->pstate
, UNOP_CAST
);
819 write_exp_elt_opcode (&p
->pstate
, UNOP_IND
);
822 /* Getting rid of the register name suffix. */
823 if (stap_check_register_suffix (gdbarch
, p
->arg
, ®_suffix
))
824 p
->arg
+= strlen (reg_suffix
);
826 error (_("Missing register name suffix on expression `%s'."),
829 /* Getting rid of the register indirection suffix. */
832 if (stap_check_register_indirection_suffix (gdbarch
, p
->arg
,
834 p
->arg
+= strlen (reg_ind_suffix
);
836 error (_("Missing indirection suffix on expression `%s'."),
841 /* This function is responsible for parsing a single operand.
843 A single operand can be:
845 - an unary operation (e.g., `-5', `~2', or even with subexpressions
847 - a register displacement, which will be treated as a register
848 operand (e.g., `-4(%eax)' on x86)
849 - a numeric constant, or
850 - a register operand (see function `stap_parse_register_operand')
852 The function also calls special-handling functions to deal with
853 unrecognized operands, allowing arch-specific parsers to be
857 stap_parse_single_operand (struct stap_parse_info
*p
)
859 struct gdbarch
*gdbarch
= p
->gdbarch
;
860 const char *int_prefix
= NULL
;
862 /* We first try to parse this token as a "special token". */
863 if (gdbarch_stap_parse_special_token_p (gdbarch
)
864 && (gdbarch_stap_parse_special_token (gdbarch
, p
) != 0))
866 /* If the return value of the above function is not zero,
867 it means it successfully parsed the special token.
869 If it is NULL, we try to parse it using our method. */
873 if (*p
->arg
== '-' || *p
->arg
== '~' || *p
->arg
== '+' || *p
->arg
== '!')
876 /* We use this variable to do a lookahead. */
877 const char *tmp
= p
->arg
;
878 bool has_digit
= false;
880 /* Skipping signal. */
883 /* This is an unary operation. Here is a list of allowed tokens
887 - number (from register displacement)
888 - subexpression (beginning with `(')
890 We handle the register displacement here, and the other cases
892 if (p
->inside_paren_p
)
893 tmp
= skip_spaces (tmp
);
895 while (isdigit (*tmp
))
897 /* We skip the digit here because we are only interested in
898 knowing what kind of unary operation this is. The digit
899 will be handled by one of the functions that will be
900 called below ('stap_parse_argument_conditionally' or
901 'stap_parse_register_operand'). */
906 if (has_digit
&& stap_is_register_indirection_prefix (gdbarch
, tmp
,
909 /* If we are here, it means it is a displacement. The only
910 operations allowed here are `-' and `+'. */
911 if (c
!= '-' && c
!= '+')
912 error (_("Invalid operator `%c' for register displacement "
913 "on expression `%s'."), c
, p
->saved_arg
);
915 stap_parse_register_operand (p
);
919 /* This is not a displacement. We skip the operator, and
920 deal with it when the recursion returns. */
922 stap_parse_argument_conditionally (p
);
924 write_exp_elt_opcode (&p
->pstate
, UNOP_NEG
);
926 write_exp_elt_opcode (&p
->pstate
, UNOP_COMPLEMENT
);
928 write_exp_elt_opcode (&p
->pstate
, UNOP_LOGICAL_NOT
);
931 else if (isdigit (*p
->arg
))
933 /* A temporary variable, needed for lookahead. */
934 const char *tmp
= p
->arg
;
938 /* We can be dealing with a numeric constant, or with a register
940 number
= strtol (tmp
, &endp
, 10);
943 if (p
->inside_paren_p
)
944 tmp
= skip_spaces (tmp
);
946 /* If "stap_is_integer_prefix" returns true, it means we can
947 accept integers without a prefix here. But we also need to
948 check whether the next token (i.e., "tmp") is not a register
949 indirection prefix. */
950 if (stap_is_integer_prefix (gdbarch
, p
->arg
, NULL
)
951 && !stap_is_register_indirection_prefix (gdbarch
, tmp
, NULL
))
953 const char *int_suffix
;
955 /* We are dealing with a numeric constant. */
956 write_exp_elt_opcode (&p
->pstate
, OP_LONG
);
957 write_exp_elt_type (&p
->pstate
,
958 builtin_type (gdbarch
)->builtin_long
);
959 write_exp_elt_longcst (&p
->pstate
, number
);
960 write_exp_elt_opcode (&p
->pstate
, OP_LONG
);
964 if (stap_check_integer_suffix (gdbarch
, p
->arg
, &int_suffix
))
965 p
->arg
+= strlen (int_suffix
);
967 error (_("Invalid constant suffix on expression `%s'."),
970 else if (stap_is_register_indirection_prefix (gdbarch
, tmp
, NULL
))
971 stap_parse_register_operand (p
);
973 error (_("Unknown numeric token on expression `%s'."),
976 else if (stap_is_integer_prefix (gdbarch
, p
->arg
, &int_prefix
))
978 /* We are dealing with a numeric constant. */
981 const char *int_suffix
;
983 p
->arg
+= strlen (int_prefix
);
984 number
= strtol (p
->arg
, &endp
, 10);
987 write_exp_elt_opcode (&p
->pstate
, OP_LONG
);
988 write_exp_elt_type (&p
->pstate
, builtin_type (gdbarch
)->builtin_long
);
989 write_exp_elt_longcst (&p
->pstate
, number
);
990 write_exp_elt_opcode (&p
->pstate
, OP_LONG
);
992 if (stap_check_integer_suffix (gdbarch
, p
->arg
, &int_suffix
))
993 p
->arg
+= strlen (int_suffix
);
995 error (_("Invalid constant suffix on expression `%s'."),
998 else if (stap_is_register_prefix (gdbarch
, p
->arg
, NULL
)
999 || stap_is_register_indirection_prefix (gdbarch
, p
->arg
, NULL
))
1000 stap_parse_register_operand (p
);
1002 error (_("Operator `%c' not recognized on expression `%s'."),
1003 *p
->arg
, p
->saved_arg
);
1006 /* This function parses an argument conditionally, based on single or
1007 non-single operands. A non-single operand would be a parenthesized
1008 expression (e.g., `(2 + 1)'), and a single operand is anything that
1009 starts with `-', `~', `+' (i.e., unary operators), a digit, or
1010 something recognized by `gdbarch_stap_is_single_operand'. */
1013 stap_parse_argument_conditionally (struct stap_parse_info
*p
)
1015 gdb_assert (gdbarch_stap_is_single_operand_p (p
->gdbarch
));
1017 if (*p
->arg
== '-' || *p
->arg
== '~' || *p
->arg
== '+' || *p
->arg
== '!'
1018 || isdigit (*p
->arg
)
1019 || gdbarch_stap_is_single_operand (p
->gdbarch
, p
->arg
))
1020 stap_parse_single_operand (p
);
1021 else if (*p
->arg
== '(')
1023 /* We are dealing with a parenthesized operand. It means we
1024 have to parse it as it was a separate expression, without
1025 left-side or precedence. */
1027 p
->arg
= skip_spaces (p
->arg
);
1028 ++p
->inside_paren_p
;
1030 stap_parse_argument_1 (p
, 0, STAP_OPERAND_PREC_NONE
);
1032 p
->arg
= skip_spaces (p
->arg
);
1034 error (_("Missign close-parenthesis on expression `%s'."),
1037 --p
->inside_paren_p
;
1039 if (p
->inside_paren_p
)
1040 p
->arg
= skip_spaces (p
->arg
);
1043 error (_("Cannot parse expression `%s'."), p
->saved_arg
);
1046 /* Helper function for `stap_parse_argument'. Please, see its comments to
1047 better understand what this function does. */
1050 stap_parse_argument_1 (struct stap_parse_info
*p
, bool has_lhs
,
1051 enum stap_operand_prec prec
)
1053 /* This is an operator-precedence parser.
1055 We work with left- and right-sides of expressions, and
1056 parse them depending on the precedence of the operators
1059 gdb_assert (p
->arg
!= NULL
);
1061 if (p
->inside_paren_p
)
1062 p
->arg
= skip_spaces (p
->arg
);
1066 /* We were called without a left-side, either because this is the
1067 first call, or because we were called to parse a parenthesized
1068 expression. It doesn't really matter; we have to parse the
1069 left-side in order to continue the process. */
1070 stap_parse_argument_conditionally (p
);
1073 if (p
->inside_paren_p
)
1074 p
->arg
= skip_spaces (p
->arg
);
1076 /* Start to parse the right-side, and to "join" left and right sides
1077 depending on the operation specified.
1079 This loop shall continue until we run out of characters in the input,
1080 or until we find a close-parenthesis, which means that we've reached
1081 the end of a sub-expression. */
1082 while (*p
->arg
!= '\0' && *p
->arg
!= ')' && !isspace (*p
->arg
))
1084 const char *tmp_exp_buf
;
1085 enum exp_opcode opcode
;
1086 enum stap_operand_prec cur_prec
;
1088 if (!stap_is_operator (p
->arg
))
1089 error (_("Invalid operator `%c' on expression `%s'."), *p
->arg
,
1092 /* We have to save the current value of the expression buffer because
1093 the `stap_get_opcode' modifies it in order to get the current
1094 operator. If this operator's precedence is lower than PREC, we
1095 should return and not advance the expression buffer pointer. */
1096 tmp_exp_buf
= p
->arg
;
1097 opcode
= stap_get_opcode (&tmp_exp_buf
);
1099 cur_prec
= stap_get_operator_prec (opcode
);
1100 if (cur_prec
< prec
)
1102 /* If the precedence of the operator that we are seeing now is
1103 lower than the precedence of the first operator seen before
1104 this parsing process began, it means we should stop parsing
1109 p
->arg
= tmp_exp_buf
;
1110 if (p
->inside_paren_p
)
1111 p
->arg
= skip_spaces (p
->arg
);
1113 /* Parse the right-side of the expression.
1115 We save whether the right-side is a parenthesized
1116 subexpression because, if it is, we will have to finish
1117 processing this part of the expression before continuing. */
1118 bool paren_subexp
= *p
->arg
== '(';
1120 stap_parse_argument_conditionally (p
);
1121 if (p
->inside_paren_p
)
1122 p
->arg
= skip_spaces (p
->arg
);
1125 write_exp_elt_opcode (&p
->pstate
, opcode
);
1129 /* While we still have operators, try to parse another
1130 right-side, but using the current right-side as a left-side. */
1131 while (*p
->arg
!= '\0' && stap_is_operator (p
->arg
))
1133 enum exp_opcode lookahead_opcode
;
1134 enum stap_operand_prec lookahead_prec
;
1136 /* Saving the current expression buffer position. The explanation
1137 is the same as above. */
1138 tmp_exp_buf
= p
->arg
;
1139 lookahead_opcode
= stap_get_opcode (&tmp_exp_buf
);
1140 lookahead_prec
= stap_get_operator_prec (lookahead_opcode
);
1142 if (lookahead_prec
<= prec
)
1144 /* If we are dealing with an operator whose precedence is lower
1145 than the first one, just abandon the attempt. */
1149 /* Parse the right-side of the expression, but since we already
1150 have a left-side at this point, set `has_lhs' to 1. */
1151 stap_parse_argument_1 (p
, 1, lookahead_prec
);
1152 if (p
->inside_paren_p
)
1153 p
->arg
= skip_spaces (p
->arg
);
1156 write_exp_elt_opcode (&p
->pstate
, opcode
);
1160 /* Parse a probe's argument.
1164 LP = literal integer prefix
1165 LS = literal integer suffix
1167 RP = register prefix
1168 RS = register suffix
1170 RIP = register indirection prefix
1171 RIS = register indirection suffix
1173 This routine assumes that arguments' tokens are of the form:
1176 - [RP] REGISTER [RS]
1177 - [RIP] [RP] REGISTER [RS] [RIS]
1178 - If we find a number without LP, we try to parse it as a literal integer
1179 constant (if LP == NULL), or as a register displacement.
1180 - We count parenthesis, and only skip whitespaces if we are inside them.
1181 - If we find an operator, we skip it.
1183 This function can also call a special function that will try to match
1184 unknown tokens. It will return the expression_up generated from
1185 parsing the argument. */
1187 static expression_up
1188 stap_parse_argument (const char **arg
, struct type
*atype
,
1189 struct gdbarch
*gdbarch
)
1191 /* We need to initialize the expression buffer, in order to begin
1192 our parsing efforts. We use language_c here because we may need
1193 to do pointer arithmetics. */
1194 struct stap_parse_info
p (*arg
, atype
, language_def (language_c
),
1197 stap_parse_argument_1 (&p
, 0, STAP_OPERAND_PREC_NONE
);
1199 gdb_assert (p
.inside_paren_p
== 0);
1201 /* Casting the final expression to the appropriate type. */
1202 write_exp_elt_opcode (&p
.pstate
, UNOP_CAST
);
1203 write_exp_elt_type (&p
.pstate
, atype
);
1204 write_exp_elt_opcode (&p
.pstate
, UNOP_CAST
);
1206 p
.arg
= skip_spaces (p
.arg
);
1209 return p
.pstate
.release ();
1212 /* Implementation of 'parse_arguments' method. */
1215 stap_probe::parse_arguments (struct gdbarch
*gdbarch
)
1219 gdb_assert (!m_have_parsed_args
);
1220 cur
= m_unparsed_args_text
;
1221 m_have_parsed_args
= true;
1223 if (cur
== NULL
|| *cur
== '\0' || *cur
== ':')
1226 while (*cur
!= '\0')
1228 enum stap_arg_bitness bitness
;
1229 bool got_minus
= false;
1231 /* We expect to find something like:
1235 Where `N' can be [+,-][1,2,4,8]. This is not mandatory, so
1236 we check it here. If we don't find it, go to the next
1238 if ((cur
[0] == '-' && isdigit (cur
[1]) && cur
[2] == '@')
1239 || (isdigit (cur
[0]) && cur
[1] == '@'))
1243 /* Discard the `-'. */
1248 /* Defining the bitness. */
1252 bitness
= (got_minus
? STAP_ARG_BITNESS_8BIT_SIGNED
1253 : STAP_ARG_BITNESS_8BIT_UNSIGNED
);
1257 bitness
= (got_minus
? STAP_ARG_BITNESS_16BIT_SIGNED
1258 : STAP_ARG_BITNESS_16BIT_UNSIGNED
);
1262 bitness
= (got_minus
? STAP_ARG_BITNESS_32BIT_SIGNED
1263 : STAP_ARG_BITNESS_32BIT_UNSIGNED
);
1267 bitness
= (got_minus
? STAP_ARG_BITNESS_64BIT_SIGNED
1268 : STAP_ARG_BITNESS_64BIT_UNSIGNED
);
1273 /* We have an error, because we don't expect anything
1274 except 1, 2, 4 and 8. */
1275 warning (_("unrecognized bitness %s%c' for probe `%s'"),
1276 got_minus
? "`-" : "`", *cur
,
1277 this->get_name ().c_str ());
1281 /* Discard the number and the `@' sign. */
1285 bitness
= STAP_ARG_BITNESS_UNDEFINED
;
1288 = stap_get_expected_argument_type (gdbarch
, bitness
,
1289 this->get_name ().c_str ());
1291 expression_up expr
= stap_parse_argument (&cur
, atype
, gdbarch
);
1293 if (stap_expression_debug
)
1294 dump_raw_expression (expr
.get (), gdb_stdlog
,
1295 "before conversion to prefix form");
1297 prefixify_expression (expr
.get ());
1299 if (stap_expression_debug
)
1300 dump_prefix_expression (expr
.get (), gdb_stdlog
);
1302 m_parsed_args
.emplace_back (bitness
, atype
, std::move (expr
));
1304 /* Start it over again. */
1305 cur
= skip_spaces (cur
);
1309 /* Helper function to relocate an address. */
1312 relocate_address (CORE_ADDR address
, struct objfile
*objfile
)
1314 return address
+ objfile
->data_section_offset ();
1317 /* Implementation of the get_relocated_address method. */
1320 stap_probe::get_relocated_address (struct objfile
*objfile
)
1322 return relocate_address (this->get_address (), objfile
);
1325 /* Given PROBE, returns the number of arguments present in that probe's
1329 stap_probe::get_argument_count (struct gdbarch
*gdbarch
)
1331 if (!m_have_parsed_args
)
1333 if (this->can_evaluate_arguments ())
1334 this->parse_arguments (gdbarch
);
1337 static bool have_warned_stap_incomplete
= false;
1339 if (!have_warned_stap_incomplete
)
1342 "The SystemTap SDT probe support is not fully implemented on this target;\n"
1343 "you will not be able to inspect the arguments of the probes.\n"
1344 "Please report a bug against GDB requesting a port to this target."));
1345 have_warned_stap_incomplete
= true;
1348 /* Marking the arguments as "already parsed". */
1349 m_have_parsed_args
= true;
1353 gdb_assert (m_have_parsed_args
);
1354 return m_parsed_args
.size ();
1357 /* Return true if OP is a valid operator inside a probe argument, or
1361 stap_is_operator (const char *op
)
1386 /* We didn't find any operator. */
1393 /* Implement the `can_evaluate_arguments' method. */
1396 stap_probe::can_evaluate_arguments () const
1398 struct gdbarch
*gdbarch
= this->get_gdbarch ();
1400 /* For SystemTap probes, we have to guarantee that the method
1401 stap_is_single_operand is defined on gdbarch. If it is not, then it
1402 means that argument evaluation is not implemented on this target. */
1403 return gdbarch_stap_is_single_operand_p (gdbarch
);
1406 /* Evaluate the probe's argument N (indexed from 0), returning a value
1407 corresponding to it. Assertion is thrown if N does not exist. */
1410 stap_probe::evaluate_argument (unsigned n
, struct frame_info
*frame
)
1412 struct stap_probe_arg
*arg
;
1413 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1415 arg
= this->get_arg_by_number (n
, gdbarch
);
1416 return evaluate_expression (arg
->aexpr
.get (), arg
->atype
);
1419 /* Compile the probe's argument N (indexed from 0) to agent expression.
1420 Assertion is thrown if N does not exist. */
1423 stap_probe::compile_to_ax (struct agent_expr
*expr
, struct axs_value
*value
,
1426 struct stap_probe_arg
*arg
;
1427 union exp_element
*pc
;
1429 arg
= this->get_arg_by_number (n
, expr
->gdbarch
);
1431 pc
= arg
->aexpr
->elts
;
1432 gen_expr (arg
->aexpr
.get (), &pc
, expr
, value
);
1434 require_rvalue (expr
, value
);
1435 value
->type
= arg
->atype
;
1439 /* Set or clear a SystemTap semaphore. ADDRESS is the semaphore's
1440 address. SET is zero if the semaphore should be cleared, or one if
1441 it should be set. This is a helper function for
1442 'stap_probe::set_semaphore' and 'stap_probe::clear_semaphore'. */
1445 stap_modify_semaphore (CORE_ADDR address
, int set
, struct gdbarch
*gdbarch
)
1447 gdb_byte bytes
[sizeof (LONGEST
)];
1448 /* The ABI specifies "unsigned short". */
1449 struct type
*type
= builtin_type (gdbarch
)->builtin_unsigned_short
;
1452 /* Swallow errors. */
1453 if (target_read_memory (address
, bytes
, TYPE_LENGTH (type
)) != 0)
1455 warning (_("Could not read the value of a SystemTap semaphore."));
1459 enum bfd_endian byte_order
= type_byte_order (type
);
1460 value
= extract_unsigned_integer (bytes
, TYPE_LENGTH (type
), byte_order
);
1461 /* Note that we explicitly don't worry about overflow or
1468 store_unsigned_integer (bytes
, TYPE_LENGTH (type
), byte_order
, value
);
1470 if (target_write_memory (address
, bytes
, TYPE_LENGTH (type
)) != 0)
1471 warning (_("Could not write the value of a SystemTap semaphore."));
1474 /* Implementation of the 'set_semaphore' method.
1476 SystemTap semaphores act as reference counters, so calls to this
1477 function must be paired with calls to 'clear_semaphore'.
1479 This function and 'clear_semaphore' race with another tool
1480 changing the probes, but that is too rare to care. */
1483 stap_probe::set_semaphore (struct objfile
*objfile
, struct gdbarch
*gdbarch
)
1485 if (m_sem_addr
== 0)
1487 stap_modify_semaphore (relocate_address (m_sem_addr
, objfile
), 1, gdbarch
);
1490 /* Implementation of the 'clear_semaphore' method. */
1493 stap_probe::clear_semaphore (struct objfile
*objfile
, struct gdbarch
*gdbarch
)
1495 if (m_sem_addr
== 0)
1497 stap_modify_semaphore (relocate_address (m_sem_addr
, objfile
), 0, gdbarch
);
1500 /* Implementation of the 'get_static_ops' method. */
1502 const static_probe_ops
*
1503 stap_probe::get_static_ops () const
1505 return &stap_static_probe_ops
;
1508 /* Implementation of the 'gen_info_probes_table_values' method. */
1510 std::vector
<const char *>
1511 stap_probe::gen_info_probes_table_values () const
1513 const char *val
= NULL
;
1515 if (m_sem_addr
!= 0)
1516 val
= print_core_address (this->get_gdbarch (), m_sem_addr
);
1518 return std::vector
<const char *> { val
};
1521 /* Helper function that parses the information contained in a
1522 SystemTap's probe. Basically, the information consists in:
1524 - Probe's PC address;
1525 - Link-time section address of `.stapsdt.base' section;
1526 - Link-time address of the semaphore variable, or ZERO if the
1527 probe doesn't have an associated semaphore;
1528 - Probe's provider name;
1530 - Probe's argument format. */
1533 handle_stap_probe (struct objfile
*objfile
, struct sdt_note
*el
,
1534 std::vector
<std::unique_ptr
<probe
>> *probesp
,
1537 bfd
*abfd
= objfile
->obfd
;
1538 int size
= bfd_get_arch_size (abfd
) / 8;
1539 struct gdbarch
*gdbarch
= objfile
->arch ();
1540 struct type
*ptr_type
= builtin_type (gdbarch
)->builtin_data_ptr
;
1542 /* Provider and the name of the probe. */
1543 const char *provider
= (const char *) &el
->data
[3 * size
];
1544 const char *name
= ((const char *)
1545 memchr (provider
, '\0',
1546 (char *) el
->data
+ el
->size
- provider
));
1547 /* Making sure there is a name. */
1550 complaint (_("corrupt probe name when reading `%s'"),
1551 objfile_name (objfile
));
1553 /* There is no way to use a probe without a name or a provider, so
1554 returning here makes sense. */
1560 /* Retrieving the probe's address. */
1561 CORE_ADDR address
= extract_typed_address (&el
->data
[0], ptr_type
);
1563 /* Link-time sh_addr of `.stapsdt.base' section. */
1564 CORE_ADDR base_ref
= extract_typed_address (&el
->data
[size
], ptr_type
);
1566 /* Semaphore address. */
1567 CORE_ADDR sem_addr
= extract_typed_address (&el
->data
[2 * size
], ptr_type
);
1569 address
+= base
- base_ref
;
1571 sem_addr
+= base
- base_ref
;
1573 /* Arguments. We can only extract the argument format if there is a valid
1574 name for this probe. */
1575 const char *probe_args
= ((const char*)
1577 (char *) el
->data
+ el
->size
- name
));
1579 if (probe_args
!= NULL
)
1582 if (probe_args
== NULL
1583 || (memchr (probe_args
, '\0', (char *) el
->data
+ el
->size
- name
)
1584 != el
->data
+ el
->size
- 1))
1586 complaint (_("corrupt probe argument when reading `%s'"),
1587 objfile_name (objfile
));
1588 /* If the argument string is NULL, it means some problem happened with
1589 it. So we return. */
1593 stap_probe
*ret
= new stap_probe (std::string (name
), std::string (provider
),
1594 address
, gdbarch
, sem_addr
, probe_args
);
1596 /* Successfully created probe. */
1597 probesp
->emplace_back (ret
);
1600 /* Helper function which iterates over every section in the BFD file,
1601 trying to find the base address of the SystemTap base section.
1602 Returns 1 if found (setting BASE to the proper value), zero otherwise. */
1605 get_stap_base_address (bfd
*obfd
, bfd_vma
*base
)
1607 asection
*ret
= NULL
;
1609 for (asection
*sect
: gdb_bfd_sections (obfd
))
1610 if ((sect
->flags
& (SEC_DATA
| SEC_ALLOC
| SEC_HAS_CONTENTS
))
1611 && sect
->name
&& !strcmp (sect
->name
, STAP_BASE_SECTION_NAME
))
1616 complaint (_("could not obtain base address for "
1617 "SystemTap section on objfile `%s'."),
1618 bfd_get_filename (obfd
));
1628 /* Implementation of the 'is_linespec' method. */
1631 stap_static_probe_ops::is_linespec (const char **linespecp
) const
1633 static const char *const keywords
[] = { "-pstap", "-probe-stap", NULL
};
1635 return probe_is_linespec_by_keyword (linespecp
, keywords
);
1638 /* Implementation of the 'get_probes' method. */
1641 stap_static_probe_ops::get_probes
1642 (std::vector
<std::unique_ptr
<probe
>> *probesp
,
1643 struct objfile
*objfile
) const
1645 /* If we are here, then this is the first time we are parsing the
1646 SystemTap probe's information. We basically have to count how many
1647 probes the objfile has, and then fill in the necessary information
1649 bfd
*obfd
= objfile
->obfd
;
1651 struct sdt_note
*iter
;
1652 unsigned save_probesp_len
= probesp
->size ();
1654 if (objfile
->separate_debug_objfile_backlink
!= NULL
)
1656 /* This is a .debug file, not the objfile itself. */
1660 if (elf_tdata (obfd
)->sdt_note_head
== NULL
)
1662 /* There isn't any probe here. */
1666 if (!get_stap_base_address (obfd
, &base
))
1668 /* There was an error finding the base address for the section.
1669 Just return NULL. */
1673 /* Parsing each probe's information. */
1674 for (iter
= elf_tdata (obfd
)->sdt_note_head
;
1678 /* We first have to handle all the information about the
1679 probe which is present in the section. */
1680 handle_stap_probe (objfile
, iter
, probesp
, base
);
1683 if (save_probesp_len
== probesp
->size ())
1685 /* If we are here, it means we have failed to parse every known
1687 complaint (_("could not parse SystemTap probe(s) from inferior"));
1692 /* Implementation of the type_name method. */
1695 stap_static_probe_ops::type_name () const
1700 /* Implementation of the 'gen_info_probes_table_header' method. */
1702 std::vector
<struct info_probe_column
>
1703 stap_static_probe_ops::gen_info_probes_table_header () const
1705 struct info_probe_column stap_probe_column
;
1707 stap_probe_column
.field_name
= "semaphore";
1708 stap_probe_column
.print_name
= _("Semaphore");
1710 return std::vector
<struct info_probe_column
> { stap_probe_column
};
1713 /* Implementation of the `info probes stap' command. */
1716 info_probes_stap_command (const char *arg
, int from_tty
)
1718 info_probes_for_spops (arg
, from_tty
, &stap_static_probe_ops
);
1721 void _initialize_stap_probe ();
1723 _initialize_stap_probe ()
1725 all_static_probe_ops
.push_back (&stap_static_probe_ops
);
1727 add_setshow_zuinteger_cmd ("stap-expression", class_maintenance
,
1728 &stap_expression_debug
,
1729 _("Set SystemTap expression debugging."),
1730 _("Show SystemTap expression debugging."),
1731 _("When non-zero, the internal representation "
1732 "of SystemTap expressions will be printed."),
1734 show_stapexpressiondebug
,
1735 &setdebuglist
, &showdebuglist
);
1737 add_cmd ("stap", class_info
, info_probes_stap_command
,
1739 Show information about SystemTap static probes.\n\
1740 Usage: info probes stap [PROVIDER [NAME [OBJECT]]]\n\
1741 Each argument is a regular expression, used to select probes.\n\
1742 PROVIDER matches probe provider names.\n\
1743 NAME matches the probe names.\n\
1744 OBJECT matches the executable or shared library name."),
1745 info_probes_cmdlist_get ());