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 (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. */
213 stap_get_opcode (const char **s
, enum exp_opcode
*op
)
249 *op
= BINOP_NOTEQUAL
;
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
;
311 /* We didn't find any operator. */
319 /* Given the bitness of the argument, represented by B, return the
320 corresponding `struct type *'. */
323 stap_get_expected_argument_type (struct gdbarch
*gdbarch
,
324 enum stap_arg_bitness b
)
328 case STAP_ARG_BITNESS_UNDEFINED
:
329 if (gdbarch_addr_bit (gdbarch
) == 32)
330 return builtin_type (gdbarch
)->builtin_uint32
;
332 return builtin_type (gdbarch
)->builtin_uint64
;
334 case STAP_ARG_BITNESS_32BIT_SIGNED
:
335 return builtin_type (gdbarch
)->builtin_int32
;
337 case STAP_ARG_BITNESS_32BIT_UNSIGNED
:
338 return builtin_type (gdbarch
)->builtin_uint32
;
340 case STAP_ARG_BITNESS_64BIT_SIGNED
:
341 return builtin_type (gdbarch
)->builtin_int64
;
343 case STAP_ARG_BITNESS_64BIT_UNSIGNED
:
344 return builtin_type (gdbarch
)->builtin_uint64
;
347 internal_error (__FILE__
, __LINE__
,
348 _("Undefined bitness for probe."));
353 /* Function responsible for parsing a register operand according to
354 SystemTap parlance. Assuming:
358 RIP = register indirection prefix
359 RIS = register indirection suffix
361 Then a register operand can be:
363 [RIP] [RP] REGISTER [RS] [RIS]
365 This function takes care of a register's indirection, displacement and
366 direct access. It also takes into consideration the fact that some
367 registers are named differently inside and outside GDB, e.g., PPC's
368 general-purpose registers are represented by integers in the assembly
369 language (e.g., `15' is the 15th general-purpose register), but inside
370 GDB they have a prefix (the letter `r') appended. */
373 stap_parse_register_operand (struct stap_parse_info
*p
)
375 /* Simple flag to indicate whether we have seen a minus signal before
379 /* Flags to indicate whether this register access is being displaced and/or
381 int disp_p
= 0, indirect_p
= 0;
382 struct gdbarch
*gdbarch
= p
->gdbarch
;
384 /* Needed to generate the register name as a part of an expression. */
387 /* Variables used to extract the register name from the probe's
393 /* Prefixes for the parser. */
394 const char *reg_prefix
= gdbarch_stap_register_prefix (gdbarch
);
395 const char *reg_ind_prefix
396 = gdbarch_stap_register_indirection_prefix (gdbarch
);
397 const char *gdb_reg_prefix
= gdbarch_stap_gdb_register_prefix (gdbarch
);
398 int reg_prefix_len
= reg_prefix
? strlen (reg_prefix
) : 0;
399 int reg_ind_prefix_len
= reg_ind_prefix
? strlen (reg_ind_prefix
) : 0;
400 int gdb_reg_prefix_len
= gdb_reg_prefix
? strlen (gdb_reg_prefix
) : 0;
402 /* Suffixes for the parser. */
403 const char *reg_suffix
= gdbarch_stap_register_suffix (gdbarch
);
404 const char *reg_ind_suffix
405 = gdbarch_stap_register_indirection_suffix (gdbarch
);
406 const char *gdb_reg_suffix
= gdbarch_stap_gdb_register_suffix (gdbarch
);
407 int reg_suffix_len
= reg_suffix
? strlen (reg_suffix
) : 0;
408 int reg_ind_suffix_len
= reg_ind_suffix
? strlen (reg_ind_suffix
) : 0;
409 int gdb_reg_suffix_len
= gdb_reg_suffix
? strlen (gdb_reg_suffix
) : 0;
411 /* Checking for a displacement argument. */
414 /* If it's a plus sign, we don't need to do anything, just advance the
425 if (isdigit (*p
->arg
))
427 /* The value of the displacement. */
431 displacement
= strtol (p
->arg
, (char **) &p
->arg
, 10);
433 /* Generating the expression for the displacement. */
434 write_exp_elt_opcode (OP_LONG
);
435 write_exp_elt_type (builtin_type (gdbarch
)->builtin_long
);
436 write_exp_elt_longcst (displacement
);
437 write_exp_elt_opcode (OP_LONG
);
439 write_exp_elt_opcode (UNOP_NEG
);
442 /* Getting rid of register indirection prefix. */
444 && strncmp (p
->arg
, reg_ind_prefix
, reg_ind_prefix_len
) == 0)
447 p
->arg
+= reg_ind_prefix_len
;
450 if (disp_p
&& !indirect_p
)
451 error (_("Invalid register displacement syntax on expression `%s'."),
454 /* Getting rid of register prefix. */
455 if (reg_prefix
&& strncmp (p
->arg
, reg_prefix
, reg_prefix_len
) == 0)
456 p
->arg
+= reg_prefix_len
;
458 /* Now we should have only the register name. Let's extract it and get
459 the associated number. */
462 /* We assume the register name is composed by letters and numbers. */
463 while (isalnum (*p
->arg
))
466 len
= p
->arg
- start
;
468 regname
= alloca (len
+ gdb_reg_prefix_len
+ gdb_reg_suffix_len
+ 1);
471 /* We only add the GDB's register prefix/suffix if we are dealing with
472 a numeric register. */
473 if (gdb_reg_prefix
&& isdigit (*start
))
475 strncpy (regname
, gdb_reg_prefix
, gdb_reg_prefix_len
);
476 strncpy (regname
+ gdb_reg_prefix_len
, start
, len
);
479 strncpy (regname
+ gdb_reg_prefix_len
+ len
,
480 gdb_reg_suffix
, gdb_reg_suffix_len
);
482 len
+= gdb_reg_prefix_len
+ gdb_reg_suffix_len
;
485 strncpy (regname
, start
, len
);
489 /* Is this a valid register name? */
490 if (user_reg_map_name_to_regnum (gdbarch
, regname
, len
) == -1)
491 error (_("Invalid register name `%s' on expression `%s'."),
492 regname
, p
->saved_arg
);
494 write_exp_elt_opcode (OP_REGISTER
);
497 write_exp_string (str
);
498 write_exp_elt_opcode (OP_REGISTER
);
503 write_exp_elt_opcode (BINOP_ADD
);
505 /* Casting to the expected type. */
506 write_exp_elt_opcode (UNOP_CAST
);
507 write_exp_elt_type (lookup_pointer_type (p
->arg_type
));
508 write_exp_elt_opcode (UNOP_CAST
);
510 write_exp_elt_opcode (UNOP_IND
);
513 /* Getting rid of the register name suffix. */
516 if (strncmp (p
->arg
, reg_suffix
, reg_suffix_len
) != 0)
517 error (_("Missing register name suffix `%s' on expression `%s'."),
518 reg_suffix
, p
->saved_arg
);
520 p
->arg
+= reg_suffix_len
;
523 /* Getting rid of the register indirection suffix. */
524 if (indirect_p
&& reg_ind_suffix
)
526 if (strncmp (p
->arg
, reg_ind_suffix
, reg_ind_suffix_len
) != 0)
527 error (_("Missing indirection suffix `%s' on expression `%s'."),
528 reg_ind_suffix
, p
->saved_arg
);
530 p
->arg
+= reg_ind_suffix_len
;
534 /* This function is responsible for parsing a single operand.
536 A single operand can be:
538 - an unary operation (e.g., `-5', `~2', or even with subexpressions
540 - a register displacement, which will be treated as a register
541 operand (e.g., `-4(%eax)' on x86)
542 - a numeric constant, or
543 - a register operand (see function `stap_parse_register_operand')
545 The function also calls special-handling functions to deal with
546 unrecognized operands, allowing arch-specific parsers to be
550 stap_parse_single_operand (struct stap_parse_info
*p
)
552 struct gdbarch
*gdbarch
= p
->gdbarch
;
554 /* Prefixes for the parser. */
555 const char *const_prefix
= gdbarch_stap_integer_prefix (gdbarch
);
556 const char *reg_prefix
= gdbarch_stap_register_prefix (gdbarch
);
557 const char *reg_ind_prefix
558 = gdbarch_stap_register_indirection_prefix (gdbarch
);
559 int const_prefix_len
= const_prefix
? strlen (const_prefix
) : 0;
560 int reg_prefix_len
= reg_prefix
? strlen (reg_prefix
) : 0;
561 int reg_ind_prefix_len
= reg_ind_prefix
? strlen (reg_ind_prefix
) : 0;
563 /* Suffixes for the parser. */
564 const char *const_suffix
= gdbarch_stap_integer_suffix (gdbarch
);
565 int const_suffix_len
= const_suffix
? strlen (const_suffix
) : 0;
567 /* We first try to parse this token as a "special token". */
568 if (gdbarch_stap_parse_special_token_p (gdbarch
))
570 int ret
= gdbarch_stap_parse_special_token (gdbarch
, p
);
574 /* If the return value of the above function is not zero,
575 it means it successfully parsed the special token.
577 If it is NULL, we try to parse it using our method. */
582 if (*p
->arg
== '-' || *p
->arg
== '~' || *p
->arg
== '+')
587 /* We use this variable to do a lookahead. */
588 const char *tmp
= p
->arg
;
592 /* This is an unary operation. Here is a list of allowed tokens
596 - number (from register displacement)
597 - subexpression (beginning with `(')
599 We handle the register displacement here, and the other cases
601 if (p
->inside_paren_p
)
602 tmp
= skip_spaces_const (tmp
);
605 number
= strtol (tmp
, (char **) &tmp
, 10);
608 || strncmp (tmp
, reg_ind_prefix
, reg_ind_prefix_len
) != 0)
610 /* This is not a displacement. We skip the operator, and deal
613 stap_parse_argument_conditionally (p
);
615 write_exp_elt_opcode (UNOP_NEG
);
617 write_exp_elt_opcode (UNOP_COMPLEMENT
);
621 /* If we are here, it means it is a displacement. The only
622 operations allowed here are `-' and `+'. */
624 error (_("Invalid operator `%c' for register displacement "
625 "on expression `%s'."), c
, p
->saved_arg
);
627 stap_parse_register_operand (p
);
630 else if (isdigit (*p
->arg
))
632 /* A temporary variable, needed for lookahead. */
633 const char *tmp
= p
->arg
;
636 /* We can be dealing with a numeric constant (if `const_prefix' is
637 NULL), or with a register displacement. */
638 number
= strtol (tmp
, (char **) &tmp
, 10);
640 if (p
->inside_paren_p
)
641 tmp
= skip_spaces_const (tmp
);
642 if (!const_prefix
&& reg_ind_prefix
643 && strncmp (tmp
, reg_ind_prefix
, reg_ind_prefix_len
) != 0)
645 /* We are dealing with a numeric constant. */
646 write_exp_elt_opcode (OP_LONG
);
647 write_exp_elt_type (builtin_type (gdbarch
)->builtin_long
);
648 write_exp_elt_longcst (number
);
649 write_exp_elt_opcode (OP_LONG
);
655 if (strncmp (p
->arg
, const_suffix
, const_suffix_len
) == 0)
656 p
->arg
+= const_suffix_len
;
658 error (_("Invalid constant suffix on expression `%s'."),
662 else if (reg_ind_prefix
663 && strncmp (tmp
, reg_ind_prefix
, reg_ind_prefix_len
) == 0)
664 stap_parse_register_operand (p
);
666 error (_("Unknown numeric token on expression `%s'."),
669 else if (const_prefix
670 && strncmp (p
->arg
, const_prefix
, const_prefix_len
) == 0)
672 /* We are dealing with a numeric constant. */
675 p
->arg
+= const_prefix_len
;
676 number
= strtol (p
->arg
, (char **) &p
->arg
, 10);
678 write_exp_elt_opcode (OP_LONG
);
679 write_exp_elt_type (builtin_type (gdbarch
)->builtin_long
);
680 write_exp_elt_longcst (number
);
681 write_exp_elt_opcode (OP_LONG
);
685 if (strncmp (p
->arg
, const_suffix
, const_suffix_len
) == 0)
686 p
->arg
+= const_suffix_len
;
688 error (_("Invalid constant suffix on expression `%s'."),
693 && strncmp (p
->arg
, reg_prefix
, reg_prefix_len
) == 0)
695 && strncmp (p
->arg
, reg_ind_prefix
, reg_ind_prefix_len
) == 0))
696 stap_parse_register_operand (p
);
698 error (_("Operator `%c' not recognized on expression `%s'."),
699 *p
->arg
, p
->saved_arg
);
702 /* This function parses an argument conditionally, based on single or
703 non-single operands. A non-single operand would be a parenthesized
704 expression (e.g., `(2 + 1)'), and a single operand is anything that
705 starts with `-', `~', `+' (i.e., unary operators), a digit, or
706 something recognized by `gdbarch_stap_is_single_operand'. */
709 stap_parse_argument_conditionally (struct stap_parse_info
*p
)
711 if (*p
->arg
== '-' || *p
->arg
== '~' || *p
->arg
== '+' /* Unary. */
713 || gdbarch_stap_is_single_operand (p
->gdbarch
, p
->arg
))
714 stap_parse_single_operand (p
);
715 else if (*p
->arg
== '(')
717 /* We are dealing with a parenthesized operand. It means we
718 have to parse it as it was a separate expression, without
719 left-side or precedence. */
721 p
->arg
= skip_spaces_const (p
->arg
);
724 stap_parse_argument_1 (p
, 0, STAP_OPERAND_PREC_NONE
);
728 error (_("Missign close-paren on expression `%s'."),
732 if (p
->inside_paren_p
)
733 p
->arg
= skip_spaces_const (p
->arg
);
736 error (_("Cannot parse expression `%s'."), p
->saved_arg
);
739 /* Helper function for `stap_parse_argument'. Please, see its comments to
740 better understand what this function does. */
743 stap_parse_argument_1 (struct stap_parse_info
*p
, int has_lhs
,
744 enum stap_operand_prec prec
)
746 /* This is an operator-precedence parser.
748 We work with left- and right-sides of expressions, and
749 parse them depending on the precedence of the operators
752 if (p
->inside_paren_p
)
753 p
->arg
= skip_spaces_const (p
->arg
);
757 /* We were called without a left-side, either because this is the
758 first call, or because we were called to parse a parenthesized
759 expression. It doesn't really matter; we have to parse the
760 left-side in order to continue the process. */
761 stap_parse_argument_conditionally (p
);
764 /* Start to parse the right-side, and to "join" left and right sides
765 depending on the operation specified.
767 This loop shall continue until we run out of characters in the input,
768 or until we find a close-parenthesis, which means that we've reached
769 the end of a sub-expression. */
770 while (p
->arg
&& *p
->arg
&& *p
->arg
!= ')' && !isspace (*p
->arg
))
772 const char *tmp_exp_buf
;
773 enum exp_opcode opcode
;
774 enum stap_operand_prec cur_prec
;
776 if (!stap_is_operator (*p
->arg
))
777 error (_("Invalid operator `%c' on expression `%s'."), *p
->arg
,
780 /* We have to save the current value of the expression buffer because
781 the `stap_get_opcode' modifies it in order to get the current
782 operator. If this operator's precedence is lower than PREC, we
783 should return and not advance the expression buffer pointer. */
784 tmp_exp_buf
= p
->arg
;
785 stap_get_opcode (&tmp_exp_buf
, &opcode
);
787 cur_prec
= stap_get_operator_prec (opcode
);
790 /* If the precedence of the operator that we are seeing now is
791 lower than the precedence of the first operator seen before
792 this parsing process began, it means we should stop parsing
797 p
->arg
= tmp_exp_buf
;
798 if (p
->inside_paren_p
)
799 p
->arg
= skip_spaces_const (p
->arg
);
801 /* Parse the right-side of the expression. */
802 stap_parse_argument_conditionally (p
);
804 /* While we still have operators, try to parse another
805 right-side, but using the current right-side as a left-side. */
806 while (*p
->arg
&& stap_is_operator (*p
->arg
))
808 enum exp_opcode lookahead_opcode
;
809 enum stap_operand_prec lookahead_prec
;
811 /* Saving the current expression buffer position. The explanation
812 is the same as above. */
813 tmp_exp_buf
= p
->arg
;
814 stap_get_opcode (&tmp_exp_buf
, &lookahead_opcode
);
815 lookahead_prec
= stap_get_operator_prec (lookahead_opcode
);
817 if (lookahead_prec
<= prec
)
819 /* If we are dealing with an operator whose precedence is lower
820 than the first one, just abandon the attempt. */
824 /* Parse the right-side of the expression, but since we already
825 have a left-side at this point, set `has_lhs' to 1. */
826 stap_parse_argument_1 (p
, 1, lookahead_prec
);
829 write_exp_elt_opcode (opcode
);
833 /* Parse a probe's argument.
837 LP = literal integer prefix
838 LS = literal integer suffix
843 RIP = register indirection prefix
844 RIS = register indirection suffix
846 This routine assumes that arguments' tokens are of the form:
850 - [RIP] [RP] REGISTER [RS] [RIS]
851 - If we find a number without LP, we try to parse it as a literal integer
852 constant (if LP == NULL), or as a register displacement.
853 - We count parenthesis, and only skip whitespaces if we are inside them.
854 - If we find an operator, we skip it.
856 This function can also call a special function that will try to match
857 unknown tokens. It will return 1 if the argument has been parsed
858 successfully, or zero otherwise. */
860 static struct expression
*
861 stap_parse_argument (const char **arg
, struct type
*atype
,
862 struct gdbarch
*gdbarch
)
864 struct stap_parse_info p
;
865 struct cleanup
*back_to
;
867 /* We need to initialize the expression buffer, in order to begin
868 our parsing efforts. The language here does not matter, since we
869 are using our own parser. */
870 initialize_expout (10, current_language
, gdbarch
);
871 back_to
= make_cleanup (free_current_contents
, &expout
);
877 p
.inside_paren_p
= 0;
879 stap_parse_argument_1 (&p
, 0, STAP_OPERAND_PREC_NONE
);
881 discard_cleanups (back_to
);
883 gdb_assert (p
.inside_paren_p
== 0);
885 /* Casting the final expression to the appropriate type. */
886 write_exp_elt_opcode (UNOP_CAST
);
887 write_exp_elt_type (atype
);
888 write_exp_elt_opcode (UNOP_CAST
);
890 reallocate_expout ();
892 p
.arg
= skip_spaces_const (p
.arg
);
898 /* Function which parses an argument string from PROBE, correctly splitting
899 the arguments and storing their information in properly ways.
901 Consider the following argument string (x86 syntax):
905 We have two arguments, `%eax' and `$10', both with 32-bit unsigned bitness.
906 This function basically handles them, properly filling some structures with
910 stap_parse_probe_arguments (struct stap_probe
*probe
, struct objfile
*objfile
)
913 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
915 gdb_assert (!probe
->args_parsed
);
916 cur
= probe
->args_u
.text
;
917 probe
->args_parsed
= 1;
918 probe
->args_u
.vec
= NULL
;
920 if (!cur
|| !*cur
|| *cur
== ':')
925 struct stap_probe_arg arg
;
926 enum stap_arg_bitness b
;
928 struct expression
*expr
;
930 memset (&arg
, 0, sizeof (arg
));
932 /* We expect to find something like:
936 Where `N' can be [+,-][4,8]. This is not mandatory, so
937 we check it here. If we don't find it, go to the next
939 if ((*cur
== '-' && cur
[1] && cur
[2] != '@')
941 arg
.bitness
= STAP_ARG_BITNESS_UNDEFINED
;
946 /* Discard the `-'. */
952 b
= (got_minus
? STAP_ARG_BITNESS_32BIT_SIGNED
953 : STAP_ARG_BITNESS_32BIT_UNSIGNED
);
954 else if (*cur
== '8')
955 b
= (got_minus
? STAP_ARG_BITNESS_64BIT_SIGNED
956 : STAP_ARG_BITNESS_64BIT_UNSIGNED
);
959 /* We have an error, because we don't expect anything
961 complaint (&symfile_complaints
,
962 _("unrecognized bitness `%c' for probe `%s'"),
963 *cur
, probe
->p
.name
);
968 arg
.atype
= stap_get_expected_argument_type (gdbarch
, b
);
970 /* Discard the number and the `@' sign. */
974 expr
= stap_parse_argument (&cur
, arg
.atype
, gdbarch
);
976 if (stap_expression_debug
)
977 dump_raw_expression (expr
, gdb_stdlog
,
978 "before conversion to prefix form");
980 prefixify_expression (expr
);
982 if (stap_expression_debug
)
983 dump_prefix_expression (expr
, gdb_stdlog
);
987 /* Start it over again. */
988 cur
= skip_spaces_const (cur
);
990 VEC_safe_push (stap_probe_arg_s
, probe
->args_u
.vec
, &arg
);
994 /* Given PROBE, returns the number of arguments present in that probe's
998 stap_get_probe_argument_count (struct probe
*probe_generic
,
999 struct objfile
*objfile
)
1001 struct stap_probe
*probe
= (struct stap_probe
*) probe_generic
;
1003 gdb_assert (probe_generic
->pops
== &stap_probe_ops
);
1005 if (!probe
->args_parsed
)
1006 stap_parse_probe_arguments (probe
, objfile
);
1008 gdb_assert (probe
->args_parsed
);
1009 return VEC_length (stap_probe_arg_s
, probe
->args_u
.vec
);
1012 /* Return 1 if OP is a valid operator inside a probe argument, or zero
1016 stap_is_operator (char op
)
1018 return (op
== '+' || op
== '-' || op
== '*' || op
== '/'
1019 || op
== '>' || op
== '<' || op
== '!' || op
== '^'
1020 || op
== '|' || op
== '&' || op
== '%' || op
== '=');
1023 static struct stap_probe_arg
*
1024 stap_get_arg (struct stap_probe
*probe
, struct objfile
*objfile
, unsigned n
)
1026 if (!probe
->args_parsed
)
1027 stap_parse_probe_arguments (probe
, objfile
);
1029 return VEC_index (stap_probe_arg_s
, probe
->args_u
.vec
, n
);
1032 /* Evaluate the probe's argument N (indexed from 0), returning a value
1033 corresponding to it. Assertion is thrown if N does not exist. */
1035 static struct value
*
1036 stap_evaluate_probe_argument (struct probe
*probe_generic
,
1037 struct objfile
*objfile
, unsigned n
)
1039 struct stap_probe
*stap_probe
= (struct stap_probe
*) probe_generic
;
1040 struct stap_probe_arg
*arg
;
1043 gdb_assert (probe_generic
->pops
== &stap_probe_ops
);
1045 arg
= stap_get_arg (stap_probe
, objfile
, n
);
1046 return evaluate_subexp_standard (arg
->atype
, arg
->aexpr
, &pos
, EVAL_NORMAL
);
1049 /* Compile the probe's argument N (indexed from 0) to agent expression.
1050 Assertion is thrown if N does not exist. */
1053 stap_compile_to_ax (struct probe
*probe_generic
, struct objfile
*objfile
,
1054 struct agent_expr
*expr
, struct axs_value
*value
,
1057 struct stap_probe
*stap_probe
= (struct stap_probe
*) probe_generic
;
1058 struct stap_probe_arg
*arg
;
1059 union exp_element
*pc
;
1061 gdb_assert (probe_generic
->pops
== &stap_probe_ops
);
1063 arg
= stap_get_arg (stap_probe
, objfile
, n
);
1065 pc
= arg
->aexpr
->elts
;
1066 gen_expr (arg
->aexpr
, &pc
, expr
, value
);
1068 require_rvalue (expr
, value
);
1069 value
->type
= arg
->atype
;
1072 /* Destroy (free) the data related to PROBE. PROBE memory itself is not feed
1073 as it is allocated from OBJFILE_OBSTACK. */
1076 stap_probe_destroy (struct probe
*probe_generic
)
1078 struct stap_probe
*probe
= (struct stap_probe
*) probe_generic
;
1080 gdb_assert (probe_generic
->pops
== &stap_probe_ops
);
1082 if (probe
->args_parsed
)
1084 struct stap_probe_arg
*arg
;
1087 for (ix
= 0; VEC_iterate (stap_probe_arg_s
, probe
->args_u
.vec
, ix
, arg
);
1090 VEC_free (stap_probe_arg_s
, probe
->args_u
.vec
);
1096 /* This is called to compute the value of one of the $_probe_arg*
1097 convenience variables. */
1099 static struct value
*
1100 compute_probe_arg (struct gdbarch
*arch
, struct internalvar
*ivar
,
1103 struct frame_info
*frame
= get_selected_frame (_("No frame selected"));
1104 CORE_ADDR pc
= get_frame_pc (frame
);
1105 int sel
= (int) (uintptr_t) data
;
1106 struct objfile
*objfile
;
1107 struct probe
*pc_probe
;
1110 /* SEL == -1 means "_probe_argc". */
1111 gdb_assert (sel
>= -1);
1113 pc_probe
= find_probe_by_pc (pc
, &objfile
);
1114 if (pc_probe
== NULL
)
1115 error (_("No SystemTap probe at PC %s"), core_addr_to_string (pc
));
1118 = objfile
->sf
->sym_probe_fns
->sym_get_probe_argument_count (objfile
,
1121 return value_from_longest (builtin_type (arch
)->builtin_int
, n_args
);
1124 error (_("Invalid probe argument %d -- probe has %u arguments available"),
1127 return objfile
->sf
->sym_probe_fns
->sym_evaluate_probe_argument (objfile
,
1132 /* This is called to compile one of the $_probe_arg* convenience
1133 variables into an agent expression. */
1136 compile_probe_arg (struct internalvar
*ivar
, struct agent_expr
*expr
,
1137 struct axs_value
*value
, void *data
)
1139 CORE_ADDR pc
= expr
->scope
;
1140 int sel
= (int) (uintptr_t) data
;
1141 struct objfile
*objfile
;
1142 struct probe
*pc_probe
;
1145 /* SEL == -1 means "_probe_argc". */
1146 gdb_assert (sel
>= -1);
1148 pc_probe
= find_probe_by_pc (pc
, &objfile
);
1149 if (pc_probe
== NULL
)
1150 error (_("No SystemTap probe at PC %s"), core_addr_to_string (pc
));
1153 = objfile
->sf
->sym_probe_fns
->sym_get_probe_argument_count (objfile
,
1157 value
->kind
= axs_rvalue
;
1158 value
->type
= builtin_type (expr
->gdbarch
)->builtin_int
;
1159 ax_const_l (expr
, n_probes
);
1163 gdb_assert (sel
>= 0);
1164 if (sel
>= n_probes
)
1165 error (_("Invalid probe argument %d -- probe has %d arguments available"),
1168 objfile
->sf
->sym_probe_fns
->sym_compile_to_ax (objfile
, pc_probe
,
1174 /* Set or clear a SystemTap semaphore. ADDRESS is the semaphore's
1175 address. SET is zero if the semaphore should be cleared, or one
1176 if it should be set. This is a helper function for `stap_semaphore_down'
1177 and `stap_semaphore_up'. */
1180 stap_modify_semaphore (CORE_ADDR address
, int set
, struct gdbarch
*gdbarch
)
1182 gdb_byte bytes
[sizeof (LONGEST
)];
1183 /* The ABI specifies "unsigned short". */
1184 struct type
*type
= builtin_type (gdbarch
)->builtin_unsigned_short
;
1190 /* Swallow errors. */
1191 if (target_read_memory (address
, bytes
, TYPE_LENGTH (type
)) != 0)
1193 warning (_("Could not read the value of a SystemTap semaphore."));
1197 value
= extract_unsigned_integer (bytes
, TYPE_LENGTH (type
),
1198 gdbarch_byte_order (gdbarch
));
1199 /* Note that we explicitly don't worry about overflow or
1206 store_unsigned_integer (bytes
, TYPE_LENGTH (type
),
1207 gdbarch_byte_order (gdbarch
), value
);
1209 if (target_write_memory (address
, bytes
, TYPE_LENGTH (type
)) != 0)
1210 warning (_("Could not write the value of a SystemTap semaphore."));
1213 /* Set a SystemTap semaphore. SEM is the semaphore's address. Semaphores
1214 act as reference counters, so calls to this function must be paired with
1215 calls to `stap_semaphore_down'.
1217 This function and `stap_semaphore_down' race with another tool changing
1218 the probes, but that is too rare to care. */
1221 stap_set_semaphore (struct probe
*probe_generic
, struct gdbarch
*gdbarch
)
1223 struct stap_probe
*probe
= (struct stap_probe
*) probe_generic
;
1225 gdb_assert (probe_generic
->pops
== &stap_probe_ops
);
1227 stap_modify_semaphore (probe
->sem_addr
, 1, gdbarch
);
1230 /* Clear a SystemTap semaphore. SEM is the semaphore's address. */
1233 stap_clear_semaphore (struct probe
*probe_generic
, struct gdbarch
*gdbarch
)
1235 struct stap_probe
*probe
= (struct stap_probe
*) probe_generic
;
1237 gdb_assert (probe_generic
->pops
== &stap_probe_ops
);
1239 stap_modify_semaphore (probe
->sem_addr
, 0, gdbarch
);
1242 /* Implementation of `$_probe_arg*' set of variables. */
1244 static const struct internalvar_funcs probe_funcs
=
1251 /* Helper function that parses the information contained in a
1252 SystemTap's probe. Basically, the information consists in:
1254 - Probe's PC address;
1255 - Link-time section address of `.stapsdt.base' section;
1256 - Link-time address of the semaphore variable, or ZERO if the
1257 probe doesn't have an associated semaphore;
1258 - Probe's provider name;
1260 - Probe's argument format
1262 This function returns 1 if the handling was successful, and zero
1266 handle_stap_probe (struct objfile
*objfile
, struct sdt_note
*el
,
1267 VEC (probe_p
) **probesp
, CORE_ADDR base
)
1269 bfd
*abfd
= objfile
->obfd
;
1270 int size
= bfd_get_arch_size (abfd
) / 8;
1271 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
1272 struct type
*ptr_type
= builtin_type (gdbarch
)->builtin_data_ptr
;
1274 const char *probe_args
= NULL
;
1275 struct stap_probe
*ret
;
1277 ret
= obstack_alloc (&objfile
->objfile_obstack
, sizeof (*ret
));
1278 ret
->p
.pops
= &stap_probe_ops
;
1280 /* Provider and the name of the probe. */
1281 ret
->p
.provider
= &el
->data
[3 * size
];
1282 ret
->p
.name
= memchr (ret
->p
.provider
, '\0',
1283 (char *) el
->data
+ el
->size
- ret
->p
.provider
);
1284 /* Making sure there is a name. */
1287 complaint (&symfile_complaints
, _("corrupt probe name when "
1288 "reading `%s'"), objfile
->name
);
1290 /* There is no way to use a probe without a name or a provider, so
1291 returning zero here makes sense. */
1297 /* Retrieving the probe's address. */
1298 ret
->p
.address
= extract_typed_address (&el
->data
[0], ptr_type
);
1300 /* Link-time sh_addr of `.stapsdt.base' section. */
1301 base_ref
= extract_typed_address (&el
->data
[size
], ptr_type
);
1303 /* Semaphore address. */
1304 ret
->sem_addr
= extract_typed_address (&el
->data
[2 * size
], ptr_type
);
1306 ret
->p
.address
+= (ANOFFSET (objfile
->section_offsets
,
1307 SECT_OFF_TEXT (objfile
))
1310 ret
->sem_addr
+= (ANOFFSET (objfile
->section_offsets
,
1311 SECT_OFF_DATA (objfile
))
1314 /* Arguments. We can only extract the argument format if there is a valid
1315 name for this probe. */
1316 probe_args
= memchr (ret
->p
.name
, '\0',
1317 (char *) el
->data
+ el
->size
- ret
->p
.name
);
1319 if (probe_args
!= NULL
)
1322 if (probe_args
== NULL
|| (memchr (probe_args
, '\0',
1323 (char *) el
->data
+ el
->size
- ret
->p
.name
)
1324 != el
->data
+ el
->size
- 1))
1326 complaint (&symfile_complaints
, _("corrupt probe argument when "
1327 "reading `%s'"), objfile
->name
);
1328 /* If the argument string is NULL, it means some problem happened with
1329 it. So we return 0. */
1333 ret
->args_parsed
= 0;
1334 ret
->args_u
.text
= (void *) probe_args
;
1336 /* Successfully created probe. */
1337 VEC_safe_push (probe_p
, *probesp
, (struct probe
*) ret
);
1340 /* Helper function which tries to find the base address of the SystemTap
1341 base section named STAP_BASE_SECTION_NAME. */
1344 get_stap_base_address_1 (bfd
*abfd
, asection
*sect
, void *obj
)
1346 asection
**ret
= obj
;
1348 if ((sect
->flags
& (SEC_DATA
| SEC_ALLOC
| SEC_HAS_CONTENTS
))
1349 && sect
->name
&& !strcmp (sect
->name
, STAP_BASE_SECTION_NAME
))
1353 /* Helper function which iterates over every section in the BFD file,
1354 trying to find the base address of the SystemTap base section.
1355 Returns 1 if found (setting BASE to the proper value), zero otherwise. */
1358 get_stap_base_address (bfd
*obfd
, bfd_vma
*base
)
1360 asection
*ret
= NULL
;
1362 bfd_map_over_sections (obfd
, get_stap_base_address_1
, (void *) &ret
);
1366 complaint (&symfile_complaints
, _("could not obtain base address for "
1367 "SystemTap section on objfile `%s'."),
1378 /* Helper function for `elf_get_probes', which gathers information about all
1379 SystemTap probes from OBJFILE. */
1382 stap_get_probes (VEC (probe_p
) **probesp
, struct objfile
*objfile
)
1384 /* If we are here, then this is the first time we are parsing the
1385 SystemTap probe's information. We basically have to count how many
1386 probes the objfile has, and then fill in the necessary information
1388 bfd
*obfd
= objfile
->obfd
;
1390 struct sdt_note
*iter
;
1391 unsigned save_probesp_len
= VEC_length (probe_p
, *probesp
);
1393 if (!elf_tdata (obfd
)->sdt_note_head
)
1395 /* There isn't any probe here. */
1399 if (!get_stap_base_address (obfd
, &base
))
1401 /* There was an error finding the base address for the section.
1402 Just return NULL. */
1406 /* Parsing each probe's information. */
1407 for (iter
= elf_tdata (obfd
)->sdt_note_head
; iter
; iter
= iter
->next
)
1409 /* We first have to handle all the information about the
1410 probe which is present in the section. */
1411 handle_stap_probe (objfile
, iter
, probesp
, base
);
1414 if (save_probesp_len
== VEC_length (probe_p
, *probesp
))
1416 /* If we are here, it means we have failed to parse every known
1418 complaint (&symfile_complaints
, _("could not parse SystemTap probe(s) "
1425 stap_relocate (struct probe
*probe_generic
, CORE_ADDR delta
)
1427 struct stap_probe
*probe
= (struct stap_probe
*) probe_generic
;
1429 gdb_assert (probe_generic
->pops
== &stap_probe_ops
);
1431 probe
->p
.address
+= delta
;
1432 if (probe
->sem_addr
)
1433 probe
->sem_addr
+= delta
;
1437 stap_probe_is_linespec (const char **linespecp
)
1439 static const char *const keywords
[] = { "-pstap", "-probe-stap", NULL
};
1441 return probe_is_linespec_by_keyword (linespecp
, keywords
);
1445 stap_gen_info_probes_table_header (VEC (info_probe_column_s
) **heads
)
1447 info_probe_column_s stap_probe_column
;
1449 stap_probe_column
.field_name
= "semaphore";
1450 stap_probe_column
.print_name
= _("Semaphore");
1452 VEC_safe_push (info_probe_column_s
, *heads
, &stap_probe_column
);
1456 stap_gen_info_probes_table_values (struct probe
*probe_generic
,
1457 struct objfile
*objfile
,
1458 VEC (const_char_ptr
) **ret
)
1460 struct stap_probe
*probe
= (struct stap_probe
*) probe_generic
;
1461 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
1462 const char *val
= NULL
;
1464 gdb_assert (probe_generic
->pops
== &stap_probe_ops
);
1466 if (probe
->sem_addr
)
1467 val
= print_core_address (gdbarch
, probe
->sem_addr
);
1469 VEC_safe_push (const_char_ptr
, *ret
, val
);
1472 /* SystemTap probe_ops. */
1474 static const struct probe_ops stap_probe_ops
=
1476 stap_probe_is_linespec
,
1479 stap_get_probe_argument_count
,
1480 stap_evaluate_probe_argument
,
1483 stap_clear_semaphore
,
1485 stap_gen_info_probes_table_header
,
1486 stap_gen_info_probes_table_values
,
1489 /* Implementation of the `info probes stap' command. */
1492 info_probes_stap_command (char *arg
, int from_tty
)
1494 info_probes_for_ops (arg
, from_tty
, &stap_probe_ops
);
1497 void _initialize_stap_probe (void);
1500 _initialize_stap_probe (void)
1502 VEC_safe_push (probe_ops_cp
, all_probe_ops
, &stap_probe_ops
);
1504 add_setshow_zinteger_cmd ("stap-expression", class_maintenance
,
1505 &stap_expression_debug
,
1506 _("Set SystemTap expression debugging."),
1507 _("Show SystemTap expression debugging."),
1508 _("When non-zero, the internal representation "
1509 "of SystemTap expressions will be printed."),
1511 show_stapexpressiondebug
,
1512 &setdebuglist
, &showdebuglist
);
1514 create_internalvar_type_lazy ("_probe_argc", &probe_funcs
,
1515 (void *) (uintptr_t) -1);
1516 create_internalvar_type_lazy ("_probe_arg0", &probe_funcs
,
1517 (void *) (uintptr_t) 0);
1518 create_internalvar_type_lazy ("_probe_arg1", &probe_funcs
,
1519 (void *) (uintptr_t) 1);
1520 create_internalvar_type_lazy ("_probe_arg2", &probe_funcs
,
1521 (void *) (uintptr_t) 2);
1522 create_internalvar_type_lazy ("_probe_arg3", &probe_funcs
,
1523 (void *) (uintptr_t) 3);
1524 create_internalvar_type_lazy ("_probe_arg4", &probe_funcs
,
1525 (void *) (uintptr_t) 4);
1526 create_internalvar_type_lazy ("_probe_arg5", &probe_funcs
,
1527 (void *) (uintptr_t) 5);
1528 create_internalvar_type_lazy ("_probe_arg6", &probe_funcs
,
1529 (void *) (uintptr_t) 6);
1530 create_internalvar_type_lazy ("_probe_arg7", &probe_funcs
,
1531 (void *) (uintptr_t) 7);
1532 create_internalvar_type_lazy ("_probe_arg8", &probe_funcs
,
1533 (void *) (uintptr_t) 8);
1534 create_internalvar_type_lazy ("_probe_arg9", &probe_funcs
,
1535 (void *) (uintptr_t) 9);
1536 create_internalvar_type_lazy ("_probe_arg10", &probe_funcs
,
1537 (void *) (uintptr_t) 10);
1538 create_internalvar_type_lazy ("_probe_arg11", &probe_funcs
,
1539 (void *) (uintptr_t) 11);
1541 add_cmd ("stap", class_info
, info_probes_stap_command
,
1543 Show information about SystemTap static probes.\n\
1544 Usage: info probes stap [PROVIDER [NAME [OBJECT]]]\n\
1545 Each argument is a regular expression, used to select probes.\n\
1546 PROVIDER matches probe provider names.\n\
1547 NAME matches the probe names.\n\
1548 OBJECT matches the executable or shared library name."),
1549 info_probes_cmdlist_get ());