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"
40 #include <unordered_map>
41 #include "gdbsupport/hash_enum.h"
45 /* The name of the SystemTap section where we will find information about
48 #define STAP_BASE_SECTION_NAME ".stapsdt.base"
50 /* Should we display debug information for the probe's argument expression
53 static unsigned int stap_expression_debug
= 0;
55 /* The various possibilities of bitness defined for a probe's argument.
59 - STAP_ARG_BITNESS_UNDEFINED: The user hasn't specified the bitness.
60 - STAP_ARG_BITNESS_8BIT_UNSIGNED: argument string starts with `1@'.
61 - STAP_ARG_BITNESS_8BIT_SIGNED: argument string starts with `-1@'.
62 - STAP_ARG_BITNESS_16BIT_UNSIGNED: argument string starts with `2@'.
63 - STAP_ARG_BITNESS_16BIT_SIGNED: argument string starts with `-2@'.
64 - STAP_ARG_BITNESS_32BIT_UNSIGNED: argument string starts with `4@'.
65 - STAP_ARG_BITNESS_32BIT_SIGNED: argument string starts with `-4@'.
66 - STAP_ARG_BITNESS_64BIT_UNSIGNED: argument string starts with `8@'.
67 - STAP_ARG_BITNESS_64BIT_SIGNED: argument string starts with `-8@'. */
71 STAP_ARG_BITNESS_UNDEFINED
,
72 STAP_ARG_BITNESS_8BIT_UNSIGNED
,
73 STAP_ARG_BITNESS_8BIT_SIGNED
,
74 STAP_ARG_BITNESS_16BIT_UNSIGNED
,
75 STAP_ARG_BITNESS_16BIT_SIGNED
,
76 STAP_ARG_BITNESS_32BIT_UNSIGNED
,
77 STAP_ARG_BITNESS_32BIT_SIGNED
,
78 STAP_ARG_BITNESS_64BIT_UNSIGNED
,
79 STAP_ARG_BITNESS_64BIT_SIGNED
,
82 /* The following structure represents a single argument for the probe. */
86 /* Constructor for stap_probe_arg. */
87 stap_probe_arg (enum stap_arg_bitness bitness_
, struct type
*atype_
,
88 expression_up
&&aexpr_
)
89 : bitness (bitness_
), atype (atype_
), aexpr (std::move (aexpr_
))
92 /* The bitness of this argument. */
93 enum stap_arg_bitness bitness
;
95 /* The corresponding `struct type *' to the bitness. */
98 /* The argument converted to an internal GDB expression. */
102 /* Class that implements the static probe methods for "stap" probes. */
104 class stap_static_probe_ops
: public static_probe_ops
107 /* We need a user-provided constructor to placate some compilers.
108 See PR build/24937. */
109 stap_static_probe_ops ()
114 bool is_linespec (const char **linespecp
) const override
;
117 void get_probes (std::vector
<std::unique_ptr
<probe
>> *probesp
,
118 struct objfile
*objfile
) const override
;
121 const char *type_name () const override
;
124 std::vector
<struct info_probe_column
> gen_info_probes_table_header
128 /* SystemTap static_probe_ops. */
130 const stap_static_probe_ops stap_static_probe_ops
{};
132 class stap_probe
: public probe
135 /* Constructor for stap_probe. */
136 stap_probe (std::string
&&name_
, std::string
&&provider_
, CORE_ADDR address_
,
137 struct gdbarch
*arch_
, CORE_ADDR sem_addr
, const char *args_text
)
138 : probe (std::move (name_
), std::move (provider_
), address_
, arch_
),
139 m_sem_addr (sem_addr
),
140 m_have_parsed_args (false), m_unparsed_args_text (args_text
)
144 CORE_ADDR
get_relocated_address (struct objfile
*objfile
) override
;
147 unsigned get_argument_count (struct gdbarch
*gdbarch
) override
;
150 bool can_evaluate_arguments () const override
;
153 struct value
*evaluate_argument (unsigned n
,
154 struct frame_info
*frame
) override
;
157 void compile_to_ax (struct agent_expr
*aexpr
,
158 struct axs_value
*axs_value
,
159 unsigned n
) override
;
162 void set_semaphore (struct objfile
*objfile
,
163 struct gdbarch
*gdbarch
) override
;
166 void clear_semaphore (struct objfile
*objfile
,
167 struct gdbarch
*gdbarch
) override
;
170 const static_probe_ops
*get_static_ops () const override
;
173 std::vector
<const char *> gen_info_probes_table_values () const override
;
175 /* Return argument N of probe.
177 If the probe's arguments have not been parsed yet, parse them. If
178 there are no arguments, throw an exception (error). Otherwise,
179 return the requested argument. */
180 struct stap_probe_arg
*get_arg_by_number (unsigned n
,
181 struct gdbarch
*gdbarch
)
183 if (!m_have_parsed_args
)
184 this->parse_arguments (gdbarch
);
186 gdb_assert (m_have_parsed_args
);
187 if (m_parsed_args
.empty ())
188 internal_error (__FILE__
, __LINE__
,
189 _("Probe '%s' apparently does not have arguments, but \n"
190 "GDB is requesting its argument number %u anyway. "
191 "This should not happen. Please report this bug."),
192 this->get_name ().c_str (), n
);
194 if (n
> m_parsed_args
.size ())
195 internal_error (__FILE__
, __LINE__
,
196 _("Probe '%s' has %d arguments, but GDB is requesting\n"
197 "argument %u. This should not happen. Please\n"
199 this->get_name ().c_str (),
200 (int) m_parsed_args
.size (), n
);
202 return &m_parsed_args
[n
];
205 /* Function which parses an argument string from the probe,
206 correctly splitting the arguments and storing their information
209 Consider the following argument string (x86 syntax):
213 We have two arguments, `%eax' and `$10', both with 32-bit
214 unsigned bitness. This function basically handles them, properly
215 filling some structures with this information. */
216 void parse_arguments (struct gdbarch
*gdbarch
);
219 /* If the probe has a semaphore associated, then this is the value of
220 it, relative to SECT_OFF_DATA. */
221 CORE_ADDR m_sem_addr
;
223 /* True if the arguments have been parsed. */
224 bool m_have_parsed_args
;
226 /* The text version of the probe's arguments, unparsed. */
227 const char *m_unparsed_args_text
;
229 /* Information about each argument. This is an array of `stap_probe_arg',
230 with each entry representing one argument. This is only valid if
231 M_ARGS_PARSED is true. */
232 std::vector
<struct stap_probe_arg
> m_parsed_args
;
235 /* When parsing the arguments, we have to establish different precedences
236 for the various kinds of asm operators. This enumeration represents those
239 This logic behind this is available at
240 <http://sourceware.org/binutils/docs/as/Infix-Ops.html#Infix-Ops>, or using
241 the command "info '(as)Infix Ops'". */
243 enum stap_operand_prec
245 /* Lowest precedence, used for non-recognized operands or for the beginning
246 of the parsing process. */
247 STAP_OPERAND_PREC_NONE
= 0,
249 /* Precedence of logical OR. */
250 STAP_OPERAND_PREC_LOGICAL_OR
,
252 /* Precedence of logical AND. */
253 STAP_OPERAND_PREC_LOGICAL_AND
,
255 /* Precedence of additive (plus, minus) and comparative (equal, less,
256 greater-than, etc) operands. */
257 STAP_OPERAND_PREC_ADD_CMP
,
259 /* Precedence of bitwise operands (bitwise OR, XOR, bitwise AND,
261 STAP_OPERAND_PREC_BITWISE
,
263 /* Precedence of multiplicative operands (multiplication, division,
264 remainder, left shift and right shift). */
265 STAP_OPERAND_PREC_MUL
268 static expr::operation_up
stap_parse_argument_1 (struct stap_parse_info
*p
,
269 expr::operation_up
&&lhs
,
270 enum stap_operand_prec prec
)
271 ATTRIBUTE_UNUSED_RESULT
;
273 static expr::operation_up stap_parse_argument_conditionally
274 (struct stap_parse_info
*p
) ATTRIBUTE_UNUSED_RESULT
;
276 /* Returns true if *S is an operator, false otherwise. */
278 static bool stap_is_operator (const char *op
);
281 show_stapexpressiondebug (struct ui_file
*file
, int from_tty
,
282 struct cmd_list_element
*c
, const char *value
)
284 fprintf_filtered (file
, _("SystemTap Probe expression debugging is %s.\n"),
288 /* Returns the operator precedence level of OP, or STAP_OPERAND_PREC_NONE
289 if the operator code was not recognized. */
291 static enum stap_operand_prec
292 stap_get_operator_prec (enum exp_opcode op
)
296 case BINOP_LOGICAL_OR
:
297 return STAP_OPERAND_PREC_LOGICAL_OR
;
299 case BINOP_LOGICAL_AND
:
300 return STAP_OPERAND_PREC_LOGICAL_AND
;
310 return STAP_OPERAND_PREC_ADD_CMP
;
312 case BINOP_BITWISE_IOR
:
313 case BINOP_BITWISE_AND
:
314 case BINOP_BITWISE_XOR
:
315 case UNOP_LOGICAL_NOT
:
316 return STAP_OPERAND_PREC_BITWISE
;
323 return STAP_OPERAND_PREC_MUL
;
326 return STAP_OPERAND_PREC_NONE
;
330 /* Given S, read the operator in it. Return the EXP_OPCODE which
331 represents the operator detected, or throw an error if no operator
334 static enum exp_opcode
335 stap_get_opcode (const char **s
)
390 op
= BINOP_BITWISE_IOR
;
394 op
= BINOP_LOGICAL_OR
;
399 op
= BINOP_BITWISE_AND
;
403 op
= BINOP_LOGICAL_AND
;
408 op
= BINOP_BITWISE_XOR
;
412 op
= UNOP_LOGICAL_NOT
;
424 gdb_assert (**s
== '=');
429 error (_("Invalid opcode in expression `%s' for SystemTap"
436 typedef expr::operation_up
binop_maker_ftype (expr::operation_up
&&,
437 expr::operation_up
&&);
438 /* Map from an expression opcode to a function that can create a
439 binary operation of that type. */
440 static std::unordered_map
<exp_opcode
, binop_maker_ftype
*,
441 gdb::hash_enum
<exp_opcode
>> stap_maker_map
;
443 /* Helper function to create a binary operation. */
444 static expr::operation_up
445 stap_make_binop (enum exp_opcode opcode
, expr::operation_up
&&lhs
,
446 expr::operation_up
&&rhs
)
448 auto iter
= stap_maker_map
.find (opcode
);
449 gdb_assert (iter
!= stap_maker_map
.end ());
450 return iter
->second (std::move (lhs
), std::move (rhs
));
453 /* Given the bitness of the argument, represented by B, return the
454 corresponding `struct type *', or throw an error if B is
458 stap_get_expected_argument_type (struct gdbarch
*gdbarch
,
459 enum stap_arg_bitness b
,
460 const char *probe_name
)
464 case STAP_ARG_BITNESS_UNDEFINED
:
465 if (gdbarch_addr_bit (gdbarch
) == 32)
466 return builtin_type (gdbarch
)->builtin_uint32
;
468 return builtin_type (gdbarch
)->builtin_uint64
;
470 case STAP_ARG_BITNESS_8BIT_UNSIGNED
:
471 return builtin_type (gdbarch
)->builtin_uint8
;
473 case STAP_ARG_BITNESS_8BIT_SIGNED
:
474 return builtin_type (gdbarch
)->builtin_int8
;
476 case STAP_ARG_BITNESS_16BIT_UNSIGNED
:
477 return builtin_type (gdbarch
)->builtin_uint16
;
479 case STAP_ARG_BITNESS_16BIT_SIGNED
:
480 return builtin_type (gdbarch
)->builtin_int16
;
482 case STAP_ARG_BITNESS_32BIT_SIGNED
:
483 return builtin_type (gdbarch
)->builtin_int32
;
485 case STAP_ARG_BITNESS_32BIT_UNSIGNED
:
486 return builtin_type (gdbarch
)->builtin_uint32
;
488 case STAP_ARG_BITNESS_64BIT_SIGNED
:
489 return builtin_type (gdbarch
)->builtin_int64
;
491 case STAP_ARG_BITNESS_64BIT_UNSIGNED
:
492 return builtin_type (gdbarch
)->builtin_uint64
;
495 error (_("Undefined bitness for probe '%s'."), probe_name
);
500 /* Helper function to check for a generic list of prefixes. GDBARCH
501 is the current gdbarch being used. S is the expression being
502 analyzed. If R is not NULL, it will be used to return the found
503 prefix. PREFIXES is the list of expected prefixes.
505 This function does a case-insensitive match.
507 Return true if any prefix has been found, false otherwise. */
510 stap_is_generic_prefix (struct gdbarch
*gdbarch
, const char *s
,
511 const char **r
, const char *const *prefixes
)
513 const char *const *p
;
515 if (prefixes
== NULL
)
523 for (p
= prefixes
; *p
!= NULL
; ++p
)
524 if (strncasecmp (s
, *p
, strlen (*p
)) == 0)
535 /* Return true if S points to a register prefix, false otherwise. For
536 a description of the arguments, look at stap_is_generic_prefix. */
539 stap_is_register_prefix (struct gdbarch
*gdbarch
, const char *s
,
542 const char *const *t
= gdbarch_stap_register_prefixes (gdbarch
);
544 return stap_is_generic_prefix (gdbarch
, s
, r
, t
);
547 /* Return true if S points to a register indirection prefix, false
548 otherwise. For a description of the arguments, look at
549 stap_is_generic_prefix. */
552 stap_is_register_indirection_prefix (struct gdbarch
*gdbarch
, const char *s
,
555 const char *const *t
= gdbarch_stap_register_indirection_prefixes (gdbarch
);
557 return stap_is_generic_prefix (gdbarch
, s
, r
, t
);
560 /* Return true if S points to an integer prefix, false otherwise. For
561 a description of the arguments, look at stap_is_generic_prefix.
563 This function takes care of analyzing whether we are dealing with
564 an expected integer prefix, or, if there is no integer prefix to be
565 expected, whether we are dealing with a digit. It does a
566 case-insensitive match. */
569 stap_is_integer_prefix (struct gdbarch
*gdbarch
, const char *s
,
572 const char *const *t
= gdbarch_stap_integer_prefixes (gdbarch
);
573 const char *const *p
;
577 /* A NULL value here means that integers do not have a prefix.
578 We just check for a digit then. */
582 return isdigit (*s
) > 0;
585 for (p
= t
; *p
!= NULL
; ++p
)
587 size_t len
= strlen (*p
);
589 if ((len
== 0 && isdigit (*s
))
590 || (len
> 0 && strncasecmp (s
, *p
, len
) == 0))
592 /* Integers may or may not have a prefix. The "len == 0"
593 check covers the case when integers do not have a prefix
594 (therefore, we just check if we have a digit). The call
595 to "strncasecmp" covers the case when they have a
607 /* Helper function to check for a generic list of suffixes. If we are
608 not expecting any suffixes, then it just returns 1. If we are
609 expecting at least one suffix, then it returns true if a suffix has
610 been found, false otherwise. GDBARCH is the current gdbarch being
611 used. S is the expression being analyzed. If R is not NULL, it
612 will be used to return the found suffix. SUFFIXES is the list of
613 expected suffixes. This function does a case-insensitive
617 stap_generic_check_suffix (struct gdbarch
*gdbarch
, const char *s
,
618 const char **r
, const char *const *suffixes
)
620 const char *const *p
;
623 if (suffixes
== NULL
)
631 for (p
= suffixes
; *p
!= NULL
; ++p
)
632 if (strncasecmp (s
, *p
, strlen (*p
)) == 0)
644 /* Return true if S points to an integer suffix, false otherwise. For
645 a description of the arguments, look at
646 stap_generic_check_suffix. */
649 stap_check_integer_suffix (struct gdbarch
*gdbarch
, const char *s
,
652 const char *const *p
= gdbarch_stap_integer_suffixes (gdbarch
);
654 return stap_generic_check_suffix (gdbarch
, s
, r
, p
);
657 /* Return true if S points to a register suffix, false otherwise. For
658 a description of the arguments, look at
659 stap_generic_check_suffix. */
662 stap_check_register_suffix (struct gdbarch
*gdbarch
, const char *s
,
665 const char *const *p
= gdbarch_stap_register_suffixes (gdbarch
);
667 return stap_generic_check_suffix (gdbarch
, s
, r
, p
);
670 /* Return true if S points to a register indirection suffix, false
671 otherwise. For a description of the arguments, look at
672 stap_generic_check_suffix. */
675 stap_check_register_indirection_suffix (struct gdbarch
*gdbarch
, const char *s
,
678 const char *const *p
= gdbarch_stap_register_indirection_suffixes (gdbarch
);
680 return stap_generic_check_suffix (gdbarch
, s
, r
, p
);
683 /* Function responsible for parsing a register operand according to
684 SystemTap parlance. Assuming:
688 RIP = register indirection prefix
689 RIS = register indirection suffix
691 Then a register operand can be:
693 [RIP] [RP] REGISTER [RS] [RIS]
695 This function takes care of a register's indirection, displacement and
696 direct access. It also takes into consideration the fact that some
697 registers are named differently inside and outside GDB, e.g., PPC's
698 general-purpose registers are represented by integers in the assembly
699 language (e.g., `15' is the 15th general-purpose register), but inside
700 GDB they have a prefix (the letter `r') appended. */
702 static expr::operation_up
703 stap_parse_register_operand (struct stap_parse_info
*p
)
705 /* Simple flag to indicate whether we have seen a minus signal before
707 bool got_minus
= false;
708 /* Flag to indicate whether this register access is being
710 bool indirect_p
= false;
711 struct gdbarch
*gdbarch
= p
->gdbarch
;
712 /* Variables used to extract the register name from the probe's
715 const char *gdb_reg_prefix
= gdbarch_stap_gdb_register_prefix (gdbarch
);
716 const char *gdb_reg_suffix
= gdbarch_stap_gdb_register_suffix (gdbarch
);
717 const char *reg_prefix
;
718 const char *reg_ind_prefix
;
719 const char *reg_suffix
;
720 const char *reg_ind_suffix
;
722 using namespace expr
;
724 /* Checking for a displacement argument. */
727 /* If it's a plus sign, we don't need to do anything, just advance the
731 else if (*p
->arg
== '-')
737 struct type
*long_type
= builtin_type (gdbarch
)->builtin_long
;
738 operation_up disp_op
;
739 if (isdigit (*p
->arg
))
741 /* The value of the displacement. */
745 displacement
= strtol (p
->arg
, &endp
, 10);
748 /* Generating the expression for the displacement. */
750 displacement
= -displacement
;
751 disp_op
= make_operation
<long_const_operation
> (long_type
, displacement
);
754 /* Getting rid of register indirection prefix. */
755 if (stap_is_register_indirection_prefix (gdbarch
, p
->arg
, ®_ind_prefix
))
758 p
->arg
+= strlen (reg_ind_prefix
);
761 if (disp_op
!= nullptr && !indirect_p
)
762 error (_("Invalid register displacement syntax on expression `%s'."),
765 /* Getting rid of register prefix. */
766 if (stap_is_register_prefix (gdbarch
, p
->arg
, ®_prefix
))
767 p
->arg
+= strlen (reg_prefix
);
769 /* Now we should have only the register name. Let's extract it and get
770 the associated number. */
773 /* We assume the register name is composed by letters and numbers. */
774 while (isalnum (*p
->arg
))
777 std::string
regname (start
, p
->arg
- start
);
779 /* We only add the GDB's register prefix/suffix if we are dealing with
780 a numeric register. */
781 if (isdigit (*start
))
783 if (gdb_reg_prefix
!= NULL
)
784 regname
= gdb_reg_prefix
+ regname
;
786 if (gdb_reg_suffix
!= NULL
)
787 regname
+= gdb_reg_suffix
;
790 int regnum
= user_reg_map_name_to_regnum (gdbarch
, regname
.c_str (),
793 /* Is this a valid register name? */
795 error (_("Invalid register name `%s' on expression `%s'."),
796 regname
.c_str (), p
->saved_arg
);
798 /* Check if there's any special treatment that the arch-specific
799 code would like to perform on the register name. */
800 if (gdbarch_stap_adjust_register_p (gdbarch
))
802 std::string newregname
803 = gdbarch_stap_adjust_register (gdbarch
, p
, regname
, regnum
);
805 if (regname
!= newregname
)
807 /* This is just a check we perform to make sure that the
808 arch-dependent code has provided us with a valid
810 regnum
= user_reg_map_name_to_regnum (gdbarch
, newregname
.c_str (),
814 internal_error (__FILE__
, __LINE__
,
815 _("Invalid register name '%s' after replacing it"
816 " (previous name was '%s')"),
817 newregname
.c_str (), regname
.c_str ());
819 regname
= std::move (newregname
);
823 operation_up reg
= make_operation
<register_operation
> (std::move (regname
));
827 if (disp_op
!= nullptr)
828 reg
= make_operation
<add_operation
> (std::move (disp_op
),
831 /* Casting to the expected type. */
832 struct type
*arg_ptr_type
= lookup_pointer_type (p
->arg_type
);
833 reg
= make_operation
<unop_cast_operation
> (std::move (reg
),
835 reg
= make_operation
<unop_ind_operation
> (std::move (reg
));
838 /* Getting rid of the register name suffix. */
839 if (stap_check_register_suffix (gdbarch
, p
->arg
, ®_suffix
))
840 p
->arg
+= strlen (reg_suffix
);
842 error (_("Missing register name suffix on expression `%s'."),
845 /* Getting rid of the register indirection suffix. */
848 if (stap_check_register_indirection_suffix (gdbarch
, p
->arg
,
850 p
->arg
+= strlen (reg_ind_suffix
);
852 error (_("Missing indirection suffix on expression `%s'."),
859 /* This function is responsible for parsing a single operand.
861 A single operand can be:
863 - an unary operation (e.g., `-5', `~2', or even with subexpressions
865 - a register displacement, which will be treated as a register
866 operand (e.g., `-4(%eax)' on x86)
867 - a numeric constant, or
868 - a register operand (see function `stap_parse_register_operand')
870 The function also calls special-handling functions to deal with
871 unrecognized operands, allowing arch-specific parsers to be
874 static expr::operation_up
875 stap_parse_single_operand (struct stap_parse_info
*p
)
877 struct gdbarch
*gdbarch
= p
->gdbarch
;
878 const char *int_prefix
= NULL
;
880 using namespace expr
;
882 /* We first try to parse this token as a "special token". */
883 if (gdbarch_stap_parse_special_token_p (gdbarch
))
885 operation_up token
= gdbarch_stap_parse_special_token (gdbarch
, p
);
886 if (token
!= nullptr)
890 struct type
*long_type
= builtin_type (gdbarch
)->builtin_long
;
892 if (*p
->arg
== '-' || *p
->arg
== '~' || *p
->arg
== '+' || *p
->arg
== '!')
895 /* We use this variable to do a lookahead. */
896 const char *tmp
= p
->arg
;
897 bool has_digit
= false;
899 /* Skipping signal. */
902 /* This is an unary operation. Here is a list of allowed tokens
906 - number (from register displacement)
907 - subexpression (beginning with `(')
909 We handle the register displacement here, and the other cases
911 if (p
->inside_paren_p
)
912 tmp
= skip_spaces (tmp
);
914 while (isdigit (*tmp
))
916 /* We skip the digit here because we are only interested in
917 knowing what kind of unary operation this is. The digit
918 will be handled by one of the functions that will be
919 called below ('stap_parse_argument_conditionally' or
920 'stap_parse_register_operand'). */
925 if (has_digit
&& stap_is_register_indirection_prefix (gdbarch
, tmp
,
928 /* If we are here, it means it is a displacement. The only
929 operations allowed here are `-' and `+'. */
930 if (c
!= '-' && c
!= '+')
931 error (_("Invalid operator `%c' for register displacement "
932 "on expression `%s'."), c
, p
->saved_arg
);
934 result
= stap_parse_register_operand (p
);
938 /* This is not a displacement. We skip the operator, and
939 deal with it when the recursion returns. */
941 result
= stap_parse_argument_conditionally (p
);
943 result
= make_operation
<unary_neg_operation
> (std::move (result
));
945 result
= (make_operation
<unary_complement_operation
>
946 (std::move (result
)));
948 result
= (make_operation
<unary_logical_not_operation
>
949 (std::move (result
)));
952 else if (isdigit (*p
->arg
))
954 /* A temporary variable, needed for lookahead. */
955 const char *tmp
= p
->arg
;
959 /* We can be dealing with a numeric constant, or with a register
961 number
= strtol (tmp
, &endp
, 10);
964 if (p
->inside_paren_p
)
965 tmp
= skip_spaces (tmp
);
967 /* If "stap_is_integer_prefix" returns true, it means we can
968 accept integers without a prefix here. But we also need to
969 check whether the next token (i.e., "tmp") is not a register
970 indirection prefix. */
971 if (stap_is_integer_prefix (gdbarch
, p
->arg
, NULL
)
972 && !stap_is_register_indirection_prefix (gdbarch
, tmp
, NULL
))
974 const char *int_suffix
;
976 /* We are dealing with a numeric constant. */
977 result
= make_operation
<long_const_operation
> (long_type
, number
);
981 if (stap_check_integer_suffix (gdbarch
, p
->arg
, &int_suffix
))
982 p
->arg
+= strlen (int_suffix
);
984 error (_("Invalid constant suffix on expression `%s'."),
987 else if (stap_is_register_indirection_prefix (gdbarch
, tmp
, NULL
))
988 result
= stap_parse_register_operand (p
);
990 error (_("Unknown numeric token on expression `%s'."),
993 else if (stap_is_integer_prefix (gdbarch
, p
->arg
, &int_prefix
))
995 /* We are dealing with a numeric constant. */
998 const char *int_suffix
;
1000 p
->arg
+= strlen (int_prefix
);
1001 number
= strtol (p
->arg
, &endp
, 10);
1004 result
= make_operation
<long_const_operation
> (long_type
, number
);
1006 if (stap_check_integer_suffix (gdbarch
, p
->arg
, &int_suffix
))
1007 p
->arg
+= strlen (int_suffix
);
1009 error (_("Invalid constant suffix on expression `%s'."),
1012 else if (stap_is_register_prefix (gdbarch
, p
->arg
, NULL
)
1013 || stap_is_register_indirection_prefix (gdbarch
, p
->arg
, NULL
))
1014 result
= stap_parse_register_operand (p
);
1016 error (_("Operator `%c' not recognized on expression `%s'."),
1017 *p
->arg
, p
->saved_arg
);
1022 /* This function parses an argument conditionally, based on single or
1023 non-single operands. A non-single operand would be a parenthesized
1024 expression (e.g., `(2 + 1)'), and a single operand is anything that
1025 starts with `-', `~', `+' (i.e., unary operators), a digit, or
1026 something recognized by `gdbarch_stap_is_single_operand'. */
1028 static expr::operation_up
1029 stap_parse_argument_conditionally (struct stap_parse_info
*p
)
1031 gdb_assert (gdbarch_stap_is_single_operand_p (p
->gdbarch
));
1033 expr::operation_up result
;
1034 if (*p
->arg
== '-' || *p
->arg
== '~' || *p
->arg
== '+' || *p
->arg
== '!'
1035 || isdigit (*p
->arg
)
1036 || gdbarch_stap_is_single_operand (p
->gdbarch
, p
->arg
))
1037 result
= stap_parse_single_operand (p
);
1038 else if (*p
->arg
== '(')
1040 /* We are dealing with a parenthesized operand. It means we
1041 have to parse it as it was a separate expression, without
1042 left-side or precedence. */
1044 p
->arg
= skip_spaces (p
->arg
);
1045 ++p
->inside_paren_p
;
1047 result
= stap_parse_argument_1 (p
, {}, STAP_OPERAND_PREC_NONE
);
1049 p
->arg
= skip_spaces (p
->arg
);
1051 error (_("Missing close-parenthesis on expression `%s'."),
1054 --p
->inside_paren_p
;
1056 if (p
->inside_paren_p
)
1057 p
->arg
= skip_spaces (p
->arg
);
1060 error (_("Cannot parse expression `%s'."), p
->saved_arg
);
1065 /* Helper function for `stap_parse_argument'. Please, see its comments to
1066 better understand what this function does. */
1068 static expr::operation_up ATTRIBUTE_UNUSED_RESULT
1069 stap_parse_argument_1 (struct stap_parse_info
*p
,
1070 expr::operation_up
&&lhs_in
,
1071 enum stap_operand_prec prec
)
1073 /* This is an operator-precedence parser.
1075 We work with left- and right-sides of expressions, and
1076 parse them depending on the precedence of the operators
1079 gdb_assert (p
->arg
!= NULL
);
1081 if (p
->inside_paren_p
)
1082 p
->arg
= skip_spaces (p
->arg
);
1084 using namespace expr
;
1085 operation_up lhs
= std::move (lhs_in
);
1088 /* We were called without a left-side, either because this is the
1089 first call, or because we were called to parse a parenthesized
1090 expression. It doesn't really matter; we have to parse the
1091 left-side in order to continue the process. */
1092 lhs
= stap_parse_argument_conditionally (p
);
1095 if (p
->inside_paren_p
)
1096 p
->arg
= skip_spaces (p
->arg
);
1098 /* Start to parse the right-side, and to "join" left and right sides
1099 depending on the operation specified.
1101 This loop shall continue until we run out of characters in the input,
1102 or until we find a close-parenthesis, which means that we've reached
1103 the end of a sub-expression. */
1104 while (*p
->arg
!= '\0' && *p
->arg
!= ')' && !isspace (*p
->arg
))
1106 const char *tmp_exp_buf
;
1107 enum exp_opcode opcode
;
1108 enum stap_operand_prec cur_prec
;
1110 if (!stap_is_operator (p
->arg
))
1111 error (_("Invalid operator `%c' on expression `%s'."), *p
->arg
,
1114 /* We have to save the current value of the expression buffer because
1115 the `stap_get_opcode' modifies it in order to get the current
1116 operator. If this operator's precedence is lower than PREC, we
1117 should return and not advance the expression buffer pointer. */
1118 tmp_exp_buf
= p
->arg
;
1119 opcode
= stap_get_opcode (&tmp_exp_buf
);
1121 cur_prec
= stap_get_operator_prec (opcode
);
1122 if (cur_prec
< prec
)
1124 /* If the precedence of the operator that we are seeing now is
1125 lower than the precedence of the first operator seen before
1126 this parsing process began, it means we should stop parsing
1131 p
->arg
= tmp_exp_buf
;
1132 if (p
->inside_paren_p
)
1133 p
->arg
= skip_spaces (p
->arg
);
1135 /* Parse the right-side of the expression.
1137 We save whether the right-side is a parenthesized
1138 subexpression because, if it is, we will have to finish
1139 processing this part of the expression before continuing. */
1140 bool paren_subexp
= *p
->arg
== '(';
1142 operation_up rhs
= stap_parse_argument_conditionally (p
);
1143 if (p
->inside_paren_p
)
1144 p
->arg
= skip_spaces (p
->arg
);
1147 lhs
= stap_make_binop (opcode
, std::move (lhs
), std::move (rhs
));
1151 /* While we still have operators, try to parse another
1152 right-side, but using the current right-side as a left-side. */
1153 while (*p
->arg
!= '\0' && stap_is_operator (p
->arg
))
1155 enum exp_opcode lookahead_opcode
;
1156 enum stap_operand_prec lookahead_prec
;
1158 /* Saving the current expression buffer position. The explanation
1159 is the same as above. */
1160 tmp_exp_buf
= p
->arg
;
1161 lookahead_opcode
= stap_get_opcode (&tmp_exp_buf
);
1162 lookahead_prec
= stap_get_operator_prec (lookahead_opcode
);
1164 if (lookahead_prec
<= prec
)
1166 /* If we are dealing with an operator whose precedence is lower
1167 than the first one, just abandon the attempt. */
1171 /* Parse the right-side of the expression, using the current
1172 right-hand-side as the left-hand-side of the new
1174 rhs
= stap_parse_argument_1 (p
, std::move (rhs
), lookahead_prec
);
1175 if (p
->inside_paren_p
)
1176 p
->arg
= skip_spaces (p
->arg
);
1179 lhs
= stap_make_binop (opcode
, std::move (lhs
), std::move (rhs
));
1185 /* Parse a probe's argument.
1189 LP = literal integer prefix
1190 LS = literal integer suffix
1192 RP = register prefix
1193 RS = register suffix
1195 RIP = register indirection prefix
1196 RIS = register indirection suffix
1198 This routine assumes that arguments' tokens are of the form:
1201 - [RP] REGISTER [RS]
1202 - [RIP] [RP] REGISTER [RS] [RIS]
1203 - If we find a number without LP, we try to parse it as a literal integer
1204 constant (if LP == NULL), or as a register displacement.
1205 - We count parenthesis, and only skip whitespaces if we are inside them.
1206 - If we find an operator, we skip it.
1208 This function can also call a special function that will try to match
1209 unknown tokens. It will return the expression_up generated from
1210 parsing the argument. */
1212 static expression_up
1213 stap_parse_argument (const char **arg
, struct type
*atype
,
1214 struct gdbarch
*gdbarch
)
1216 /* We need to initialize the expression buffer, in order to begin
1217 our parsing efforts. We use language_c here because we may need
1218 to do pointer arithmetics. */
1219 struct stap_parse_info
p (*arg
, atype
, language_def (language_c
),
1222 using namespace expr
;
1223 operation_up result
= stap_parse_argument_1 (&p
, {}, STAP_OPERAND_PREC_NONE
);
1225 gdb_assert (p
.inside_paren_p
== 0);
1227 /* Casting the final expression to the appropriate type. */
1228 result
= make_operation
<unop_cast_operation
> (std::move (result
), atype
);
1229 p
.pstate
.set_operation (std::move (result
));
1231 p
.arg
= skip_spaces (p
.arg
);
1234 return p
.pstate
.release ();
1237 /* Implementation of 'parse_arguments' method. */
1240 stap_probe::parse_arguments (struct gdbarch
*gdbarch
)
1244 gdb_assert (!m_have_parsed_args
);
1245 cur
= m_unparsed_args_text
;
1246 m_have_parsed_args
= true;
1248 if (cur
== NULL
|| *cur
== '\0' || *cur
== ':')
1251 while (*cur
!= '\0')
1253 enum stap_arg_bitness bitness
;
1254 bool got_minus
= false;
1256 /* We expect to find something like:
1260 Where `N' can be [+,-][1,2,4,8]. This is not mandatory, so
1261 we check it here. If we don't find it, go to the next
1263 if ((cur
[0] == '-' && isdigit (cur
[1]) && cur
[2] == '@')
1264 || (isdigit (cur
[0]) && cur
[1] == '@'))
1268 /* Discard the `-'. */
1273 /* Defining the bitness. */
1277 bitness
= (got_minus
? STAP_ARG_BITNESS_8BIT_SIGNED
1278 : STAP_ARG_BITNESS_8BIT_UNSIGNED
);
1282 bitness
= (got_minus
? STAP_ARG_BITNESS_16BIT_SIGNED
1283 : STAP_ARG_BITNESS_16BIT_UNSIGNED
);
1287 bitness
= (got_minus
? STAP_ARG_BITNESS_32BIT_SIGNED
1288 : STAP_ARG_BITNESS_32BIT_UNSIGNED
);
1292 bitness
= (got_minus
? STAP_ARG_BITNESS_64BIT_SIGNED
1293 : STAP_ARG_BITNESS_64BIT_UNSIGNED
);
1298 /* We have an error, because we don't expect anything
1299 except 1, 2, 4 and 8. */
1300 warning (_("unrecognized bitness %s%c' for probe `%s'"),
1301 got_minus
? "`-" : "`", *cur
,
1302 this->get_name ().c_str ());
1306 /* Discard the number and the `@' sign. */
1310 bitness
= STAP_ARG_BITNESS_UNDEFINED
;
1313 = stap_get_expected_argument_type (gdbarch
, bitness
,
1314 this->get_name ().c_str ());
1316 expression_up expr
= stap_parse_argument (&cur
, atype
, gdbarch
);
1318 if (stap_expression_debug
)
1319 dump_prefix_expression (expr
.get (), gdb_stdlog
);
1321 m_parsed_args
.emplace_back (bitness
, atype
, std::move (expr
));
1323 /* Start it over again. */
1324 cur
= skip_spaces (cur
);
1328 /* Helper function to relocate an address. */
1331 relocate_address (CORE_ADDR address
, struct objfile
*objfile
)
1333 return address
+ objfile
->data_section_offset ();
1336 /* Implementation of the get_relocated_address method. */
1339 stap_probe::get_relocated_address (struct objfile
*objfile
)
1341 return relocate_address (this->get_address (), objfile
);
1344 /* Given PROBE, returns the number of arguments present in that probe's
1348 stap_probe::get_argument_count (struct gdbarch
*gdbarch
)
1350 if (!m_have_parsed_args
)
1352 if (this->can_evaluate_arguments ())
1353 this->parse_arguments (gdbarch
);
1356 static bool have_warned_stap_incomplete
= false;
1358 if (!have_warned_stap_incomplete
)
1361 "The SystemTap SDT probe support is not fully implemented on this target;\n"
1362 "you will not be able to inspect the arguments of the probes.\n"
1363 "Please report a bug against GDB requesting a port to this target."));
1364 have_warned_stap_incomplete
= true;
1367 /* Marking the arguments as "already parsed". */
1368 m_have_parsed_args
= true;
1372 gdb_assert (m_have_parsed_args
);
1373 return m_parsed_args
.size ();
1376 /* Return true if OP is a valid operator inside a probe argument, or
1380 stap_is_operator (const char *op
)
1405 /* We didn't find any operator. */
1412 /* Implement the `can_evaluate_arguments' method. */
1415 stap_probe::can_evaluate_arguments () const
1417 struct gdbarch
*gdbarch
= this->get_gdbarch ();
1419 /* For SystemTap probes, we have to guarantee that the method
1420 stap_is_single_operand is defined on gdbarch. If it is not, then it
1421 means that argument evaluation is not implemented on this target. */
1422 return gdbarch_stap_is_single_operand_p (gdbarch
);
1425 /* Evaluate the probe's argument N (indexed from 0), returning a value
1426 corresponding to it. Assertion is thrown if N does not exist. */
1429 stap_probe::evaluate_argument (unsigned n
, struct frame_info
*frame
)
1431 struct stap_probe_arg
*arg
;
1432 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1434 arg
= this->get_arg_by_number (n
, gdbarch
);
1435 return evaluate_expression (arg
->aexpr
.get (), arg
->atype
);
1438 /* Compile the probe's argument N (indexed from 0) to agent expression.
1439 Assertion is thrown if N does not exist. */
1442 stap_probe::compile_to_ax (struct agent_expr
*expr
, struct axs_value
*value
,
1445 struct stap_probe_arg
*arg
;
1447 arg
= this->get_arg_by_number (n
, expr
->gdbarch
);
1449 arg
->aexpr
->op
->generate_ax (arg
->aexpr
.get (), expr
, value
);
1451 require_rvalue (expr
, value
);
1452 value
->type
= arg
->atype
;
1456 /* Set or clear a SystemTap semaphore. ADDRESS is the semaphore's
1457 address. SET is zero if the semaphore should be cleared, or one if
1458 it should be set. This is a helper function for
1459 'stap_probe::set_semaphore' and 'stap_probe::clear_semaphore'. */
1462 stap_modify_semaphore (CORE_ADDR address
, int set
, struct gdbarch
*gdbarch
)
1464 gdb_byte bytes
[sizeof (LONGEST
)];
1465 /* The ABI specifies "unsigned short". */
1466 struct type
*type
= builtin_type (gdbarch
)->builtin_unsigned_short
;
1469 /* Swallow errors. */
1470 if (target_read_memory (address
, bytes
, TYPE_LENGTH (type
)) != 0)
1472 warning (_("Could not read the value of a SystemTap semaphore."));
1476 enum bfd_endian byte_order
= type_byte_order (type
);
1477 value
= extract_unsigned_integer (bytes
, TYPE_LENGTH (type
), byte_order
);
1478 /* Note that we explicitly don't worry about overflow or
1485 store_unsigned_integer (bytes
, TYPE_LENGTH (type
), byte_order
, value
);
1487 if (target_write_memory (address
, bytes
, TYPE_LENGTH (type
)) != 0)
1488 warning (_("Could not write the value of a SystemTap semaphore."));
1491 /* Implementation of the 'set_semaphore' method.
1493 SystemTap semaphores act as reference counters, so calls to this
1494 function must be paired with calls to 'clear_semaphore'.
1496 This function and 'clear_semaphore' race with another tool
1497 changing the probes, but that is too rare to care. */
1500 stap_probe::set_semaphore (struct objfile
*objfile
, struct gdbarch
*gdbarch
)
1502 if (m_sem_addr
== 0)
1504 stap_modify_semaphore (relocate_address (m_sem_addr
, objfile
), 1, gdbarch
);
1507 /* Implementation of the 'clear_semaphore' method. */
1510 stap_probe::clear_semaphore (struct objfile
*objfile
, struct gdbarch
*gdbarch
)
1512 if (m_sem_addr
== 0)
1514 stap_modify_semaphore (relocate_address (m_sem_addr
, objfile
), 0, gdbarch
);
1517 /* Implementation of the 'get_static_ops' method. */
1519 const static_probe_ops
*
1520 stap_probe::get_static_ops () const
1522 return &stap_static_probe_ops
;
1525 /* Implementation of the 'gen_info_probes_table_values' method. */
1527 std::vector
<const char *>
1528 stap_probe::gen_info_probes_table_values () const
1530 const char *val
= NULL
;
1532 if (m_sem_addr
!= 0)
1533 val
= print_core_address (this->get_gdbarch (), m_sem_addr
);
1535 return std::vector
<const char *> { val
};
1538 /* Helper function that parses the information contained in a
1539 SystemTap's probe. Basically, the information consists in:
1541 - Probe's PC address;
1542 - Link-time section address of `.stapsdt.base' section;
1543 - Link-time address of the semaphore variable, or ZERO if the
1544 probe doesn't have an associated semaphore;
1545 - Probe's provider name;
1547 - Probe's argument format. */
1550 handle_stap_probe (struct objfile
*objfile
, struct sdt_note
*el
,
1551 std::vector
<std::unique_ptr
<probe
>> *probesp
,
1554 bfd
*abfd
= objfile
->obfd
;
1555 int size
= bfd_get_arch_size (abfd
) / 8;
1556 struct gdbarch
*gdbarch
= objfile
->arch ();
1557 struct type
*ptr_type
= builtin_type (gdbarch
)->builtin_data_ptr
;
1559 /* Provider and the name of the probe. */
1560 const char *provider
= (const char *) &el
->data
[3 * size
];
1561 const char *name
= ((const char *)
1562 memchr (provider
, '\0',
1563 (char *) el
->data
+ el
->size
- provider
));
1564 /* Making sure there is a name. */
1567 complaint (_("corrupt probe name when reading `%s'"),
1568 objfile_name (objfile
));
1570 /* There is no way to use a probe without a name or a provider, so
1571 returning here makes sense. */
1577 /* Retrieving the probe's address. */
1578 CORE_ADDR address
= extract_typed_address (&el
->data
[0], ptr_type
);
1580 /* Link-time sh_addr of `.stapsdt.base' section. */
1581 CORE_ADDR base_ref
= extract_typed_address (&el
->data
[size
], ptr_type
);
1583 /* Semaphore address. */
1584 CORE_ADDR sem_addr
= extract_typed_address (&el
->data
[2 * size
], ptr_type
);
1586 address
+= base
- base_ref
;
1588 sem_addr
+= base
- base_ref
;
1590 /* Arguments. We can only extract the argument format if there is a valid
1591 name for this probe. */
1592 const char *probe_args
= ((const char*)
1594 (char *) el
->data
+ el
->size
- name
));
1596 if (probe_args
!= NULL
)
1599 if (probe_args
== NULL
1600 || (memchr (probe_args
, '\0', (char *) el
->data
+ el
->size
- name
)
1601 != el
->data
+ el
->size
- 1))
1603 complaint (_("corrupt probe argument when reading `%s'"),
1604 objfile_name (objfile
));
1605 /* If the argument string is NULL, it means some problem happened with
1606 it. So we return. */
1610 stap_probe
*ret
= new stap_probe (std::string (name
), std::string (provider
),
1611 address
, gdbarch
, sem_addr
, probe_args
);
1613 /* Successfully created probe. */
1614 probesp
->emplace_back (ret
);
1617 /* Helper function which iterates over every section in the BFD file,
1618 trying to find the base address of the SystemTap base section.
1619 Returns 1 if found (setting BASE to the proper value), zero otherwise. */
1622 get_stap_base_address (bfd
*obfd
, bfd_vma
*base
)
1624 asection
*ret
= NULL
;
1626 for (asection
*sect
: gdb_bfd_sections (obfd
))
1627 if ((sect
->flags
& (SEC_DATA
| SEC_ALLOC
| SEC_HAS_CONTENTS
))
1628 && sect
->name
&& !strcmp (sect
->name
, STAP_BASE_SECTION_NAME
))
1633 complaint (_("could not obtain base address for "
1634 "SystemTap section on objfile `%s'."),
1635 bfd_get_filename (obfd
));
1645 /* Implementation of the 'is_linespec' method. */
1648 stap_static_probe_ops::is_linespec (const char **linespecp
) const
1650 static const char *const keywords
[] = { "-pstap", "-probe-stap", NULL
};
1652 return probe_is_linespec_by_keyword (linespecp
, keywords
);
1655 /* Implementation of the 'get_probes' method. */
1658 stap_static_probe_ops::get_probes
1659 (std::vector
<std::unique_ptr
<probe
>> *probesp
,
1660 struct objfile
*objfile
) const
1662 /* If we are here, then this is the first time we are parsing the
1663 SystemTap probe's information. We basically have to count how many
1664 probes the objfile has, and then fill in the necessary information
1666 bfd
*obfd
= objfile
->obfd
;
1668 struct sdt_note
*iter
;
1669 unsigned save_probesp_len
= probesp
->size ();
1671 if (objfile
->separate_debug_objfile_backlink
!= NULL
)
1673 /* This is a .debug file, not the objfile itself. */
1677 if (elf_tdata (obfd
)->sdt_note_head
== NULL
)
1679 /* There isn't any probe here. */
1683 if (!get_stap_base_address (obfd
, &base
))
1685 /* There was an error finding the base address for the section.
1686 Just return NULL. */
1690 /* Parsing each probe's information. */
1691 for (iter
= elf_tdata (obfd
)->sdt_note_head
;
1695 /* We first have to handle all the information about the
1696 probe which is present in the section. */
1697 handle_stap_probe (objfile
, iter
, probesp
, base
);
1700 if (save_probesp_len
== probesp
->size ())
1702 /* If we are here, it means we have failed to parse every known
1704 complaint (_("could not parse SystemTap probe(s) from inferior"));
1709 /* Implementation of the type_name method. */
1712 stap_static_probe_ops::type_name () const
1717 /* Implementation of the 'gen_info_probes_table_header' method. */
1719 std::vector
<struct info_probe_column
>
1720 stap_static_probe_ops::gen_info_probes_table_header () const
1722 struct info_probe_column stap_probe_column
;
1724 stap_probe_column
.field_name
= "semaphore";
1725 stap_probe_column
.print_name
= _("Semaphore");
1727 return std::vector
<struct info_probe_column
> { stap_probe_column
};
1730 /* Implementation of the `info probes stap' command. */
1733 info_probes_stap_command (const char *arg
, int from_tty
)
1735 info_probes_for_spops (arg
, from_tty
, &stap_static_probe_ops
);
1738 void _initialize_stap_probe ();
1740 _initialize_stap_probe ()
1742 all_static_probe_ops
.push_back (&stap_static_probe_ops
);
1744 add_setshow_zuinteger_cmd ("stap-expression", class_maintenance
,
1745 &stap_expression_debug
,
1746 _("Set SystemTap expression debugging."),
1747 _("Show SystemTap expression debugging."),
1748 _("When non-zero, the internal representation "
1749 "of SystemTap expressions will be printed."),
1751 show_stapexpressiondebug
,
1752 &setdebuglist
, &showdebuglist
);
1754 add_cmd ("stap", class_info
, info_probes_stap_command
,
1756 Show information about SystemTap static probes.\n\
1757 Usage: info probes stap [PROVIDER [NAME [OBJECT]]]\n\
1758 Each argument is a regular expression, used to select probes.\n\
1759 PROVIDER matches probe provider names.\n\
1760 NAME matches the probe names.\n\
1761 OBJECT matches the executable or shared library name."),
1762 info_probes_cmdlist_get ());
1765 using namespace expr
;
1766 stap_maker_map
[BINOP_ADD
] = make_operation
<add_operation
>;
1767 stap_maker_map
[BINOP_BITWISE_AND
] = make_operation
<bitwise_and_operation
>;
1768 stap_maker_map
[BINOP_BITWISE_IOR
] = make_operation
<bitwise_ior_operation
>;
1769 stap_maker_map
[BINOP_BITWISE_XOR
] = make_operation
<bitwise_xor_operation
>;
1770 stap_maker_map
[BINOP_DIV
] = make_operation
<div_operation
>;
1771 stap_maker_map
[BINOP_EQUAL
] = make_operation
<equal_operation
>;
1772 stap_maker_map
[BINOP_GEQ
] = make_operation
<geq_operation
>;
1773 stap_maker_map
[BINOP_GTR
] = make_operation
<gtr_operation
>;
1774 stap_maker_map
[BINOP_LEQ
] = make_operation
<leq_operation
>;
1775 stap_maker_map
[BINOP_LESS
] = make_operation
<less_operation
>;
1776 stap_maker_map
[BINOP_LOGICAL_AND
] = make_operation
<logical_and_operation
>;
1777 stap_maker_map
[BINOP_LOGICAL_OR
] = make_operation
<logical_or_operation
>;
1778 stap_maker_map
[BINOP_LSH
] = make_operation
<lsh_operation
>;
1779 stap_maker_map
[BINOP_MUL
] = make_operation
<mul_operation
>;
1780 stap_maker_map
[BINOP_NOTEQUAL
] = make_operation
<notequal_operation
>;
1781 stap_maker_map
[BINOP_REM
] = make_operation
<rem_operation
>;
1782 stap_maker_map
[BINOP_RSH
] = make_operation
<rsh_operation
>;
1783 stap_maker_map
[BINOP_SUB
] = make_operation
<sub_operation
>;