X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=gdb%2Fstap-probe.c;h=d88c47095595862f529c47794cb2b6ca9b33f1d3;hb=19ba03f49581e407097a3e4821a957c422551ae5;hp=33d4569967aa2455185ccac33764478356b43115;hpb=08a6411c715c2d8bf31d5a5c8a477fa4651639aa;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/stap-probe.c b/gdb/stap-probe.c index 33d4569967..d88c470955 100644 --- a/gdb/stap-probe.c +++ b/gdb/stap-probe.c @@ -1,6 +1,6 @@ /* SystemTap probe support for GDB. - Copyright (C) 2012-2013 Free Software Foundation, Inc. + Copyright (C) 2012-2015 Free Software Foundation, Inc. This file is part of GDB. @@ -28,7 +28,6 @@ #include "gdbcmd.h" #include "filenames.h" #include "value.h" -#include "exceptions.h" #include "ax.h" #include "ax-gdb.h" #include "complaints.h" @@ -48,7 +47,7 @@ /* Forward declaration. */ -static const struct probe_ops stap_probe_ops; +extern const struct probe_ops stap_probe_ops; /* Should we display debug information for the probe's argument expression parsing? */ @@ -60,6 +59,10 @@ static unsigned int stap_expression_debug = 0; The relationship is: - STAP_ARG_BITNESS_UNDEFINED: The user hasn't specified the bitness. + - STAP_ARG_BITNESS_8BIT_UNSIGNED: argument string starts with `1@'. + - STAP_ARG_BITNESS_8BIT_SIGNED: argument string starts with `-1@'. + - STAP_ARG_BITNESS_16BIT_UNSIGNED: argument string starts with `2@'. + - STAP_ARG_BITNESS_16BIT_SIGNED: argument string starts with `-2@'. - STAP_ARG_BITNESS_32BIT_UNSIGNED: argument string starts with `4@'. - STAP_ARG_BITNESS_32BIT_SIGNED: argument string starts with `-4@'. - STAP_ARG_BITNESS_64BIT_UNSIGNED: argument string starts with `8@'. @@ -68,6 +71,10 @@ static unsigned int stap_expression_debug = 0; enum stap_arg_bitness { STAP_ARG_BITNESS_UNDEFINED, + STAP_ARG_BITNESS_8BIT_UNSIGNED, + STAP_ARG_BITNESS_8BIT_SIGNED, + STAP_ARG_BITNESS_16BIT_UNSIGNED, + STAP_ARG_BITNESS_16BIT_SIGNED, STAP_ARG_BITNESS_32BIT_UNSIGNED, STAP_ARG_BITNESS_32BIT_SIGNED, STAP_ARG_BITNESS_64BIT_UNSIGNED, @@ -99,10 +106,12 @@ struct stap_probe struct probe p; /* If the probe has a semaphore associated, then this is the value of - it. */ + it, relative to SECT_OFF_DATA. */ CORE_ADDR sem_addr; + /* One if the arguments have been parsed. */ unsigned int args_parsed : 1; + union { const char *text; @@ -304,9 +313,8 @@ stap_get_opcode (const char **s) break; default: - internal_error (__FILE__, __LINE__, - _("Invalid opcode in expression `%s' for SystemTap" - "probe"), *s); + error (_("Invalid opcode in expression `%s' for SystemTap" + "probe"), *s); } return op; @@ -317,7 +325,8 @@ stap_get_opcode (const char **s) static struct type * stap_get_expected_argument_type (struct gdbarch *gdbarch, - enum stap_arg_bitness b) + enum stap_arg_bitness b, + const struct stap_probe *probe) { switch (b) { @@ -327,6 +336,18 @@ stap_get_expected_argument_type (struct gdbarch *gdbarch, else return builtin_type (gdbarch)->builtin_uint64; + case STAP_ARG_BITNESS_8BIT_UNSIGNED: + return builtin_type (gdbarch)->builtin_uint8; + + case STAP_ARG_BITNESS_8BIT_SIGNED: + return builtin_type (gdbarch)->builtin_int8; + + case STAP_ARG_BITNESS_16BIT_UNSIGNED: + return builtin_type (gdbarch)->builtin_uint16; + + case STAP_ARG_BITNESS_16BIT_SIGNED: + return builtin_type (gdbarch)->builtin_int16; + case STAP_ARG_BITNESS_32BIT_SIGNED: return builtin_type (gdbarch)->builtin_int32; @@ -340,12 +361,195 @@ stap_get_expected_argument_type (struct gdbarch *gdbarch, return builtin_type (gdbarch)->builtin_uint64; default: - internal_error (__FILE__, __LINE__, - _("Undefined bitness for probe.")); + error (_("Undefined bitness for probe '%s'."), + probe->p.name); break; } } +/* Helper function to check for a generic list of prefixes. GDBARCH + is the current gdbarch being used. S is the expression being + analyzed. If R is not NULL, it will be used to return the found + prefix. PREFIXES is the list of expected prefixes. + + This function does a case-insensitive match. + + Return 1 if any prefix has been found, zero otherwise. */ + +static int +stap_is_generic_prefix (struct gdbarch *gdbarch, const char *s, + const char **r, const char *const *prefixes) +{ + const char *const *p; + + if (prefixes == NULL) + { + if (r != NULL) + *r = ""; + + return 1; + } + + for (p = prefixes; *p != NULL; ++p) + if (strncasecmp (s, *p, strlen (*p)) == 0) + { + if (r != NULL) + *r = *p; + + return 1; + } + + return 0; +} + +/* Return 1 if S points to a register prefix, zero otherwise. For a + description of the arguments, look at stap_is_generic_prefix. */ + +static int +stap_is_register_prefix (struct gdbarch *gdbarch, const char *s, + const char **r) +{ + const char *const *t = gdbarch_stap_register_prefixes (gdbarch); + + return stap_is_generic_prefix (gdbarch, s, r, t); +} + +/* Return 1 if S points to a register indirection prefix, zero + otherwise. For a description of the arguments, look at + stap_is_generic_prefix. */ + +static int +stap_is_register_indirection_prefix (struct gdbarch *gdbarch, const char *s, + const char **r) +{ + const char *const *t = gdbarch_stap_register_indirection_prefixes (gdbarch); + + return stap_is_generic_prefix (gdbarch, s, r, t); +} + +/* Return 1 if S points to an integer prefix, zero otherwise. For a + description of the arguments, look at stap_is_generic_prefix. + + This function takes care of analyzing whether we are dealing with + an expected integer prefix, or, if there is no integer prefix to be + expected, whether we are dealing with a digit. It does a + case-insensitive match. */ + +static int +stap_is_integer_prefix (struct gdbarch *gdbarch, const char *s, + const char **r) +{ + const char *const *t = gdbarch_stap_integer_prefixes (gdbarch); + const char *const *p; + + if (t == NULL) + { + /* A NULL value here means that integers do not have a prefix. + We just check for a digit then. */ + if (r != NULL) + *r = ""; + + return isdigit (*s); + } + + for (p = t; *p != NULL; ++p) + { + size_t len = strlen (*p); + + if ((len == 0 && isdigit (*s)) + || (len > 0 && strncasecmp (s, *p, len) == 0)) + { + /* Integers may or may not have a prefix. The "len == 0" + check covers the case when integers do not have a prefix + (therefore, we just check if we have a digit). The call + to "strncasecmp" covers the case when they have a + prefix. */ + if (r != NULL) + *r = *p; + + return 1; + } + } + + return 0; +} + +/* Helper function to check for a generic list of suffixes. If we are + not expecting any suffixes, then it just returns 1. If we are + expecting at least one suffix, then it returns 1 if a suffix has + been found, zero otherwise. GDBARCH is the current gdbarch being + used. S is the expression being analyzed. If R is not NULL, it + will be used to return the found suffix. SUFFIXES is the list of + expected suffixes. This function does a case-insensitive + match. */ + +static int +stap_generic_check_suffix (struct gdbarch *gdbarch, const char *s, + const char **r, const char *const *suffixes) +{ + const char *const *p; + int found = 0; + + if (suffixes == NULL) + { + if (r != NULL) + *r = ""; + + return 1; + } + + for (p = suffixes; *p != NULL; ++p) + if (strncasecmp (s, *p, strlen (*p)) == 0) + { + if (r != NULL) + *r = *p; + + found = 1; + break; + } + + return found; +} + +/* Return 1 if S points to an integer suffix, zero otherwise. For a + description of the arguments, look at + stap_generic_check_suffix. */ + +static int +stap_check_integer_suffix (struct gdbarch *gdbarch, const char *s, + const char **r) +{ + const char *const *p = gdbarch_stap_integer_suffixes (gdbarch); + + return stap_generic_check_suffix (gdbarch, s, r, p); +} + +/* Return 1 if S points to a register suffix, zero otherwise. For a + description of the arguments, look at + stap_generic_check_suffix. */ + +static int +stap_check_register_suffix (struct gdbarch *gdbarch, const char *s, + const char **r) +{ + const char *const *p = gdbarch_stap_register_suffixes (gdbarch); + + return stap_generic_check_suffix (gdbarch, s, r, p); +} + +/* Return 1 if S points to a register indirection suffix, zero + otherwise. For a description of the arguments, look at + stap_generic_check_suffix. */ + +static int +stap_check_register_indirection_suffix (struct gdbarch *gdbarch, const char *s, + const char **r) +{ + const char *const *p = gdbarch_stap_register_indirection_suffixes (gdbarch); + + return stap_generic_check_suffix (gdbarch, s, r, p); +} + /* Function responsible for parsing a register operand according to SystemTap parlance. Assuming: @@ -371,38 +575,25 @@ stap_parse_register_operand (struct stap_parse_info *p) /* Simple flag to indicate whether we have seen a minus signal before certain number. */ int got_minus = 0; - /* Flags to indicate whether this register access is being displaced and/or indirected. */ int disp_p = 0, indirect_p = 0; struct gdbarch *gdbarch = p->gdbarch; - /* Needed to generate the register name as a part of an expression. */ struct stoken str; - /* Variables used to extract the register name from the probe's argument. */ const char *start; char *regname; int len; - - /* Prefixes for the parser. */ - const char *reg_prefix = gdbarch_stap_register_prefix (gdbarch); - const char *reg_ind_prefix - = gdbarch_stap_register_indirection_prefix (gdbarch); const char *gdb_reg_prefix = gdbarch_stap_gdb_register_prefix (gdbarch); - int reg_prefix_len = reg_prefix ? strlen (reg_prefix) : 0; - int reg_ind_prefix_len = reg_ind_prefix ? strlen (reg_ind_prefix) : 0; int gdb_reg_prefix_len = gdb_reg_prefix ? strlen (gdb_reg_prefix) : 0; - - /* Suffixes for the parser. */ - const char *reg_suffix = gdbarch_stap_register_suffix (gdbarch); - const char *reg_ind_suffix - = gdbarch_stap_register_indirection_suffix (gdbarch); const char *gdb_reg_suffix = gdbarch_stap_gdb_register_suffix (gdbarch); - int reg_suffix_len = reg_suffix ? strlen (reg_suffix) : 0; - int reg_ind_suffix_len = reg_ind_suffix ? strlen (reg_ind_suffix) : 0; int gdb_reg_suffix_len = gdb_reg_suffix ? strlen (gdb_reg_suffix) : 0; + const char *reg_prefix; + const char *reg_ind_prefix; + const char *reg_suffix; + const char *reg_ind_suffix; /* Checking for a displacement argument. */ if (*p->arg == '+') @@ -429,20 +620,19 @@ stap_parse_register_operand (struct stap_parse_info *p) p->arg = endp; /* Generating the expression for the displacement. */ - write_exp_elt_opcode (OP_LONG); - write_exp_elt_type (builtin_type (gdbarch)->builtin_long); - write_exp_elt_longcst (displacement); - write_exp_elt_opcode (OP_LONG); + write_exp_elt_opcode (&p->pstate, OP_LONG); + write_exp_elt_type (&p->pstate, builtin_type (gdbarch)->builtin_long); + write_exp_elt_longcst (&p->pstate, displacement); + write_exp_elt_opcode (&p->pstate, OP_LONG); if (got_minus) - write_exp_elt_opcode (UNOP_NEG); + write_exp_elt_opcode (&p->pstate, UNOP_NEG); } /* Getting rid of register indirection prefix. */ - if (reg_ind_prefix - && strncmp (p->arg, reg_ind_prefix, reg_ind_prefix_len) == 0) + if (stap_is_register_indirection_prefix (gdbarch, p->arg, ®_ind_prefix)) { indirect_p = 1; - p->arg += reg_ind_prefix_len; + p->arg += strlen (reg_ind_prefix); } if (disp_p && !indirect_p) @@ -450,8 +640,8 @@ stap_parse_register_operand (struct stap_parse_info *p) p->saved_arg); /* Getting rid of register prefix. */ - if (reg_prefix && strncmp (p->arg, reg_prefix, reg_prefix_len) == 0) - p->arg += reg_prefix_len; + if (stap_is_register_prefix (gdbarch, p->arg, ®_prefix)) + p->arg += strlen (reg_prefix); /* Now we should have only the register name. Let's extract it and get the associated number. */ @@ -463,7 +653,7 @@ stap_parse_register_operand (struct stap_parse_info *p) len = p->arg - start; - regname = alloca (len + gdb_reg_prefix_len + gdb_reg_suffix_len + 1); + regname = (char *) alloca (len + gdb_reg_prefix_len + gdb_reg_suffix_len + 1); regname[0] = '\0'; /* We only add the GDB's register prefix/suffix if we are dealing with @@ -489,43 +679,41 @@ stap_parse_register_operand (struct stap_parse_info *p) error (_("Invalid register name `%s' on expression `%s'."), regname, p->saved_arg); - write_exp_elt_opcode (OP_REGISTER); + write_exp_elt_opcode (&p->pstate, OP_REGISTER); str.ptr = regname; str.length = len; - write_exp_string (str); - write_exp_elt_opcode (OP_REGISTER); + write_exp_string (&p->pstate, str); + write_exp_elt_opcode (&p->pstate, OP_REGISTER); if (indirect_p) { if (disp_p) - write_exp_elt_opcode (BINOP_ADD); + write_exp_elt_opcode (&p->pstate, BINOP_ADD); /* Casting to the expected type. */ - write_exp_elt_opcode (UNOP_CAST); - write_exp_elt_type (lookup_pointer_type (p->arg_type)); - write_exp_elt_opcode (UNOP_CAST); + write_exp_elt_opcode (&p->pstate, UNOP_CAST); + write_exp_elt_type (&p->pstate, lookup_pointer_type (p->arg_type)); + write_exp_elt_opcode (&p->pstate, UNOP_CAST); - write_exp_elt_opcode (UNOP_IND); + write_exp_elt_opcode (&p->pstate, UNOP_IND); } /* Getting rid of the register name suffix. */ - if (reg_suffix) - { - if (strncmp (p->arg, reg_suffix, reg_suffix_len) != 0) - error (_("Missing register name suffix `%s' on expression `%s'."), - reg_suffix, p->saved_arg); - - p->arg += reg_suffix_len; - } + if (stap_check_register_suffix (gdbarch, p->arg, ®_suffix)) + p->arg += strlen (reg_suffix); + else + error (_("Missing register name suffix on expression `%s'."), + p->saved_arg); /* Getting rid of the register indirection suffix. */ - if (indirect_p && reg_ind_suffix) + if (indirect_p) { - if (strncmp (p->arg, reg_ind_suffix, reg_ind_suffix_len) != 0) - error (_("Missing indirection suffix `%s' on expression `%s'."), - reg_ind_suffix, p->saved_arg); - - p->arg += reg_ind_suffix_len; + if (stap_check_register_indirection_suffix (gdbarch, p->arg, + ®_ind_suffix)) + p->arg += strlen (reg_ind_suffix); + else + error (_("Missing indirection suffix on expression `%s'."), + p->saved_arg); } } @@ -548,43 +736,27 @@ static void stap_parse_single_operand (struct stap_parse_info *p) { struct gdbarch *gdbarch = p->gdbarch; - - /* Prefixes for the parser. */ - const char *const_prefix = gdbarch_stap_integer_prefix (gdbarch); - const char *reg_prefix = gdbarch_stap_register_prefix (gdbarch); - const char *reg_ind_prefix - = gdbarch_stap_register_indirection_prefix (gdbarch); - int const_prefix_len = const_prefix ? strlen (const_prefix) : 0; - int reg_prefix_len = reg_prefix ? strlen (reg_prefix) : 0; - int reg_ind_prefix_len = reg_ind_prefix ? strlen (reg_ind_prefix) : 0; - - /* Suffixes for the parser. */ - const char *const_suffix = gdbarch_stap_integer_suffix (gdbarch); - int const_suffix_len = const_suffix ? strlen (const_suffix) : 0; + const char *int_prefix = NULL; /* We first try to parse this token as a "special token". */ if (gdbarch_stap_parse_special_token_p (gdbarch)) - { - int ret = gdbarch_stap_parse_special_token (gdbarch, p); + if (gdbarch_stap_parse_special_token (gdbarch, p) != 0) + { + /* If the return value of the above function is not zero, + it means it successfully parsed the special token. - if (ret) - { - /* If the return value of the above function is not zero, - it means it successfully parsed the special token. - - If it is NULL, we try to parse it using our method. */ - return; - } - } + If it is NULL, we try to parse it using our method. */ + return; + } if (*p->arg == '-' || *p->arg == '~' || *p->arg == '+') { char c = *p->arg; - int number; - /* We use this variable to do a lookahead. */ const char *tmp = p->arg; + int has_digit = 0; + /* Skipping signal. */ ++tmp; /* This is an unary operation. Here is a list of allowed tokens @@ -599,27 +771,19 @@ stap_parse_single_operand (struct stap_parse_info *p) if (p->inside_paren_p) tmp = skip_spaces_const (tmp); - if (isdigit (*tmp)) + while (isdigit (*tmp)) { - char *endp; - - number = strtol (tmp, &endp, 10); - tmp = endp; + /* We skip the digit here because we are only interested in + knowing what kind of unary operation this is. The digit + will be handled by one of the functions that will be + called below ('stap_parse_argument_conditionally' or + 'stap_parse_register_operand'). */ + ++tmp; + has_digit = 1; } - if (!reg_ind_prefix - || strncmp (tmp, reg_ind_prefix, reg_ind_prefix_len) != 0) - { - /* This is not a displacement. We skip the operator, and deal - with it later. */ - ++p->arg; - stap_parse_argument_conditionally (p); - if (c == '-') - write_exp_elt_opcode (UNOP_NEG); - else if (c == '~') - write_exp_elt_opcode (UNOP_COMPLEMENT); - } - else + if (has_digit && stap_is_register_indirection_prefix (gdbarch, tmp, + NULL)) { /* If we are here, it means it is a displacement. The only operations allowed here are `-' and `+'. */ @@ -629,6 +793,17 @@ stap_parse_single_operand (struct stap_parse_info *p) stap_parse_register_operand (p); } + else + { + /* This is not a displacement. We skip the operator, and + deal with it when the recursion returns. */ + ++p->arg; + stap_parse_argument_conditionally (p); + if (c == '-') + write_exp_elt_opcode (&p->pstate, UNOP_NEG); + else if (c == '~') + write_exp_elt_opcode (&p->pstate, UNOP_COMPLEMENT); + } } else if (isdigit (*p->arg)) { @@ -637,69 +812,68 @@ stap_parse_single_operand (struct stap_parse_info *p) char *endp; long number; - /* We can be dealing with a numeric constant (if `const_prefix' is - NULL), or with a register displacement. */ + /* We can be dealing with a numeric constant, or with a register + displacement. */ number = strtol (tmp, &endp, 10); tmp = endp; if (p->inside_paren_p) tmp = skip_spaces_const (tmp); - if (!const_prefix && reg_ind_prefix - && strncmp (tmp, reg_ind_prefix, reg_ind_prefix_len) != 0) + + /* If "stap_is_integer_prefix" returns true, it means we can + accept integers without a prefix here. But we also need to + check whether the next token (i.e., "tmp") is not a register + indirection prefix. */ + if (stap_is_integer_prefix (gdbarch, p->arg, NULL) + && !stap_is_register_indirection_prefix (gdbarch, tmp, NULL)) { + const char *int_suffix; + /* We are dealing with a numeric constant. */ - write_exp_elt_opcode (OP_LONG); - write_exp_elt_type (builtin_type (gdbarch)->builtin_long); - write_exp_elt_longcst (number); - write_exp_elt_opcode (OP_LONG); + write_exp_elt_opcode (&p->pstate, OP_LONG); + write_exp_elt_type (&p->pstate, + builtin_type (gdbarch)->builtin_long); + write_exp_elt_longcst (&p->pstate, number); + write_exp_elt_opcode (&p->pstate, OP_LONG); p->arg = tmp; - if (const_suffix) - { - if (strncmp (p->arg, const_suffix, const_suffix_len) == 0) - p->arg += const_suffix_len; - else - error (_("Invalid constant suffix on expression `%s'."), - p->saved_arg); - } + if (stap_check_integer_suffix (gdbarch, p->arg, &int_suffix)) + p->arg += strlen (int_suffix); + else + error (_("Invalid constant suffix on expression `%s'."), + p->saved_arg); } - else if (reg_ind_prefix - && strncmp (tmp, reg_ind_prefix, reg_ind_prefix_len) == 0) + else if (stap_is_register_indirection_prefix (gdbarch, tmp, NULL)) stap_parse_register_operand (p); else error (_("Unknown numeric token on expression `%s'."), p->saved_arg); } - else if (const_prefix - && strncmp (p->arg, const_prefix, const_prefix_len) == 0) + else if (stap_is_integer_prefix (gdbarch, p->arg, &int_prefix)) { /* We are dealing with a numeric constant. */ long number; char *endp; + const char *int_suffix; - p->arg += const_prefix_len; + p->arg += strlen (int_prefix); number = strtol (p->arg, &endp, 10); p->arg = endp; - write_exp_elt_opcode (OP_LONG); - write_exp_elt_type (builtin_type (gdbarch)->builtin_long); - write_exp_elt_longcst (number); - write_exp_elt_opcode (OP_LONG); + write_exp_elt_opcode (&p->pstate, OP_LONG); + write_exp_elt_type (&p->pstate, builtin_type (gdbarch)->builtin_long); + write_exp_elt_longcst (&p->pstate, number); + write_exp_elt_opcode (&p->pstate, OP_LONG); - if (const_suffix) - { - if (strncmp (p->arg, const_suffix, const_suffix_len) == 0) - p->arg += const_suffix_len; - else - error (_("Invalid constant suffix on expression `%s'."), - p->saved_arg); - } + if (stap_check_integer_suffix (gdbarch, p->arg, &int_suffix)) + p->arg += strlen (int_suffix); + else + error (_("Invalid constant suffix on expression `%s'."), + p->saved_arg); } - else if ((reg_prefix - && strncmp (p->arg, reg_prefix, reg_prefix_len) == 0) - || (reg_ind_prefix - && strncmp (p->arg, reg_ind_prefix, reg_ind_prefix_len) == 0)) + else if (stap_is_register_prefix (gdbarch, p->arg, NULL) + || stap_is_register_indirection_prefix (gdbarch, p->arg, NULL)) stap_parse_register_operand (p); else error (_("Operator `%c' not recognized on expression `%s'."), @@ -715,6 +889,8 @@ stap_parse_single_operand (struct stap_parse_info *p) static void stap_parse_argument_conditionally (struct stap_parse_info *p) { + gdb_assert (gdbarch_stap_is_single_operand_p (p->gdbarch)); + if (*p->arg == '-' || *p->arg == '~' || *p->arg == '+' /* Unary. */ || isdigit (*p->arg) || gdbarch_stap_is_single_operand (p->gdbarch, p->arg)) @@ -756,6 +932,8 @@ stap_parse_argument_1 (struct stap_parse_info *p, int has_lhs, parse them depending on the precedence of the operators we find. */ + gdb_assert (p->arg != NULL); + if (p->inside_paren_p) p->arg = skip_spaces_const (p->arg); @@ -774,7 +952,7 @@ stap_parse_argument_1 (struct stap_parse_info *p, int has_lhs, This loop shall continue until we run out of characters in the input, or until we find a close-parenthesis, which means that we've reached the end of a sub-expression. */ - while (p->arg && *p->arg && *p->arg != ')' && !isspace (*p->arg)) + while (*p->arg != '\0' && *p->arg != ')' && !isspace (*p->arg)) { const char *tmp_exp_buf; enum exp_opcode opcode; @@ -810,7 +988,7 @@ stap_parse_argument_1 (struct stap_parse_info *p, int has_lhs, /* While we still have operators, try to parse another right-side, but using the current right-side as a left-side. */ - while (*p->arg && stap_is_operator (p->arg)) + while (*p->arg != '\0' && stap_is_operator (p->arg)) { enum exp_opcode lookahead_opcode; enum stap_operand_prec lookahead_prec; @@ -833,7 +1011,7 @@ stap_parse_argument_1 (struct stap_parse_info *p, int has_lhs, stap_parse_argument_1 (p, 1, lookahead_prec); } - write_exp_elt_opcode (opcode); + write_exp_elt_opcode (&p->pstate, opcode); } } @@ -872,10 +1050,10 @@ stap_parse_argument (const char **arg, struct type *atype, struct cleanup *back_to; /* We need to initialize the expression buffer, in order to begin - our parsing efforts. The language here does not matter, since we - are using our own parser. */ - initialize_expout (10, current_language, gdbarch); - back_to = make_cleanup (free_current_contents, &expout); + our parsing efforts. We use language_c here because we may need + to do pointer arithmetics. */ + initialize_expout (&p.pstate, 10, language_def (language_c), gdbarch); + back_to = make_cleanup (free_current_contents, &p.pstate.expout); p.saved_arg = *arg; p.arg = *arg; @@ -890,16 +1068,17 @@ stap_parse_argument (const char **arg, struct type *atype, gdb_assert (p.inside_paren_p == 0); /* Casting the final expression to the appropriate type. */ - write_exp_elt_opcode (UNOP_CAST); - write_exp_elt_type (atype); - write_exp_elt_opcode (UNOP_CAST); + write_exp_elt_opcode (&p.pstate, UNOP_CAST); + write_exp_elt_type (&p.pstate, atype); + write_exp_elt_opcode (&p.pstate, UNOP_CAST); - reallocate_expout (); + reallocate_expout (&p.pstate); p.arg = skip_spaces_const (p.arg); *arg = p.arg; - return expout; + /* We can safely return EXPOUT here. */ + return p.pstate.expout; } /* Function which parses an argument string from PROBE, correctly splitting @@ -923,10 +1102,10 @@ stap_parse_probe_arguments (struct stap_probe *probe, struct gdbarch *gdbarch) probe->args_parsed = 1; probe->args_u.vec = NULL; - if (!cur || !*cur || *cur == ':') + if (cur == NULL || *cur == '\0' || *cur == ':') return; - while (*cur) + while (*cur != '\0') { struct stap_probe_arg arg; enum stap_arg_bitness b; @@ -939,13 +1118,11 @@ stap_parse_probe_arguments (struct stap_probe *probe, struct gdbarch *gdbarch) N@OP - Where `N' can be [+,-][4,8]. This is not mandatory, so + Where `N' can be [+,-][1,2,4,8]. This is not mandatory, so we check it here. If we don't find it, go to the next state. */ - if ((*cur == '-' && cur[1] && cur[2] != '@') - && cur[1] != '@') - arg.bitness = STAP_ARG_BITNESS_UNDEFINED; - else + if ((cur[0] == '-' && isdigit (cur[1]) && cur[2] == '@') + || (isdigit (cur[0]) && cur[1] == '@')) { if (*cur == '-') { @@ -954,28 +1131,49 @@ stap_parse_probe_arguments (struct stap_probe *probe, struct gdbarch *gdbarch) got_minus = 1; } - if (*cur == '4') - b = (got_minus ? STAP_ARG_BITNESS_32BIT_SIGNED - : STAP_ARG_BITNESS_32BIT_UNSIGNED); - else if (*cur == '8') - b = (got_minus ? STAP_ARG_BITNESS_64BIT_SIGNED - : STAP_ARG_BITNESS_64BIT_UNSIGNED); - else + /* Defining the bitness. */ + switch (*cur) { - /* We have an error, because we don't expect anything - except 4 and 8. */ - complaint (&symfile_complaints, - _("unrecognized bitness `%c' for probe `%s'"), - *cur, probe->p.name); - return; + case '1': + b = (got_minus ? STAP_ARG_BITNESS_8BIT_SIGNED + : STAP_ARG_BITNESS_8BIT_UNSIGNED); + break; + + case '2': + b = (got_minus ? STAP_ARG_BITNESS_16BIT_SIGNED + : STAP_ARG_BITNESS_16BIT_UNSIGNED); + break; + + case '4': + b = (got_minus ? STAP_ARG_BITNESS_32BIT_SIGNED + : STAP_ARG_BITNESS_32BIT_UNSIGNED); + break; + + case '8': + b = (got_minus ? STAP_ARG_BITNESS_64BIT_SIGNED + : STAP_ARG_BITNESS_64BIT_UNSIGNED); + break; + + default: + { + /* We have an error, because we don't expect anything + except 1, 2, 4 and 8. */ + warning (_("unrecognized bitness %s%c' for probe `%s'"), + got_minus ? "`-" : "`", *cur, probe->p.name); + return; + } } arg.bitness = b; - arg.atype = stap_get_expected_argument_type (gdbarch, b); /* Discard the number and the `@' sign. */ cur += 2; } + else + arg.bitness = STAP_ARG_BITNESS_UNDEFINED; + + arg.atype = stap_get_expected_argument_type (gdbarch, arg.bitness, + probe); expr = stap_parse_argument (&cur, arg.atype, gdbarch); @@ -997,6 +1195,15 @@ stap_parse_probe_arguments (struct stap_probe *probe, struct gdbarch *gdbarch) } } +/* Implementation of the get_probe_address method. */ + +static CORE_ADDR +stap_get_probe_address (struct probe *probe, struct objfile *objfile) +{ + return probe->address + ANOFFSET (objfile->section_offsets, + SECT_OFF_DATA (objfile)); +} + /* Given PROBE, returns the number of arguments present in that probe's argument string. */ @@ -1072,12 +1279,26 @@ stap_is_operator (const char *op) return ret; } +/* Return argument N of probe PROBE. + + If the probe's arguments have not been parsed yet, parse them. If + there are no arguments, throw an exception (error). Otherwise, + return the requested argument. */ + static struct stap_probe_arg * stap_get_arg (struct stap_probe *probe, unsigned n, struct gdbarch *gdbarch) { if (!probe->args_parsed) stap_parse_probe_arguments (probe, gdbarch); + gdb_assert (probe->args_parsed); + if (probe->args_u.vec == NULL) + internal_error (__FILE__, __LINE__, + _("Probe '%s' apparently does not have arguments, but \n" + "GDB is requesting its argument number %u anyway. " + "This should not happen. Please report this bug."), + probe->p.name, n); + return VEC_index (stap_probe_arg_s, probe->args_u.vec, n); } @@ -1087,7 +1308,7 @@ static int stap_can_evaluate_probe_arguments (struct probe *probe_generic) { struct stap_probe *stap_probe = (struct stap_probe *) probe_generic; - struct gdbarch *gdbarch = get_objfile_arch (stap_probe->p.objfile); + struct gdbarch *gdbarch = stap_probe->p.arch; /* For SystemTap probes, we have to guarantee that the method stap_is_single_operand is defined on gdbarch. If it is not, then it @@ -1136,7 +1357,7 @@ stap_compile_to_ax (struct probe *probe_generic, struct agent_expr *expr, } /* Destroy (free) the data related to PROBE. PROBE memory itself is not feed - as it is allocated from OBJFILE_OBSTACK. */ + as it is allocated on an obstack. */ static void stap_probe_destroy (struct probe *probe_generic) @@ -1159,79 +1380,6 @@ stap_probe_destroy (struct probe *probe_generic) -/* This is called to compute the value of one of the $_probe_arg* - convenience variables. */ - -static struct value * -compute_probe_arg (struct gdbarch *arch, struct internalvar *ivar, - void *data) -{ - struct frame_info *frame = get_selected_frame (_("No frame selected")); - CORE_ADDR pc = get_frame_pc (frame); - int sel = (int) (uintptr_t) data; - struct probe *pc_probe; - const struct sym_probe_fns *pc_probe_fns; - unsigned n_args; - - /* SEL == -1 means "_probe_argc". */ - gdb_assert (sel >= -1); - - pc_probe = find_probe_by_pc (pc); - if (pc_probe == NULL) - error (_("No SystemTap probe at PC %s"), core_addr_to_string (pc)); - - n_args = get_probe_argument_count (pc_probe, frame); - if (sel == -1) - return value_from_longest (builtin_type (arch)->builtin_int, n_args); - - if (sel >= n_args) - error (_("Invalid probe argument %d -- probe has %u arguments available"), - sel, n_args); - - return evaluate_probe_argument (pc_probe, sel, frame); -} - -/* This is called to compile one of the $_probe_arg* convenience - variables into an agent expression. */ - -static void -compile_probe_arg (struct internalvar *ivar, struct agent_expr *expr, - struct axs_value *value, void *data) -{ - CORE_ADDR pc = expr->scope; - int sel = (int) (uintptr_t) data; - struct probe *pc_probe; - const struct sym_probe_fns *pc_probe_fns; - int n_args; - struct frame_info *frame = get_selected_frame (NULL); - - /* SEL == -1 means "_probe_argc". */ - gdb_assert (sel >= -1); - - pc_probe = find_probe_by_pc (pc); - if (pc_probe == NULL) - error (_("No SystemTap probe at PC %s"), core_addr_to_string (pc)); - - n_args = get_probe_argument_count (pc_probe, frame); - - if (sel == -1) - { - value->kind = axs_rvalue; - value->type = builtin_type (expr->gdbarch)->builtin_int; - ax_const_l (expr, n_args); - return; - } - - gdb_assert (sel >= 0); - if (sel >= n_args) - error (_("Invalid probe argument %d -- probe has %d arguments available"), - sel, n_args); - - pc_probe->pops->compile_to_ax (pc_probe, expr, value, sel); -} - - - /* Set or clear a SystemTap semaphore. ADDRESS is the semaphore's address. SET is zero if the semaphore should be cleared, or one if it should be set. This is a helper function for `stap_semaphore_down' @@ -1279,36 +1427,35 @@ stap_modify_semaphore (CORE_ADDR address, int set, struct gdbarch *gdbarch) the probes, but that is too rare to care. */ static void -stap_set_semaphore (struct probe *probe_generic, struct gdbarch *gdbarch) +stap_set_semaphore (struct probe *probe_generic, struct objfile *objfile, + struct gdbarch *gdbarch) { struct stap_probe *probe = (struct stap_probe *) probe_generic; + CORE_ADDR addr; gdb_assert (probe_generic->pops == &stap_probe_ops); - stap_modify_semaphore (probe->sem_addr, 1, gdbarch); + addr = (probe->sem_addr + + ANOFFSET (objfile->section_offsets, SECT_OFF_DATA (objfile))); + stap_modify_semaphore (addr, 1, gdbarch); } /* Clear a SystemTap semaphore. SEM is the semaphore's address. */ static void -stap_clear_semaphore (struct probe *probe_generic, struct gdbarch *gdbarch) +stap_clear_semaphore (struct probe *probe_generic, struct objfile *objfile, + struct gdbarch *gdbarch) { struct stap_probe *probe = (struct stap_probe *) probe_generic; + CORE_ADDR addr; gdb_assert (probe_generic->pops == &stap_probe_ops); - stap_modify_semaphore (probe->sem_addr, 0, gdbarch); + addr = (probe->sem_addr + + ANOFFSET (objfile->section_offsets, SECT_OFF_DATA (objfile))); + stap_modify_semaphore (addr, 0, gdbarch); } -/* Implementation of `$_probe_arg*' set of variables. */ - -static const struct internalvar_funcs probe_funcs = -{ - compute_probe_arg, - compile_probe_arg, - NULL -}; - /* Helper function that parses the information contained in a SystemTap's probe. Basically, the information consists in: @@ -1335,16 +1482,16 @@ handle_stap_probe (struct objfile *objfile, struct sdt_note *el, const char *probe_args = NULL; struct stap_probe *ret; - ret = obstack_alloc (&objfile->objfile_obstack, sizeof (*ret)); + ret = XOBNEW (&objfile->per_bfd->storage_obstack, struct stap_probe); ret->p.pops = &stap_probe_ops; - ret->p.objfile = objfile; + ret->p.arch = gdbarch; /* Provider and the name of the probe. */ ret->p.provider = (char *) &el->data[3 * size]; ret->p.name = memchr (ret->p.provider, '\0', (char *) el->data + el->size - ret->p.provider); /* Making sure there is a name. */ - if (!ret->p.name) + if (ret->p.name == NULL) { complaint (&symfile_complaints, _("corrupt probe name when " "reading `%s'"), @@ -1366,13 +1513,9 @@ handle_stap_probe (struct objfile *objfile, struct sdt_note *el, /* Semaphore address. */ ret->sem_addr = extract_typed_address (&el->data[2 * size], ptr_type); - ret->p.address += (ANOFFSET (objfile->section_offsets, - SECT_OFF_TEXT (objfile)) - + base - base_ref); - if (ret->sem_addr) - ret->sem_addr += (ANOFFSET (objfile->section_offsets, - SECT_OFF_DATA (objfile)) - + base - base_ref); + ret->p.address += base - base_ref; + if (ret->sem_addr != 0) + ret->sem_addr += base - base_ref; /* Arguments. We can only extract the argument format if there is a valid name for this probe. */ @@ -1382,9 +1525,9 @@ handle_stap_probe (struct objfile *objfile, struct sdt_note *el, if (probe_args != NULL) ++probe_args; - if (probe_args == NULL || (memchr (probe_args, '\0', - (char *) el->data + el->size - ret->p.name) - != el->data + el->size - 1)) + if (probe_args == NULL + || (memchr (probe_args, '\0', (char *) el->data + el->size - ret->p.name) + != el->data + el->size - 1)) { complaint (&symfile_complaints, _("corrupt probe argument when " "reading `%s'"), @@ -1395,7 +1538,7 @@ handle_stap_probe (struct objfile *objfile, struct sdt_note *el, } ret->args_parsed = 0; - ret->args_u.text = (void *) probe_args; + ret->args_u.text = probe_args; /* Successfully created probe. */ VEC_safe_push (probe_p, *probesp, (struct probe *) ret); @@ -1407,7 +1550,7 @@ handle_stap_probe (struct objfile *objfile, struct sdt_note *el, static void get_stap_base_address_1 (bfd *abfd, asection *sect, void *obj) { - asection **ret = obj; + asection **ret = (asection **) obj; if ((sect->flags & (SEC_DATA | SEC_ALLOC | SEC_HAS_CONTENTS)) && sect->name && !strcmp (sect->name, STAP_BASE_SECTION_NAME)) @@ -1425,7 +1568,7 @@ get_stap_base_address (bfd *obfd, bfd_vma *base) bfd_map_over_sections (obfd, get_stap_base_address_1, (void *) &ret); - if (!ret) + if (ret == NULL) { complaint (&symfile_complaints, _("could not obtain base address for " "SystemTap section on objfile `%s'."), @@ -1433,7 +1576,7 @@ get_stap_base_address (bfd *obfd, bfd_vma *base) return 0; } - if (base) + if (base != NULL) *base = ret->vma; return 1; @@ -1460,7 +1603,7 @@ stap_get_probes (VEC (probe_p) **probesp, struct objfile *objfile) return; } - if (!elf_tdata (obfd)->sdt_note_head) + if (elf_tdata (obfd)->sdt_note_head == NULL) { /* There isn't any probe here. */ return; @@ -1474,7 +1617,9 @@ stap_get_probes (VEC (probe_p) **probesp, struct objfile *objfile) } /* Parsing each probe's information. */ - for (iter = elf_tdata (obfd)->sdt_note_head; iter; iter = iter->next) + for (iter = elf_tdata (obfd)->sdt_note_head; + iter != NULL; + iter = iter->next) { /* We first have to handle all the information about the probe which is present in the section. */ @@ -1491,16 +1636,13 @@ stap_get_probes (VEC (probe_p) **probesp, struct objfile *objfile) } } -static void -stap_relocate (struct probe *probe_generic, CORE_ADDR delta) -{ - struct stap_probe *probe = (struct stap_probe *) probe_generic; - - gdb_assert (probe_generic->pops == &stap_probe_ops); +/* Implementation of the type_name method. */ - probe->p.address += delta; - if (probe->sem_addr) - probe->sem_addr += delta; +static const char * +stap_type_name (struct probe *probe) +{ + gdb_assert (probe->pops == &stap_probe_ops); + return "stap"; } static int @@ -1532,9 +1674,9 @@ stap_gen_info_probes_table_values (struct probe *probe_generic, gdb_assert (probe_generic->pops == &stap_probe_ops); - gdbarch = get_objfile_arch (probe->p.objfile); + gdbarch = probe->p.arch; - if (probe->sem_addr) + if (probe->sem_addr != 0) val = print_core_address (gdbarch, probe->sem_addr); VEC_safe_push (const_char_ptr, *ret, val); @@ -1542,11 +1684,11 @@ stap_gen_info_probes_table_values (struct probe *probe_generic, /* SystemTap probe_ops. */ -static const struct probe_ops stap_probe_ops = +const struct probe_ops stap_probe_ops = { stap_probe_is_linespec, stap_get_probes, - stap_relocate, + stap_get_probe_address, stap_get_probe_argument_count, stap_can_evaluate_probe_arguments, stap_evaluate_probe_argument, @@ -1554,8 +1696,11 @@ static const struct probe_ops stap_probe_ops = stap_set_semaphore, stap_clear_semaphore, stap_probe_destroy, + stap_type_name, stap_gen_info_probes_table_header, stap_gen_info_probes_table_values, + NULL, /* enable_probe */ + NULL /* disable_probe */ }; /* Implementation of the `info probes stap' command. */ @@ -1583,33 +1728,6 @@ _initialize_stap_probe (void) show_stapexpressiondebug, &setdebuglist, &showdebuglist); - create_internalvar_type_lazy ("_probe_argc", &probe_funcs, - (void *) (uintptr_t) -1); - create_internalvar_type_lazy ("_probe_arg0", &probe_funcs, - (void *) (uintptr_t) 0); - create_internalvar_type_lazy ("_probe_arg1", &probe_funcs, - (void *) (uintptr_t) 1); - create_internalvar_type_lazy ("_probe_arg2", &probe_funcs, - (void *) (uintptr_t) 2); - create_internalvar_type_lazy ("_probe_arg3", &probe_funcs, - (void *) (uintptr_t) 3); - create_internalvar_type_lazy ("_probe_arg4", &probe_funcs, - (void *) (uintptr_t) 4); - create_internalvar_type_lazy ("_probe_arg5", &probe_funcs, - (void *) (uintptr_t) 5); - create_internalvar_type_lazy ("_probe_arg6", &probe_funcs, - (void *) (uintptr_t) 6); - create_internalvar_type_lazy ("_probe_arg7", &probe_funcs, - (void *) (uintptr_t) 7); - create_internalvar_type_lazy ("_probe_arg8", &probe_funcs, - (void *) (uintptr_t) 8); - create_internalvar_type_lazy ("_probe_arg9", &probe_funcs, - (void *) (uintptr_t) 9); - create_internalvar_type_lazy ("_probe_arg10", &probe_funcs, - (void *) (uintptr_t) 10); - create_internalvar_type_lazy ("_probe_arg11", &probe_funcs, - (void *) (uintptr_t) 11); - add_cmd ("stap", class_info, info_probes_stap_command, _("\ Show information about SystemTap static probes.\n\