build as needed

[platform/upstream/binutils.git] / gdb / stap-probe.c

diff --git a/gdb/stap-probe.c b/gdb/stap-probe.c
index dbe9f31..a51bf8b 100644 (file)
--- a/gdb/stap-probe.c
+++ b/gdb/stap-probe.c
@@ -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"
@@ -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,
@@ -329,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;
 
@@ -733,9 +752,9 @@ stap_parse_single_operand (struct stap_parse_info *p)
   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;
@@ -752,26 +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 (!stap_is_register_indirection_prefix (gdbarch, tmp, NULL))
-       {
-         /* 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 (&p->pstate, UNOP_NEG);
-         else if (c == '~')
-           write_exp_elt_opcode (&p->pstate, 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 `+'.  */
@@ -781,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))
     {
@@ -1095,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] != '\0' && 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 == '-')
            {
@@ -1110,28 +1131,48 @@ 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);
 
       expr = stap_parse_argument (&cur, arg.atype, gdbarch);