/* SystemTap probe support for GDB.
- Copyright (C) 2012 Free Software Foundation, Inc.
+ Copyright (C) 2012-2019 Free Software Foundation, Inc.
This file is part of GDB.
#include "defs.h"
#include "stap-probe.h"
#include "probe.h"
-#include "vec.h"
+#include "gdbsupport/vec.h"
#include "ui-out.h"
#include "objfiles.h"
#include "arch-utils.h"
#include "gdbcmd.h"
#include "filenames.h"
#include "value.h"
-#include "exceptions.h"
#include "ax.h"
#include "ax-gdb.h"
#include "complaints.h"
#define STAP_BASE_SECTION_NAME ".stapsdt.base"
-/* Forward declaration. */
-
-static const struct probe_ops stap_probe_ops;
-
/* Should we display debug information for the probe's argument expression
parsing? */
-static int stap_expression_debug = 0;
+static unsigned int stap_expression_debug = 0;
/* The various possibilities of bitness defined for a probe's argument.
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@'.
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,
struct stap_probe_arg
{
+ /* Constructor for stap_probe_arg. */
+ stap_probe_arg (enum stap_arg_bitness bitness_, struct type *atype_,
+ expression_up &&aexpr_)
+ : bitness (bitness_), atype (atype_), aexpr (std::move (aexpr_))
+ {}
+
/* The bitness of this argument. */
enum stap_arg_bitness bitness;
struct type *atype;
/* The argument converted to an internal GDB expression. */
- struct expression *aexpr;
+ expression_up aexpr;
+};
+
+/* Class that implements the static probe methods for "stap" probes. */
+
+class stap_static_probe_ops : public static_probe_ops
+{
+public:
+ /* See probe.h. */
+ bool is_linespec (const char **linespecp) const override;
+
+ /* See probe.h. */
+ void get_probes (std::vector<std::unique_ptr<probe>> *probesp,
+ struct objfile *objfile) const override;
+
+ /* See probe.h. */
+ const char *type_name () const override;
+
+ /* See probe.h. */
+ std::vector<struct info_probe_column> gen_info_probes_table_header
+ () const override;
};
-typedef struct stap_probe_arg stap_probe_arg_s;
-DEF_VEC_O (stap_probe_arg_s);
+/* SystemTap static_probe_ops. */
-struct stap_probe
+const stap_static_probe_ops stap_static_probe_ops {};
+
+class stap_probe : public probe
{
- /* Generic information about the probe. This shall be the first element
- of this struct, in order to maintain binary compatibility with the
- `struct probe' and be able to fully abstract it. */
- struct probe p;
+public:
+ /* Constructor for stap_probe. */
+ stap_probe (std::string &&name_, std::string &&provider_, CORE_ADDR address_,
+ struct gdbarch *arch_, CORE_ADDR sem_addr, const char *args_text)
+ : probe (std::move (name_), std::move (provider_), address_, arch_),
+ m_sem_addr (sem_addr),
+ m_have_parsed_args (false), m_unparsed_args_text (args_text)
+ {}
+
+ /* See probe.h. */
+ CORE_ADDR get_relocated_address (struct objfile *objfile) override;
+
+ /* See probe.h. */
+ unsigned get_argument_count (struct frame_info *frame) override;
+
+ /* See probe.h. */
+ bool can_evaluate_arguments () const override;
+
+ /* See probe.h. */
+ struct value *evaluate_argument (unsigned n,
+ struct frame_info *frame) override;
+
+ /* See probe.h. */
+ void compile_to_ax (struct agent_expr *aexpr,
+ struct axs_value *axs_value,
+ unsigned n) override;
+
+ /* See probe.h. */
+ void set_semaphore (struct objfile *objfile,
+ struct gdbarch *gdbarch) override;
+
+ /* See probe.h. */
+ void clear_semaphore (struct objfile *objfile,
+ struct gdbarch *gdbarch) override;
+
+ /* See probe.h. */
+ const static_probe_ops *get_static_ops () const override;
+
+ /* See probe.h. */
+ std::vector<const char *> gen_info_probes_table_values () const override;
+
+ /* Return argument N of 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. */
+ struct stap_probe_arg *get_arg_by_number (unsigned n,
+ struct gdbarch *gdbarch)
+ {
+ if (!m_have_parsed_args)
+ this->parse_arguments (gdbarch);
+
+ gdb_assert (m_have_parsed_args);
+ if (m_parsed_args.empty ())
+ 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."),
+ this->get_name ().c_str (), n);
+
+ if (n > m_parsed_args.size ())
+ internal_error (__FILE__, __LINE__,
+ _("Probe '%s' has %d arguments, but GDB is requesting\n"
+ "argument %u. This should not happen. Please\n"
+ "report this bug."),
+ this->get_name ().c_str (),
+ (int) m_parsed_args.size (), n);
+
+ return &m_parsed_args[n];
+ }
+ /* Function which parses an argument string from the probe,
+ correctly splitting the arguments and storing their information
+ in properly ways.
+
+ Consider the following argument string (x86 syntax):
+
+ `4@%eax 4@$10'
+
+ We have two arguments, `%eax' and `$10', both with 32-bit
+ unsigned bitness. This function basically handles them, properly
+ filling some structures with this information. */
+ void parse_arguments (struct gdbarch *gdbarch);
+
+private:
/* If the probe has a semaphore associated, then this is the value of
- it. */
- CORE_ADDR sem_addr;
+ it, relative to SECT_OFF_DATA. */
+ CORE_ADDR m_sem_addr;
- unsigned int args_parsed : 1;
- union
- {
- const char *text;
+ /* True if the arguments have been parsed. */
+ bool m_have_parsed_args;
- /* Information about each argument. This is an array of `stap_probe_arg',
- with each entry representing one argument. */
- VEC (stap_probe_arg_s) *vec;
- }
- args_u;
+ /* The text version of the probe's arguments, unparsed. */
+ const char *m_unparsed_args_text;
+
+ /* Information about each argument. This is an array of `stap_probe_arg',
+ with each entry representing one argument. This is only valid if
+ M_ARGS_PARSED is true. */
+ std::vector<struct stap_probe_arg> m_parsed_args;
};
/* When parsing the arguments, we have to establish different precedences
STAP_OPERAND_PREC_MUL
};
-static void stap_parse_argument_1 (struct stap_parse_info *p, int has_lhs,
+static void stap_parse_argument_1 (struct stap_parse_info *p, bool has_lhs,
enum stap_operand_prec prec);
static void stap_parse_argument_conditionally (struct stap_parse_info *p);
-/* Returns 1 if *S is an operator, zero otherwise. */
+/* Returns true if *S is an operator, false otherwise. */
-static int stap_is_operator (char op);
+static bool stap_is_operator (const char *op);
static void
show_stapexpressiondebug (struct ui_file *file, int from_tty,
}
}
-/* Given S, read the operator in it and fills the OP pointer with its code.
- Return 1 on success, zero if the operator was not recognized. */
+/* Given S, read the operator in it. Return the EXP_OPCODE which
+ represents the operator detected, or throw an error if no operator
+ was found. */
-static int
-stap_get_opcode (const char **s, enum exp_opcode *op)
+static enum exp_opcode
+stap_get_opcode (const char **s)
{
const char c = **s;
- int ret = 1;
+ enum exp_opcode op;
*s += 1;
switch (c)
{
case '*':
- *op = BINOP_MUL;
+ op = BINOP_MUL;
break;
case '/':
- *op = BINOP_DIV;
+ op = BINOP_DIV;
break;
case '%':
- *op = BINOP_REM;
+ op = BINOP_REM;
break;
case '<':
- *op = BINOP_LESS;
+ op = BINOP_LESS;
if (**s == '<')
{
*s += 1;
- *op = BINOP_LSH;
+ op = BINOP_LSH;
}
else if (**s == '=')
{
*s += 1;
- *op = BINOP_LEQ;
+ op = BINOP_LEQ;
}
else if (**s == '>')
{
*s += 1;
- *op = BINOP_NOTEQUAL;
+ op = BINOP_NOTEQUAL;
}
break;
case '>':
- *op = BINOP_GTR;
+ op = BINOP_GTR;
if (**s == '>')
{
*s += 1;
- *op = BINOP_RSH;
+ op = BINOP_RSH;
}
else if (**s == '=')
{
*s += 1;
- *op = BINOP_GEQ;
+ op = BINOP_GEQ;
}
break;
case '|':
- *op = BINOP_BITWISE_IOR;
+ op = BINOP_BITWISE_IOR;
if (**s == '|')
{
*s += 1;
- *op = BINOP_LOGICAL_OR;
+ op = BINOP_LOGICAL_OR;
}
break;
case '&':
- *op = BINOP_BITWISE_AND;
+ op = BINOP_BITWISE_AND;
if (**s == '&')
{
*s += 1;
- *op = BINOP_LOGICAL_AND;
+ op = BINOP_LOGICAL_AND;
}
break;
case '^':
- *op = BINOP_BITWISE_XOR;
+ op = BINOP_BITWISE_XOR;
break;
case '!':
- *op = UNOP_LOGICAL_NOT;
+ op = UNOP_LOGICAL_NOT;
break;
case '+':
- *op = BINOP_ADD;
+ op = BINOP_ADD;
break;
case '-':
- *op = BINOP_SUB;
+ op = BINOP_SUB;
break;
case '=':
- if (**s != '=')
- {
- ret = 0;
- break;
- }
- *op = BINOP_EQUAL;
+ gdb_assert (**s == '=');
+ op = BINOP_EQUAL;
break;
default:
- /* We didn't find any operator. */
- *s -= 1;
- return 0;
+ error (_("Invalid opcode in expression `%s' for SystemTap"
+ "probe"), *s);
}
- return ret;
+ return op;
}
/* Given the bitness of the argument, represented by B, return the
- corresponding `struct type *'. */
+ corresponding `struct type *', or throw an error if B is
+ unknown. */
static struct type *
stap_get_expected_argument_type (struct gdbarch *gdbarch,
- enum stap_arg_bitness b)
+ enum stap_arg_bitness b,
+ const char *probe_name)
{
switch (b)
{
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;
return builtin_type (gdbarch)->builtin_uint64;
default:
- internal_error (__FILE__, __LINE__,
- _("Undefined bitness for probe."));
+ error (_("Undefined bitness for probe '%s'."), probe_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 true if any prefix has been found, false otherwise. */
+
+static bool
+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 true;
+ }
+
+ for (p = prefixes; *p != NULL; ++p)
+ if (strncasecmp (s, *p, strlen (*p)) == 0)
+ {
+ if (r != NULL)
+ *r = *p;
+
+ return true;
+ }
+
+ return false;
+}
+
+/* Return true if S points to a register prefix, false otherwise. For
+ a description of the arguments, look at stap_is_generic_prefix. */
+
+static bool
+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 true if S points to a register indirection prefix, false
+ otherwise. For a description of the arguments, look at
+ stap_is_generic_prefix. */
+
+static bool
+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 true if S points to an integer prefix, false 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 bool
+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) > 0;
+ }
+
+ 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 true;
+ }
+ }
+
+ return false;
+}
+
+/* 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 true if a suffix has
+ been found, false 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 bool
+stap_generic_check_suffix (struct gdbarch *gdbarch, const char *s,
+ const char **r, const char *const *suffixes)
+{
+ const char *const *p;
+ bool found = false;
+
+ if (suffixes == NULL)
+ {
+ if (r != NULL)
+ *r = "";
+
+ return true;
+ }
+
+ for (p = suffixes; *p != NULL; ++p)
+ if (strncasecmp (s, *p, strlen (*p)) == 0)
+ {
+ if (r != NULL)
+ *r = *p;
+
+ found = true;
+ break;
+ }
+
+ return found;
+}
+
+/* Return true if S points to an integer suffix, false otherwise. For
+ a description of the arguments, look at
+ stap_generic_check_suffix. */
+
+static bool
+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 true if S points to a register suffix, false otherwise. For
+ a description of the arguments, look at
+ stap_generic_check_suffix. */
+
+static bool
+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 true if S points to a register indirection suffix, false
+ otherwise. For a description of the arguments, look at
+ stap_generic_check_suffix. */
+
+static bool
+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:
{
/* Simple flag to indicate whether we have seen a minus signal before
certain number. */
- int got_minus = 0;
-
+ bool got_minus = false;
/* Flags to indicate whether this register access is being displaced and/or
indirected. */
- int disp_p = 0, indirect_p = 0;
+ bool disp_p = false;
+ bool indirect_p = false;
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 == '+')
pointer. */
++p->arg;
}
-
- if (*p->arg == '-')
+ else if (*p->arg == '-')
{
- got_minus = 1;
+ got_minus = true;
++p->arg;
}
{
/* The value of the displacement. */
long displacement;
+ char *endp;
- disp_p = 1;
- displacement = strtol (p->arg, (char **) &p->arg, 10);
+ disp_p = true;
+ displacement = strtol (p->arg, &endp, 10);
+ 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;
+ indirect_p = true;
+ p->arg += strlen (reg_ind_prefix);
}
if (disp_p && !indirect_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. */
while (isalnum (*p->arg))
++p->arg;
- len = p->arg - start;
-
- regname = alloca (len + gdb_reg_prefix_len + gdb_reg_suffix_len + 1);
- regname[0] = '\0';
+ std::string regname (start, p->arg - start);
/* We only add the GDB's register prefix/suffix if we are dealing with
a numeric register. */
- if (gdb_reg_prefix && isdigit (*start))
+ if (isdigit (*start))
{
- strncpy (regname, gdb_reg_prefix, gdb_reg_prefix_len);
- strncpy (regname + gdb_reg_prefix_len, start, len);
-
- if (gdb_reg_suffix)
- strncpy (regname + gdb_reg_prefix_len + len,
- gdb_reg_suffix, gdb_reg_suffix_len);
+ if (gdb_reg_prefix != NULL)
+ regname = gdb_reg_prefix + regname;
- len += gdb_reg_prefix_len + gdb_reg_suffix_len;
+ if (gdb_reg_suffix != NULL)
+ regname += gdb_reg_suffix;
}
- else
- strncpy (regname, start, len);
- regname[len] = '\0';
+ int regnum = user_reg_map_name_to_regnum (gdbarch, regname.c_str (),
+ regname.size ());
/* Is this a valid register name? */
- if (user_reg_map_name_to_regnum (gdbarch, regname, len) == -1)
+ if (regnum == -1)
error (_("Invalid register name `%s' on expression `%s'."),
- regname, p->saved_arg);
+ regname.c_str (), p->saved_arg);
- write_exp_elt_opcode (OP_REGISTER);
- str.ptr = regname;
- str.length = len;
- write_exp_string (str);
- write_exp_elt_opcode (OP_REGISTER);
+ /* Check if there's any special treatment that the arch-specific
+ code would like to perform on the register name. */
+ if (gdbarch_stap_adjust_register_p (gdbarch))
+ {
+ std::string newregname
+ = gdbarch_stap_adjust_register (gdbarch, p, regname, regnum);
+
+ if (regname != newregname)
+ {
+ /* This is just a check we perform to make sure that the
+ arch-dependent code has provided us with a valid
+ register name. */
+ regnum = user_reg_map_name_to_regnum (gdbarch, newregname.c_str (),
+ newregname.size ());
+
+ if (regnum == -1)
+ internal_error (__FILE__, __LINE__,
+ _("Invalid register name '%s' after replacing it"
+ " (previous name was '%s')"),
+ newregname.c_str (), regname.c_str ());
+
+ regname = newregname;
+ }
+ }
+
+ write_exp_elt_opcode (&p->pstate, OP_REGISTER);
+ str.ptr = regname.c_str ();
+ str.length = regname.size ();
+ 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);
}
}
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))
+ if (gdbarch_stap_parse_special_token_p (gdbarch)
+ && (gdbarch_stap_parse_special_token (gdbarch, p) != 0))
{
- int ret = gdbarch_stap_parse_special_token (gdbarch, p);
+ /* 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;
+ bool has_digit = false;
+ /* Skipping signal. */
++tmp;
/* This is an unary operation. Here is a list of allowed tokens
We handle the register displacement here, and the other cases
recursively. */
if (p->inside_paren_p)
- tmp = skip_spaces_const (tmp);
-
- if (isdigit (*tmp))
- number = strtol (tmp, (char **) &tmp, 10);
+ tmp = skip_spaces (tmp);
- if (!reg_ind_prefix
- || strncmp (tmp, reg_ind_prefix, reg_ind_prefix_len) != 0)
+ while (isdigit (*tmp))
{
- /* 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);
+ /* 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 = true;
}
- 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 `+'. */
- if (c == '~')
+ if (c != '-' && c != '+')
error (_("Invalid operator `%c' for register displacement "
"on expression `%s'."), c, p->saved_arg);
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))
{
/* A temporary variable, needed for lookahead. */
const char *tmp = p->arg;
+ char *endp;
long number;
- /* We can be dealing with a numeric constant (if `const_prefix' is
- NULL), or with a register displacement. */
- number = strtol (tmp, (char **) &tmp, 10);
+ /* 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)
+ tmp = skip_spaces (tmp);
+
+ /* 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;
- number = strtol (p->arg, (char **) &p->arg, 10);
+ 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'."),
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))
have to parse it as it was a separate expression, without
left-side or precedence. */
++p->arg;
- p->arg = skip_spaces_const (p->arg);
+ p->arg = skip_spaces (p->arg);
++p->inside_paren_p;
stap_parse_argument_1 (p, 0, STAP_OPERAND_PREC_NONE);
++p->arg;
if (p->inside_paren_p)
- p->arg = skip_spaces_const (p->arg);
+ p->arg = skip_spaces (p->arg);
}
else
error (_("Cannot parse expression `%s'."), p->saved_arg);
better understand what this function does. */
static void
-stap_parse_argument_1 (struct stap_parse_info *p, int has_lhs,
+stap_parse_argument_1 (struct stap_parse_info *p, bool has_lhs,
enum stap_operand_prec prec)
{
/* This is an operator-precedence parser.
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);
+ p->arg = skip_spaces (p->arg);
if (!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;
enum stap_operand_prec cur_prec;
- if (!stap_is_operator (*p->arg))
+ if (!stap_is_operator (p->arg))
error (_("Invalid operator `%c' on expression `%s'."), *p->arg,
p->saved_arg);
operator. If this operator's precedence is lower than PREC, we
should return and not advance the expression buffer pointer. */
tmp_exp_buf = p->arg;
- stap_get_opcode (&tmp_exp_buf, &opcode);
+ opcode = stap_get_opcode (&tmp_exp_buf);
cur_prec = stap_get_operator_prec (opcode);
if (cur_prec < prec)
p->arg = tmp_exp_buf;
if (p->inside_paren_p)
- p->arg = skip_spaces_const (p->arg);
+ p->arg = skip_spaces (p->arg);
/* Parse the right-side of the expression. */
stap_parse_argument_conditionally (p);
/* 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;
/* Saving the current expression buffer position. The explanation
is the same as above. */
tmp_exp_buf = p->arg;
- stap_get_opcode (&tmp_exp_buf, &lookahead_opcode);
+ lookahead_opcode = stap_get_opcode (&tmp_exp_buf);
lookahead_prec = stap_get_operator_prec (lookahead_opcode);
if (lookahead_prec <= prec)
stap_parse_argument_1 (p, 1, lookahead_prec);
}
- write_exp_elt_opcode (opcode);
+ write_exp_elt_opcode (&p->pstate, opcode);
}
}
- If we find an operator, we skip it.
This function can also call a special function that will try to match
- unknown tokens. It will return 1 if the argument has been parsed
- successfully, or zero otherwise. */
+ unknown tokens. It will return the expression_up generated from
+ parsing the argument. */
-static struct expression *
+static expression_up
stap_parse_argument (const char **arg, struct type *atype,
struct gdbarch *gdbarch)
{
- struct stap_parse_info p;
- 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);
-
- p.saved_arg = *arg;
- p.arg = *arg;
- p.arg_type = atype;
- p.gdbarch = gdbarch;
- p.inside_paren_p = 0;
+ our parsing efforts. We use language_c here because we may need
+ to do pointer arithmetics. */
+ struct stap_parse_info p (*arg, atype, language_def (language_c),
+ gdbarch);
stap_parse_argument_1 (&p, 0, STAP_OPERAND_PREC_NONE);
- discard_cleanups (back_to);
-
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);
-
- reallocate_expout ();
+ write_exp_elt_opcode (&p.pstate, UNOP_CAST);
+ write_exp_elt_type (&p.pstate, atype);
+ write_exp_elt_opcode (&p.pstate, UNOP_CAST);
- p.arg = skip_spaces_const (p.arg);
+ p.arg = skip_spaces (p.arg);
*arg = p.arg;
- return expout;
+ return p.pstate.release ();
}
-/* Function which parses an argument string from PROBE, correctly splitting
- the arguments and storing their information in properly ways.
-
- Consider the following argument string (x86 syntax):
-
- `4@%eax 4@$10'
-
- We have two arguments, `%eax' and `$10', both with 32-bit unsigned bitness.
- This function basically handles them, properly filling some structures with
- this information. */
+/* Implementation of 'parse_arguments' method. */
-static void
-stap_parse_probe_arguments (struct stap_probe *probe, struct objfile *objfile)
+void
+stap_probe::parse_arguments (struct gdbarch *gdbarch)
{
const char *cur;
- struct gdbarch *gdbarch = get_objfile_arch (objfile);
- gdb_assert (!probe->args_parsed);
- cur = probe->args_u.text;
- probe->args_parsed = 1;
- probe->args_u.vec = NULL;
+ gdb_assert (!m_have_parsed_args);
+ cur = m_unparsed_args_text;
+ m_have_parsed_args = true;
- 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;
- int got_minus = 0;
- struct expression *expr;
-
- memset (&arg, 0, sizeof (arg));
+ enum stap_arg_bitness bitness;
+ bool got_minus = false;
/* We expect to find something like:
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 == '-')
{
/* Discard the `-'. */
++cur;
- got_minus = 1;
+ got_minus = true;
}
- 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':
+ bitness = (got_minus ? STAP_ARG_BITNESS_8BIT_SIGNED
+ : STAP_ARG_BITNESS_8BIT_UNSIGNED);
+ break;
- arg.bitness = b;
- arg.atype = stap_get_expected_argument_type (gdbarch, b);
+ case '2':
+ bitness = (got_minus ? STAP_ARG_BITNESS_16BIT_SIGNED
+ : STAP_ARG_BITNESS_16BIT_UNSIGNED);
+ break;
+ case '4':
+ bitness = (got_minus ? STAP_ARG_BITNESS_32BIT_SIGNED
+ : STAP_ARG_BITNESS_32BIT_UNSIGNED);
+ break;
+
+ case '8':
+ bitness = (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,
+ this->get_name ().c_str ());
+ return;
+ }
+ }
/* Discard the number and the `@' sign. */
cur += 2;
}
+ else
+ bitness = STAP_ARG_BITNESS_UNDEFINED;
- expr = stap_parse_argument (&cur, arg.atype, gdbarch);
+ struct type *atype
+ = stap_get_expected_argument_type (gdbarch, bitness,
+ this->get_name ().c_str ());
+
+ expression_up expr = stap_parse_argument (&cur, atype, gdbarch);
if (stap_expression_debug)
- dump_raw_expression (expr, gdb_stdlog,
+ dump_raw_expression (expr.get (), gdb_stdlog,
"before conversion to prefix form");
- prefixify_expression (expr);
+ prefixify_expression (expr.get ());
if (stap_expression_debug)
- dump_prefix_expression (expr, gdb_stdlog);
+ dump_prefix_expression (expr.get (), gdb_stdlog);
- arg.aexpr = expr;
+ m_parsed_args.emplace_back (bitness, atype, std::move (expr));
/* Start it over again. */
- cur = skip_spaces_const (cur);
-
- VEC_safe_push (stap_probe_arg_s, probe->args_u.vec, &arg);
+ cur = skip_spaces (cur);
}
}
+/* Helper function to relocate an address. */
+
+static CORE_ADDR
+relocate_address (CORE_ADDR address, struct objfile *objfile)
+{
+ return address + ANOFFSET (objfile->section_offsets,
+ SECT_OFF_DATA (objfile));
+}
+
+/* Implementation of the get_relocated_address method. */
+
+CORE_ADDR
+stap_probe::get_relocated_address (struct objfile *objfile)
+{
+ return relocate_address (this->get_address (), objfile);
+}
+
/* Given PROBE, returns the number of arguments present in that probe's
argument string. */
-static unsigned
-stap_get_probe_argument_count (struct probe *probe_generic,
- struct objfile *objfile)
+unsigned
+stap_probe::get_argument_count (struct frame_info *frame)
{
- struct stap_probe *probe = (struct stap_probe *) probe_generic;
+ struct gdbarch *gdbarch = get_frame_arch (frame);
- gdb_assert (probe_generic->pops == &stap_probe_ops);
+ if (!m_have_parsed_args)
+ {
+ if (this->can_evaluate_arguments ())
+ this->parse_arguments (gdbarch);
+ else
+ {
+ static bool have_warned_stap_incomplete = false;
- if (!probe->args_parsed)
- stap_parse_probe_arguments (probe, objfile);
+ if (!have_warned_stap_incomplete)
+ {
+ warning (_(
+"The SystemTap SDT probe support is not fully implemented on this target;\n"
+"you will not be able to inspect the arguments of the probes.\n"
+"Please report a bug against GDB requesting a port to this target."));
+ have_warned_stap_incomplete = true;
+ }
- gdb_assert (probe->args_parsed);
- return VEC_length (stap_probe_arg_s, probe->args_u.vec);
+ /* Marking the arguments as "already parsed". */
+ m_have_parsed_args = true;
+ }
+ }
+
+ gdb_assert (m_have_parsed_args);
+ return m_parsed_args.size ();
}
-/* Return 1 if OP is a valid operator inside a probe argument, or zero
- otherwise. */
+/* Return true if OP is a valid operator inside a probe argument, or
+ false otherwise. */
-static int
-stap_is_operator (char op)
+static bool
+stap_is_operator (const char *op)
{
- return (op == '+' || op == '-' || op == '*' || op == '/'
- || op == '>' || op == '<' || op == '!' || op == '^'
- || op == '|' || op == '&' || op == '%' || op == '=');
+ bool ret = true;
+
+ switch (*op)
+ {
+ case '*':
+ case '/':
+ case '%':
+ case '^':
+ case '!':
+ case '+':
+ case '-':
+ case '<':
+ case '>':
+ case '|':
+ case '&':
+ break;
+
+ case '=':
+ if (op[1] != '=')
+ ret = false;
+ break;
+
+ default:
+ /* We didn't find any operator. */
+ ret = false;
+ }
+
+ return ret;
}
-static struct stap_probe_arg *
-stap_get_arg (struct stap_probe *probe, struct objfile *objfile, unsigned n)
+/* Implement the `can_evaluate_arguments' method. */
+
+bool
+stap_probe::can_evaluate_arguments () const
{
- if (!probe->args_parsed)
- stap_parse_probe_arguments (probe, objfile);
+ struct gdbarch *gdbarch = this->get_gdbarch ();
- return VEC_index (stap_probe_arg_s, probe->args_u.vec, n);
+ /* For SystemTap probes, we have to guarantee that the method
+ stap_is_single_operand is defined on gdbarch. If it is not, then it
+ means that argument evaluation is not implemented on this target. */
+ return gdbarch_stap_is_single_operand_p (gdbarch);
}
/* Evaluate the probe's argument N (indexed from 0), returning a value
corresponding to it. Assertion is thrown if N does not exist. */
-static struct value *
-stap_evaluate_probe_argument (struct probe *probe_generic,
- struct objfile *objfile, unsigned n)
+struct value *
+stap_probe::evaluate_argument (unsigned n, struct frame_info *frame)
{
- struct stap_probe *stap_probe = (struct stap_probe *) probe_generic;
struct stap_probe_arg *arg;
int pos = 0;
+ struct gdbarch *gdbarch = get_frame_arch (frame);
- gdb_assert (probe_generic->pops == &stap_probe_ops);
-
- arg = stap_get_arg (stap_probe, objfile, n);
- return evaluate_subexp_standard (arg->atype, arg->aexpr, &pos, EVAL_NORMAL);
+ arg = this->get_arg_by_number (n, gdbarch);
+ return evaluate_subexp_standard (arg->atype, arg->aexpr.get (), &pos,
+ EVAL_NORMAL);
}
/* Compile the probe's argument N (indexed from 0) to agent expression.
Assertion is thrown if N does not exist. */
-static void
-stap_compile_to_ax (struct probe *probe_generic, struct objfile *objfile,
- struct agent_expr *expr, struct axs_value *value,
- unsigned n)
+void
+stap_probe::compile_to_ax (struct agent_expr *expr, struct axs_value *value,
+ unsigned n)
{
- struct stap_probe *stap_probe = (struct stap_probe *) probe_generic;
struct stap_probe_arg *arg;
union exp_element *pc;
- gdb_assert (probe_generic->pops == &stap_probe_ops);
-
- arg = stap_get_arg (stap_probe, objfile, n);
+ arg = this->get_arg_by_number (n, expr->gdbarch);
pc = arg->aexpr->elts;
- gen_expr (arg->aexpr, &pc, expr, value);
+ gen_expr (arg->aexpr.get (), &pc, expr, value);
require_rvalue (expr, value);
value->type = arg->atype;
}
-
-/* Destroy (free) the data related to PROBE. PROBE memory itself is not feed
- as it is allocated from OBJFILE_OBSTACK. */
-
-static void
-stap_probe_destroy (struct probe *probe_generic)
-{
- struct stap_probe *probe = (struct stap_probe *) probe_generic;
-
- gdb_assert (probe_generic->pops == &stap_probe_ops);
-
- if (probe->args_parsed)
- {
- struct stap_probe_arg *arg;
- int ix;
-
- for (ix = 0; VEC_iterate (stap_probe_arg_s, probe->args_u.vec, ix, arg);
- ++ix)
- xfree (arg->aexpr);
- VEC_free (stap_probe_arg_s, probe->args_u.vec);
- }
-}
-
-\f
-
-/* 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 objfile *objfile;
- struct probe *pc_probe;
- unsigned n_args;
-
- /* SEL == -1 means "_probe_argc". */
- gdb_assert (sel >= -1);
-
- pc_probe = find_probe_by_pc (pc, &objfile);
- if (pc_probe == NULL)
- error (_("No SystemTap probe at PC %s"), core_addr_to_string (pc));
-
- n_args
- = objfile->sf->sym_probe_fns->sym_get_probe_argument_count (objfile,
- pc_probe);
- 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 objfile->sf->sym_probe_fns->sym_evaluate_probe_argument (objfile,
- pc_probe,
- sel);
-}
-
-/* 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 objfile *objfile;
- struct probe *pc_probe;
- int n_probes;
-
- /* SEL == -1 means "_probe_argc". */
- gdb_assert (sel >= -1);
-
- pc_probe = find_probe_by_pc (pc, &objfile);
- if (pc_probe == NULL)
- error (_("No SystemTap probe at PC %s"), core_addr_to_string (pc));
-
- n_probes
- = objfile->sf->sym_probe_fns->sym_get_probe_argument_count (objfile,
- pc_probe);
- if (sel == -1)
- {
- value->kind = axs_rvalue;
- value->type = builtin_type (expr->gdbarch)->builtin_int;
- ax_const_l (expr, n_probes);
- return;
- }
-
- gdb_assert (sel >= 0);
- if (sel >= n_probes)
- error (_("Invalid probe argument %d -- probe has %d arguments available"),
- sel, n_probes);
-
- objfile->sf->sym_probe_fns->sym_compile_to_ax (objfile, pc_probe,
- expr, value, sel);
-}
-
\f
/* 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'
- and `stap_semaphore_up'. */
+ address. SET is zero if the semaphore should be cleared, or one if
+ it should be set. This is a helper function for
+ 'stap_probe::set_semaphore' and 'stap_probe::clear_semaphore'. */
static void
stap_modify_semaphore (CORE_ADDR address, int set, struct gdbarch *gdbarch)
warning (_("Could not write the value of a SystemTap semaphore."));
}
-/* Set a SystemTap semaphore. SEM is the semaphore's address. Semaphores
- act as reference counters, so calls to this function must be paired with
- calls to `stap_semaphore_down'.
+/* Implementation of the 'set_semaphore' method.
- This function and `stap_semaphore_down' race with another tool changing
- the probes, but that is too rare to care. */
-
-static void
-stap_set_semaphore (struct probe *probe_generic, struct gdbarch *gdbarch)
-{
- struct stap_probe *probe = (struct stap_probe *) probe_generic;
+ SystemTap semaphores act as reference counters, so calls to this
+ function must be paired with calls to 'clear_semaphore'.
- gdb_assert (probe_generic->pops == &stap_probe_ops);
+ This function and 'clear_semaphore' race with another tool
+ changing the probes, but that is too rare to care. */
- stap_modify_semaphore (probe->sem_addr, 1, gdbarch);
+void
+stap_probe::set_semaphore (struct objfile *objfile, struct gdbarch *gdbarch)
+{
+ stap_modify_semaphore (relocate_address (m_sem_addr, objfile), 1, gdbarch);
}
-/* Clear a SystemTap semaphore. SEM is the semaphore's address. */
+/* Implementation of the 'clear_semaphore' method. */
-static void
-stap_clear_semaphore (struct probe *probe_generic, struct gdbarch *gdbarch)
+void
+stap_probe::clear_semaphore (struct objfile *objfile, struct gdbarch *gdbarch)
{
- struct stap_probe *probe = (struct stap_probe *) probe_generic;
+ stap_modify_semaphore (relocate_address (m_sem_addr, objfile), 0, gdbarch);
+}
- gdb_assert (probe_generic->pops == &stap_probe_ops);
+/* Implementation of the 'get_static_ops' method. */
- stap_modify_semaphore (probe->sem_addr, 0, gdbarch);
+const static_probe_ops *
+stap_probe::get_static_ops () const
+{
+ return &stap_static_probe_ops;
}
-/* Implementation of `$_probe_arg*' set of variables. */
+/* Implementation of the 'gen_info_probes_table_values' method. */
-static const struct internalvar_funcs probe_funcs =
+std::vector<const char *>
+stap_probe::gen_info_probes_table_values () const
{
- compute_probe_arg,
- compile_probe_arg,
- NULL
-};
+ const char *val = NULL;
+
+ if (m_sem_addr != 0)
+ val = print_core_address (this->get_gdbarch (), m_sem_addr);
+
+ return std::vector<const char *> { val };
+}
/* Helper function that parses the information contained in a
SystemTap's probe. Basically, the information consists in:
probe doesn't have an associated semaphore;
- Probe's provider name;
- Probe's name;
- - Probe's argument format
-
- This function returns 1 if the handling was successful, and zero
- otherwise. */
+ - Probe's argument format. */
static void
handle_stap_probe (struct objfile *objfile, struct sdt_note *el,
- VEC (probe_p) **probesp, CORE_ADDR base)
+ std::vector<std::unique_ptr<probe>> *probesp,
+ CORE_ADDR base)
{
bfd *abfd = objfile->obfd;
int size = bfd_get_arch_size (abfd) / 8;
struct gdbarch *gdbarch = get_objfile_arch (objfile);
struct type *ptr_type = builtin_type (gdbarch)->builtin_data_ptr;
- CORE_ADDR base_ref;
- const char *probe_args = NULL;
- struct stap_probe *ret;
-
- ret = obstack_alloc (&objfile->objfile_obstack, sizeof (*ret));
- ret->p.pops = &stap_probe_ops;
/* Provider and the name of the probe. */
- ret->p.provider = &el->data[3 * size];
- ret->p.name = memchr (ret->p.provider, '\0',
- (char *) el->data + el->size - ret->p.provider);
+ const char *provider = (const char *) &el->data[3 * size];
+ const char *name = ((const char *)
+ memchr (provider, '\0',
+ (char *) el->data + el->size - provider));
/* Making sure there is a name. */
- if (!ret->p.name)
+ if (name == NULL)
{
- complaint (&symfile_complaints, _("corrupt probe name when "
- "reading `%s'"), objfile->name);
+ complaint (_("corrupt probe name when reading `%s'"),
+ objfile_name (objfile));
/* There is no way to use a probe without a name or a provider, so
- returning zero here makes sense. */
+ returning here makes sense. */
return;
}
else
- ++ret->p.name;
+ ++name;
/* Retrieving the probe's address. */
- ret->p.address = extract_typed_address (&el->data[0], ptr_type);
+ CORE_ADDR address = extract_typed_address (&el->data[0], ptr_type);
/* Link-time sh_addr of `.stapsdt.base' section. */
- base_ref = extract_typed_address (&el->data[size], ptr_type);
+ CORE_ADDR base_ref = extract_typed_address (&el->data[size], ptr_type);
/* Semaphore address. */
- ret->sem_addr = extract_typed_address (&el->data[2 * size], ptr_type);
+ CORE_ADDR 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);
+ address += base - base_ref;
+ if (sem_addr != 0)
+ sem_addr += base - base_ref;
/* Arguments. We can only extract the argument format if there is a valid
name for this probe. */
- probe_args = memchr (ret->p.name, '\0',
- (char *) el->data + el->size - ret->p.name);
+ const char *probe_args = ((const char*)
+ memchr (name, '\0',
+ (char *) el->data + el->size - name));
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 - name)
+ != el->data + el->size - 1))
{
- complaint (&symfile_complaints, _("corrupt probe argument when "
- "reading `%s'"), objfile->name);
+ complaint (_("corrupt probe argument when reading `%s'"),
+ objfile_name (objfile));
/* If the argument string is NULL, it means some problem happened with
- it. So we return 0. */
+ it. So we return. */
return;
}
- ret->args_parsed = 0;
- ret->args_u.text = (void *) probe_args;
+ stap_probe *ret = new stap_probe (std::string (name), std::string (provider),
+ address, gdbarch, sem_addr, probe_args);
/* Successfully created probe. */
- VEC_safe_push (probe_p, *probesp, (struct probe *) ret);
+ probesp->emplace_back (ret);
}
/* Helper function which tries to find the base address of the SystemTap
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))
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 "
+ complaint (_("could not obtain base address for "
"SystemTap section on objfile `%s'."),
obfd->filename);
return 0;
}
- if (base)
+ if (base != NULL)
*base = ret->vma;
return 1;
}
-/* Helper function for `elf_get_probes', which gathers information about all
- SystemTap probes from OBJFILE. */
+/* Implementation of the 'is_linespec' method. */
-static void
-stap_get_probes (VEC (probe_p) **probesp, struct objfile *objfile)
+bool
+stap_static_probe_ops::is_linespec (const char **linespecp) const
+{
+ static const char *const keywords[] = { "-pstap", "-probe-stap", NULL };
+
+ return probe_is_linespec_by_keyword (linespecp, keywords);
+}
+
+/* Implementation of the 'get_probes' method. */
+
+void
+stap_static_probe_ops::get_probes
+ (std::vector<std::unique_ptr<probe>> *probesp,
+ struct objfile *objfile) const
{
/* If we are here, then this is the first time we are parsing the
SystemTap probe's information. We basically have to count how many
bfd *obfd = objfile->obfd;
bfd_vma base;
struct sdt_note *iter;
- unsigned save_probesp_len = VEC_length (probe_p, *probesp);
+ unsigned save_probesp_len = probesp->size ();
- if (!elf_tdata (obfd)->sdt_note_head)
+ if (objfile->separate_debug_objfile_backlink != NULL)
+ {
+ /* This is a .debug file, not the objfile itself. */
+ return;
+ }
+
+ if (elf_tdata (obfd)->sdt_note_head == NULL)
{
/* There isn't any probe here. */
return;
}
/* 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. */
handle_stap_probe (objfile, iter, probesp, base);
}
- if (save_probesp_len == VEC_length (probe_p, *probesp))
+ if (save_probesp_len == probesp->size ())
{
/* If we are here, it means we have failed to parse every known
probe. */
- complaint (&symfile_complaints, _("could not parse SystemTap probe(s) "
- "from inferior"));
+ complaint (_("could not parse SystemTap probe(s) from inferior"));
return;
}
}
-static void
-stap_relocate (struct probe *probe_generic, CORE_ADDR delta)
-{
- struct stap_probe *probe = (struct stap_probe *) probe_generic;
+/* Implementation of the type_name method. */
- gdb_assert (probe_generic->pops == &stap_probe_ops);
-
- probe->p.address += delta;
- if (probe->sem_addr)
- probe->sem_addr += delta;
-}
-
-static int
-stap_probe_is_linespec (const char **linespecp)
+const char *
+stap_static_probe_ops::type_name () const
{
- static const char *const keywords[] = { "-pstap", "-probe-stap", NULL };
-
- return probe_is_linespec_by_keyword (linespecp, keywords);
+ return "stap";
}
-static void
-stap_gen_info_probes_table_header (VEC (info_probe_column_s) **heads)
+/* Implementation of the 'gen_info_probes_table_header' method. */
+
+std::vector<struct info_probe_column>
+stap_static_probe_ops::gen_info_probes_table_header () const
{
- info_probe_column_s stap_probe_column;
+ struct info_probe_column stap_probe_column;
stap_probe_column.field_name = "semaphore";
stap_probe_column.print_name = _("Semaphore");
- VEC_safe_push (info_probe_column_s, *heads, &stap_probe_column);
+ return std::vector<struct info_probe_column> { stap_probe_column };
}
-static void
-stap_gen_info_probes_table_values (struct probe *probe_generic,
- struct objfile *objfile,
- VEC (const_char_ptr) **ret)
-{
- struct stap_probe *probe = (struct stap_probe *) probe_generic;
- struct gdbarch *gdbarch = get_objfile_arch (objfile);
- const char *val = NULL;
-
- gdb_assert (probe_generic->pops == &stap_probe_ops);
-
- if (probe->sem_addr)
- val = print_core_address (gdbarch, probe->sem_addr);
-
- VEC_safe_push (const_char_ptr, *ret, val);
-}
-
-/* SystemTap probe_ops. */
-
-static const struct probe_ops stap_probe_ops =
-{
- stap_probe_is_linespec,
- stap_get_probes,
- stap_relocate,
- stap_get_probe_argument_count,
- stap_evaluate_probe_argument,
- stap_compile_to_ax,
- stap_set_semaphore,
- stap_clear_semaphore,
- stap_probe_destroy,
- stap_gen_info_probes_table_header,
- stap_gen_info_probes_table_values,
-};
-
/* Implementation of the `info probes stap' command. */
static void
-info_probes_stap_command (char *arg, int from_tty)
+info_probes_stap_command (const char *arg, int from_tty)
{
- info_probes_for_ops (arg, from_tty, &stap_probe_ops);
+ info_probes_for_spops (arg, from_tty, &stap_static_probe_ops);
}
-void _initialize_stap_probe (void);
-
void
_initialize_stap_probe (void)
{
- VEC_safe_push (probe_ops_cp, all_probe_ops, &stap_probe_ops);
-
- add_setshow_zinteger_cmd ("stap-expression", class_maintenance,
- &stap_expression_debug,
- _("Set SystemTap expression debugging."),
- _("Show SystemTap expression debugging."),
- _("When non-zero, the internal representation "
- "of SystemTap expressions will be printed."),
- NULL,
- 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);
+ all_static_probe_ops.push_back (&stap_static_probe_ops);
+
+ add_setshow_zuinteger_cmd ("stap-expression", class_maintenance,
+ &stap_expression_debug,
+ _("Set SystemTap expression debugging."),
+ _("Show SystemTap expression debugging."),
+ _("When non-zero, the internal representation "
+ "of SystemTap expressions will be printed."),
+ NULL,
+ show_stapexpressiondebug,
+ &setdebuglist, &showdebuglist);
add_cmd ("stap", class_info, info_probes_stap_command,
_("\