GDB 7.6.50

gdb/stap-probe.c

 /* SystemTap probe support for GDB.
 
-   Copyright (C) 2012 Free Software Foundation, Inc.
+   Copyright (C) 2012-2013 Free Software Foundation, Inc.
 
    This file is part of GDB.
 
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 3 of the License, or
    (at your option) any later version.
 
    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ skipping 32 matching lines @@
 
 #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_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@'.
    - STAP_ARG_BITNESS_64BIT_SIGNED:  argument string starts with `-8@'.  */
@@ skipping 348 matching lines @@
   if (*p->arg == '-')
     {
       got_minus = 1;
       ++p->arg;
     }
 
   if (isdigit (*p->arg))
     {
       /* The value of the displacement.  */
       long displacement;
+      char *endp;
 
       disp_p = 1;
-      displacement = strtol (p->arg, (char **) &p->arg, 10);
+      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);
       if (got_minus)
         write_exp_elt_opcode (UNOP_NEG);
     }
 
@@ skipping 153 matching lines @@
          - numeric literal;
          - number (from register displacement)
          - subexpression (beginning with `(')
 
          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);
+        {
+          char *endp;
+
+          number = strtol (tmp, &endp, 10);
+          tmp = endp;
+        }
 
       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 we are here, it means it is a displacement.  The only
              operations allowed here are `-' and `+'.  */
           if (c == '~')
             error (_("Invalid operator `%c' for register displacement "
                      "on expression `%s'."), c, p->saved_arg);
 
           stap_parse_register_operand (p);
         }
     }
   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);
+      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)
         {
           /* 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);
@@ skipping 15 matching lines @@
         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)
     {
       /* We are dealing with a numeric constant.  */
       long number;
+      char *endp;
 
       p->arg += const_prefix_len;
-      number = strtol (p->arg, (char **) &p->arg, 10);
+      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);
 
       if (const_suffix)
         {
           if (strncmp (p->arg, const_suffix, const_suffix_len) == 0)
             p->arg += const_suffix_len;
@@ skipping 213 matching lines @@
 
    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.  */
 
 static void
-stap_parse_probe_arguments (struct stap_probe *probe, struct objfile *objfile)
+stap_parse_probe_arguments (struct stap_probe *probe)
 {
   const char *cur;
-  struct gdbarch *gdbarch = get_objfile_arch (objfile);
+  struct gdbarch *gdbarch = get_objfile_arch (probe->p.objfile);
 
   gdb_assert (!probe->args_parsed);
   cur = probe->args_u.text;
   probe->args_parsed = 1;
   probe->args_u.vec = NULL;
 
   if (!cur || !*cur || *cur == ':')
     return;
 
   while (*cur)
@@ skipping 64 matching lines @@
       cur = skip_spaces_const (cur);
 
       VEC_safe_push (stap_probe_arg_s, probe->args_u.vec, &arg);
     }
 }
 
 /* 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)
+stap_get_probe_argument_count (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)
-    stap_parse_probe_arguments (probe, objfile);
+    {
+      if (probe_generic->pops->can_evaluate_probe_arguments (probe_generic))
+        stap_parse_probe_arguments (probe);
+      else
+        {
+          static int have_warned_stap_incomplete = 0;
+
+          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 = 1;
+            }
+
+          /* Marking the arguments as "already parsed".  */
+          probe->args_u.vec = NULL;
+          probe->args_parsed = 1;
+        }
+    }
 
   gdb_assert (probe->args_parsed);
   return VEC_length (stap_probe_arg_s, probe->args_u.vec);
 }
 
 /* Return 1 if OP is a valid operator inside a probe argument, or zero
    otherwise.  */
 
 static int
 stap_is_operator (const char *op)
@@ skipping 22 matching lines @@
 
     default:
       /* We didn't find any operator.  */
       ret = 0;
     }
 
   return ret;
 }
 
 static struct stap_probe_arg *
-stap_get_arg (struct stap_probe *probe, struct objfile *objfile, unsigned n)
+stap_get_arg (struct stap_probe *probe, unsigned n)
 {
   if (!probe->args_parsed)
-    stap_parse_probe_arguments (probe, objfile);
+    stap_parse_probe_arguments (probe);
 
   return VEC_index (stap_probe_arg_s, probe->args_u.vec, n);
 }
 
+/* Implement the `can_evaluate_probe_arguments' method of probe_ops.  */
+
+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);
+
+  /* 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)
+stap_evaluate_probe_argument (struct probe *probe_generic, unsigned n)
 {
   struct stap_probe *stap_probe = (struct stap_probe *) probe_generic;
   struct stap_probe_arg *arg;
   int pos = 0;
 
   gdb_assert (probe_generic->pops == &stap_probe_ops);
 
-  arg = stap_get_arg (stap_probe, objfile, n);
+  arg = stap_get_arg (stap_probe, n);
   return evaluate_subexp_standard (arg->atype, arg->aexpr, &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)
+stap_compile_to_ax (struct probe *probe_generic, 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 = stap_get_arg (stap_probe, n);
 
   pc = arg->aexpr->elts;
   gen_expr (arg->aexpr, &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.  */
@@ skipping 19 matching lines @@
 
 
 
 
 /* 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)