Add casts to memory allocation related calls
[external/binutils.git] / gdb / stap-probe.c
1 /* SystemTap probe support for GDB.
2
3    Copyright (C) 2012-2015 Free Software Foundation, Inc.
4
5    This file is part of GDB.
6
7    This program is free software; you can redistribute it and/or modify
8    it under the terms of the GNU General Public License as published by
9    the Free Software Foundation; either version 3 of the License, or
10    (at your option) any later version.
11
12    This program is distributed in the hope that it will be useful,
13    but WITHOUT ANY WARRANTY; without even the implied warranty of
14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15    GNU General Public License for more details.
16
17    You should have received a copy of the GNU General Public License
18    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
19
20 #include "defs.h"
21 #include "stap-probe.h"
22 #include "probe.h"
23 #include "vec.h"
24 #include "ui-out.h"
25 #include "objfiles.h"
26 #include "arch-utils.h"
27 #include "command.h"
28 #include "gdbcmd.h"
29 #include "filenames.h"
30 #include "value.h"
31 #include "ax.h"
32 #include "ax-gdb.h"
33 #include "complaints.h"
34 #include "cli/cli-utils.h"
35 #include "linespec.h"
36 #include "user-regs.h"
37 #include "parser-defs.h"
38 #include "language.h"
39 #include "elf-bfd.h"
40
41 #include <ctype.h>
42
43 /* The name of the SystemTap section where we will find information about
44    the probes.  */
45
46 #define STAP_BASE_SECTION_NAME ".stapsdt.base"
47
48 /* Forward declaration. */
49
50 extern const struct probe_ops stap_probe_ops;
51
52 /* Should we display debug information for the probe's argument expression
53    parsing?  */
54
55 static unsigned int stap_expression_debug = 0;
56
57 /* The various possibilities of bitness defined for a probe's argument.
58
59    The relationship is:
60
61    - STAP_ARG_BITNESS_UNDEFINED:  The user hasn't specified the bitness.
62    - STAP_ARG_BITNESS_8BIT_UNSIGNED:  argument string starts with `1@'.
63    - STAP_ARG_BITNESS_8BIT_SIGNED:  argument string starts with `-1@'.
64    - STAP_ARG_BITNESS_16BIT_UNSIGNED:  argument string starts with `2@'.
65    - STAP_ARG_BITNESS_16BIT_SIGNED:  argument string starts with `-2@'.
66    - STAP_ARG_BITNESS_32BIT_UNSIGNED:  argument string starts with `4@'.
67    - STAP_ARG_BITNESS_32BIT_SIGNED:  argument string starts with `-4@'.
68    - STAP_ARG_BITNESS_64BIT_UNSIGNED:  argument string starts with `8@'.
69    - STAP_ARG_BITNESS_64BIT_SIGNED:  argument string starts with `-8@'.  */
70
71 enum stap_arg_bitness
72 {
73   STAP_ARG_BITNESS_UNDEFINED,
74   STAP_ARG_BITNESS_8BIT_UNSIGNED,
75   STAP_ARG_BITNESS_8BIT_SIGNED,
76   STAP_ARG_BITNESS_16BIT_UNSIGNED,
77   STAP_ARG_BITNESS_16BIT_SIGNED,
78   STAP_ARG_BITNESS_32BIT_UNSIGNED,
79   STAP_ARG_BITNESS_32BIT_SIGNED,
80   STAP_ARG_BITNESS_64BIT_UNSIGNED,
81   STAP_ARG_BITNESS_64BIT_SIGNED,
82 };
83
84 /* The following structure represents a single argument for the probe.  */
85
86 struct stap_probe_arg
87 {
88   /* The bitness of this argument.  */
89   enum stap_arg_bitness bitness;
90
91   /* The corresponding `struct type *' to the bitness.  */
92   struct type *atype;
93
94   /* The argument converted to an internal GDB expression.  */
95   struct expression *aexpr;
96 };
97
98 typedef struct stap_probe_arg stap_probe_arg_s;
99 DEF_VEC_O (stap_probe_arg_s);
100
101 struct stap_probe
102 {
103   /* Generic information about the probe.  This shall be the first element
104      of this struct, in order to maintain binary compatibility with the
105      `struct probe' and be able to fully abstract it.  */
106   struct probe p;
107
108   /* If the probe has a semaphore associated, then this is the value of
109      it, relative to SECT_OFF_DATA.  */
110   CORE_ADDR sem_addr;
111
112   /* One if the arguments have been parsed.  */
113   unsigned int args_parsed : 1;
114
115   union
116     {
117       const char *text;
118
119       /* Information about each argument.  This is an array of `stap_probe_arg',
120          with each entry representing one argument.  */
121       VEC (stap_probe_arg_s) *vec;
122     }
123   args_u;
124 };
125
126 /* When parsing the arguments, we have to establish different precedences
127    for the various kinds of asm operators.  This enumeration represents those
128    precedences.
129
130    This logic behind this is available at
131    <http://sourceware.org/binutils/docs/as/Infix-Ops.html#Infix-Ops>, or using
132    the command "info '(as)Infix Ops'".  */
133
134 enum stap_operand_prec
135 {
136   /* Lowest precedence, used for non-recognized operands or for the beginning
137      of the parsing process.  */
138   STAP_OPERAND_PREC_NONE = 0,
139
140   /* Precedence of logical OR.  */
141   STAP_OPERAND_PREC_LOGICAL_OR,
142
143   /* Precedence of logical AND.  */
144   STAP_OPERAND_PREC_LOGICAL_AND,
145
146   /* Precedence of additive (plus, minus) and comparative (equal, less,
147      greater-than, etc) operands.  */
148   STAP_OPERAND_PREC_ADD_CMP,
149
150   /* Precedence of bitwise operands (bitwise OR, XOR, bitwise AND,
151      logical NOT).  */
152   STAP_OPERAND_PREC_BITWISE,
153
154   /* Precedence of multiplicative operands (multiplication, division,
155      remainder, left shift and right shift).  */
156   STAP_OPERAND_PREC_MUL
157 };
158
159 static void stap_parse_argument_1 (struct stap_parse_info *p, int has_lhs,
160                                    enum stap_operand_prec prec);
161
162 static void stap_parse_argument_conditionally (struct stap_parse_info *p);
163
164 /* Returns 1 if *S is an operator, zero otherwise.  */
165
166 static int stap_is_operator (const char *op);
167
168 static void
169 show_stapexpressiondebug (struct ui_file *file, int from_tty,
170                           struct cmd_list_element *c, const char *value)
171 {
172   fprintf_filtered (file, _("SystemTap Probe expression debugging is %s.\n"),
173                     value);
174 }
175
176 /* Returns the operator precedence level of OP, or STAP_OPERAND_PREC_NONE
177    if the operator code was not recognized.  */
178
179 static enum stap_operand_prec
180 stap_get_operator_prec (enum exp_opcode op)
181 {
182   switch (op)
183     {
184     case BINOP_LOGICAL_OR:
185       return STAP_OPERAND_PREC_LOGICAL_OR;
186
187     case BINOP_LOGICAL_AND:
188       return STAP_OPERAND_PREC_LOGICAL_AND;
189
190     case BINOP_ADD:
191     case BINOP_SUB:
192     case BINOP_EQUAL:
193     case BINOP_NOTEQUAL:
194     case BINOP_LESS:
195     case BINOP_LEQ:
196     case BINOP_GTR:
197     case BINOP_GEQ:
198       return STAP_OPERAND_PREC_ADD_CMP;
199
200     case BINOP_BITWISE_IOR:
201     case BINOP_BITWISE_AND:
202     case BINOP_BITWISE_XOR:
203     case UNOP_LOGICAL_NOT:
204       return STAP_OPERAND_PREC_BITWISE;
205
206     case BINOP_MUL:
207     case BINOP_DIV:
208     case BINOP_REM:
209     case BINOP_LSH:
210     case BINOP_RSH:
211       return STAP_OPERAND_PREC_MUL;
212
213     default:
214       return STAP_OPERAND_PREC_NONE;
215     }
216 }
217
218 /* Given S, read the operator in it and fills the OP pointer with its code.
219    Return 1 on success, zero if the operator was not recognized.  */
220
221 static enum exp_opcode
222 stap_get_opcode (const char **s)
223 {
224   const char c = **s;
225   enum exp_opcode op;
226
227   *s += 1;
228
229   switch (c)
230     {
231     case '*':
232       op = BINOP_MUL;
233       break;
234
235     case '/':
236       op = BINOP_DIV;
237       break;
238
239     case '%':
240       op = BINOP_REM;
241     break;
242
243     case '<':
244       op = BINOP_LESS;
245       if (**s == '<')
246         {
247           *s += 1;
248           op = BINOP_LSH;
249         }
250       else if (**s == '=')
251         {
252           *s += 1;
253           op = BINOP_LEQ;
254         }
255       else if (**s == '>')
256         {
257           *s += 1;
258           op = BINOP_NOTEQUAL;
259         }
260     break;
261
262     case '>':
263       op = BINOP_GTR;
264       if (**s == '>')
265         {
266           *s += 1;
267           op = BINOP_RSH;
268         }
269       else if (**s == '=')
270         {
271           *s += 1;
272           op = BINOP_GEQ;
273         }
274     break;
275
276     case '|':
277       op = BINOP_BITWISE_IOR;
278       if (**s == '|')
279         {
280           *s += 1;
281           op = BINOP_LOGICAL_OR;
282         }
283     break;
284
285     case '&':
286       op = BINOP_BITWISE_AND;
287       if (**s == '&')
288         {
289           *s += 1;
290           op = BINOP_LOGICAL_AND;
291         }
292     break;
293
294     case '^':
295       op = BINOP_BITWISE_XOR;
296       break;
297
298     case '!':
299       op = UNOP_LOGICAL_NOT;
300       break;
301
302     case '+':
303       op = BINOP_ADD;
304       break;
305
306     case '-':
307       op = BINOP_SUB;
308       break;
309
310     case '=':
311       gdb_assert (**s == '=');
312       op = BINOP_EQUAL;
313       break;
314
315     default:
316       error (_("Invalid opcode in expression `%s' for SystemTap"
317                "probe"), *s);
318     }
319
320   return op;
321 }
322
323 /* Given the bitness of the argument, represented by B, return the
324    corresponding `struct type *'.  */
325
326 static struct type *
327 stap_get_expected_argument_type (struct gdbarch *gdbarch,
328                                  enum stap_arg_bitness b,
329                                  const struct stap_probe *probe)
330 {
331   switch (b)
332     {
333     case STAP_ARG_BITNESS_UNDEFINED:
334       if (gdbarch_addr_bit (gdbarch) == 32)
335         return builtin_type (gdbarch)->builtin_uint32;
336       else
337         return builtin_type (gdbarch)->builtin_uint64;
338
339     case STAP_ARG_BITNESS_8BIT_UNSIGNED:
340       return builtin_type (gdbarch)->builtin_uint8;
341
342     case STAP_ARG_BITNESS_8BIT_SIGNED:
343       return builtin_type (gdbarch)->builtin_int8;
344
345     case STAP_ARG_BITNESS_16BIT_UNSIGNED:
346       return builtin_type (gdbarch)->builtin_uint16;
347
348     case STAP_ARG_BITNESS_16BIT_SIGNED:
349       return builtin_type (gdbarch)->builtin_int16;
350
351     case STAP_ARG_BITNESS_32BIT_SIGNED:
352       return builtin_type (gdbarch)->builtin_int32;
353
354     case STAP_ARG_BITNESS_32BIT_UNSIGNED:
355       return builtin_type (gdbarch)->builtin_uint32;
356
357     case STAP_ARG_BITNESS_64BIT_SIGNED:
358       return builtin_type (gdbarch)->builtin_int64;
359
360     case STAP_ARG_BITNESS_64BIT_UNSIGNED:
361       return builtin_type (gdbarch)->builtin_uint64;
362
363     default:
364       error (_("Undefined bitness for probe '%s'."),
365              probe->p.name);
366       break;
367     }
368 }
369
370 /* Helper function to check for a generic list of prefixes.  GDBARCH
371    is the current gdbarch being used.  S is the expression being
372    analyzed.  If R is not NULL, it will be used to return the found
373    prefix.  PREFIXES is the list of expected prefixes.
374
375    This function does a case-insensitive match.
376
377    Return 1 if any prefix has been found, zero otherwise.  */
378
379 static int
380 stap_is_generic_prefix (struct gdbarch *gdbarch, const char *s,
381                         const char **r, const char *const *prefixes)
382 {
383   const char *const *p;
384
385   if (prefixes == NULL)
386     {
387       if (r != NULL)
388         *r = "";
389
390       return 1;
391     }
392
393   for (p = prefixes; *p != NULL; ++p)
394     if (strncasecmp (s, *p, strlen (*p)) == 0)
395       {
396         if (r != NULL)
397           *r = *p;
398
399         return 1;
400       }
401
402   return 0;
403 }
404
405 /* Return 1 if S points to a register prefix, zero otherwise.  For a
406    description of the arguments, look at stap_is_generic_prefix.  */
407
408 static int
409 stap_is_register_prefix (struct gdbarch *gdbarch, const char *s,
410                          const char **r)
411 {
412   const char *const *t = gdbarch_stap_register_prefixes (gdbarch);
413
414   return stap_is_generic_prefix (gdbarch, s, r, t);
415 }
416
417 /* Return 1 if S points to a register indirection prefix, zero
418    otherwise.  For a description of the arguments, look at
419    stap_is_generic_prefix.  */
420
421 static int
422 stap_is_register_indirection_prefix (struct gdbarch *gdbarch, const char *s,
423                                      const char **r)
424 {
425   const char *const *t = gdbarch_stap_register_indirection_prefixes (gdbarch);
426
427   return stap_is_generic_prefix (gdbarch, s, r, t);
428 }
429
430 /* Return 1 if S points to an integer prefix, zero otherwise.  For a
431    description of the arguments, look at stap_is_generic_prefix.
432
433    This function takes care of analyzing whether we are dealing with
434    an expected integer prefix, or, if there is no integer prefix to be
435    expected, whether we are dealing with a digit.  It does a
436    case-insensitive match.  */
437
438 static int
439 stap_is_integer_prefix (struct gdbarch *gdbarch, const char *s,
440                         const char **r)
441 {
442   const char *const *t = gdbarch_stap_integer_prefixes (gdbarch);
443   const char *const *p;
444
445   if (t == NULL)
446     {
447       /* A NULL value here means that integers do not have a prefix.
448          We just check for a digit then.  */
449       if (r != NULL)
450         *r = "";
451
452       return isdigit (*s);
453     }
454
455   for (p = t; *p != NULL; ++p)
456     {
457       size_t len = strlen (*p);
458
459       if ((len == 0 && isdigit (*s))
460           || (len > 0 && strncasecmp (s, *p, len) == 0))
461         {
462           /* Integers may or may not have a prefix.  The "len == 0"
463              check covers the case when integers do not have a prefix
464              (therefore, we just check if we have a digit).  The call
465              to "strncasecmp" covers the case when they have a
466              prefix.  */
467           if (r != NULL)
468             *r = *p;
469
470           return 1;
471         }
472     }
473
474   return 0;
475 }
476
477 /* Helper function to check for a generic list of suffixes.  If we are
478    not expecting any suffixes, then it just returns 1.  If we are
479    expecting at least one suffix, then it returns 1 if a suffix has
480    been found, zero otherwise.  GDBARCH is the current gdbarch being
481    used.  S is the expression being analyzed.  If R is not NULL, it
482    will be used to return the found suffix.  SUFFIXES is the list of
483    expected suffixes.  This function does a case-insensitive
484    match.  */
485
486 static int
487 stap_generic_check_suffix (struct gdbarch *gdbarch, const char *s,
488                            const char **r, const char *const *suffixes)
489 {
490   const char *const *p;
491   int found = 0;
492
493   if (suffixes == NULL)
494     {
495       if (r != NULL)
496         *r = "";
497
498       return 1;
499     }
500
501   for (p = suffixes; *p != NULL; ++p)
502     if (strncasecmp (s, *p, strlen (*p)) == 0)
503       {
504         if (r != NULL)
505           *r = *p;
506
507         found = 1;
508         break;
509       }
510
511   return found;
512 }
513
514 /* Return 1 if S points to an integer suffix, zero otherwise.  For a
515    description of the arguments, look at
516    stap_generic_check_suffix.  */
517
518 static int
519 stap_check_integer_suffix (struct gdbarch *gdbarch, const char *s,
520                            const char **r)
521 {
522   const char *const *p = gdbarch_stap_integer_suffixes (gdbarch);
523
524   return stap_generic_check_suffix (gdbarch, s, r, p);
525 }
526
527 /* Return 1 if S points to a register suffix, zero otherwise.  For a
528    description of the arguments, look at
529    stap_generic_check_suffix.  */
530
531 static int
532 stap_check_register_suffix (struct gdbarch *gdbarch, const char *s,
533                             const char **r)
534 {
535   const char *const *p = gdbarch_stap_register_suffixes (gdbarch);
536
537   return stap_generic_check_suffix (gdbarch, s, r, p);
538 }
539
540 /* Return 1 if S points to a register indirection suffix, zero
541    otherwise.  For a description of the arguments, look at
542    stap_generic_check_suffix.  */
543
544 static int
545 stap_check_register_indirection_suffix (struct gdbarch *gdbarch, const char *s,
546                                         const char **r)
547 {
548   const char *const *p = gdbarch_stap_register_indirection_suffixes (gdbarch);
549
550   return stap_generic_check_suffix (gdbarch, s, r, p);
551 }
552
553 /* Function responsible for parsing a register operand according to
554    SystemTap parlance.  Assuming:
555
556    RP  = register prefix
557    RS  = register suffix
558    RIP = register indirection prefix
559    RIS = register indirection suffix
560    
561    Then a register operand can be:
562    
563    [RIP] [RP] REGISTER [RS] [RIS]
564
565    This function takes care of a register's indirection, displacement and
566    direct access.  It also takes into consideration the fact that some
567    registers are named differently inside and outside GDB, e.g., PPC's
568    general-purpose registers are represented by integers in the assembly
569    language (e.g., `15' is the 15th general-purpose register), but inside
570    GDB they have a prefix (the letter `r') appended.  */
571
572 static void
573 stap_parse_register_operand (struct stap_parse_info *p)
574 {
575   /* Simple flag to indicate whether we have seen a minus signal before
576      certain number.  */
577   int got_minus = 0;
578   /* Flags to indicate whether this register access is being displaced and/or
579      indirected.  */
580   int disp_p = 0, indirect_p = 0;
581   struct gdbarch *gdbarch = p->gdbarch;
582   /* Needed to generate the register name as a part of an expression.  */
583   struct stoken str;
584   /* Variables used to extract the register name from the probe's
585      argument.  */
586   const char *start;
587   char *regname;
588   int len;
589   const char *gdb_reg_prefix = gdbarch_stap_gdb_register_prefix (gdbarch);
590   int gdb_reg_prefix_len = gdb_reg_prefix ? strlen (gdb_reg_prefix) : 0;
591   const char *gdb_reg_suffix = gdbarch_stap_gdb_register_suffix (gdbarch);
592   int gdb_reg_suffix_len = gdb_reg_suffix ? strlen (gdb_reg_suffix) : 0;
593   const char *reg_prefix;
594   const char *reg_ind_prefix;
595   const char *reg_suffix;
596   const char *reg_ind_suffix;
597
598   /* Checking for a displacement argument.  */
599   if (*p->arg == '+')
600     {
601       /* If it's a plus sign, we don't need to do anything, just advance the
602          pointer.  */
603       ++p->arg;
604     }
605
606   if (*p->arg == '-')
607     {
608       got_minus = 1;
609       ++p->arg;
610     }
611
612   if (isdigit (*p->arg))
613     {
614       /* The value of the displacement.  */
615       long displacement;
616       char *endp;
617
618       disp_p = 1;
619       displacement = strtol (p->arg, &endp, 10);
620       p->arg = endp;
621
622       /* Generating the expression for the displacement.  */
623       write_exp_elt_opcode (&p->pstate, OP_LONG);
624       write_exp_elt_type (&p->pstate, builtin_type (gdbarch)->builtin_long);
625       write_exp_elt_longcst (&p->pstate, displacement);
626       write_exp_elt_opcode (&p->pstate, OP_LONG);
627       if (got_minus)
628         write_exp_elt_opcode (&p->pstate, UNOP_NEG);
629     }
630
631   /* Getting rid of register indirection prefix.  */
632   if (stap_is_register_indirection_prefix (gdbarch, p->arg, &reg_ind_prefix))
633     {
634       indirect_p = 1;
635       p->arg += strlen (reg_ind_prefix);
636     }
637
638   if (disp_p && !indirect_p)
639     error (_("Invalid register displacement syntax on expression `%s'."),
640            p->saved_arg);
641
642   /* Getting rid of register prefix.  */
643   if (stap_is_register_prefix (gdbarch, p->arg, &reg_prefix))
644     p->arg += strlen (reg_prefix);
645
646   /* Now we should have only the register name.  Let's extract it and get
647      the associated number.  */
648   start = p->arg;
649
650   /* We assume the register name is composed by letters and numbers.  */
651   while (isalnum (*p->arg))
652     ++p->arg;
653
654   len = p->arg - start;
655
656   regname = (char *) alloca (len + gdb_reg_prefix_len + gdb_reg_suffix_len + 1);
657   regname[0] = '\0';
658
659   /* We only add the GDB's register prefix/suffix if we are dealing with
660      a numeric register.  */
661   if (gdb_reg_prefix && isdigit (*start))
662     {
663       strncpy (regname, gdb_reg_prefix, gdb_reg_prefix_len);
664       strncpy (regname + gdb_reg_prefix_len, start, len);
665
666       if (gdb_reg_suffix)
667         strncpy (regname + gdb_reg_prefix_len + len,
668                  gdb_reg_suffix, gdb_reg_suffix_len);
669
670       len += gdb_reg_prefix_len + gdb_reg_suffix_len;
671     }
672   else
673     strncpy (regname, start, len);
674
675   regname[len] = '\0';
676
677   /* Is this a valid register name?  */
678   if (user_reg_map_name_to_regnum (gdbarch, regname, len) == -1)
679     error (_("Invalid register name `%s' on expression `%s'."),
680            regname, p->saved_arg);
681
682   write_exp_elt_opcode (&p->pstate, OP_REGISTER);
683   str.ptr = regname;
684   str.length = len;
685   write_exp_string (&p->pstate, str);
686   write_exp_elt_opcode (&p->pstate, OP_REGISTER);
687
688   if (indirect_p)
689     {
690       if (disp_p)
691         write_exp_elt_opcode (&p->pstate, BINOP_ADD);
692
693       /* Casting to the expected type.  */
694       write_exp_elt_opcode (&p->pstate, UNOP_CAST);
695       write_exp_elt_type (&p->pstate, lookup_pointer_type (p->arg_type));
696       write_exp_elt_opcode (&p->pstate, UNOP_CAST);
697
698       write_exp_elt_opcode (&p->pstate, UNOP_IND);
699     }
700
701   /* Getting rid of the register name suffix.  */
702   if (stap_check_register_suffix (gdbarch, p->arg, &reg_suffix))
703     p->arg += strlen (reg_suffix);
704   else
705     error (_("Missing register name suffix on expression `%s'."),
706            p->saved_arg);
707
708   /* Getting rid of the register indirection suffix.  */
709   if (indirect_p)
710     {
711       if (stap_check_register_indirection_suffix (gdbarch, p->arg,
712                                                   &reg_ind_suffix))
713         p->arg += strlen (reg_ind_suffix);
714       else
715         error (_("Missing indirection suffix on expression `%s'."),
716                p->saved_arg);
717     }
718 }
719
720 /* This function is responsible for parsing a single operand.
721
722    A single operand can be:
723
724       - an unary operation (e.g., `-5', `~2', or even with subexpressions
725         like `-(2 + 1)')
726       - a register displacement, which will be treated as a register
727         operand (e.g., `-4(%eax)' on x86)
728       - a numeric constant, or
729       - a register operand (see function `stap_parse_register_operand')
730
731    The function also calls special-handling functions to deal with
732    unrecognized operands, allowing arch-specific parsers to be
733    created.  */
734
735 static void
736 stap_parse_single_operand (struct stap_parse_info *p)
737 {
738   struct gdbarch *gdbarch = p->gdbarch;
739   const char *int_prefix = NULL;
740
741   /* We first try to parse this token as a "special token".  */
742   if (gdbarch_stap_parse_special_token_p (gdbarch))
743     if (gdbarch_stap_parse_special_token (gdbarch, p) != 0)
744       {
745         /* If the return value of the above function is not zero,
746            it means it successfully parsed the special token.
747
748            If it is NULL, we try to parse it using our method.  */
749         return;
750       }
751
752   if (*p->arg == '-' || *p->arg == '~' || *p->arg == '+')
753     {
754       char c = *p->arg;
755       /* We use this variable to do a lookahead.  */
756       const char *tmp = p->arg;
757       int has_digit = 0;
758
759       /* Skipping signal.  */
760       ++tmp;
761
762       /* This is an unary operation.  Here is a list of allowed tokens
763          here:
764
765          - numeric literal;
766          - number (from register displacement)
767          - subexpression (beginning with `(')
768
769          We handle the register displacement here, and the other cases
770          recursively.  */
771       if (p->inside_paren_p)
772         tmp = skip_spaces_const (tmp);
773
774       while (isdigit (*tmp))
775         {
776           /* We skip the digit here because we are only interested in
777              knowing what kind of unary operation this is.  The digit
778              will be handled by one of the functions that will be
779              called below ('stap_parse_argument_conditionally' or
780              'stap_parse_register_operand').  */
781           ++tmp;
782           has_digit = 1;
783         }
784
785       if (has_digit && stap_is_register_indirection_prefix (gdbarch, tmp,
786                                                             NULL))
787         {
788           /* If we are here, it means it is a displacement.  The only
789              operations allowed here are `-' and `+'.  */
790           if (c == '~')
791             error (_("Invalid operator `%c' for register displacement "
792                      "on expression `%s'."), c, p->saved_arg);
793
794           stap_parse_register_operand (p);
795         }
796       else
797         {
798           /* This is not a displacement.  We skip the operator, and
799              deal with it when the recursion returns.  */
800           ++p->arg;
801           stap_parse_argument_conditionally (p);
802           if (c == '-')
803             write_exp_elt_opcode (&p->pstate, UNOP_NEG);
804           else if (c == '~')
805             write_exp_elt_opcode (&p->pstate, UNOP_COMPLEMENT);
806         }
807     }
808   else if (isdigit (*p->arg))
809     {
810       /* A temporary variable, needed for lookahead.  */
811       const char *tmp = p->arg;
812       char *endp;
813       long number;
814
815       /* We can be dealing with a numeric constant, or with a register
816          displacement.  */
817       number = strtol (tmp, &endp, 10);
818       tmp = endp;
819
820       if (p->inside_paren_p)
821         tmp = skip_spaces_const (tmp);
822
823       /* If "stap_is_integer_prefix" returns true, it means we can
824          accept integers without a prefix here.  But we also need to
825          check whether the next token (i.e., "tmp") is not a register
826          indirection prefix.  */
827       if (stap_is_integer_prefix (gdbarch, p->arg, NULL)
828           && !stap_is_register_indirection_prefix (gdbarch, tmp, NULL))
829         {
830           const char *int_suffix;
831
832           /* We are dealing with a numeric constant.  */
833           write_exp_elt_opcode (&p->pstate, OP_LONG);
834           write_exp_elt_type (&p->pstate,
835                               builtin_type (gdbarch)->builtin_long);
836           write_exp_elt_longcst (&p->pstate, number);
837           write_exp_elt_opcode (&p->pstate, OP_LONG);
838
839           p->arg = tmp;
840
841           if (stap_check_integer_suffix (gdbarch, p->arg, &int_suffix))
842             p->arg += strlen (int_suffix);
843           else
844             error (_("Invalid constant suffix on expression `%s'."),
845                    p->saved_arg);
846         }
847       else if (stap_is_register_indirection_prefix (gdbarch, tmp, NULL))
848         stap_parse_register_operand (p);
849       else
850         error (_("Unknown numeric token on expression `%s'."),
851                p->saved_arg);
852     }
853   else if (stap_is_integer_prefix (gdbarch, p->arg, &int_prefix))
854     {
855       /* We are dealing with a numeric constant.  */
856       long number;
857       char *endp;
858       const char *int_suffix;
859
860       p->arg += strlen (int_prefix);
861       number = strtol (p->arg, &endp, 10);
862       p->arg = endp;
863
864       write_exp_elt_opcode (&p->pstate, OP_LONG);
865       write_exp_elt_type (&p->pstate, builtin_type (gdbarch)->builtin_long);
866       write_exp_elt_longcst (&p->pstate, number);
867       write_exp_elt_opcode (&p->pstate, OP_LONG);
868
869       if (stap_check_integer_suffix (gdbarch, p->arg, &int_suffix))
870         p->arg += strlen (int_suffix);
871       else
872         error (_("Invalid constant suffix on expression `%s'."),
873                p->saved_arg);
874     }
875   else if (stap_is_register_prefix (gdbarch, p->arg, NULL)
876            || stap_is_register_indirection_prefix (gdbarch, p->arg, NULL))
877     stap_parse_register_operand (p);
878   else
879     error (_("Operator `%c' not recognized on expression `%s'."),
880            *p->arg, p->saved_arg);
881 }
882
883 /* This function parses an argument conditionally, based on single or
884    non-single operands.  A non-single operand would be a parenthesized
885    expression (e.g., `(2 + 1)'), and a single operand is anything that
886    starts with `-', `~', `+' (i.e., unary operators), a digit, or
887    something recognized by `gdbarch_stap_is_single_operand'.  */
888
889 static void
890 stap_parse_argument_conditionally (struct stap_parse_info *p)
891 {
892   gdb_assert (gdbarch_stap_is_single_operand_p (p->gdbarch));
893
894   if (*p->arg == '-' || *p->arg == '~' || *p->arg == '+' /* Unary.  */
895       || isdigit (*p->arg)
896       || gdbarch_stap_is_single_operand (p->gdbarch, p->arg))
897     stap_parse_single_operand (p);
898   else if (*p->arg == '(')
899     {
900       /* We are dealing with a parenthesized operand.  It means we
901          have to parse it as it was a separate expression, without
902          left-side or precedence.  */
903       ++p->arg;
904       p->arg = skip_spaces_const (p->arg);
905       ++p->inside_paren_p;
906
907       stap_parse_argument_1 (p, 0, STAP_OPERAND_PREC_NONE);
908
909       --p->inside_paren_p;
910       if (*p->arg != ')')
911         error (_("Missign close-paren on expression `%s'."),
912                p->saved_arg);
913
914       ++p->arg;
915       if (p->inside_paren_p)
916         p->arg = skip_spaces_const (p->arg);
917     }
918   else
919     error (_("Cannot parse expression `%s'."), p->saved_arg);
920 }
921
922 /* Helper function for `stap_parse_argument'.  Please, see its comments to
923    better understand what this function does.  */
924
925 static void
926 stap_parse_argument_1 (struct stap_parse_info *p, int has_lhs,
927                        enum stap_operand_prec prec)
928 {
929   /* This is an operator-precedence parser.
930
931      We work with left- and right-sides of expressions, and
932      parse them depending on the precedence of the operators
933      we find.  */
934
935   gdb_assert (p->arg != NULL);
936
937   if (p->inside_paren_p)
938     p->arg = skip_spaces_const (p->arg);
939
940   if (!has_lhs)
941     {
942       /* We were called without a left-side, either because this is the
943          first call, or because we were called to parse a parenthesized
944          expression.  It doesn't really matter; we have to parse the
945          left-side in order to continue the process.  */
946       stap_parse_argument_conditionally (p);
947     }
948
949   /* Start to parse the right-side, and to "join" left and right sides
950      depending on the operation specified.
951
952      This loop shall continue until we run out of characters in the input,
953      or until we find a close-parenthesis, which means that we've reached
954      the end of a sub-expression.  */
955   while (*p->arg != '\0' && *p->arg != ')' && !isspace (*p->arg))
956     {
957       const char *tmp_exp_buf;
958       enum exp_opcode opcode;
959       enum stap_operand_prec cur_prec;
960
961       if (!stap_is_operator (p->arg))
962         error (_("Invalid operator `%c' on expression `%s'."), *p->arg,
963                p->saved_arg);
964
965       /* We have to save the current value of the expression buffer because
966          the `stap_get_opcode' modifies it in order to get the current
967          operator.  If this operator's precedence is lower than PREC, we
968          should return and not advance the expression buffer pointer.  */
969       tmp_exp_buf = p->arg;
970       opcode = stap_get_opcode (&tmp_exp_buf);
971
972       cur_prec = stap_get_operator_prec (opcode);
973       if (cur_prec < prec)
974         {
975           /* If the precedence of the operator that we are seeing now is
976              lower than the precedence of the first operator seen before
977              this parsing process began, it means we should stop parsing
978              and return.  */
979           break;
980         }
981
982       p->arg = tmp_exp_buf;
983       if (p->inside_paren_p)
984         p->arg = skip_spaces_const (p->arg);
985
986       /* Parse the right-side of the expression.  */
987       stap_parse_argument_conditionally (p);
988
989       /* While we still have operators, try to parse another
990          right-side, but using the current right-side as a left-side.  */
991       while (*p->arg != '\0' && stap_is_operator (p->arg))
992         {
993           enum exp_opcode lookahead_opcode;
994           enum stap_operand_prec lookahead_prec;
995
996           /* Saving the current expression buffer position.  The explanation
997              is the same as above.  */
998           tmp_exp_buf = p->arg;
999           lookahead_opcode = stap_get_opcode (&tmp_exp_buf);
1000           lookahead_prec = stap_get_operator_prec (lookahead_opcode);
1001
1002           if (lookahead_prec <= prec)
1003             {
1004               /* If we are dealing with an operator whose precedence is lower
1005                  than the first one, just abandon the attempt.  */
1006               break;
1007             }
1008
1009           /* Parse the right-side of the expression, but since we already
1010              have a left-side at this point, set `has_lhs' to 1.  */
1011           stap_parse_argument_1 (p, 1, lookahead_prec);
1012         }
1013
1014       write_exp_elt_opcode (&p->pstate, opcode);
1015     }
1016 }
1017
1018 /* Parse a probe's argument.
1019
1020    Assuming that:
1021
1022    LP = literal integer prefix
1023    LS = literal integer suffix
1024
1025    RP = register prefix
1026    RS = register suffix
1027
1028    RIP = register indirection prefix
1029    RIS = register indirection suffix
1030
1031    This routine assumes that arguments' tokens are of the form:
1032
1033    - [LP] NUMBER [LS]
1034    - [RP] REGISTER [RS]
1035    - [RIP] [RP] REGISTER [RS] [RIS]
1036    - If we find a number without LP, we try to parse it as a literal integer
1037    constant (if LP == NULL), or as a register displacement.
1038    - We count parenthesis, and only skip whitespaces if we are inside them.
1039    - If we find an operator, we skip it.
1040
1041    This function can also call a special function that will try to match
1042    unknown tokens.  It will return 1 if the argument has been parsed
1043    successfully, or zero otherwise.  */
1044
1045 static struct expression *
1046 stap_parse_argument (const char **arg, struct type *atype,
1047                      struct gdbarch *gdbarch)
1048 {
1049   struct stap_parse_info p;
1050   struct cleanup *back_to;
1051
1052   /* We need to initialize the expression buffer, in order to begin
1053      our parsing efforts.  We use language_c here because we may need
1054      to do pointer arithmetics.  */
1055   initialize_expout (&p.pstate, 10, language_def (language_c), gdbarch);
1056   back_to = make_cleanup (free_current_contents, &p.pstate.expout);
1057
1058   p.saved_arg = *arg;
1059   p.arg = *arg;
1060   p.arg_type = atype;
1061   p.gdbarch = gdbarch;
1062   p.inside_paren_p = 0;
1063
1064   stap_parse_argument_1 (&p, 0, STAP_OPERAND_PREC_NONE);
1065
1066   discard_cleanups (back_to);
1067
1068   gdb_assert (p.inside_paren_p == 0);
1069
1070   /* Casting the final expression to the appropriate type.  */
1071   write_exp_elt_opcode (&p.pstate, UNOP_CAST);
1072   write_exp_elt_type (&p.pstate, atype);
1073   write_exp_elt_opcode (&p.pstate, UNOP_CAST);
1074
1075   reallocate_expout (&p.pstate);
1076
1077   p.arg = skip_spaces_const (p.arg);
1078   *arg = p.arg;
1079
1080   /* We can safely return EXPOUT here.  */
1081   return p.pstate.expout;
1082 }
1083
1084 /* Function which parses an argument string from PROBE, correctly splitting
1085    the arguments and storing their information in properly ways.
1086
1087    Consider the following argument string (x86 syntax):
1088
1089    `4@%eax 4@$10'
1090
1091    We have two arguments, `%eax' and `$10', both with 32-bit unsigned bitness.
1092    This function basically handles them, properly filling some structures with
1093    this information.  */
1094
1095 static void
1096 stap_parse_probe_arguments (struct stap_probe *probe, struct gdbarch *gdbarch)
1097 {
1098   const char *cur;
1099
1100   gdb_assert (!probe->args_parsed);
1101   cur = probe->args_u.text;
1102   probe->args_parsed = 1;
1103   probe->args_u.vec = NULL;
1104
1105   if (cur == NULL || *cur == '\0' || *cur == ':')
1106     return;
1107
1108   while (*cur != '\0')
1109     {
1110       struct stap_probe_arg arg;
1111       enum stap_arg_bitness b;
1112       int got_minus = 0;
1113       struct expression *expr;
1114
1115       memset (&arg, 0, sizeof (arg));
1116
1117       /* We expect to find something like:
1118
1119          N@OP
1120
1121          Where `N' can be [+,-][1,2,4,8].  This is not mandatory, so
1122          we check it here.  If we don't find it, go to the next
1123          state.  */
1124       if ((cur[0] == '-' && isdigit (cur[1]) && cur[2] == '@')
1125           || (isdigit (cur[0]) && cur[1] == '@'))
1126         {
1127           if (*cur == '-')
1128             {
1129               /* Discard the `-'.  */
1130               ++cur;
1131               got_minus = 1;
1132             }
1133
1134           /* Defining the bitness.  */
1135           switch (*cur)
1136             {
1137             case '1':
1138               b = (got_minus ? STAP_ARG_BITNESS_8BIT_SIGNED
1139                    : STAP_ARG_BITNESS_8BIT_UNSIGNED);
1140               break;
1141
1142             case '2':
1143               b = (got_minus ? STAP_ARG_BITNESS_16BIT_SIGNED
1144                    : STAP_ARG_BITNESS_16BIT_UNSIGNED);
1145               break;
1146
1147             case '4':
1148               b = (got_minus ? STAP_ARG_BITNESS_32BIT_SIGNED
1149                    : STAP_ARG_BITNESS_32BIT_UNSIGNED);
1150               break;
1151
1152             case '8':
1153               b = (got_minus ? STAP_ARG_BITNESS_64BIT_SIGNED
1154                    : STAP_ARG_BITNESS_64BIT_UNSIGNED);
1155               break;
1156
1157             default:
1158               {
1159                 /* We have an error, because we don't expect anything
1160                    except 1, 2, 4 and 8.  */
1161                 warning (_("unrecognized bitness %s%c' for probe `%s'"),
1162                          got_minus ? "`-" : "`", *cur, probe->p.name);
1163                 return;
1164               }
1165             }
1166
1167           arg.bitness = b;
1168
1169           /* Discard the number and the `@' sign.  */
1170           cur += 2;
1171         }
1172       else
1173         arg.bitness = STAP_ARG_BITNESS_UNDEFINED;
1174
1175       arg.atype = stap_get_expected_argument_type (gdbarch, arg.bitness,
1176                                                    probe);
1177
1178       expr = stap_parse_argument (&cur, arg.atype, gdbarch);
1179
1180       if (stap_expression_debug)
1181         dump_raw_expression (expr, gdb_stdlog,
1182                              "before conversion to prefix form");
1183
1184       prefixify_expression (expr);
1185
1186       if (stap_expression_debug)
1187         dump_prefix_expression (expr, gdb_stdlog);
1188
1189       arg.aexpr = expr;
1190
1191       /* Start it over again.  */
1192       cur = skip_spaces_const (cur);
1193
1194       VEC_safe_push (stap_probe_arg_s, probe->args_u.vec, &arg);
1195     }
1196 }
1197
1198 /* Implementation of the get_probe_address method.  */
1199
1200 static CORE_ADDR
1201 stap_get_probe_address (struct probe *probe, struct objfile *objfile)
1202 {
1203   return probe->address + ANOFFSET (objfile->section_offsets,
1204                                     SECT_OFF_DATA (objfile));
1205 }
1206
1207 /* Given PROBE, returns the number of arguments present in that probe's
1208    argument string.  */
1209
1210 static unsigned
1211 stap_get_probe_argument_count (struct probe *probe_generic,
1212                                struct frame_info *frame)
1213 {
1214   struct stap_probe *probe = (struct stap_probe *) probe_generic;
1215   struct gdbarch *gdbarch = get_frame_arch (frame);
1216
1217   gdb_assert (probe_generic->pops == &stap_probe_ops);
1218
1219   if (!probe->args_parsed)
1220     {
1221       if (can_evaluate_probe_arguments (probe_generic))
1222         stap_parse_probe_arguments (probe, gdbarch);
1223       else
1224         {
1225           static int have_warned_stap_incomplete = 0;
1226
1227           if (!have_warned_stap_incomplete)
1228             {
1229               warning (_(
1230 "The SystemTap SDT probe support is not fully implemented on this target;\n"
1231 "you will not be able to inspect the arguments of the probes.\n"
1232 "Please report a bug against GDB requesting a port to this target."));
1233               have_warned_stap_incomplete = 1;
1234             }
1235
1236           /* Marking the arguments as "already parsed".  */
1237           probe->args_u.vec = NULL;
1238           probe->args_parsed = 1;
1239         }
1240     }
1241
1242   gdb_assert (probe->args_parsed);
1243   return VEC_length (stap_probe_arg_s, probe->args_u.vec);
1244 }
1245
1246 /* Return 1 if OP is a valid operator inside a probe argument, or zero
1247    otherwise.  */
1248
1249 static int
1250 stap_is_operator (const char *op)
1251 {
1252   int ret = 1;
1253
1254   switch (*op)
1255     {
1256     case '*':
1257     case '/':
1258     case '%':
1259     case '^':
1260     case '!':
1261     case '+':
1262     case '-':
1263     case '<':
1264     case '>':
1265     case '|':
1266     case '&':
1267       break;
1268
1269     case '=':
1270       if (op[1] != '=')
1271         ret = 0;
1272       break;
1273
1274     default:
1275       /* We didn't find any operator.  */
1276       ret = 0;
1277     }
1278
1279   return ret;
1280 }
1281
1282 /* Return argument N of probe PROBE.
1283
1284    If the probe's arguments have not been parsed yet, parse them.  If
1285    there are no arguments, throw an exception (error).  Otherwise,
1286    return the requested argument.  */
1287
1288 static struct stap_probe_arg *
1289 stap_get_arg (struct stap_probe *probe, unsigned n, struct gdbarch *gdbarch)
1290 {
1291   if (!probe->args_parsed)
1292     stap_parse_probe_arguments (probe, gdbarch);
1293
1294   gdb_assert (probe->args_parsed);
1295   if (probe->args_u.vec == NULL)
1296     internal_error (__FILE__, __LINE__,
1297                     _("Probe '%s' apparently does not have arguments, but \n"
1298                       "GDB is requesting its argument number %u anyway.  "
1299                       "This should not happen.  Please report this bug."),
1300                     probe->p.name, n);
1301
1302   return VEC_index (stap_probe_arg_s, probe->args_u.vec, n);
1303 }
1304
1305 /* Implement the `can_evaluate_probe_arguments' method of probe_ops.  */
1306
1307 static int
1308 stap_can_evaluate_probe_arguments (struct probe *probe_generic)
1309 {
1310   struct stap_probe *stap_probe = (struct stap_probe *) probe_generic;
1311   struct gdbarch *gdbarch = stap_probe->p.arch;
1312
1313   /* For SystemTap probes, we have to guarantee that the method
1314      stap_is_single_operand is defined on gdbarch.  If it is not, then it
1315      means that argument evaluation is not implemented on this target.  */
1316   return gdbarch_stap_is_single_operand_p (gdbarch);
1317 }
1318
1319 /* Evaluate the probe's argument N (indexed from 0), returning a value
1320    corresponding to it.  Assertion is thrown if N does not exist.  */
1321
1322 static struct value *
1323 stap_evaluate_probe_argument (struct probe *probe_generic, unsigned n,
1324                               struct frame_info *frame)
1325 {
1326   struct stap_probe *stap_probe = (struct stap_probe *) probe_generic;
1327   struct gdbarch *gdbarch = get_frame_arch (frame);
1328   struct stap_probe_arg *arg;
1329   int pos = 0;
1330
1331   gdb_assert (probe_generic->pops == &stap_probe_ops);
1332
1333   arg = stap_get_arg (stap_probe, n, gdbarch);
1334   return evaluate_subexp_standard (arg->atype, arg->aexpr, &pos, EVAL_NORMAL);
1335 }
1336
1337 /* Compile the probe's argument N (indexed from 0) to agent expression.
1338    Assertion is thrown if N does not exist.  */
1339
1340 static void
1341 stap_compile_to_ax (struct probe *probe_generic, struct agent_expr *expr,
1342                     struct axs_value *value, unsigned n)
1343 {
1344   struct stap_probe *stap_probe = (struct stap_probe *) probe_generic;
1345   struct stap_probe_arg *arg;
1346   union exp_element *pc;
1347
1348   gdb_assert (probe_generic->pops == &stap_probe_ops);
1349
1350   arg = stap_get_arg (stap_probe, n, expr->gdbarch);
1351
1352   pc = arg->aexpr->elts;
1353   gen_expr (arg->aexpr, &pc, expr, value);
1354
1355   require_rvalue (expr, value);
1356   value->type = arg->atype;
1357 }
1358
1359 /* Destroy (free) the data related to PROBE.  PROBE memory itself is not feed
1360    as it is allocated on an obstack.  */
1361
1362 static void
1363 stap_probe_destroy (struct probe *probe_generic)
1364 {
1365   struct stap_probe *probe = (struct stap_probe *) probe_generic;
1366
1367   gdb_assert (probe_generic->pops == &stap_probe_ops);
1368
1369   if (probe->args_parsed)
1370     {
1371       struct stap_probe_arg *arg;
1372       int ix;
1373
1374       for (ix = 0; VEC_iterate (stap_probe_arg_s, probe->args_u.vec, ix, arg);
1375            ++ix)
1376         xfree (arg->aexpr);
1377       VEC_free (stap_probe_arg_s, probe->args_u.vec);
1378     }
1379 }
1380
1381 \f
1382
1383 /* Set or clear a SystemTap semaphore.  ADDRESS is the semaphore's
1384    address.  SET is zero if the semaphore should be cleared, or one
1385    if it should be set.  This is a helper function for `stap_semaphore_down'
1386    and `stap_semaphore_up'.  */
1387
1388 static void
1389 stap_modify_semaphore (CORE_ADDR address, int set, struct gdbarch *gdbarch)
1390 {
1391   gdb_byte bytes[sizeof (LONGEST)];
1392   /* The ABI specifies "unsigned short".  */
1393   struct type *type = builtin_type (gdbarch)->builtin_unsigned_short;
1394   ULONGEST value;
1395
1396   if (address == 0)
1397     return;
1398
1399   /* Swallow errors.  */
1400   if (target_read_memory (address, bytes, TYPE_LENGTH (type)) != 0)
1401     {
1402       warning (_("Could not read the value of a SystemTap semaphore."));
1403       return;
1404     }
1405
1406   value = extract_unsigned_integer (bytes, TYPE_LENGTH (type),
1407                                     gdbarch_byte_order (gdbarch));
1408   /* Note that we explicitly don't worry about overflow or
1409      underflow.  */
1410   if (set)
1411     ++value;
1412   else
1413     --value;
1414
1415   store_unsigned_integer (bytes, TYPE_LENGTH (type),
1416                           gdbarch_byte_order (gdbarch), value);
1417
1418   if (target_write_memory (address, bytes, TYPE_LENGTH (type)) != 0)
1419     warning (_("Could not write the value of a SystemTap semaphore."));
1420 }
1421
1422 /* Set a SystemTap semaphore.  SEM is the semaphore's address.  Semaphores
1423    act as reference counters, so calls to this function must be paired with
1424    calls to `stap_semaphore_down'.
1425
1426    This function and `stap_semaphore_down' race with another tool changing
1427    the probes, but that is too rare to care.  */
1428
1429 static void
1430 stap_set_semaphore (struct probe *probe_generic, struct objfile *objfile,
1431                     struct gdbarch *gdbarch)
1432 {
1433   struct stap_probe *probe = (struct stap_probe *) probe_generic;
1434   CORE_ADDR addr;
1435
1436   gdb_assert (probe_generic->pops == &stap_probe_ops);
1437
1438   addr = (probe->sem_addr
1439           + ANOFFSET (objfile->section_offsets, SECT_OFF_DATA (objfile)));
1440   stap_modify_semaphore (addr, 1, gdbarch);
1441 }
1442
1443 /* Clear a SystemTap semaphore.  SEM is the semaphore's address.  */
1444
1445 static void
1446 stap_clear_semaphore (struct probe *probe_generic, struct objfile *objfile,
1447                       struct gdbarch *gdbarch)
1448 {
1449   struct stap_probe *probe = (struct stap_probe *) probe_generic;
1450   CORE_ADDR addr;
1451
1452   gdb_assert (probe_generic->pops == &stap_probe_ops);
1453
1454   addr = (probe->sem_addr
1455           + ANOFFSET (objfile->section_offsets, SECT_OFF_DATA (objfile)));
1456   stap_modify_semaphore (addr, 0, gdbarch);
1457 }
1458
1459 /* Helper function that parses the information contained in a
1460    SystemTap's probe.  Basically, the information consists in:
1461
1462    - Probe's PC address;
1463    - Link-time section address of `.stapsdt.base' section;
1464    - Link-time address of the semaphore variable, or ZERO if the
1465      probe doesn't have an associated semaphore;
1466    - Probe's provider name;
1467    - Probe's name;
1468    - Probe's argument format
1469    
1470    This function returns 1 if the handling was successful, and zero
1471    otherwise.  */
1472
1473 static void
1474 handle_stap_probe (struct objfile *objfile, struct sdt_note *el,
1475                    VEC (probe_p) **probesp, CORE_ADDR base)
1476 {
1477   bfd *abfd = objfile->obfd;
1478   int size = bfd_get_arch_size (abfd) / 8;
1479   struct gdbarch *gdbarch = get_objfile_arch (objfile);
1480   struct type *ptr_type = builtin_type (gdbarch)->builtin_data_ptr;
1481   CORE_ADDR base_ref;
1482   const char *probe_args = NULL;
1483   struct stap_probe *ret;
1484
1485   ret = XOBNEW (&objfile->per_bfd->storage_obstack, struct stap_probe);
1486   ret->p.pops = &stap_probe_ops;
1487   ret->p.arch = gdbarch;
1488
1489   /* Provider and the name of the probe.  */
1490   ret->p.provider = (char *) &el->data[3 * size];
1491   ret->p.name = memchr (ret->p.provider, '\0',
1492                         (char *) el->data + el->size - ret->p.provider);
1493   /* Making sure there is a name.  */
1494   if (ret->p.name == NULL)
1495     {
1496       complaint (&symfile_complaints, _("corrupt probe name when "
1497                                         "reading `%s'"),
1498                  objfile_name (objfile));
1499
1500       /* There is no way to use a probe without a name or a provider, so
1501          returning zero here makes sense.  */
1502       return;
1503     }
1504   else
1505     ++ret->p.name;
1506
1507   /* Retrieving the probe's address.  */
1508   ret->p.address = extract_typed_address (&el->data[0], ptr_type);
1509
1510   /* Link-time sh_addr of `.stapsdt.base' section.  */
1511   base_ref = extract_typed_address (&el->data[size], ptr_type);
1512
1513   /* Semaphore address.  */
1514   ret->sem_addr = extract_typed_address (&el->data[2 * size], ptr_type);
1515
1516   ret->p.address += base - base_ref;
1517   if (ret->sem_addr != 0)
1518     ret->sem_addr += base - base_ref;
1519
1520   /* Arguments.  We can only extract the argument format if there is a valid
1521      name for this probe.  */
1522   probe_args = memchr (ret->p.name, '\0',
1523                        (char *) el->data + el->size - ret->p.name);
1524
1525   if (probe_args != NULL)
1526     ++probe_args;
1527
1528   if (probe_args == NULL
1529       || (memchr (probe_args, '\0', (char *) el->data + el->size - ret->p.name)
1530           != el->data + el->size - 1))
1531     {
1532       complaint (&symfile_complaints, _("corrupt probe argument when "
1533                                         "reading `%s'"),
1534                  objfile_name (objfile));
1535       /* If the argument string is NULL, it means some problem happened with
1536          it.  So we return 0.  */
1537       return;
1538     }
1539
1540   ret->args_parsed = 0;
1541   ret->args_u.text = probe_args;
1542
1543   /* Successfully created probe.  */
1544   VEC_safe_push (probe_p, *probesp, (struct probe *) ret);
1545 }
1546
1547 /* Helper function which tries to find the base address of the SystemTap
1548    base section named STAP_BASE_SECTION_NAME.  */
1549
1550 static void
1551 get_stap_base_address_1 (bfd *abfd, asection *sect, void *obj)
1552 {
1553   asection **ret = obj;
1554
1555   if ((sect->flags & (SEC_DATA | SEC_ALLOC | SEC_HAS_CONTENTS))
1556       && sect->name && !strcmp (sect->name, STAP_BASE_SECTION_NAME))
1557     *ret = sect;
1558 }
1559
1560 /* Helper function which iterates over every section in the BFD file,
1561    trying to find the base address of the SystemTap base section.
1562    Returns 1 if found (setting BASE to the proper value), zero otherwise.  */
1563
1564 static int
1565 get_stap_base_address (bfd *obfd, bfd_vma *base)
1566 {
1567   asection *ret = NULL;
1568
1569   bfd_map_over_sections (obfd, get_stap_base_address_1, (void *) &ret);
1570
1571   if (ret == NULL)
1572     {
1573       complaint (&symfile_complaints, _("could not obtain base address for "
1574                                         "SystemTap section on objfile `%s'."),
1575                  obfd->filename);
1576       return 0;
1577     }
1578
1579   if (base != NULL)
1580     *base = ret->vma;
1581
1582   return 1;
1583 }
1584
1585 /* Helper function for `elf_get_probes', which gathers information about all
1586    SystemTap probes from OBJFILE.  */
1587
1588 static void
1589 stap_get_probes (VEC (probe_p) **probesp, struct objfile *objfile)
1590 {
1591   /* If we are here, then this is the first time we are parsing the
1592      SystemTap probe's information.  We basically have to count how many
1593      probes the objfile has, and then fill in the necessary information
1594      for each one.  */
1595   bfd *obfd = objfile->obfd;
1596   bfd_vma base;
1597   struct sdt_note *iter;
1598   unsigned save_probesp_len = VEC_length (probe_p, *probesp);
1599
1600   if (objfile->separate_debug_objfile_backlink != NULL)
1601     {
1602       /* This is a .debug file, not the objfile itself.  */
1603       return;
1604     }
1605
1606   if (elf_tdata (obfd)->sdt_note_head == NULL)
1607     {
1608       /* There isn't any probe here.  */
1609       return;
1610     }
1611
1612   if (!get_stap_base_address (obfd, &base))
1613     {
1614       /* There was an error finding the base address for the section.
1615          Just return NULL.  */
1616       return;
1617     }
1618
1619   /* Parsing each probe's information.  */
1620   for (iter = elf_tdata (obfd)->sdt_note_head;
1621        iter != NULL;
1622        iter = iter->next)
1623     {
1624       /* We first have to handle all the information about the
1625          probe which is present in the section.  */
1626       handle_stap_probe (objfile, iter, probesp, base);
1627     }
1628
1629   if (save_probesp_len == VEC_length (probe_p, *probesp))
1630     {
1631       /* If we are here, it means we have failed to parse every known
1632          probe.  */
1633       complaint (&symfile_complaints, _("could not parse SystemTap probe(s) "
1634                                         "from inferior"));
1635       return;
1636     }
1637 }
1638
1639 /* Implementation of the type_name method.  */
1640
1641 static const char *
1642 stap_type_name (struct probe *probe)
1643 {
1644   gdb_assert (probe->pops == &stap_probe_ops);
1645   return "stap";
1646 }
1647
1648 static int
1649 stap_probe_is_linespec (const char **linespecp)
1650 {
1651   static const char *const keywords[] = { "-pstap", "-probe-stap", NULL };
1652
1653   return probe_is_linespec_by_keyword (linespecp, keywords);
1654 }
1655
1656 static void
1657 stap_gen_info_probes_table_header (VEC (info_probe_column_s) **heads)
1658 {
1659   info_probe_column_s stap_probe_column;
1660
1661   stap_probe_column.field_name = "semaphore";
1662   stap_probe_column.print_name = _("Semaphore");
1663
1664   VEC_safe_push (info_probe_column_s, *heads, &stap_probe_column);
1665 }
1666
1667 static void
1668 stap_gen_info_probes_table_values (struct probe *probe_generic,
1669                                    VEC (const_char_ptr) **ret)
1670 {
1671   struct stap_probe *probe = (struct stap_probe *) probe_generic;
1672   struct gdbarch *gdbarch;
1673   const char *val = NULL;
1674
1675   gdb_assert (probe_generic->pops == &stap_probe_ops);
1676
1677   gdbarch = probe->p.arch;
1678
1679   if (probe->sem_addr != 0)
1680     val = print_core_address (gdbarch, probe->sem_addr);
1681
1682   VEC_safe_push (const_char_ptr, *ret, val);
1683 }
1684
1685 /* SystemTap probe_ops.  */
1686
1687 const struct probe_ops stap_probe_ops =
1688 {
1689   stap_probe_is_linespec,
1690   stap_get_probes,
1691   stap_get_probe_address,
1692   stap_get_probe_argument_count,
1693   stap_can_evaluate_probe_arguments,
1694   stap_evaluate_probe_argument,
1695   stap_compile_to_ax,
1696   stap_set_semaphore,
1697   stap_clear_semaphore,
1698   stap_probe_destroy,
1699   stap_type_name,
1700   stap_gen_info_probes_table_header,
1701   stap_gen_info_probes_table_values,
1702   NULL,  /* enable_probe  */
1703   NULL   /* disable_probe  */
1704 };
1705
1706 /* Implementation of the `info probes stap' command.  */
1707
1708 static void
1709 info_probes_stap_command (char *arg, int from_tty)
1710 {
1711   info_probes_for_ops (arg, from_tty, &stap_probe_ops);
1712 }
1713
1714 void _initialize_stap_probe (void);
1715
1716 void
1717 _initialize_stap_probe (void)
1718 {
1719   VEC_safe_push (probe_ops_cp, all_probe_ops, &stap_probe_ops);
1720
1721   add_setshow_zuinteger_cmd ("stap-expression", class_maintenance,
1722                              &stap_expression_debug,
1723                              _("Set SystemTap expression debugging."),
1724                              _("Show SystemTap expression debugging."),
1725                              _("When non-zero, the internal representation "
1726                                "of SystemTap expressions will be printed."),
1727                              NULL,
1728                              show_stapexpressiondebug,
1729                              &setdebuglist, &showdebuglist);
1730
1731   add_cmd ("stap", class_info, info_probes_stap_command,
1732            _("\
1733 Show information about SystemTap static probes.\n\
1734 Usage: info probes stap [PROVIDER [NAME [OBJECT]]]\n\
1735 Each argument is a regular expression, used to select probes.\n\
1736 PROVIDER matches probe provider names.\n\
1737 NAME matches the probe names.\n\
1738 OBJECT matches the executable or shared library name."),
1739            info_probes_cmdlist_get ());
1740
1741 }