1 /* SystemTap probe support for GDB.
3 Copyright (C) 2012 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"
26 #include "arch-utils.h"
29 #include "filenames.h"
31 #include "exceptions.h"
34 #include "complaints.h"
35 #include "cli/cli-utils.h"
37 #include "user-regs.h"
38 #include "parser-defs.h"
44 /* The name of the SystemTap section where we will find information about
47 #define STAP_BASE_SECTION_NAME ".stapsdt.base"
49 /* Forward declaration. */
51 static const struct probe_ops stap_probe_ops
;
53 /* Should we display debug information for the probe's argument expression
56 static int stap_expression_debug
= 0;
58 /* The various possibilities of bitness defined for a probe's argument.
62 - STAP_ARG_BITNESS_UNDEFINED: The user hasn't specified the bitness.
63 - STAP_ARG_BITNESS_32BIT_UNSIGNED: argument string starts with `4@'.
64 - STAP_ARG_BITNESS_32BIT_SIGNED: argument string starts with `-4@'.
65 - STAP_ARG_BITNESS_64BIT_UNSIGNED: argument string starts with `8@'.
66 - STAP_ARG_BITNESS_64BIT_SIGNED: argument string starts with `-8@'. */
70 STAP_ARG_BITNESS_UNDEFINED
,
71 STAP_ARG_BITNESS_32BIT_UNSIGNED
,
72 STAP_ARG_BITNESS_32BIT_SIGNED
,
73 STAP_ARG_BITNESS_64BIT_UNSIGNED
,
74 STAP_ARG_BITNESS_64BIT_SIGNED
,
77 /* The following structure represents a single argument for the probe. */
81 /* The bitness of this argument. */
82 enum stap_arg_bitness bitness
;
84 /* The corresponding `struct type *' to the bitness. */
87 /* The argument converted to an internal GDB expression. */
88 struct expression
*aexpr
;
91 typedef struct stap_probe_arg stap_probe_arg_s
;
92 DEF_VEC_O (stap_probe_arg_s
);
96 /* Generic information about the probe. This shall be the first element
97 of this struct, in order to maintain binary compatibility with the
98 `struct probe' and be able to fully abstract it. */
101 /* If the probe has a semaphore associated, then this is the value of
105 unsigned int args_parsed
: 1;
110 /* Information about each argument. This is an array of `stap_probe_arg',
111 with each entry representing one argument. */
112 VEC (stap_probe_arg_s
) *vec
;
117 /* When parsing the arguments, we have to establish different precedences
118 for the various kinds of asm operators. This enumeration represents those
121 This logic behind this is available at
122 <http://sourceware.org/binutils/docs/as/Infix-Ops.html#Infix-Ops>, or using
123 the command "info '(as)Infix Ops'". */
125 enum stap_operand_prec
127 /* Lowest precedence, used for non-recognized operands or for the beginning
128 of the parsing process. */
129 STAP_OPERAND_PREC_NONE
= 0,
131 /* Precedence of logical OR. */
132 STAP_OPERAND_PREC_LOGICAL_OR
,
134 /* Precedence of logical AND. */
135 STAP_OPERAND_PREC_LOGICAL_AND
,
137 /* Precedence of additive (plus, minus) and comparative (equal, less,
138 greater-than, etc) operands. */
139 STAP_OPERAND_PREC_ADD_CMP
,
141 /* Precedence of bitwise operands (bitwise OR, XOR, bitwise AND,
143 STAP_OPERAND_PREC_BITWISE
,
145 /* Precedence of multiplicative operands (multiplication, division,
146 remainder, left shift and right shift). */
147 STAP_OPERAND_PREC_MUL
150 static void stap_parse_argument_1 (struct stap_parse_info
*p
, int has_lhs
,
151 enum stap_operand_prec prec
);
153 static void stap_parse_argument_conditionally (struct stap_parse_info
*p
);
155 /* Returns 1 if *S is an operator, zero otherwise. */
157 static int stap_is_operator (const char *op
);
160 show_stapexpressiondebug (struct ui_file
*file
, int from_tty
,
161 struct cmd_list_element
*c
, const char *value
)
163 fprintf_filtered (file
, _("SystemTap Probe expression debugging is %s.\n"),
167 /* Returns the operator precedence level of OP, or STAP_OPERAND_PREC_NONE
168 if the operator code was not recognized. */
170 static enum stap_operand_prec
171 stap_get_operator_prec (enum exp_opcode op
)
175 case BINOP_LOGICAL_OR
:
176 return STAP_OPERAND_PREC_LOGICAL_OR
;
178 case BINOP_LOGICAL_AND
:
179 return STAP_OPERAND_PREC_LOGICAL_AND
;
189 return STAP_OPERAND_PREC_ADD_CMP
;
191 case BINOP_BITWISE_IOR
:
192 case BINOP_BITWISE_AND
:
193 case BINOP_BITWISE_XOR
:
194 case UNOP_LOGICAL_NOT
:
195 return STAP_OPERAND_PREC_BITWISE
;
202 return STAP_OPERAND_PREC_MUL
;
205 return STAP_OPERAND_PREC_NONE
;
209 /* Given S, read the operator in it and fills the OP pointer with its code.
210 Return 1 on success, zero if the operator was not recognized. */
212 static enum exp_opcode
213 stap_get_opcode (const char **s
)
268 op
= BINOP_BITWISE_IOR
;
272 op
= BINOP_LOGICAL_OR
;
277 op
= BINOP_BITWISE_AND
;
281 op
= BINOP_LOGICAL_AND
;
286 op
= BINOP_BITWISE_XOR
;
290 op
= UNOP_LOGICAL_NOT
;
302 gdb_assert (**s
== '=');
307 internal_error (__FILE__
, __LINE__
,
308 _("Invalid opcode in expression `%s' for SystemTap"
315 /* Given the bitness of the argument, represented by B, return the
316 corresponding `struct type *'. */
319 stap_get_expected_argument_type (struct gdbarch
*gdbarch
,
320 enum stap_arg_bitness b
)
324 case STAP_ARG_BITNESS_UNDEFINED
:
325 if (gdbarch_addr_bit (gdbarch
) == 32)
326 return builtin_type (gdbarch
)->builtin_uint32
;
328 return builtin_type (gdbarch
)->builtin_uint64
;
330 case STAP_ARG_BITNESS_32BIT_SIGNED
:
331 return builtin_type (gdbarch
)->builtin_int32
;
333 case STAP_ARG_BITNESS_32BIT_UNSIGNED
:
334 return builtin_type (gdbarch
)->builtin_uint32
;
336 case STAP_ARG_BITNESS_64BIT_SIGNED
:
337 return builtin_type (gdbarch
)->builtin_int64
;
339 case STAP_ARG_BITNESS_64BIT_UNSIGNED
:
340 return builtin_type (gdbarch
)->builtin_uint64
;
343 internal_error (__FILE__
, __LINE__
,
344 _("Undefined bitness for probe."));
349 /* Function responsible for parsing a register operand according to
350 SystemTap parlance. Assuming:
354 RIP = register indirection prefix
355 RIS = register indirection suffix
357 Then a register operand can be:
359 [RIP] [RP] REGISTER [RS] [RIS]
361 This function takes care of a register's indirection, displacement and
362 direct access. It also takes into consideration the fact that some
363 registers are named differently inside and outside GDB, e.g., PPC's
364 general-purpose registers are represented by integers in the assembly
365 language (e.g., `15' is the 15th general-purpose register), but inside
366 GDB they have a prefix (the letter `r') appended. */
369 stap_parse_register_operand (struct stap_parse_info
*p
)
371 /* Simple flag to indicate whether we have seen a minus signal before
375 /* Flags to indicate whether this register access is being displaced and/or
377 int disp_p
= 0, indirect_p
= 0;
378 struct gdbarch
*gdbarch
= p
->gdbarch
;
380 /* Needed to generate the register name as a part of an expression. */
383 /* Variables used to extract the register name from the probe's
389 /* Prefixes for the parser. */
390 const char *reg_prefix
= gdbarch_stap_register_prefix (gdbarch
);
391 const char *reg_ind_prefix
392 = gdbarch_stap_register_indirection_prefix (gdbarch
);
393 const char *gdb_reg_prefix
= gdbarch_stap_gdb_register_prefix (gdbarch
);
394 int reg_prefix_len
= reg_prefix
? strlen (reg_prefix
) : 0;
395 int reg_ind_prefix_len
= reg_ind_prefix
? strlen (reg_ind_prefix
) : 0;
396 int gdb_reg_prefix_len
= gdb_reg_prefix
? strlen (gdb_reg_prefix
) : 0;
398 /* Suffixes for the parser. */
399 const char *reg_suffix
= gdbarch_stap_register_suffix (gdbarch
);
400 const char *reg_ind_suffix
401 = gdbarch_stap_register_indirection_suffix (gdbarch
);
402 const char *gdb_reg_suffix
= gdbarch_stap_gdb_register_suffix (gdbarch
);
403 int reg_suffix_len
= reg_suffix
? strlen (reg_suffix
) : 0;
404 int reg_ind_suffix_len
= reg_ind_suffix
? strlen (reg_ind_suffix
) : 0;
405 int gdb_reg_suffix_len
= gdb_reg_suffix
? strlen (gdb_reg_suffix
) : 0;
407 /* Checking for a displacement argument. */
410 /* If it's a plus sign, we don't need to do anything, just advance the
421 if (isdigit (*p
->arg
))
423 /* The value of the displacement. */
427 displacement
= strtol (p
->arg
, (char **) &p
->arg
, 10);
429 /* Generating the expression for the displacement. */
430 write_exp_elt_opcode (OP_LONG
);
431 write_exp_elt_type (builtin_type (gdbarch
)->builtin_long
);
432 write_exp_elt_longcst (displacement
);
433 write_exp_elt_opcode (OP_LONG
);
435 write_exp_elt_opcode (UNOP_NEG
);
438 /* Getting rid of register indirection prefix. */
440 && strncmp (p
->arg
, reg_ind_prefix
, reg_ind_prefix_len
) == 0)
443 p
->arg
+= reg_ind_prefix_len
;
446 if (disp_p
&& !indirect_p
)
447 error (_("Invalid register displacement syntax on expression `%s'."),
450 /* Getting rid of register prefix. */
451 if (reg_prefix
&& strncmp (p
->arg
, reg_prefix
, reg_prefix_len
) == 0)
452 p
->arg
+= reg_prefix_len
;
454 /* Now we should have only the register name. Let's extract it and get
455 the associated number. */
458 /* We assume the register name is composed by letters and numbers. */
459 while (isalnum (*p
->arg
))
462 len
= p
->arg
- start
;
464 regname
= alloca (len
+ gdb_reg_prefix_len
+ gdb_reg_suffix_len
+ 1);
467 /* We only add the GDB's register prefix/suffix if we are dealing with
468 a numeric register. */
469 if (gdb_reg_prefix
&& isdigit (*start
))
471 strncpy (regname
, gdb_reg_prefix
, gdb_reg_prefix_len
);
472 strncpy (regname
+ gdb_reg_prefix_len
, start
, len
);
475 strncpy (regname
+ gdb_reg_prefix_len
+ len
,
476 gdb_reg_suffix
, gdb_reg_suffix_len
);
478 len
+= gdb_reg_prefix_len
+ gdb_reg_suffix_len
;
481 strncpy (regname
, start
, len
);
485 /* Is this a valid register name? */
486 if (user_reg_map_name_to_regnum (gdbarch
, regname
, len
) == -1)
487 error (_("Invalid register name `%s' on expression `%s'."),
488 regname
, p
->saved_arg
);
490 write_exp_elt_opcode (OP_REGISTER
);
493 write_exp_string (str
);
494 write_exp_elt_opcode (OP_REGISTER
);
499 write_exp_elt_opcode (BINOP_ADD
);
501 /* Casting to the expected type. */
502 write_exp_elt_opcode (UNOP_CAST
);
503 write_exp_elt_type (lookup_pointer_type (p
->arg_type
));
504 write_exp_elt_opcode (UNOP_CAST
);
506 write_exp_elt_opcode (UNOP_IND
);
509 /* Getting rid of the register name suffix. */
512 if (strncmp (p
->arg
, reg_suffix
, reg_suffix_len
) != 0)
513 error (_("Missing register name suffix `%s' on expression `%s'."),
514 reg_suffix
, p
->saved_arg
);
516 p
->arg
+= reg_suffix_len
;
519 /* Getting rid of the register indirection suffix. */
520 if (indirect_p
&& reg_ind_suffix
)
522 if (strncmp (p
->arg
, reg_ind_suffix
, reg_ind_suffix_len
) != 0)
523 error (_("Missing indirection suffix `%s' on expression `%s'."),
524 reg_ind_suffix
, p
->saved_arg
);
526 p
->arg
+= reg_ind_suffix_len
;
530 /* This function is responsible for parsing a single operand.
532 A single operand can be:
534 - an unary operation (e.g., `-5', `~2', or even with subexpressions
536 - a register displacement, which will be treated as a register
537 operand (e.g., `-4(%eax)' on x86)
538 - a numeric constant, or
539 - a register operand (see function `stap_parse_register_operand')
541 The function also calls special-handling functions to deal with
542 unrecognized operands, allowing arch-specific parsers to be
546 stap_parse_single_operand (struct stap_parse_info
*p
)
548 struct gdbarch
*gdbarch
= p
->gdbarch
;
550 /* Prefixes for the parser. */
551 const char *const_prefix
= gdbarch_stap_integer_prefix (gdbarch
);
552 const char *reg_prefix
= gdbarch_stap_register_prefix (gdbarch
);
553 const char *reg_ind_prefix
554 = gdbarch_stap_register_indirection_prefix (gdbarch
);
555 int const_prefix_len
= const_prefix
? strlen (const_prefix
) : 0;
556 int reg_prefix_len
= reg_prefix
? strlen (reg_prefix
) : 0;
557 int reg_ind_prefix_len
= reg_ind_prefix
? strlen (reg_ind_prefix
) : 0;
559 /* Suffixes for the parser. */
560 const char *const_suffix
= gdbarch_stap_integer_suffix (gdbarch
);
561 int const_suffix_len
= const_suffix
? strlen (const_suffix
) : 0;
563 /* We first try to parse this token as a "special token". */
564 if (gdbarch_stap_parse_special_token_p (gdbarch
))
566 int ret
= gdbarch_stap_parse_special_token (gdbarch
, p
);
570 /* If the return value of the above function is not zero,
571 it means it successfully parsed the special token.
573 If it is NULL, we try to parse it using our method. */
578 if (*p
->arg
== '-' || *p
->arg
== '~' || *p
->arg
== '+')
583 /* We use this variable to do a lookahead. */
584 const char *tmp
= p
->arg
;
588 /* This is an unary operation. Here is a list of allowed tokens
592 - number (from register displacement)
593 - subexpression (beginning with `(')
595 We handle the register displacement here, and the other cases
597 if (p
->inside_paren_p
)
598 tmp
= skip_spaces_const (tmp
);
601 number
= strtol (tmp
, (char **) &tmp
, 10);
604 || strncmp (tmp
, reg_ind_prefix
, reg_ind_prefix_len
) != 0)
606 /* This is not a displacement. We skip the operator, and deal
609 stap_parse_argument_conditionally (p
);
611 write_exp_elt_opcode (UNOP_NEG
);
613 write_exp_elt_opcode (UNOP_COMPLEMENT
);
617 /* If we are here, it means it is a displacement. The only
618 operations allowed here are `-' and `+'. */
620 error (_("Invalid operator `%c' for register displacement "
621 "on expression `%s'."), c
, p
->saved_arg
);
623 stap_parse_register_operand (p
);
626 else if (isdigit (*p
->arg
))
628 /* A temporary variable, needed for lookahead. */
629 const char *tmp
= p
->arg
;
632 /* We can be dealing with a numeric constant (if `const_prefix' is
633 NULL), or with a register displacement. */
634 number
= strtol (tmp
, (char **) &tmp
, 10);
636 if (p
->inside_paren_p
)
637 tmp
= skip_spaces_const (tmp
);
638 if (!const_prefix
&& reg_ind_prefix
639 && strncmp (tmp
, reg_ind_prefix
, reg_ind_prefix_len
) != 0)
641 /* We are dealing with a numeric constant. */
642 write_exp_elt_opcode (OP_LONG
);
643 write_exp_elt_type (builtin_type (gdbarch
)->builtin_long
);
644 write_exp_elt_longcst (number
);
645 write_exp_elt_opcode (OP_LONG
);
651 if (strncmp (p
->arg
, const_suffix
, const_suffix_len
) == 0)
652 p
->arg
+= const_suffix_len
;
654 error (_("Invalid constant suffix on expression `%s'."),
658 else if (reg_ind_prefix
659 && strncmp (tmp
, reg_ind_prefix
, reg_ind_prefix_len
) == 0)
660 stap_parse_register_operand (p
);
662 error (_("Unknown numeric token on expression `%s'."),
665 else if (const_prefix
666 && strncmp (p
->arg
, const_prefix
, const_prefix_len
) == 0)
668 /* We are dealing with a numeric constant. */
671 p
->arg
+= const_prefix_len
;
672 number
= strtol (p
->arg
, (char **) &p
->arg
, 10);
674 write_exp_elt_opcode (OP_LONG
);
675 write_exp_elt_type (builtin_type (gdbarch
)->builtin_long
);
676 write_exp_elt_longcst (number
);
677 write_exp_elt_opcode (OP_LONG
);
681 if (strncmp (p
->arg
, const_suffix
, const_suffix_len
) == 0)
682 p
->arg
+= const_suffix_len
;
684 error (_("Invalid constant suffix on expression `%s'."),
689 && strncmp (p
->arg
, reg_prefix
, reg_prefix_len
) == 0)
691 && strncmp (p
->arg
, reg_ind_prefix
, reg_ind_prefix_len
) == 0))
692 stap_parse_register_operand (p
);
694 error (_("Operator `%c' not recognized on expression `%s'."),
695 *p
->arg
, p
->saved_arg
);
698 /* This function parses an argument conditionally, based on single or
699 non-single operands. A non-single operand would be a parenthesized
700 expression (e.g., `(2 + 1)'), and a single operand is anything that
701 starts with `-', `~', `+' (i.e., unary operators), a digit, or
702 something recognized by `gdbarch_stap_is_single_operand'. */
705 stap_parse_argument_conditionally (struct stap_parse_info
*p
)
707 if (*p
->arg
== '-' || *p
->arg
== '~' || *p
->arg
== '+' /* Unary. */
709 || gdbarch_stap_is_single_operand (p
->gdbarch
, p
->arg
))
710 stap_parse_single_operand (p
);
711 else if (*p
->arg
== '(')
713 /* We are dealing with a parenthesized operand. It means we
714 have to parse it as it was a separate expression, without
715 left-side or precedence. */
717 p
->arg
= skip_spaces_const (p
->arg
);
720 stap_parse_argument_1 (p
, 0, STAP_OPERAND_PREC_NONE
);
724 error (_("Missign close-paren on expression `%s'."),
728 if (p
->inside_paren_p
)
729 p
->arg
= skip_spaces_const (p
->arg
);
732 error (_("Cannot parse expression `%s'."), p
->saved_arg
);
735 /* Helper function for `stap_parse_argument'. Please, see its comments to
736 better understand what this function does. */
739 stap_parse_argument_1 (struct stap_parse_info
*p
, int has_lhs
,
740 enum stap_operand_prec prec
)
742 /* This is an operator-precedence parser.
744 We work with left- and right-sides of expressions, and
745 parse them depending on the precedence of the operators
748 if (p
->inside_paren_p
)
749 p
->arg
= skip_spaces_const (p
->arg
);
753 /* We were called without a left-side, either because this is the
754 first call, or because we were called to parse a parenthesized
755 expression. It doesn't really matter; we have to parse the
756 left-side in order to continue the process. */
757 stap_parse_argument_conditionally (p
);
760 /* Start to parse the right-side, and to "join" left and right sides
761 depending on the operation specified.
763 This loop shall continue until we run out of characters in the input,
764 or until we find a close-parenthesis, which means that we've reached
765 the end of a sub-expression. */
766 while (p
->arg
&& *p
->arg
&& *p
->arg
!= ')' && !isspace (*p
->arg
))
768 const char *tmp_exp_buf
;
769 enum exp_opcode opcode
;
770 enum stap_operand_prec cur_prec
;
772 if (!stap_is_operator (p
->arg
))
773 error (_("Invalid operator `%c' on expression `%s'."), *p
->arg
,
776 /* We have to save the current value of the expression buffer because
777 the `stap_get_opcode' modifies it in order to get the current
778 operator. If this operator's precedence is lower than PREC, we
779 should return and not advance the expression buffer pointer. */
780 tmp_exp_buf
= p
->arg
;
781 opcode
= stap_get_opcode (&tmp_exp_buf
);
783 cur_prec
= stap_get_operator_prec (opcode
);
786 /* If the precedence of the operator that we are seeing now is
787 lower than the precedence of the first operator seen before
788 this parsing process began, it means we should stop parsing
793 p
->arg
= tmp_exp_buf
;
794 if (p
->inside_paren_p
)
795 p
->arg
= skip_spaces_const (p
->arg
);
797 /* Parse the right-side of the expression. */
798 stap_parse_argument_conditionally (p
);
800 /* While we still have operators, try to parse another
801 right-side, but using the current right-side as a left-side. */
802 while (*p
->arg
&& stap_is_operator (p
->arg
))
804 enum exp_opcode lookahead_opcode
;
805 enum stap_operand_prec lookahead_prec
;
807 /* Saving the current expression buffer position. The explanation
808 is the same as above. */
809 tmp_exp_buf
= p
->arg
;
810 lookahead_opcode
= stap_get_opcode (&tmp_exp_buf
);
811 lookahead_prec
= stap_get_operator_prec (lookahead_opcode
);
813 if (lookahead_prec
<= prec
)
815 /* If we are dealing with an operator whose precedence is lower
816 than the first one, just abandon the attempt. */
820 /* Parse the right-side of the expression, but since we already
821 have a left-side at this point, set `has_lhs' to 1. */
822 stap_parse_argument_1 (p
, 1, lookahead_prec
);
825 write_exp_elt_opcode (opcode
);
829 /* Parse a probe's argument.
833 LP = literal integer prefix
834 LS = literal integer suffix
839 RIP = register indirection prefix
840 RIS = register indirection suffix
842 This routine assumes that arguments' tokens are of the form:
846 - [RIP] [RP] REGISTER [RS] [RIS]
847 - If we find a number without LP, we try to parse it as a literal integer
848 constant (if LP == NULL), or as a register displacement.
849 - We count parenthesis, and only skip whitespaces if we are inside them.
850 - If we find an operator, we skip it.
852 This function can also call a special function that will try to match
853 unknown tokens. It will return 1 if the argument has been parsed
854 successfully, or zero otherwise. */
856 static struct expression
*
857 stap_parse_argument (const char **arg
, struct type
*atype
,
858 struct gdbarch
*gdbarch
)
860 struct stap_parse_info p
;
861 struct cleanup
*back_to
;
863 /* We need to initialize the expression buffer, in order to begin
864 our parsing efforts. The language here does not matter, since we
865 are using our own parser. */
866 initialize_expout (10, current_language
, gdbarch
);
867 back_to
= make_cleanup (free_current_contents
, &expout
);
873 p
.inside_paren_p
= 0;
875 stap_parse_argument_1 (&p
, 0, STAP_OPERAND_PREC_NONE
);
877 discard_cleanups (back_to
);
879 gdb_assert (p
.inside_paren_p
== 0);
881 /* Casting the final expression to the appropriate type. */
882 write_exp_elt_opcode (UNOP_CAST
);
883 write_exp_elt_type (atype
);
884 write_exp_elt_opcode (UNOP_CAST
);
886 reallocate_expout ();
888 p
.arg
= skip_spaces_const (p
.arg
);
894 /* Function which parses an argument string from PROBE, correctly splitting
895 the arguments and storing their information in properly ways.
897 Consider the following argument string (x86 syntax):
901 We have two arguments, `%eax' and `$10', both with 32-bit unsigned bitness.
902 This function basically handles them, properly filling some structures with
906 stap_parse_probe_arguments (struct stap_probe
*probe
, struct objfile
*objfile
)
909 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
911 gdb_assert (!probe
->args_parsed
);
912 cur
= probe
->args_u
.text
;
913 probe
->args_parsed
= 1;
914 probe
->args_u
.vec
= NULL
;
916 if (!cur
|| !*cur
|| *cur
== ':')
921 struct stap_probe_arg arg
;
922 enum stap_arg_bitness b
;
924 struct expression
*expr
;
926 memset (&arg
, 0, sizeof (arg
));
928 /* We expect to find something like:
932 Where `N' can be [+,-][4,8]. This is not mandatory, so
933 we check it here. If we don't find it, go to the next
935 if ((*cur
== '-' && cur
[1] && cur
[2] != '@')
937 arg
.bitness
= STAP_ARG_BITNESS_UNDEFINED
;
942 /* Discard the `-'. */
948 b
= (got_minus
? STAP_ARG_BITNESS_32BIT_SIGNED
949 : STAP_ARG_BITNESS_32BIT_UNSIGNED
);
950 else if (*cur
== '8')
951 b
= (got_minus
? STAP_ARG_BITNESS_64BIT_SIGNED
952 : STAP_ARG_BITNESS_64BIT_UNSIGNED
);
955 /* We have an error, because we don't expect anything
957 complaint (&symfile_complaints
,
958 _("unrecognized bitness `%c' for probe `%s'"),
959 *cur
, probe
->p
.name
);
964 arg
.atype
= stap_get_expected_argument_type (gdbarch
, b
);
966 /* Discard the number and the `@' sign. */
970 expr
= stap_parse_argument (&cur
, arg
.atype
, gdbarch
);
972 if (stap_expression_debug
)
973 dump_raw_expression (expr
, gdb_stdlog
,
974 "before conversion to prefix form");
976 prefixify_expression (expr
);
978 if (stap_expression_debug
)
979 dump_prefix_expression (expr
, gdb_stdlog
);
983 /* Start it over again. */
984 cur
= skip_spaces_const (cur
);
986 VEC_safe_push (stap_probe_arg_s
, probe
->args_u
.vec
, &arg
);
990 /* Given PROBE, returns the number of arguments present in that probe's
994 stap_get_probe_argument_count (struct probe
*probe_generic
,
995 struct objfile
*objfile
)
997 struct stap_probe
*probe
= (struct stap_probe
*) probe_generic
;
999 gdb_assert (probe_generic
->pops
== &stap_probe_ops
);
1001 if (!probe
->args_parsed
)
1002 stap_parse_probe_arguments (probe
, objfile
);
1004 gdb_assert (probe
->args_parsed
);
1005 return VEC_length (stap_probe_arg_s
, probe
->args_u
.vec
);
1008 /* Return 1 if OP is a valid operator inside a probe argument, or zero
1012 stap_is_operator (const char *op
)
1037 /* We didn't find any operator. */
1044 static struct stap_probe_arg
*
1045 stap_get_arg (struct stap_probe
*probe
, struct objfile
*objfile
, unsigned n
)
1047 if (!probe
->args_parsed
)
1048 stap_parse_probe_arguments (probe
, objfile
);
1050 return VEC_index (stap_probe_arg_s
, probe
->args_u
.vec
, n
);
1053 /* Evaluate the probe's argument N (indexed from 0), returning a value
1054 corresponding to it. Assertion is thrown if N does not exist. */
1056 static struct value
*
1057 stap_evaluate_probe_argument (struct probe
*probe_generic
,
1058 struct objfile
*objfile
, unsigned n
)
1060 struct stap_probe
*stap_probe
= (struct stap_probe
*) probe_generic
;
1061 struct stap_probe_arg
*arg
;
1064 gdb_assert (probe_generic
->pops
== &stap_probe_ops
);
1066 arg
= stap_get_arg (stap_probe
, objfile
, n
);
1067 return evaluate_subexp_standard (arg
->atype
, arg
->aexpr
, &pos
, EVAL_NORMAL
);
1070 /* Compile the probe's argument N (indexed from 0) to agent expression.
1071 Assertion is thrown if N does not exist. */
1074 stap_compile_to_ax (struct probe
*probe_generic
, struct objfile
*objfile
,
1075 struct agent_expr
*expr
, struct axs_value
*value
,
1078 struct stap_probe
*stap_probe
= (struct stap_probe
*) probe_generic
;
1079 struct stap_probe_arg
*arg
;
1080 union exp_element
*pc
;
1082 gdb_assert (probe_generic
->pops
== &stap_probe_ops
);
1084 arg
= stap_get_arg (stap_probe
, objfile
, n
);
1086 pc
= arg
->aexpr
->elts
;
1087 gen_expr (arg
->aexpr
, &pc
, expr
, value
);
1089 require_rvalue (expr
, value
);
1090 value
->type
= arg
->atype
;
1093 /* Destroy (free) the data related to PROBE. PROBE memory itself is not feed
1094 as it is allocated from OBJFILE_OBSTACK. */
1097 stap_probe_destroy (struct probe
*probe_generic
)
1099 struct stap_probe
*probe
= (struct stap_probe
*) probe_generic
;
1101 gdb_assert (probe_generic
->pops
== &stap_probe_ops
);
1103 if (probe
->args_parsed
)
1105 struct stap_probe_arg
*arg
;
1108 for (ix
= 0; VEC_iterate (stap_probe_arg_s
, probe
->args_u
.vec
, ix
, arg
);
1111 VEC_free (stap_probe_arg_s
, probe
->args_u
.vec
);
1117 /* This is called to compute the value of one of the $_probe_arg*
1118 convenience variables. */
1120 static struct value
*
1121 compute_probe_arg (struct gdbarch
*arch
, struct internalvar
*ivar
,
1124 struct frame_info
*frame
= get_selected_frame (_("No frame selected"));
1125 CORE_ADDR pc
= get_frame_pc (frame
);
1126 int sel
= (int) (uintptr_t) data
;
1127 struct objfile
*objfile
;
1128 struct probe
*pc_probe
;
1131 /* SEL == -1 means "_probe_argc". */
1132 gdb_assert (sel
>= -1);
1134 pc_probe
= find_probe_by_pc (pc
, &objfile
);
1135 if (pc_probe
== NULL
)
1136 error (_("No SystemTap probe at PC %s"), core_addr_to_string (pc
));
1139 = objfile
->sf
->sym_probe_fns
->sym_get_probe_argument_count (objfile
,
1142 return value_from_longest (builtin_type (arch
)->builtin_int
, n_args
);
1145 error (_("Invalid probe argument %d -- probe has %u arguments available"),
1148 return objfile
->sf
->sym_probe_fns
->sym_evaluate_probe_argument (objfile
,
1153 /* This is called to compile one of the $_probe_arg* convenience
1154 variables into an agent expression. */
1157 compile_probe_arg (struct internalvar
*ivar
, struct agent_expr
*expr
,
1158 struct axs_value
*value
, void *data
)
1160 CORE_ADDR pc
= expr
->scope
;
1161 int sel
= (int) (uintptr_t) data
;
1162 struct objfile
*objfile
;
1163 struct probe
*pc_probe
;
1166 /* SEL == -1 means "_probe_argc". */
1167 gdb_assert (sel
>= -1);
1169 pc_probe
= find_probe_by_pc (pc
, &objfile
);
1170 if (pc_probe
== NULL
)
1171 error (_("No SystemTap probe at PC %s"), core_addr_to_string (pc
));
1174 = objfile
->sf
->sym_probe_fns
->sym_get_probe_argument_count (objfile
,
1178 value
->kind
= axs_rvalue
;
1179 value
->type
= builtin_type (expr
->gdbarch
)->builtin_int
;
1180 ax_const_l (expr
, n_probes
);
1184 gdb_assert (sel
>= 0);
1185 if (sel
>= n_probes
)
1186 error (_("Invalid probe argument %d -- probe has %d arguments available"),
1189 objfile
->sf
->sym_probe_fns
->sym_compile_to_ax (objfile
, pc_probe
,
1195 /* Set or clear a SystemTap semaphore. ADDRESS is the semaphore's
1196 address. SET is zero if the semaphore should be cleared, or one
1197 if it should be set. This is a helper function for `stap_semaphore_down'
1198 and `stap_semaphore_up'. */
1201 stap_modify_semaphore (CORE_ADDR address
, int set
, struct gdbarch
*gdbarch
)
1203 gdb_byte bytes
[sizeof (LONGEST
)];
1204 /* The ABI specifies "unsigned short". */
1205 struct type
*type
= builtin_type (gdbarch
)->builtin_unsigned_short
;
1211 /* Swallow errors. */
1212 if (target_read_memory (address
, bytes
, TYPE_LENGTH (type
)) != 0)
1214 warning (_("Could not read the value of a SystemTap semaphore."));
1218 value
= extract_unsigned_integer (bytes
, TYPE_LENGTH (type
),
1219 gdbarch_byte_order (gdbarch
));
1220 /* Note that we explicitly don't worry about overflow or
1227 store_unsigned_integer (bytes
, TYPE_LENGTH (type
),
1228 gdbarch_byte_order (gdbarch
), value
);
1230 if (target_write_memory (address
, bytes
, TYPE_LENGTH (type
)) != 0)
1231 warning (_("Could not write the value of a SystemTap semaphore."));
1234 /* Set a SystemTap semaphore. SEM is the semaphore's address. Semaphores
1235 act as reference counters, so calls to this function must be paired with
1236 calls to `stap_semaphore_down'.
1238 This function and `stap_semaphore_down' race with another tool changing
1239 the probes, but that is too rare to care. */
1242 stap_set_semaphore (struct probe
*probe_generic
, struct gdbarch
*gdbarch
)
1244 struct stap_probe
*probe
= (struct stap_probe
*) probe_generic
;
1246 gdb_assert (probe_generic
->pops
== &stap_probe_ops
);
1248 stap_modify_semaphore (probe
->sem_addr
, 1, gdbarch
);
1251 /* Clear a SystemTap semaphore. SEM is the semaphore's address. */
1254 stap_clear_semaphore (struct probe
*probe_generic
, struct gdbarch
*gdbarch
)
1256 struct stap_probe
*probe
= (struct stap_probe
*) probe_generic
;
1258 gdb_assert (probe_generic
->pops
== &stap_probe_ops
);
1260 stap_modify_semaphore (probe
->sem_addr
, 0, gdbarch
);
1263 /* Implementation of `$_probe_arg*' set of variables. */
1265 static const struct internalvar_funcs probe_funcs
=
1272 /* Helper function that parses the information contained in a
1273 SystemTap's probe. Basically, the information consists in:
1275 - Probe's PC address;
1276 - Link-time section address of `.stapsdt.base' section;
1277 - Link-time address of the semaphore variable, or ZERO if the
1278 probe doesn't have an associated semaphore;
1279 - Probe's provider name;
1281 - Probe's argument format
1283 This function returns 1 if the handling was successful, and zero
1287 handle_stap_probe (struct objfile
*objfile
, struct sdt_note
*el
,
1288 VEC (probe_p
) **probesp
, CORE_ADDR base
)
1290 bfd
*abfd
= objfile
->obfd
;
1291 int size
= bfd_get_arch_size (abfd
) / 8;
1292 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
1293 struct type
*ptr_type
= builtin_type (gdbarch
)->builtin_data_ptr
;
1295 const char *probe_args
= NULL
;
1296 struct stap_probe
*ret
;
1298 ret
= obstack_alloc (&objfile
->objfile_obstack
, sizeof (*ret
));
1299 ret
->p
.pops
= &stap_probe_ops
;
1301 /* Provider and the name of the probe. */
1302 ret
->p
.provider
= &el
->data
[3 * size
];
1303 ret
->p
.name
= memchr (ret
->p
.provider
, '\0',
1304 (char *) el
->data
+ el
->size
- ret
->p
.provider
);
1305 /* Making sure there is a name. */
1308 complaint (&symfile_complaints
, _("corrupt probe name when "
1309 "reading `%s'"), objfile
->name
);
1311 /* There is no way to use a probe without a name or a provider, so
1312 returning zero here makes sense. */
1318 /* Retrieving the probe's address. */
1319 ret
->p
.address
= extract_typed_address (&el
->data
[0], ptr_type
);
1321 /* Link-time sh_addr of `.stapsdt.base' section. */
1322 base_ref
= extract_typed_address (&el
->data
[size
], ptr_type
);
1324 /* Semaphore address. */
1325 ret
->sem_addr
= extract_typed_address (&el
->data
[2 * size
], ptr_type
);
1327 ret
->p
.address
+= (ANOFFSET (objfile
->section_offsets
,
1328 SECT_OFF_TEXT (objfile
))
1331 ret
->sem_addr
+= (ANOFFSET (objfile
->section_offsets
,
1332 SECT_OFF_DATA (objfile
))
1335 /* Arguments. We can only extract the argument format if there is a valid
1336 name for this probe. */
1337 probe_args
= memchr (ret
->p
.name
, '\0',
1338 (char *) el
->data
+ el
->size
- ret
->p
.name
);
1340 if (probe_args
!= NULL
)
1343 if (probe_args
== NULL
|| (memchr (probe_args
, '\0',
1344 (char *) el
->data
+ el
->size
- ret
->p
.name
)
1345 != el
->data
+ el
->size
- 1))
1347 complaint (&symfile_complaints
, _("corrupt probe argument when "
1348 "reading `%s'"), objfile
->name
);
1349 /* If the argument string is NULL, it means some problem happened with
1350 it. So we return 0. */
1354 ret
->args_parsed
= 0;
1355 ret
->args_u
.text
= (void *) probe_args
;
1357 /* Successfully created probe. */
1358 VEC_safe_push (probe_p
, *probesp
, (struct probe
*) ret
);
1361 /* Helper function which tries to find the base address of the SystemTap
1362 base section named STAP_BASE_SECTION_NAME. */
1365 get_stap_base_address_1 (bfd
*abfd
, asection
*sect
, void *obj
)
1367 asection
**ret
= obj
;
1369 if ((sect
->flags
& (SEC_DATA
| SEC_ALLOC
| SEC_HAS_CONTENTS
))
1370 && sect
->name
&& !strcmp (sect
->name
, STAP_BASE_SECTION_NAME
))
1374 /* Helper function which iterates over every section in the BFD file,
1375 trying to find the base address of the SystemTap base section.
1376 Returns 1 if found (setting BASE to the proper value), zero otherwise. */
1379 get_stap_base_address (bfd
*obfd
, bfd_vma
*base
)
1381 asection
*ret
= NULL
;
1383 bfd_map_over_sections (obfd
, get_stap_base_address_1
, (void *) &ret
);
1387 complaint (&symfile_complaints
, _("could not obtain base address for "
1388 "SystemTap section on objfile `%s'."),
1399 /* Helper function for `elf_get_probes', which gathers information about all
1400 SystemTap probes from OBJFILE. */
1403 stap_get_probes (VEC (probe_p
) **probesp
, struct objfile
*objfile
)
1405 /* If we are here, then this is the first time we are parsing the
1406 SystemTap probe's information. We basically have to count how many
1407 probes the objfile has, and then fill in the necessary information
1409 bfd
*obfd
= objfile
->obfd
;
1411 struct sdt_note
*iter
;
1412 unsigned save_probesp_len
= VEC_length (probe_p
, *probesp
);
1414 if (objfile
->separate_debug_objfile_backlink
!= NULL
)
1416 /* This is a .debug file, not the objfile itself. */
1420 if (!elf_tdata (obfd
)->sdt_note_head
)
1422 /* There isn't any probe here. */
1426 if (!get_stap_base_address (obfd
, &base
))
1428 /* There was an error finding the base address for the section.
1429 Just return NULL. */
1433 /* Parsing each probe's information. */
1434 for (iter
= elf_tdata (obfd
)->sdt_note_head
; iter
; iter
= iter
->next
)
1436 /* We first have to handle all the information about the
1437 probe which is present in the section. */
1438 handle_stap_probe (objfile
, iter
, probesp
, base
);
1441 if (save_probesp_len
== VEC_length (probe_p
, *probesp
))
1443 /* If we are here, it means we have failed to parse every known
1445 complaint (&symfile_complaints
, _("could not parse SystemTap probe(s) "
1452 stap_relocate (struct probe
*probe_generic
, CORE_ADDR delta
)
1454 struct stap_probe
*probe
= (struct stap_probe
*) probe_generic
;
1456 gdb_assert (probe_generic
->pops
== &stap_probe_ops
);
1458 probe
->p
.address
+= delta
;
1459 if (probe
->sem_addr
)
1460 probe
->sem_addr
+= delta
;
1464 stap_probe_is_linespec (const char **linespecp
)
1466 static const char *const keywords
[] = { "-pstap", "-probe-stap", NULL
};
1468 return probe_is_linespec_by_keyword (linespecp
, keywords
);
1472 stap_gen_info_probes_table_header (VEC (info_probe_column_s
) **heads
)
1474 info_probe_column_s stap_probe_column
;
1476 stap_probe_column
.field_name
= "semaphore";
1477 stap_probe_column
.print_name
= _("Semaphore");
1479 VEC_safe_push (info_probe_column_s
, *heads
, &stap_probe_column
);
1483 stap_gen_info_probes_table_values (struct probe
*probe_generic
,
1484 struct objfile
*objfile
,
1485 VEC (const_char_ptr
) **ret
)
1487 struct stap_probe
*probe
= (struct stap_probe
*) probe_generic
;
1488 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
1489 const char *val
= NULL
;
1491 gdb_assert (probe_generic
->pops
== &stap_probe_ops
);
1493 if (probe
->sem_addr
)
1494 val
= print_core_address (gdbarch
, probe
->sem_addr
);
1496 VEC_safe_push (const_char_ptr
, *ret
, val
);
1499 /* SystemTap probe_ops. */
1501 static const struct probe_ops stap_probe_ops
=
1503 stap_probe_is_linespec
,
1506 stap_get_probe_argument_count
,
1507 stap_evaluate_probe_argument
,
1510 stap_clear_semaphore
,
1512 stap_gen_info_probes_table_header
,
1513 stap_gen_info_probes_table_values
,
1516 /* Implementation of the `info probes stap' command. */
1519 info_probes_stap_command (char *arg
, int from_tty
)
1521 info_probes_for_ops (arg
, from_tty
, &stap_probe_ops
);
1524 void _initialize_stap_probe (void);
1527 _initialize_stap_probe (void)
1529 VEC_safe_push (probe_ops_cp
, all_probe_ops
, &stap_probe_ops
);
1531 add_setshow_zinteger_cmd ("stap-expression", class_maintenance
,
1532 &stap_expression_debug
,
1533 _("Set SystemTap expression debugging."),
1534 _("Show SystemTap expression debugging."),
1535 _("When non-zero, the internal representation "
1536 "of SystemTap expressions will be printed."),
1538 show_stapexpressiondebug
,
1539 &setdebuglist
, &showdebuglist
);
1541 create_internalvar_type_lazy ("_probe_argc", &probe_funcs
,
1542 (void *) (uintptr_t) -1);
1543 create_internalvar_type_lazy ("_probe_arg0", &probe_funcs
,
1544 (void *) (uintptr_t) 0);
1545 create_internalvar_type_lazy ("_probe_arg1", &probe_funcs
,
1546 (void *) (uintptr_t) 1);
1547 create_internalvar_type_lazy ("_probe_arg2", &probe_funcs
,
1548 (void *) (uintptr_t) 2);
1549 create_internalvar_type_lazy ("_probe_arg3", &probe_funcs
,
1550 (void *) (uintptr_t) 3);
1551 create_internalvar_type_lazy ("_probe_arg4", &probe_funcs
,
1552 (void *) (uintptr_t) 4);
1553 create_internalvar_type_lazy ("_probe_arg5", &probe_funcs
,
1554 (void *) (uintptr_t) 5);
1555 create_internalvar_type_lazy ("_probe_arg6", &probe_funcs
,
1556 (void *) (uintptr_t) 6);
1557 create_internalvar_type_lazy ("_probe_arg7", &probe_funcs
,
1558 (void *) (uintptr_t) 7);
1559 create_internalvar_type_lazy ("_probe_arg8", &probe_funcs
,
1560 (void *) (uintptr_t) 8);
1561 create_internalvar_type_lazy ("_probe_arg9", &probe_funcs
,
1562 (void *) (uintptr_t) 9);
1563 create_internalvar_type_lazy ("_probe_arg10", &probe_funcs
,
1564 (void *) (uintptr_t) 10);
1565 create_internalvar_type_lazy ("_probe_arg11", &probe_funcs
,
1566 (void *) (uintptr_t) 11);
1568 add_cmd ("stap", class_info
, info_probes_stap_command
,
1570 Show information about SystemTap static probes.\n\
1571 Usage: info probes stap [PROVIDER [NAME [OBJECT]]]\n\
1572 Each argument is a regular expression, used to select probes.\n\
1573 PROVIDER matches probe provider names.\n\
1574 NAME matches the probe names.\n\
1575 OBJECT matches the executable or shared library name."),
1576 info_probes_cmdlist_get ());