1 /* SystemTap probe support for GDB.
3 Copyright (C) 2012-2013 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 unsigned 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 /* One if the arguments have been parsed. */
106 unsigned int args_parsed : 1;
112 /* Information about each argument. This is an array of `stap_probe_arg',
113 with each entry representing one argument. */
114 VEC (stap_probe_arg_s) *vec;
119 /* When parsing the arguments, we have to establish different precedences
120 for the various kinds of asm operators. This enumeration represents those
123 This logic behind this is available at
124 <http://sourceware.org/binutils/docs/as/Infix-Ops.html#Infix-Ops>, or using
125 the command "info '(as)Infix Ops'". */
127 enum stap_operand_prec
129 /* Lowest precedence, used for non-recognized operands or for the beginning
130 of the parsing process. */
131 STAP_OPERAND_PREC_NONE = 0,
133 /* Precedence of logical OR. */
134 STAP_OPERAND_PREC_LOGICAL_OR,
136 /* Precedence of logical AND. */
137 STAP_OPERAND_PREC_LOGICAL_AND,
139 /* Precedence of additive (plus, minus) and comparative (equal, less,
140 greater-than, etc) operands. */
141 STAP_OPERAND_PREC_ADD_CMP,
143 /* Precedence of bitwise operands (bitwise OR, XOR, bitwise AND,
145 STAP_OPERAND_PREC_BITWISE,
147 /* Precedence of multiplicative operands (multiplication, division,
148 remainder, left shift and right shift). */
149 STAP_OPERAND_PREC_MUL
152 static void stap_parse_argument_1 (struct stap_parse_info *p, int has_lhs,
153 enum stap_operand_prec prec);
155 static void stap_parse_argument_conditionally (struct stap_parse_info *p);
157 /* Returns 1 if *S is an operator, zero otherwise. */
159 static int stap_is_operator (const char *op);
162 show_stapexpressiondebug (struct ui_file *file, int from_tty,
163 struct cmd_list_element *c, const char *value)
165 fprintf_filtered (file, _("SystemTap Probe expression debugging is %s.\n"),
169 /* Returns the operator precedence level of OP, or STAP_OPERAND_PREC_NONE
170 if the operator code was not recognized. */
172 static enum stap_operand_prec
173 stap_get_operator_prec (enum exp_opcode op)
177 case BINOP_LOGICAL_OR:
178 return STAP_OPERAND_PREC_LOGICAL_OR;
180 case BINOP_LOGICAL_AND:
181 return STAP_OPERAND_PREC_LOGICAL_AND;
191 return STAP_OPERAND_PREC_ADD_CMP;
193 case BINOP_BITWISE_IOR:
194 case BINOP_BITWISE_AND:
195 case BINOP_BITWISE_XOR:
196 case UNOP_LOGICAL_NOT:
197 return STAP_OPERAND_PREC_BITWISE;
204 return STAP_OPERAND_PREC_MUL;
207 return STAP_OPERAND_PREC_NONE;
211 /* Given S, read the operator in it and fills the OP pointer with its code.
212 Return 1 on success, zero if the operator was not recognized. */
214 static enum exp_opcode
215 stap_get_opcode (const char **s)
270 op = BINOP_BITWISE_IOR;
274 op = BINOP_LOGICAL_OR;
279 op = BINOP_BITWISE_AND;
283 op = BINOP_LOGICAL_AND;
288 op = BINOP_BITWISE_XOR;
292 op = UNOP_LOGICAL_NOT;
304 gdb_assert (**s == '=');
309 internal_error (__FILE__, __LINE__,
310 _("Invalid opcode in expression `%s' for SystemTap"
317 /* Given the bitness of the argument, represented by B, return the
318 corresponding `struct type *'. */
321 stap_get_expected_argument_type (struct gdbarch *gdbarch,
322 enum stap_arg_bitness b)
326 case STAP_ARG_BITNESS_UNDEFINED:
327 if (gdbarch_addr_bit (gdbarch) == 32)
328 return builtin_type (gdbarch)->builtin_uint32;
330 return builtin_type (gdbarch)->builtin_uint64;
332 case STAP_ARG_BITNESS_32BIT_SIGNED:
333 return builtin_type (gdbarch)->builtin_int32;
335 case STAP_ARG_BITNESS_32BIT_UNSIGNED:
336 return builtin_type (gdbarch)->builtin_uint32;
338 case STAP_ARG_BITNESS_64BIT_SIGNED:
339 return builtin_type (gdbarch)->builtin_int64;
341 case STAP_ARG_BITNESS_64BIT_UNSIGNED:
342 return builtin_type (gdbarch)->builtin_uint64;
345 internal_error (__FILE__, __LINE__,
346 _("Undefined bitness for probe."));
351 /* Helper function to check for a generic list of prefixes. GDBARCH
352 is the current gdbarch being used. S is the expression being
353 analyzed. If R is not NULL, it will be used to return the found
354 prefix. PREFIXES is the list of expected prefixes.
356 This function does a case-insensitive match.
358 Return 1 if any prefix has been found, zero otherwise. */
361 stap_is_generic_prefix (struct gdbarch *gdbarch, const char *s,
362 const char **r, const char *const *prefixes)
364 const char *const *p;
366 if (prefixes == NULL)
374 for (p = prefixes; *p != NULL; ++p)
375 if (strncasecmp (s, *p, strlen (*p)) == 0)
386 /* Return 1 if S points to a register prefix, zero otherwise. For a
387 description of the arguments, look at stap_is_generic_prefix. */
390 stap_is_register_prefix (struct gdbarch *gdbarch, const char *s,
393 const char *const *t = gdbarch_stap_register_prefixes (gdbarch);
395 return stap_is_generic_prefix (gdbarch, s, r, t);
398 /* Return 1 if S points to a register indirection prefix, zero
399 otherwise. For a description of the arguments, look at
400 stap_is_generic_prefix. */
403 stap_is_register_indirection_prefix (struct gdbarch *gdbarch, const char *s,
406 const char *const *t = gdbarch_stap_register_indirection_prefixes (gdbarch);
408 return stap_is_generic_prefix (gdbarch, s, r, t);
411 /* Return 1 if S points to an integer prefix, zero otherwise. For a
412 description of the arguments, look at stap_is_generic_prefix.
414 This function takes care of analyzing whether we are dealing with
415 an expected integer prefix, or, if there is no integer prefix to be
416 expected, whether we are dealing with a digit. It does a
417 case-insensitive match. */
420 stap_is_integer_prefix (struct gdbarch *gdbarch, const char *s,
423 const char *const *t = gdbarch_stap_integer_prefixes (gdbarch);
424 const char *const *p;
428 /* A NULL value here means that integers do not have a prefix.
429 We just check for a digit then. */
436 for (p = t; *p != NULL; ++p)
438 size_t len = strlen (*p);
440 if ((len == 0 && isdigit (*s))
441 || (len > 0 && strncasecmp (s, *p, len) == 0))
443 /* Integers may or may not have a prefix. The "len == 0"
444 check covers the case when integers do not have a prefix
445 (therefore, we just check if we have a digit). The call
446 to "strncasecmp" covers the case when they have a
458 /* Helper function to check for a generic list of suffixes. If we are
459 not expecting any suffixes, then it just returns 1. If we are
460 expecting at least one suffix, then it returns 1 if a suffix has
461 been found, zero otherwise. GDBARCH is the current gdbarch being
462 used. S is the expression being analyzed. If R is not NULL, it
463 will be used to return the found suffix. SUFFIXES is the list of
464 expected suffixes. This function does a case-insensitive
468 stap_generic_check_suffix (struct gdbarch *gdbarch, const char *s,
469 const char **r, const char *const *suffixes)
471 const char *const *p;
474 if (suffixes == NULL)
482 for (p = suffixes; *p != NULL; ++p)
483 if (strncasecmp (s, *p, strlen (*p)) == 0)
495 /* Return 1 if S points to an integer suffix, zero otherwise. For a
496 description of the arguments, look at
497 stap_generic_check_suffix. */
500 stap_check_integer_suffix (struct gdbarch *gdbarch, const char *s,
503 const char *const *p = gdbarch_stap_integer_suffixes (gdbarch);
505 return stap_generic_check_suffix (gdbarch, s, r, p);
508 /* Return 1 if S points to a register suffix, zero otherwise. For a
509 description of the arguments, look at
510 stap_generic_check_suffix. */
513 stap_check_register_suffix (struct gdbarch *gdbarch, const char *s,
516 const char *const *p = gdbarch_stap_register_suffixes (gdbarch);
518 return stap_generic_check_suffix (gdbarch, s, r, p);
521 /* Return 1 if S points to a register indirection suffix, zero
522 otherwise. For a description of the arguments, look at
523 stap_generic_check_suffix. */
526 stap_check_register_indirection_suffix (struct gdbarch *gdbarch, const char *s,
529 const char *const *p = gdbarch_stap_register_indirection_suffixes (gdbarch);
531 return stap_generic_check_suffix (gdbarch, s, r, p);
534 /* Function responsible for parsing a register operand according to
535 SystemTap parlance. Assuming:
539 RIP = register indirection prefix
540 RIS = register indirection suffix
542 Then a register operand can be:
544 [RIP] [RP] REGISTER [RS] [RIS]
546 This function takes care of a register's indirection, displacement and
547 direct access. It also takes into consideration the fact that some
548 registers are named differently inside and outside GDB, e.g., PPC's
549 general-purpose registers are represented by integers in the assembly
550 language (e.g., `15' is the 15th general-purpose register), but inside
551 GDB they have a prefix (the letter `r') appended. */
554 stap_parse_register_operand (struct stap_parse_info *p)
556 /* Simple flag to indicate whether we have seen a minus signal before
559 /* Flags to indicate whether this register access is being displaced and/or
561 int disp_p = 0, indirect_p = 0;
562 struct gdbarch *gdbarch = p->gdbarch;
563 /* Needed to generate the register name as a part of an expression. */
565 /* Variables used to extract the register name from the probe's
570 const char *gdb_reg_prefix = gdbarch_stap_gdb_register_prefix (gdbarch);
571 int gdb_reg_prefix_len = gdb_reg_prefix ? strlen (gdb_reg_prefix) : 0;
572 const char *gdb_reg_suffix = gdbarch_stap_gdb_register_suffix (gdbarch);
573 int gdb_reg_suffix_len = gdb_reg_suffix ? strlen (gdb_reg_suffix) : 0;
574 const char *reg_prefix;
575 const char *reg_ind_prefix;
576 const char *reg_suffix;
577 const char *reg_ind_suffix;
579 /* Checking for a displacement argument. */
582 /* If it's a plus sign, we don't need to do anything, just advance the
593 if (isdigit (*p->arg))
595 /* The value of the displacement. */
600 displacement = strtol (p->arg, &endp, 10);
603 /* Generating the expression for the displacement. */
604 write_exp_elt_opcode (OP_LONG);
605 write_exp_elt_type (builtin_type (gdbarch)->builtin_long);
606 write_exp_elt_longcst (displacement);
607 write_exp_elt_opcode (OP_LONG);
609 write_exp_elt_opcode (UNOP_NEG);
612 /* Getting rid of register indirection prefix. */
613 if (stap_is_register_indirection_prefix (gdbarch, p->arg, ®_ind_prefix))
616 p->arg += strlen (reg_ind_prefix);
619 if (disp_p && !indirect_p)
620 error (_("Invalid register displacement syntax on expression `%s'."),
623 /* Getting rid of register prefix. */
624 if (stap_is_register_prefix (gdbarch, p->arg, ®_prefix))
625 p->arg += strlen (reg_prefix);
627 /* Now we should have only the register name. Let's extract it and get
628 the associated number. */
631 /* We assume the register name is composed by letters and numbers. */
632 while (isalnum (*p->arg))
635 len = p->arg - start;
637 regname = alloca (len + gdb_reg_prefix_len + gdb_reg_suffix_len + 1);
640 /* We only add the GDB's register prefix/suffix if we are dealing with
641 a numeric register. */
642 if (gdb_reg_prefix && isdigit (*start))
644 strncpy (regname, gdb_reg_prefix, gdb_reg_prefix_len);
645 strncpy (regname + gdb_reg_prefix_len, start, len);
648 strncpy (regname + gdb_reg_prefix_len + len,
649 gdb_reg_suffix, gdb_reg_suffix_len);
651 len += gdb_reg_prefix_len + gdb_reg_suffix_len;
654 strncpy (regname, start, len);
658 /* Is this a valid register name? */
659 if (user_reg_map_name_to_regnum (gdbarch, regname, len) == -1)
660 error (_("Invalid register name `%s' on expression `%s'."),
661 regname, p->saved_arg);
663 write_exp_elt_opcode (OP_REGISTER);
666 write_exp_string (str);
667 write_exp_elt_opcode (OP_REGISTER);
672 write_exp_elt_opcode (BINOP_ADD);
674 /* Casting to the expected type. */
675 write_exp_elt_opcode (UNOP_CAST);
676 write_exp_elt_type (lookup_pointer_type (p->arg_type));
677 write_exp_elt_opcode (UNOP_CAST);
679 write_exp_elt_opcode (UNOP_IND);
682 /* Getting rid of the register name suffix. */
683 if (stap_check_register_suffix (gdbarch, p->arg, ®_suffix))
684 p->arg += strlen (reg_suffix);
686 error (_("Missing register name suffix on expression `%s'."),
689 /* Getting rid of the register indirection suffix. */
692 if (stap_check_register_indirection_suffix (gdbarch, p->arg,
694 p->arg += strlen (reg_ind_suffix);
696 error (_("Missing indirection suffix on expression `%s'."),
701 /* This function is responsible for parsing a single operand.
703 A single operand can be:
705 - an unary operation (e.g., `-5', `~2', or even with subexpressions
707 - a register displacement, which will be treated as a register
708 operand (e.g., `-4(%eax)' on x86)
709 - a numeric constant, or
710 - a register operand (see function `stap_parse_register_operand')
712 The function also calls special-handling functions to deal with
713 unrecognized operands, allowing arch-specific parsers to be
717 stap_parse_single_operand (struct stap_parse_info *p)
719 struct gdbarch *gdbarch = p->gdbarch;
720 const char *int_prefix = NULL;
722 /* We first try to parse this token as a "special token". */
723 if (gdbarch_stap_parse_special_token_p (gdbarch))
724 if (gdbarch_stap_parse_special_token (gdbarch, p) != 0)
726 /* If the return value of the above function is not zero,
727 it means it successfully parsed the special token.
729 If it is NULL, we try to parse it using our method. */
733 if (*p->arg == '-' || *p->arg == '~' || *p->arg == '+')
737 /* We use this variable to do a lookahead. */
738 const char *tmp = p->arg;
740 /* Skipping signal. */
743 /* This is an unary operation. Here is a list of allowed tokens
747 - number (from register displacement)
748 - subexpression (beginning with `(')
750 We handle the register displacement here, and the other cases
752 if (p->inside_paren_p)
753 tmp = skip_spaces_const (tmp);
759 number = strtol (tmp, &endp, 10);
763 if (!stap_is_register_indirection_prefix (gdbarch, tmp, NULL))
765 /* This is not a displacement. We skip the operator, and deal
768 stap_parse_argument_conditionally (p);
770 write_exp_elt_opcode (UNOP_NEG);
772 write_exp_elt_opcode (UNOP_COMPLEMENT);
776 /* If we are here, it means it is a displacement. The only
777 operations allowed here are `-' and `+'. */
779 error (_("Invalid operator `%c' for register displacement "
780 "on expression `%s'."), c, p->saved_arg);
782 stap_parse_register_operand (p);
785 else if (isdigit (*p->arg))
787 /* A temporary variable, needed for lookahead. */
788 const char *tmp = p->arg;
792 /* We can be dealing with a numeric constant, or with a register
794 number = strtol (tmp, &endp, 10);
797 if (p->inside_paren_p)
798 tmp = skip_spaces_const (tmp);
800 /* If "stap_is_integer_prefix" returns true, it means we can
801 accept integers without a prefix here. But we also need to
802 check whether the next token (i.e., "tmp") is not a register
803 indirection prefix. */
804 if (stap_is_integer_prefix (gdbarch, p->arg, NULL)
805 && !stap_is_register_indirection_prefix (gdbarch, tmp, NULL))
807 const char *int_suffix;
809 /* We are dealing with a numeric constant. */
810 write_exp_elt_opcode (OP_LONG);
811 write_exp_elt_type (builtin_type (gdbarch)->builtin_long);
812 write_exp_elt_longcst (number);
813 write_exp_elt_opcode (OP_LONG);
817 if (stap_check_integer_suffix (gdbarch, p->arg, &int_suffix))
818 p->arg += strlen (int_suffix);
820 error (_("Invalid constant suffix on expression `%s'."),
823 else if (stap_is_register_indirection_prefix (gdbarch, tmp, NULL))
824 stap_parse_register_operand (p);
826 error (_("Unknown numeric token on expression `%s'."),
829 else if (stap_is_integer_prefix (gdbarch, p->arg, &int_prefix))
831 /* We are dealing with a numeric constant. */
834 const char *int_suffix;
836 p->arg += strlen (int_prefix);
837 number = strtol (p->arg, &endp, 10);
840 write_exp_elt_opcode (OP_LONG);
841 write_exp_elt_type (builtin_type (gdbarch)->builtin_long);
842 write_exp_elt_longcst (number);
843 write_exp_elt_opcode (OP_LONG);
845 if (stap_check_integer_suffix (gdbarch, p->arg, &int_suffix))
846 p->arg += strlen (int_suffix);
848 error (_("Invalid constant suffix on expression `%s'."),
851 else if (stap_is_register_prefix (gdbarch, p->arg, NULL)
852 || stap_is_register_indirection_prefix (gdbarch, p->arg, NULL))
853 stap_parse_register_operand (p);
855 error (_("Operator `%c' not recognized on expression `%s'."),
856 *p->arg, p->saved_arg);
859 /* This function parses an argument conditionally, based on single or
860 non-single operands. A non-single operand would be a parenthesized
861 expression (e.g., `(2 + 1)'), and a single operand is anything that
862 starts with `-', `~', `+' (i.e., unary operators), a digit, or
863 something recognized by `gdbarch_stap_is_single_operand'. */
866 stap_parse_argument_conditionally (struct stap_parse_info *p)
868 gdb_assert (gdbarch_stap_is_single_operand_p (p->gdbarch));
870 if (*p->arg == '-' || *p->arg == '~' || *p->arg == '+' /* Unary. */
872 || gdbarch_stap_is_single_operand (p->gdbarch, p->arg))
873 stap_parse_single_operand (p);
874 else if (*p->arg == '(')
876 /* We are dealing with a parenthesized operand. It means we
877 have to parse it as it was a separate expression, without
878 left-side or precedence. */
880 p->arg = skip_spaces_const (p->arg);
883 stap_parse_argument_1 (p, 0, STAP_OPERAND_PREC_NONE);
887 error (_("Missign close-paren on expression `%s'."),
891 if (p->inside_paren_p)
892 p->arg = skip_spaces_const (p->arg);
895 error (_("Cannot parse expression `%s'."), p->saved_arg);
898 /* Helper function for `stap_parse_argument'. Please, see its comments to
899 better understand what this function does. */
902 stap_parse_argument_1 (struct stap_parse_info *p, int has_lhs,
903 enum stap_operand_prec prec)
905 /* This is an operator-precedence parser.
907 We work with left- and right-sides of expressions, and
908 parse them depending on the precedence of the operators
911 gdb_assert (p->arg != NULL);
913 if (p->inside_paren_p)
914 p->arg = skip_spaces_const (p->arg);
918 /* We were called without a left-side, either because this is the
919 first call, or because we were called to parse a parenthesized
920 expression. It doesn't really matter; we have to parse the
921 left-side in order to continue the process. */
922 stap_parse_argument_conditionally (p);
925 /* Start to parse the right-side, and to "join" left and right sides
926 depending on the operation specified.
928 This loop shall continue until we run out of characters in the input,
929 or until we find a close-parenthesis, which means that we've reached
930 the end of a sub-expression. */
931 while (*p->arg != '\0' && *p->arg != ')' && !isspace (*p->arg))
933 const char *tmp_exp_buf;
934 enum exp_opcode opcode;
935 enum stap_operand_prec cur_prec;
937 if (!stap_is_operator (p->arg))
938 error (_("Invalid operator `%c' on expression `%s'."), *p->arg,
941 /* We have to save the current value of the expression buffer because
942 the `stap_get_opcode' modifies it in order to get the current
943 operator. If this operator's precedence is lower than PREC, we
944 should return and not advance the expression buffer pointer. */
945 tmp_exp_buf = p->arg;
946 opcode = stap_get_opcode (&tmp_exp_buf);
948 cur_prec = stap_get_operator_prec (opcode);
951 /* If the precedence of the operator that we are seeing now is
952 lower than the precedence of the first operator seen before
953 this parsing process began, it means we should stop parsing
958 p->arg = tmp_exp_buf;
959 if (p->inside_paren_p)
960 p->arg = skip_spaces_const (p->arg);
962 /* Parse the right-side of the expression. */
963 stap_parse_argument_conditionally (p);
965 /* While we still have operators, try to parse another
966 right-side, but using the current right-side as a left-side. */
967 while (*p->arg != '\0' && stap_is_operator (p->arg))
969 enum exp_opcode lookahead_opcode;
970 enum stap_operand_prec lookahead_prec;
972 /* Saving the current expression buffer position. The explanation
973 is the same as above. */
974 tmp_exp_buf = p->arg;
975 lookahead_opcode = stap_get_opcode (&tmp_exp_buf);
976 lookahead_prec = stap_get_operator_prec (lookahead_opcode);
978 if (lookahead_prec <= prec)
980 /* If we are dealing with an operator whose precedence is lower
981 than the first one, just abandon the attempt. */
985 /* Parse the right-side of the expression, but since we already
986 have a left-side at this point, set `has_lhs' to 1. */
987 stap_parse_argument_1 (p, 1, lookahead_prec);
990 write_exp_elt_opcode (opcode);
994 /* Parse a probe's argument.
998 LP = literal integer prefix
999 LS = literal integer suffix
1001 RP = register prefix
1002 RS = register suffix
1004 RIP = register indirection prefix
1005 RIS = register indirection suffix
1007 This routine assumes that arguments' tokens are of the form:
1010 - [RP] REGISTER [RS]
1011 - [RIP] [RP] REGISTER [RS] [RIS]
1012 - If we find a number without LP, we try to parse it as a literal integer
1013 constant (if LP == NULL), or as a register displacement.
1014 - We count parenthesis, and only skip whitespaces if we are inside them.
1015 - If we find an operator, we skip it.
1017 This function can also call a special function that will try to match
1018 unknown tokens. It will return 1 if the argument has been parsed
1019 successfully, or zero otherwise. */
1021 static struct expression *
1022 stap_parse_argument (const char **arg, struct type *atype,
1023 struct gdbarch *gdbarch)
1025 struct stap_parse_info p;
1026 struct cleanup *back_to;
1028 /* We need to initialize the expression buffer, in order to begin
1029 our parsing efforts. The language here does not matter, since we
1030 are using our own parser. */
1031 initialize_expout (10, current_language, gdbarch);
1032 back_to = make_cleanup (free_current_contents, &expout);
1037 p.gdbarch = gdbarch;
1038 p.inside_paren_p = 0;
1040 stap_parse_argument_1 (&p, 0, STAP_OPERAND_PREC_NONE);
1042 discard_cleanups (back_to);
1044 gdb_assert (p.inside_paren_p == 0);
1046 /* Casting the final expression to the appropriate type. */
1047 write_exp_elt_opcode (UNOP_CAST);
1048 write_exp_elt_type (atype);
1049 write_exp_elt_opcode (UNOP_CAST);
1051 reallocate_expout ();
1053 p.arg = skip_spaces_const (p.arg);
1059 /* Function which parses an argument string from PROBE, correctly splitting
1060 the arguments and storing their information in properly ways.
1062 Consider the following argument string (x86 syntax):
1066 We have two arguments, `%eax' and `$10', both with 32-bit unsigned bitness.
1067 This function basically handles them, properly filling some structures with
1068 this information. */
1071 stap_parse_probe_arguments (struct stap_probe *probe, struct gdbarch *gdbarch)
1075 gdb_assert (!probe->args_parsed);
1076 cur = probe->args_u.text;
1077 probe->args_parsed = 1;
1078 probe->args_u.vec = NULL;
1080 if (cur == NULL || *cur == '\0' || *cur == ':')
1083 while (*cur != '\0')
1085 struct stap_probe_arg arg;
1086 enum stap_arg_bitness b;
1088 struct expression *expr;
1090 memset (&arg, 0, sizeof (arg));
1092 /* We expect to find something like:
1096 Where `N' can be [+,-][4,8]. This is not mandatory, so
1097 we check it here. If we don't find it, go to the next
1099 if ((*cur == '-' && cur[1] != '\0' && cur[2] != '@')
1101 arg.bitness = STAP_ARG_BITNESS_UNDEFINED;
1106 /* Discard the `-'. */
1112 b = (got_minus ? STAP_ARG_BITNESS_32BIT_SIGNED
1113 : STAP_ARG_BITNESS_32BIT_UNSIGNED);
1114 else if (*cur == '8')
1115 b = (got_minus ? STAP_ARG_BITNESS_64BIT_SIGNED
1116 : STAP_ARG_BITNESS_64BIT_UNSIGNED);
1119 /* We have an error, because we don't expect anything
1121 complaint (&symfile_complaints,
1122 _("unrecognized bitness `%c' for probe `%s'"),
1123 *cur, probe->p.name);
1128 arg.atype = stap_get_expected_argument_type (gdbarch, b);
1130 /* Discard the number and the `@' sign. */
1134 expr = stap_parse_argument (&cur, arg.atype, gdbarch);
1136 if (stap_expression_debug)
1137 dump_raw_expression (expr, gdb_stdlog,
1138 "before conversion to prefix form");
1140 prefixify_expression (expr);
1142 if (stap_expression_debug)
1143 dump_prefix_expression (expr, gdb_stdlog);
1147 /* Start it over again. */
1148 cur = skip_spaces_const (cur);
1150 VEC_safe_push (stap_probe_arg_s, probe->args_u.vec, &arg);
1154 /* Given PROBE, returns the number of arguments present in that probe's
1158 stap_get_probe_argument_count (struct probe *probe_generic,
1159 struct frame_info *frame)
1161 struct stap_probe *probe = (struct stap_probe *) probe_generic;
1162 struct gdbarch *gdbarch = get_frame_arch (frame);
1164 gdb_assert (probe_generic->pops == &stap_probe_ops);
1166 if (!probe->args_parsed)
1168 if (can_evaluate_probe_arguments (probe_generic))
1169 stap_parse_probe_arguments (probe, gdbarch);
1172 static int have_warned_stap_incomplete = 0;
1174 if (!have_warned_stap_incomplete)
1177 "The SystemTap SDT probe support is not fully implemented on this target;\n"
1178 "you will not be able to inspect the arguments of the probes.\n"
1179 "Please report a bug against GDB requesting a port to this target."));
1180 have_warned_stap_incomplete = 1;
1183 /* Marking the arguments as "already parsed". */
1184 probe->args_u.vec = NULL;
1185 probe->args_parsed = 1;
1189 gdb_assert (probe->args_parsed);
1190 return VEC_length (stap_probe_arg_s, probe->args_u.vec);
1193 /* Return 1 if OP is a valid operator inside a probe argument, or zero
1197 stap_is_operator (const char *op)
1222 /* We didn't find any operator. */
1229 static struct stap_probe_arg *
1230 stap_get_arg (struct stap_probe *probe, unsigned n, struct gdbarch *gdbarch)
1232 if (!probe->args_parsed)
1233 stap_parse_probe_arguments (probe, gdbarch);
1235 return VEC_index (stap_probe_arg_s, probe->args_u.vec, n);
1238 /* Implement the `can_evaluate_probe_arguments' method of probe_ops. */
1241 stap_can_evaluate_probe_arguments (struct probe *probe_generic)
1243 struct stap_probe *stap_probe = (struct stap_probe *) probe_generic;
1244 struct gdbarch *gdbarch = get_objfile_arch (stap_probe->p.objfile);
1246 /* For SystemTap probes, we have to guarantee that the method
1247 stap_is_single_operand is defined on gdbarch. If it is not, then it
1248 means that argument evaluation is not implemented on this target. */
1249 return gdbarch_stap_is_single_operand_p (gdbarch);
1252 /* Evaluate the probe's argument N (indexed from 0), returning a value
1253 corresponding to it. Assertion is thrown if N does not exist. */
1255 static struct value *
1256 stap_evaluate_probe_argument (struct probe *probe_generic, unsigned n,
1257 struct frame_info *frame)
1259 struct stap_probe *stap_probe = (struct stap_probe *) probe_generic;
1260 struct gdbarch *gdbarch = get_frame_arch (frame);
1261 struct stap_probe_arg *arg;
1264 gdb_assert (probe_generic->pops == &stap_probe_ops);
1266 arg = stap_get_arg (stap_probe, n, gdbarch);
1267 return evaluate_subexp_standard (arg->atype, arg->aexpr, &pos, EVAL_NORMAL);
1270 /* Compile the probe's argument N (indexed from 0) to agent expression.
1271 Assertion is thrown if N does not exist. */
1274 stap_compile_to_ax (struct probe *probe_generic, struct agent_expr *expr,
1275 struct axs_value *value, unsigned n)
1277 struct stap_probe *stap_probe = (struct stap_probe *) probe_generic;
1278 struct stap_probe_arg *arg;
1279 union exp_element *pc;
1281 gdb_assert (probe_generic->pops == &stap_probe_ops);
1283 arg = stap_get_arg (stap_probe, n, expr->gdbarch);
1285 pc = arg->aexpr->elts;
1286 gen_expr (arg->aexpr, &pc, expr, value);
1288 require_rvalue (expr, value);
1289 value->type = arg->atype;
1292 /* Destroy (free) the data related to PROBE. PROBE memory itself is not feed
1293 as it is allocated from OBJFILE_OBSTACK. */
1296 stap_probe_destroy (struct probe *probe_generic)
1298 struct stap_probe *probe = (struct stap_probe *) probe_generic;
1300 gdb_assert (probe_generic->pops == &stap_probe_ops);
1302 if (probe->args_parsed)
1304 struct stap_probe_arg *arg;
1307 for (ix = 0; VEC_iterate (stap_probe_arg_s, probe->args_u.vec, ix, arg);
1310 VEC_free (stap_probe_arg_s, probe->args_u.vec);
1316 /* This is called to compute the value of one of the $_probe_arg*
1317 convenience variables. */
1319 static struct value *
1320 compute_probe_arg (struct gdbarch *arch, struct internalvar *ivar,
1323 struct frame_info *frame = get_selected_frame (_("No frame selected"));
1324 CORE_ADDR pc = get_frame_pc (frame);
1325 int sel = (int) (uintptr_t) data;
1326 struct probe *pc_probe;
1327 const struct sym_probe_fns *pc_probe_fns;
1330 /* SEL == -1 means "_probe_argc". */
1331 gdb_assert (sel >= -1);
1333 pc_probe = find_probe_by_pc (pc);
1334 if (pc_probe == NULL)
1335 error (_("No SystemTap probe at PC %s"), core_addr_to_string (pc));
1337 n_args = get_probe_argument_count (pc_probe, frame);
1339 return value_from_longest (builtin_type (arch)->builtin_int, n_args);
1342 error (_("Invalid probe argument %d -- probe has %u arguments available"),
1345 return evaluate_probe_argument (pc_probe, sel, frame);
1348 /* This is called to compile one of the $_probe_arg* convenience
1349 variables into an agent expression. */
1352 compile_probe_arg (struct internalvar *ivar, struct agent_expr *expr,
1353 struct axs_value *value, void *data)
1355 CORE_ADDR pc = expr->scope;
1356 int sel = (int) (uintptr_t) data;
1357 struct probe *pc_probe;
1358 const struct sym_probe_fns *pc_probe_fns;
1360 struct frame_info *frame = get_selected_frame (NULL);
1362 /* SEL == -1 means "_probe_argc". */
1363 gdb_assert (sel >= -1);
1365 pc_probe = find_probe_by_pc (pc);
1366 if (pc_probe == NULL)
1367 error (_("No SystemTap probe at PC %s"), core_addr_to_string (pc));
1369 n_args = get_probe_argument_count (pc_probe, frame);
1373 value->kind = axs_rvalue;
1374 value->type = builtin_type (expr->gdbarch)->builtin_int;
1375 ax_const_l (expr, n_args);
1379 gdb_assert (sel >= 0);
1381 error (_("Invalid probe argument %d -- probe has %d arguments available"),
1384 pc_probe->pops->compile_to_ax (pc_probe, expr, value, sel);
1389 /* Set or clear a SystemTap semaphore. ADDRESS is the semaphore's
1390 address. SET is zero if the semaphore should be cleared, or one
1391 if it should be set. This is a helper function for `stap_semaphore_down'
1392 and `stap_semaphore_up'. */
1395 stap_modify_semaphore (CORE_ADDR address, int set, struct gdbarch *gdbarch)
1397 gdb_byte bytes[sizeof (LONGEST)];
1398 /* The ABI specifies "unsigned short". */
1399 struct type *type = builtin_type (gdbarch)->builtin_unsigned_short;
1405 /* Swallow errors. */
1406 if (target_read_memory (address, bytes, TYPE_LENGTH (type)) != 0)
1408 warning (_("Could not read the value of a SystemTap semaphore."));
1412 value = extract_unsigned_integer (bytes, TYPE_LENGTH (type),
1413 gdbarch_byte_order (gdbarch));
1414 /* Note that we explicitly don't worry about overflow or
1421 store_unsigned_integer (bytes, TYPE_LENGTH (type),
1422 gdbarch_byte_order (gdbarch), value);
1424 if (target_write_memory (address, bytes, TYPE_LENGTH (type)) != 0)
1425 warning (_("Could not write the value of a SystemTap semaphore."));
1428 /* Set a SystemTap semaphore. SEM is the semaphore's address. Semaphores
1429 act as reference counters, so calls to this function must be paired with
1430 calls to `stap_semaphore_down'.
1432 This function and `stap_semaphore_down' race with another tool changing
1433 the probes, but that is too rare to care. */
1436 stap_set_semaphore (struct probe *probe_generic, struct gdbarch *gdbarch)
1438 struct stap_probe *probe = (struct stap_probe *) probe_generic;
1440 gdb_assert (probe_generic->pops == &stap_probe_ops);
1442 stap_modify_semaphore (probe->sem_addr, 1, gdbarch);
1445 /* Clear a SystemTap semaphore. SEM is the semaphore's address. */
1448 stap_clear_semaphore (struct probe *probe_generic, struct gdbarch *gdbarch)
1450 struct stap_probe *probe = (struct stap_probe *) probe_generic;
1452 gdb_assert (probe_generic->pops == &stap_probe_ops);
1454 stap_modify_semaphore (probe->sem_addr, 0, gdbarch);
1457 /* Implementation of `$_probe_arg*' set of variables. */
1459 static const struct internalvar_funcs probe_funcs =
1466 /* Helper function that parses the information contained in a
1467 SystemTap's probe. Basically, the information consists in:
1469 - Probe's PC address;
1470 - Link-time section address of `.stapsdt.base' section;
1471 - Link-time address of the semaphore variable, or ZERO if the
1472 probe doesn't have an associated semaphore;
1473 - Probe's provider name;
1475 - Probe's argument format
1477 This function returns 1 if the handling was successful, and zero
1481 handle_stap_probe (struct objfile *objfile, struct sdt_note *el,
1482 VEC (probe_p) **probesp, CORE_ADDR base)
1484 bfd *abfd = objfile->obfd;
1485 int size = bfd_get_arch_size (abfd) / 8;
1486 struct gdbarch *gdbarch = get_objfile_arch (objfile);
1487 struct type *ptr_type = builtin_type (gdbarch)->builtin_data_ptr;
1489 const char *probe_args = NULL;
1490 struct stap_probe *ret;
1492 ret = obstack_alloc (&objfile->objfile_obstack, sizeof (*ret));
1493 ret->p.pops = &stap_probe_ops;
1494 ret->p.objfile = objfile;
1496 /* Provider and the name of the probe. */
1497 ret->p.provider = (char *) &el->data[3 * size];
1498 ret->p.name = memchr (ret->p.provider, '\0',
1499 (char *) el->data + el->size - ret->p.provider);
1500 /* Making sure there is a name. */
1501 if (ret->p.name == NULL)
1503 complaint (&symfile_complaints, _("corrupt probe name when "
1505 objfile_name (objfile));
1507 /* There is no way to use a probe without a name or a provider, so
1508 returning zero here makes sense. */
1514 /* Retrieving the probe's address. */
1515 ret->p.address = extract_typed_address (&el->data[0], ptr_type);
1517 /* Link-time sh_addr of `.stapsdt.base' section. */
1518 base_ref = extract_typed_address (&el->data[size], ptr_type);
1520 /* Semaphore address. */
1521 ret->sem_addr = extract_typed_address (&el->data[2 * size], ptr_type);
1523 ret->p.address += (ANOFFSET (objfile->section_offsets,
1524 SECT_OFF_TEXT (objfile))
1526 if (ret->sem_addr != 0)
1527 ret->sem_addr += (ANOFFSET (objfile->section_offsets,
1528 SECT_OFF_DATA (objfile))
1531 /* Arguments. We can only extract the argument format if there is a valid
1532 name for this probe. */
1533 probe_args = memchr (ret->p.name, '\0',
1534 (char *) el->data + el->size - ret->p.name);
1536 if (probe_args != NULL)
1539 if (probe_args == NULL
1540 || (memchr (probe_args, '\0', (char *) el->data + el->size - ret->p.name)
1541 != el->data + el->size - 1))
1543 complaint (&symfile_complaints, _("corrupt probe argument when "
1545 objfile_name (objfile));
1546 /* If the argument string is NULL, it means some problem happened with
1547 it. So we return 0. */
1551 ret->args_parsed = 0;
1552 ret->args_u.text = (void *) probe_args;
1554 /* Successfully created probe. */
1555 VEC_safe_push (probe_p, *probesp, (struct probe *) ret);
1558 /* Helper function which tries to find the base address of the SystemTap
1559 base section named STAP_BASE_SECTION_NAME. */
1562 get_stap_base_address_1 (bfd *abfd, asection *sect, void *obj)
1564 asection **ret = obj;
1566 if ((sect->flags & (SEC_DATA | SEC_ALLOC | SEC_HAS_CONTENTS))
1567 && sect->name && !strcmp (sect->name, STAP_BASE_SECTION_NAME))
1571 /* Helper function which iterates over every section in the BFD file,
1572 trying to find the base address of the SystemTap base section.
1573 Returns 1 if found (setting BASE to the proper value), zero otherwise. */
1576 get_stap_base_address (bfd *obfd, bfd_vma *base)
1578 asection *ret = NULL;
1580 bfd_map_over_sections (obfd, get_stap_base_address_1, (void *) &ret);
1584 complaint (&symfile_complaints, _("could not obtain base address for "
1585 "SystemTap section on objfile `%s'."),
1596 /* Helper function for `elf_get_probes', which gathers information about all
1597 SystemTap probes from OBJFILE. */
1600 stap_get_probes (VEC (probe_p) **probesp, struct objfile *objfile)
1602 /* If we are here, then this is the first time we are parsing the
1603 SystemTap probe's information. We basically have to count how many
1604 probes the objfile has, and then fill in the necessary information
1606 bfd *obfd = objfile->obfd;
1608 struct sdt_note *iter;
1609 unsigned save_probesp_len = VEC_length (probe_p, *probesp);
1611 if (objfile->separate_debug_objfile_backlink != NULL)
1613 /* This is a .debug file, not the objfile itself. */
1617 if (elf_tdata (obfd)->sdt_note_head == NULL)
1619 /* There isn't any probe here. */
1623 if (!get_stap_base_address (obfd, &base))
1625 /* There was an error finding the base address for the section.
1626 Just return NULL. */
1630 /* Parsing each probe's information. */
1631 for (iter = elf_tdata (obfd)->sdt_note_head;
1635 /* We first have to handle all the information about the
1636 probe which is present in the section. */
1637 handle_stap_probe (objfile, iter, probesp, base);
1640 if (save_probesp_len == VEC_length (probe_p, *probesp))
1642 /* If we are here, it means we have failed to parse every known
1644 complaint (&symfile_complaints, _("could not parse SystemTap probe(s) "
1651 stap_relocate (struct probe *probe_generic, CORE_ADDR delta)
1653 struct stap_probe *probe = (struct stap_probe *) probe_generic;
1655 gdb_assert (probe_generic->pops == &stap_probe_ops);
1657 probe->p.address += delta;
1658 if (probe->sem_addr != 0)
1659 probe->sem_addr += delta;
1663 stap_probe_is_linespec (const char **linespecp)
1665 static const char *const keywords[] = { "-pstap", "-probe-stap", NULL };
1667 return probe_is_linespec_by_keyword (linespecp, keywords);
1671 stap_gen_info_probes_table_header (VEC (info_probe_column_s) **heads)
1673 info_probe_column_s stap_probe_column;
1675 stap_probe_column.field_name = "semaphore";
1676 stap_probe_column.print_name = _("Semaphore");
1678 VEC_safe_push (info_probe_column_s, *heads, &stap_probe_column);
1682 stap_gen_info_probes_table_values (struct probe *probe_generic,
1683 VEC (const_char_ptr) **ret)
1685 struct stap_probe *probe = (struct stap_probe *) probe_generic;
1686 struct gdbarch *gdbarch;
1687 const char *val = NULL;
1689 gdb_assert (probe_generic->pops == &stap_probe_ops);
1691 gdbarch = get_objfile_arch (probe->p.objfile);
1693 if (probe->sem_addr != 0)
1694 val = print_core_address (gdbarch, probe->sem_addr);
1696 VEC_safe_push (const_char_ptr, *ret, val);
1699 /* SystemTap probe_ops. */
1701 static const struct probe_ops stap_probe_ops =
1703 stap_probe_is_linespec,
1706 stap_get_probe_argument_count,
1707 stap_can_evaluate_probe_arguments,
1708 stap_evaluate_probe_argument,
1711 stap_clear_semaphore,
1713 stap_gen_info_probes_table_header,
1714 stap_gen_info_probes_table_values,
1717 /* Implementation of the `info probes stap' command. */
1720 info_probes_stap_command (char *arg, int from_tty)
1722 info_probes_for_ops (arg, from_tty, &stap_probe_ops);
1725 void _initialize_stap_probe (void);
1728 _initialize_stap_probe (void)
1730 VEC_safe_push (probe_ops_cp, all_probe_ops, &stap_probe_ops);
1732 add_setshow_zuinteger_cmd ("stap-expression", class_maintenance,
1733 &stap_expression_debug,
1734 _("Set SystemTap expression debugging."),
1735 _("Show SystemTap expression debugging."),
1736 _("When non-zero, the internal representation "
1737 "of SystemTap expressions will be printed."),
1739 show_stapexpressiondebug,
1740 &setdebuglist, &showdebuglist);
1742 create_internalvar_type_lazy ("_probe_argc", &probe_funcs,
1743 (void *) (uintptr_t) -1);
1744 create_internalvar_type_lazy ("_probe_arg0", &probe_funcs,
1745 (void *) (uintptr_t) 0);
1746 create_internalvar_type_lazy ("_probe_arg1", &probe_funcs,
1747 (void *) (uintptr_t) 1);
1748 create_internalvar_type_lazy ("_probe_arg2", &probe_funcs,
1749 (void *) (uintptr_t) 2);
1750 create_internalvar_type_lazy ("_probe_arg3", &probe_funcs,
1751 (void *) (uintptr_t) 3);
1752 create_internalvar_type_lazy ("_probe_arg4", &probe_funcs,
1753 (void *) (uintptr_t) 4);
1754 create_internalvar_type_lazy ("_probe_arg5", &probe_funcs,
1755 (void *) (uintptr_t) 5);
1756 create_internalvar_type_lazy ("_probe_arg6", &probe_funcs,
1757 (void *) (uintptr_t) 6);
1758 create_internalvar_type_lazy ("_probe_arg7", &probe_funcs,
1759 (void *) (uintptr_t) 7);
1760 create_internalvar_type_lazy ("_probe_arg8", &probe_funcs,
1761 (void *) (uintptr_t) 8);
1762 create_internalvar_type_lazy ("_probe_arg9", &probe_funcs,
1763 (void *) (uintptr_t) 9);
1764 create_internalvar_type_lazy ("_probe_arg10", &probe_funcs,
1765 (void *) (uintptr_t) 10);
1766 create_internalvar_type_lazy ("_probe_arg11", &probe_funcs,
1767 (void *) (uintptr_t) 11);
1769 add_cmd ("stap", class_info, info_probes_stap_command,
1771 Show information about SystemTap static probes.\n\
1772 Usage: info probes stap [PROVIDER [NAME [OBJECT]]]\n\
1773 Each argument is a regular expression, used to select probes.\n\
1774 PROVIDER matches probe provider names.\n\
1775 NAME matches the probe names.\n\
1776 OBJECT matches the executable or shared library name."),
1777 info_probes_cmdlist_get ());