Import gdb-7.10.1
[dragonfly.git] / contrib / gdb-7 / gdb / probe.c
1 /* Generic static 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 "probe.h"
22 #include "command.h"
23 #include "cli/cli-cmds.h"
24 #include "cli/cli-utils.h"
25 #include "objfiles.h"
26 #include "symtab.h"
27 #include "progspace.h"
28 #include "filenames.h"
29 #include "linespec.h"
30 #include "gdb_regex.h"
31 #include "frame.h"
32 #include "arch-utils.h"
33 #include "value.h"
34 #include "ax.h"
35 #include "ax-gdb.h"
36 #include <ctype.h>
37
38 typedef struct bound_probe bound_probe_s;
39 DEF_VEC_O (bound_probe_s);
40
41 \f
42
43 /* See definition in probe.h.  */
44
45 struct symtabs_and_lines
46 parse_probes (char **argptr, struct linespec_result *canonical)
47 {
48   char *arg_start, *arg_end, *arg;
49   char *objfile_namestr = NULL, *provider = NULL, *name, *p;
50   struct cleanup *cleanup;
51   struct symtabs_and_lines result;
52   struct objfile *objfile;
53   struct program_space *pspace;
54   const struct probe_ops *probe_ops;
55   const char *cs;
56
57   result.sals = NULL;
58   result.nelts = 0;
59
60   arg_start = *argptr;
61
62   cs = *argptr;
63   probe_ops = probe_linespec_to_ops (&cs);
64   if (probe_ops == NULL)
65     error (_("'%s' is not a probe linespec"), arg_start);
66
67   arg = (char *) cs;
68   arg = skip_spaces (arg);
69   if (!*arg)
70     error (_("argument to `%s' missing"), arg_start);
71
72   arg_end = skip_to_space (arg);
73
74   /* We make a copy here so we can write over parts with impunity.  */
75   arg = savestring (arg, arg_end - arg);
76   cleanup = make_cleanup (xfree, arg);
77
78   /* Extract each word from the argument, separated by ":"s.  */
79   p = strchr (arg, ':');
80   if (p == NULL)
81     {
82       /* This is `-p name'.  */
83       name = arg;
84     }
85   else
86     {
87       char *hold = p + 1;
88
89       *p = '\0';
90       p = strchr (hold, ':');
91       if (p == NULL)
92         {
93           /* This is `-p provider:name'.  */
94           provider = arg;
95           name = hold;
96         }
97       else
98         {
99           /* This is `-p objfile:provider:name'.  */
100           *p = '\0';
101           objfile_namestr = arg;
102           provider = hold;
103           name = p + 1;
104         }
105     }
106
107   if (*name == '\0')
108     error (_("no probe name specified"));
109   if (provider && *provider == '\0')
110     error (_("invalid provider name"));
111   if (objfile_namestr && *objfile_namestr == '\0')
112     error (_("invalid objfile name"));
113
114   ALL_PSPACES (pspace)
115     ALL_PSPACE_OBJFILES (pspace, objfile)
116       {
117         VEC (probe_p) *probes;
118         struct probe *probe;
119         int ix;
120
121         if (!objfile->sf || !objfile->sf->sym_probe_fns)
122           continue;
123
124         if (objfile_namestr
125             && FILENAME_CMP (objfile_name (objfile), objfile_namestr) != 0
126             && FILENAME_CMP (lbasename (objfile_name (objfile)),
127                              objfile_namestr) != 0)
128           continue;
129
130         probes = objfile->sf->sym_probe_fns->sym_get_probes (objfile);
131
132         for (ix = 0; VEC_iterate (probe_p, probes, ix, probe); ix++)
133           {
134             struct symtab_and_line *sal;
135
136             if (probe_ops != &probe_ops_any && probe->pops != probe_ops)
137               continue;
138
139             if (provider && strcmp (probe->provider, provider) != 0)
140               continue;
141
142             if (strcmp (probe->name, name) != 0)
143               continue;
144
145             ++result.nelts;
146             result.sals = xrealloc (result.sals,
147                                     result.nelts
148                                     * sizeof (struct symtab_and_line));
149             sal = &result.sals[result.nelts - 1];
150
151             init_sal (sal);
152
153             sal->pc = get_probe_address (probe, objfile);
154             sal->explicit_pc = 1;
155             sal->section = find_pc_overlay (sal->pc);
156             sal->pspace = pspace;
157             sal->probe = probe;
158             sal->objfile = objfile;
159           }
160       }
161
162   if (result.nelts == 0)
163     {
164       throw_error (NOT_FOUND_ERROR,
165                    _("No probe matching objfile=`%s', provider=`%s', name=`%s'"),
166                    objfile_namestr ? objfile_namestr : _("<any>"),
167                    provider ? provider : _("<any>"),
168                    name);
169     }
170
171   if (canonical)
172     {
173       canonical->special_display = 1;
174       canonical->pre_expanded = 1;
175       canonical->addr_string = savestring (*argptr, arg_end - *argptr);
176     }
177
178   *argptr = arg_end;
179   do_cleanups (cleanup);
180
181   return result;
182 }
183
184 /* See definition in probe.h.  */
185
186 VEC (probe_p) *
187 find_probes_in_objfile (struct objfile *objfile, const char *provider,
188                         const char *name)
189 {
190   VEC (probe_p) *probes, *result = NULL;
191   int ix;
192   struct probe *probe;
193
194   if (!objfile->sf || !objfile->sf->sym_probe_fns)
195     return NULL;
196
197   probes = objfile->sf->sym_probe_fns->sym_get_probes (objfile);
198   for (ix = 0; VEC_iterate (probe_p, probes, ix, probe); ix++)
199     {
200       if (strcmp (probe->provider, provider) != 0)
201         continue;
202
203       if (strcmp (probe->name, name) != 0)
204         continue;
205
206       VEC_safe_push (probe_p, result, probe);
207     }
208
209   return result;
210 }
211
212 /* See definition in probe.h.  */
213
214 struct bound_probe
215 find_probe_by_pc (CORE_ADDR pc)
216 {
217   struct objfile *objfile;
218   struct bound_probe result;
219
220   result.objfile = NULL;
221   result.probe = NULL;
222
223   ALL_OBJFILES (objfile)
224   {
225     VEC (probe_p) *probes;
226     int ix;
227     struct probe *probe;
228
229     if (!objfile->sf || !objfile->sf->sym_probe_fns
230         || objfile->sect_index_text == -1)
231       continue;
232
233     /* If this proves too inefficient, we can replace with a hash.  */
234     probes = objfile->sf->sym_probe_fns->sym_get_probes (objfile);
235     for (ix = 0; VEC_iterate (probe_p, probes, ix, probe); ix++)
236       if (get_probe_address (probe, objfile) == pc)
237         {
238           result.objfile = objfile;
239           result.probe = probe;
240           return result;
241         }
242   }
243
244   return result;
245 }
246
247 \f
248
249 /* Make a vector of probes matching OBJNAME, PROVIDER, and PROBE_NAME.
250    If POPS is not NULL, only probes of this certain probe_ops will match.
251    Each argument is a regexp, or NULL, which matches anything.  */
252
253 static VEC (bound_probe_s) *
254 collect_probes (char *objname, char *provider, char *probe_name,
255                 const struct probe_ops *pops)
256 {
257   struct objfile *objfile;
258   VEC (bound_probe_s) *result = NULL;
259   struct cleanup *cleanup, *cleanup_temps;
260   regex_t obj_pat, prov_pat, probe_pat;
261
262   cleanup = make_cleanup (VEC_cleanup (bound_probe_s), &result);
263
264   cleanup_temps = make_cleanup (null_cleanup, NULL);
265   if (provider != NULL)
266     compile_rx_or_error (&prov_pat, provider, _("Invalid provider regexp"));
267   if (probe_name != NULL)
268     compile_rx_or_error (&probe_pat, probe_name, _("Invalid probe regexp"));
269   if (objname != NULL)
270     compile_rx_or_error (&obj_pat, objname, _("Invalid object file regexp"));
271
272   ALL_OBJFILES (objfile)
273     {
274       VEC (probe_p) *probes;
275       struct probe *probe;
276       int ix;
277
278       if (! objfile->sf || ! objfile->sf->sym_probe_fns)
279         continue;
280
281       if (objname)
282         {
283           if (regexec (&obj_pat, objfile_name (objfile), 0, NULL, 0) != 0)
284             continue;
285         }
286
287       probes = objfile->sf->sym_probe_fns->sym_get_probes (objfile);
288
289       for (ix = 0; VEC_iterate (probe_p, probes, ix, probe); ix++)
290         {
291           struct bound_probe bound;
292
293           if (pops != NULL && probe->pops != pops)
294             continue;
295
296           if (provider
297               && regexec (&prov_pat, probe->provider, 0, NULL, 0) != 0)
298             continue;
299
300           if (probe_name
301               && regexec (&probe_pat, probe->name, 0, NULL, 0) != 0)
302             continue;
303
304           bound.objfile = objfile;
305           bound.probe = probe;
306           VEC_safe_push (bound_probe_s, result, &bound);
307         }
308     }
309
310   do_cleanups (cleanup_temps);
311   discard_cleanups (cleanup);
312   return result;
313 }
314
315 /* A qsort comparison function for bound_probe_s objects.  */
316
317 static int
318 compare_probes (const void *a, const void *b)
319 {
320   const struct bound_probe *pa = (const struct bound_probe *) a;
321   const struct bound_probe *pb = (const struct bound_probe *) b;
322   int v;
323
324   v = strcmp (pa->probe->provider, pb->probe->provider);
325   if (v)
326     return v;
327
328   v = strcmp (pa->probe->name, pb->probe->name);
329   if (v)
330     return v;
331
332   if (pa->probe->address < pb->probe->address)
333     return -1;
334   if (pa->probe->address > pb->probe->address)
335     return 1;
336
337   return strcmp (objfile_name (pa->objfile), objfile_name (pb->objfile));
338 }
339
340 /* Helper function that generate entries in the ui_out table being
341    crafted by `info_probes_for_ops'.  */
342
343 static void
344 gen_ui_out_table_header_info (VEC (bound_probe_s) *probes,
345                               const struct probe_ops *p)
346 {
347   /* `headings' refers to the names of the columns when printing `info
348      probes'.  */
349   VEC (info_probe_column_s) *headings = NULL;
350   struct cleanup *c;
351   info_probe_column_s *column;
352   size_t headings_size;
353   int ix;
354
355   gdb_assert (p != NULL);
356
357   if (p->gen_info_probes_table_header == NULL
358       && p->gen_info_probes_table_values == NULL)
359     return;
360
361   gdb_assert (p->gen_info_probes_table_header != NULL
362               && p->gen_info_probes_table_values != NULL);
363
364   c = make_cleanup (VEC_cleanup (info_probe_column_s), &headings);
365   p->gen_info_probes_table_header (&headings);
366
367   headings_size = VEC_length (info_probe_column_s, headings);
368
369   for (ix = 0;
370        VEC_iterate (info_probe_column_s, headings, ix, column);
371        ++ix)
372     {
373       struct bound_probe *probe;
374       int jx;
375       size_t size_max = strlen (column->print_name);
376
377       for (jx = 0; VEC_iterate (bound_probe_s, probes, jx, probe); ++jx)
378         {
379           /* `probe_fields' refers to the values of each new field that this
380              probe will display.  */
381           VEC (const_char_ptr) *probe_fields = NULL;
382           struct cleanup *c2;
383           const char *val;
384           int kx;
385
386           if (probe->probe->pops != p)
387             continue;
388
389           c2 = make_cleanup (VEC_cleanup (const_char_ptr), &probe_fields);
390           p->gen_info_probes_table_values (probe->probe, &probe_fields);
391
392           gdb_assert (VEC_length (const_char_ptr, probe_fields)
393                       == headings_size);
394
395           for (kx = 0; VEC_iterate (const_char_ptr, probe_fields, kx, val);
396                ++kx)
397             {
398               /* It is valid to have a NULL value here, which means that the
399                  backend does not have something to write and this particular
400                  field should be skipped.  */
401               if (val == NULL)
402                 continue;
403
404               size_max = max (strlen (val), size_max);
405             }
406           do_cleanups (c2);
407         }
408
409       ui_out_table_header (current_uiout, size_max, ui_left,
410                            column->field_name, column->print_name);
411     }
412
413   do_cleanups (c);
414 }
415
416 /* Helper function to print not-applicable strings for all the extra
417    columns defined in a probe_ops.  */
418
419 static void
420 print_ui_out_not_applicables (const struct probe_ops *pops)
421 {
422   struct cleanup *c;
423   VEC (info_probe_column_s) *headings = NULL;
424   info_probe_column_s *column;
425   int ix;
426
427   if (pops->gen_info_probes_table_header == NULL)
428     return;
429
430   c = make_cleanup (VEC_cleanup (info_probe_column_s), &headings);
431   pops->gen_info_probes_table_header (&headings);
432
433   for (ix = 0;
434        VEC_iterate (info_probe_column_s, headings, ix, column);
435        ++ix)
436     ui_out_field_string (current_uiout, column->field_name, _("n/a"));
437
438   do_cleanups (c);
439 }
440
441 /* Helper function to print extra information about a probe and an objfile
442    represented by PROBE.  */
443
444 static void
445 print_ui_out_info (struct probe *probe)
446 {
447   int ix;
448   int j = 0;
449   /* `values' refers to the actual values of each new field in the output
450      of `info probe'.  `headings' refers to the names of each new field.  */
451   VEC (const_char_ptr) *values = NULL;
452   VEC (info_probe_column_s) *headings = NULL;
453   info_probe_column_s *column;
454   struct cleanup *c;
455
456   gdb_assert (probe != NULL);
457   gdb_assert (probe->pops != NULL);
458
459   if (probe->pops->gen_info_probes_table_header == NULL
460       && probe->pops->gen_info_probes_table_values == NULL)
461     return;
462
463   gdb_assert (probe->pops->gen_info_probes_table_header != NULL
464               && probe->pops->gen_info_probes_table_values != NULL);
465
466   c = make_cleanup (VEC_cleanup (info_probe_column_s), &headings);
467   make_cleanup (VEC_cleanup (const_char_ptr), &values);
468
469   probe->pops->gen_info_probes_table_header (&headings);
470   probe->pops->gen_info_probes_table_values (probe, &values);
471
472   gdb_assert (VEC_length (info_probe_column_s, headings)
473               == VEC_length (const_char_ptr, values));
474
475   for (ix = 0;
476        VEC_iterate (info_probe_column_s, headings, ix, column);
477        ++ix)
478     {
479       const char *val = VEC_index (const_char_ptr, values, j++);
480
481       if (val == NULL)
482         ui_out_field_skip (current_uiout, column->field_name);
483       else
484         ui_out_field_string (current_uiout, column->field_name, val);
485     }
486
487   do_cleanups (c);
488 }
489
490 /* Helper function that returns the number of extra fields which POPS will
491    need.  */
492
493 static int
494 get_number_extra_fields (const struct probe_ops *pops)
495 {
496   VEC (info_probe_column_s) *headings = NULL;
497   struct cleanup *c;
498   int n;
499
500   if (pops->gen_info_probes_table_header == NULL)
501     return 0;
502
503   c = make_cleanup (VEC_cleanup (info_probe_column_s), &headings);
504   pops->gen_info_probes_table_header (&headings);
505
506   n = VEC_length (info_probe_column_s, headings);
507
508   do_cleanups (c);
509
510   return n;
511 }
512
513 /* Helper function that returns 1 if there is a probe in PROBES
514    featuring the given POPS.  It returns 0 otherwise.  */
515
516 static int
517 exists_probe_with_pops (VEC (bound_probe_s) *probes,
518                         const struct probe_ops *pops)
519 {
520   struct bound_probe *probe;
521   int ix;
522
523   for (ix = 0; VEC_iterate (bound_probe_s, probes, ix, probe); ++ix)
524     if (probe->probe->pops == pops)
525       return 1;
526
527   return 0;
528 }
529
530 /* Helper function that parses a probe linespec of the form [PROVIDER
531    [PROBE [OBJNAME]]] from the provided string STR.  */
532
533 static void
534 parse_probe_linespec (const char *str, char **provider,
535                       char **probe_name, char **objname)
536 {
537   *probe_name = *objname = NULL;
538
539   *provider = extract_arg_const (&str);
540   if (*provider != NULL)
541     {
542       *probe_name = extract_arg_const (&str);
543       if (*probe_name != NULL)
544         *objname = extract_arg_const (&str);
545     }
546 }
547
548 /* See comment in probe.h.  */
549
550 void
551 info_probes_for_ops (const char *arg, int from_tty,
552                      const struct probe_ops *pops)
553 {
554   char *provider, *probe_name = NULL, *objname = NULL;
555   struct cleanup *cleanup = make_cleanup (null_cleanup, NULL);
556   VEC (bound_probe_s) *probes;
557   int i, any_found;
558   int ui_out_extra_fields = 0;
559   size_t size_addr;
560   size_t size_name = strlen ("Name");
561   size_t size_objname = strlen ("Object");
562   size_t size_provider = strlen ("Provider");
563   size_t size_type = strlen ("Type");
564   struct bound_probe *probe;
565   struct gdbarch *gdbarch = get_current_arch ();
566
567   parse_probe_linespec (arg, &provider, &probe_name, &objname);
568   make_cleanup (xfree, provider);
569   make_cleanup (xfree, probe_name);
570   make_cleanup (xfree, objname);
571
572   probes = collect_probes (objname, provider, probe_name, pops);
573   make_cleanup (VEC_cleanup (probe_p), &probes);
574
575   if (pops == NULL)
576     {
577       const struct probe_ops *po;
578       int ix;
579
580       /* If the probe_ops is NULL, it means the user has requested a "simple"
581          `info probes', i.e., she wants to print all information about all
582          probes.  For that, we have to identify how many extra fields we will
583          need to add in the ui_out table.
584
585          To do that, we iterate over all probe_ops, querying each one about
586          its extra fields, and incrementing `ui_out_extra_fields' to reflect
587          that number.  But note that we ignore the probe_ops for which no probes
588          are defined with the given search criteria.  */
589
590       for (ix = 0; VEC_iterate (probe_ops_cp, all_probe_ops, ix, po); ++ix)
591         if (exists_probe_with_pops (probes, po))
592           ui_out_extra_fields += get_number_extra_fields (po);
593     }
594   else
595     ui_out_extra_fields = get_number_extra_fields (pops);
596
597   make_cleanup_ui_out_table_begin_end (current_uiout,
598                                        5 + ui_out_extra_fields,
599                                        VEC_length (bound_probe_s, probes),
600                                        "StaticProbes");
601
602   if (!VEC_empty (bound_probe_s, probes))
603     qsort (VEC_address (bound_probe_s, probes),
604            VEC_length (bound_probe_s, probes),
605            sizeof (bound_probe_s), compare_probes);
606
607   /* What's the size of an address in our architecture?  */
608   size_addr = gdbarch_addr_bit (gdbarch) == 64 ? 18 : 10;
609
610   /* Determining the maximum size of each field (`type', `provider',
611      `name' and `objname').  */
612   for (i = 0; VEC_iterate (bound_probe_s, probes, i, probe); ++i)
613     {
614       const char *probe_type = probe->probe->pops->type_name (probe->probe);
615
616       size_type = max (strlen (probe_type), size_type);
617       size_name = max (strlen (probe->probe->name), size_name);
618       size_provider = max (strlen (probe->probe->provider), size_provider);
619       size_objname = max (strlen (objfile_name (probe->objfile)), size_objname);
620     }
621
622   ui_out_table_header (current_uiout, size_type, ui_left, "type", _("Type"));
623   ui_out_table_header (current_uiout, size_provider, ui_left, "provider",
624                        _("Provider"));
625   ui_out_table_header (current_uiout, size_name, ui_left, "name", _("Name"));
626   ui_out_table_header (current_uiout, size_addr, ui_left, "addr", _("Where"));
627
628   if (pops == NULL)
629     {
630       const struct probe_ops *po;
631       int ix;
632
633       /* We have to generate the table header for each new probe type
634          that we will print.  Note that this excludes probe types not
635          having any defined probe with the search criteria.  */
636       for (ix = 0; VEC_iterate (probe_ops_cp, all_probe_ops, ix, po); ++ix)
637         if (exists_probe_with_pops (probes, po))
638           gen_ui_out_table_header_info (probes, po);
639     }
640   else
641     gen_ui_out_table_header_info (probes, pops);
642
643   ui_out_table_header (current_uiout, size_objname, ui_left, "object",
644                        _("Object"));
645   ui_out_table_body (current_uiout);
646
647   for (i = 0; VEC_iterate (bound_probe_s, probes, i, probe); ++i)
648     {
649       struct cleanup *inner;
650       const char *probe_type = probe->probe->pops->type_name (probe->probe);
651
652       inner = make_cleanup_ui_out_tuple_begin_end (current_uiout, "probe");
653
654       ui_out_field_string (current_uiout, "type",probe_type);
655       ui_out_field_string (current_uiout, "provider", probe->probe->provider);
656       ui_out_field_string (current_uiout, "name", probe->probe->name);
657       ui_out_field_core_addr (current_uiout, "addr",
658                               probe->probe->arch,
659                               get_probe_address (probe->probe, probe->objfile));
660
661       if (pops == NULL)
662         {
663           const struct probe_ops *po;
664           int ix;
665
666           for (ix = 0; VEC_iterate (probe_ops_cp, all_probe_ops, ix, po);
667                ++ix)
668             if (probe->probe->pops == po)
669               print_ui_out_info (probe->probe);
670             else if (exists_probe_with_pops (probes, po))
671               print_ui_out_not_applicables (po);
672         }
673       else
674         print_ui_out_info (probe->probe);
675
676       ui_out_field_string (current_uiout, "object",
677                            objfile_name (probe->objfile));
678       ui_out_text (current_uiout, "\n");
679
680       do_cleanups (inner);
681     }
682
683   any_found = !VEC_empty (bound_probe_s, probes);
684   do_cleanups (cleanup);
685
686   if (!any_found)
687     ui_out_message (current_uiout, 0, _("No probes matched.\n"));
688 }
689
690 /* Implementation of the `info probes' command.  */
691
692 static void
693 info_probes_command (char *arg, int from_tty)
694 {
695   info_probes_for_ops (arg, from_tty, NULL);
696 }
697
698 /* Implementation of the `enable probes' command.  */
699
700 static void
701 enable_probes_command (char *arg, int from_tty)
702 {
703   char *provider, *probe_name = NULL, *objname = NULL;
704   struct cleanup *cleanup = make_cleanup (null_cleanup, NULL);
705   VEC (bound_probe_s) *probes;
706   struct bound_probe *probe;
707   int i;
708
709   parse_probe_linespec ((const char *) arg, &provider, &probe_name, &objname);
710   make_cleanup (xfree, provider);
711   make_cleanup (xfree, probe_name);
712   make_cleanup (xfree, objname);
713
714   probes = collect_probes (objname, provider, probe_name, NULL);
715   if (VEC_empty (bound_probe_s, probes))
716     {
717       ui_out_message (current_uiout, 0, _("No probes matched.\n"));
718       do_cleanups (cleanup);
719       return;
720     }
721
722   /* Enable the selected probes, provided their backends support the
723      notion of enabling a probe.  */
724   for (i = 0; VEC_iterate (bound_probe_s, probes, i, probe); ++i)
725     {
726       const struct probe_ops *pops = probe->probe->pops;
727
728       if (pops->enable_probe != NULL)
729         {
730           pops->enable_probe (probe->probe);
731           ui_out_message (current_uiout, 0,
732                           _("Probe %s:%s enabled.\n"),
733                           probe->probe->provider, probe->probe->name);
734         }
735       else
736         ui_out_message (current_uiout, 0,
737                         _("Probe %s:%s cannot be enabled.\n"),
738                         probe->probe->provider, probe->probe->name);
739     }
740
741   do_cleanups (cleanup);
742 }
743
744 /* Implementation of the `disable probes' command.  */
745
746 static void
747 disable_probes_command (char *arg, int from_tty)
748 {
749   char *provider, *probe_name = NULL, *objname = NULL;
750   struct cleanup *cleanup = make_cleanup (null_cleanup, NULL);
751   VEC (bound_probe_s) *probes;
752   struct bound_probe *probe;
753   int i;
754
755   parse_probe_linespec ((const char *) arg, &provider, &probe_name, &objname);
756   make_cleanup (xfree, provider);
757   make_cleanup (xfree, probe_name);
758   make_cleanup (xfree, objname);
759
760   probes = collect_probes (objname, provider, probe_name, NULL /* pops */);
761   if (VEC_empty (bound_probe_s, probes))
762     {
763       ui_out_message (current_uiout, 0, _("No probes matched.\n"));
764       do_cleanups (cleanup);
765       return;
766     }
767
768   /* Disable the selected probes, provided their backends support the
769      notion of enabling a probe.  */
770   for (i = 0; VEC_iterate (bound_probe_s, probes, i, probe); ++i)
771     {
772       const struct probe_ops *pops = probe->probe->pops;
773
774       if (pops->disable_probe != NULL)
775         {
776           pops->disable_probe (probe->probe);
777           ui_out_message (current_uiout, 0,
778                           _("Probe %s:%s disabled.\n"),
779                           probe->probe->provider, probe->probe->name);
780         }
781       else
782         ui_out_message (current_uiout, 0,
783                         _("Probe %s:%s cannot be disabled.\n"),
784                         probe->probe->provider, probe->probe->name);
785     }
786
787   do_cleanups (cleanup);
788 }
789
790 /* See comments in probe.h.  */
791
792 CORE_ADDR
793 get_probe_address (struct probe *probe, struct objfile *objfile)
794 {
795   return probe->pops->get_probe_address (probe, objfile);
796 }
797
798 /* See comments in probe.h.  */
799
800 unsigned
801 get_probe_argument_count (struct probe *probe, struct frame_info *frame)
802 {
803   return probe->pops->get_probe_argument_count (probe, frame);
804 }
805
806 /* See comments in probe.h.  */
807
808 int
809 can_evaluate_probe_arguments (struct probe *probe)
810 {
811   return probe->pops->can_evaluate_probe_arguments (probe);
812 }
813
814 /* See comments in probe.h.  */
815
816 struct value *
817 evaluate_probe_argument (struct probe *probe, unsigned n,
818                          struct frame_info *frame)
819 {
820   return probe->pops->evaluate_probe_argument (probe, n, frame);
821 }
822
823 /* See comments in probe.h.  */
824
825 struct value *
826 probe_safe_evaluate_at_pc (struct frame_info *frame, unsigned n)
827 {
828   struct bound_probe probe;
829   unsigned n_args;
830
831   probe = find_probe_by_pc (get_frame_pc (frame));
832   if (!probe.probe)
833     return NULL;
834
835   n_args = get_probe_argument_count (probe.probe, frame);
836   if (n >= n_args)
837     return NULL;
838
839   return evaluate_probe_argument (probe.probe, n, frame);
840 }
841
842 /* See comment in probe.h.  */
843
844 const struct probe_ops *
845 probe_linespec_to_ops (const char **linespecp)
846 {
847   int ix;
848   const struct probe_ops *probe_ops;
849
850   for (ix = 0; VEC_iterate (probe_ops_cp, all_probe_ops, ix, probe_ops); ix++)
851     if (probe_ops->is_linespec (linespecp))
852       return probe_ops;
853
854   return NULL;
855 }
856
857 /* See comment in probe.h.  */
858
859 int
860 probe_is_linespec_by_keyword (const char **linespecp, const char *const *keywords)
861 {
862   const char *s = *linespecp;
863   const char *const *csp;
864
865   for (csp = keywords; *csp; csp++)
866     {
867       const char *keyword = *csp;
868       size_t len = strlen (keyword);
869
870       if (strncmp (s, keyword, len) == 0 && isspace (s[len]))
871         {
872           *linespecp += len + 1;
873           return 1;
874         }
875     }
876
877   return 0;
878 }
879
880 /* Implementation of `is_linespec' method for `struct probe_ops'.  */
881
882 static int
883 probe_any_is_linespec (const char **linespecp)
884 {
885   static const char *const keywords[] = { "-p", "-probe", NULL };
886
887   return probe_is_linespec_by_keyword (linespecp, keywords);
888 }
889
890 /* Dummy method used for `probe_ops_any'.  */
891
892 static void
893 probe_any_get_probes (VEC (probe_p) **probesp, struct objfile *objfile)
894 {
895   /* No probes can be provided by this dummy backend.  */
896 }
897
898 /* Operations associated with a generic probe.  */
899
900 const struct probe_ops probe_ops_any =
901 {
902   probe_any_is_linespec,
903   probe_any_get_probes,
904 };
905
906 /* See comments in probe.h.  */
907
908 struct cmd_list_element **
909 info_probes_cmdlist_get (void)
910 {
911   static struct cmd_list_element *info_probes_cmdlist;
912
913   if (info_probes_cmdlist == NULL)
914     add_prefix_cmd ("probes", class_info, info_probes_command,
915                     _("\
916 Show available static probes.\n\
917 Usage: info probes [all|TYPE [ARGS]]\n\
918 TYPE specifies the type of the probe, and can be one of the following:\n\
919   - stap\n\
920 If you specify TYPE, there may be additional arguments needed by the\n\
921 subcommand.\n\
922 If you do not specify any argument, or specify `all', then the command\n\
923 will show information about all types of probes."),
924                     &info_probes_cmdlist, "info probes ",
925                     0/*allow-unknown*/, &infolist);
926
927   return &info_probes_cmdlist;
928 }
929
930 \f
931
932 /* This is called to compute the value of one of the $_probe_arg*
933    convenience variables.  */
934
935 static struct value *
936 compute_probe_arg (struct gdbarch *arch, struct internalvar *ivar,
937                    void *data)
938 {
939   struct frame_info *frame = get_selected_frame (_("No frame selected"));
940   CORE_ADDR pc = get_frame_pc (frame);
941   int sel = (int) (uintptr_t) data;
942   struct bound_probe pc_probe;
943   const struct sym_probe_fns *pc_probe_fns;
944   unsigned n_args;
945
946   /* SEL == -1 means "_probe_argc".  */
947   gdb_assert (sel >= -1);
948
949   pc_probe = find_probe_by_pc (pc);
950   if (pc_probe.probe == NULL)
951     error (_("No probe at PC %s"), core_addr_to_string (pc));
952
953   n_args = get_probe_argument_count (pc_probe.probe, frame);
954   if (sel == -1)
955     return value_from_longest (builtin_type (arch)->builtin_int, n_args);
956
957   if (sel >= n_args)
958     error (_("Invalid probe argument %d -- probe has %u arguments available"),
959            sel, n_args);
960
961   return evaluate_probe_argument (pc_probe.probe, sel, frame);
962 }
963
964 /* This is called to compile one of the $_probe_arg* convenience
965    variables into an agent expression.  */
966
967 static void
968 compile_probe_arg (struct internalvar *ivar, struct agent_expr *expr,
969                    struct axs_value *value, void *data)
970 {
971   CORE_ADDR pc = expr->scope;
972   int sel = (int) (uintptr_t) data;
973   struct bound_probe pc_probe;
974   const struct sym_probe_fns *pc_probe_fns;
975   int n_args;
976   struct frame_info *frame = get_selected_frame (NULL);
977
978   /* SEL == -1 means "_probe_argc".  */
979   gdb_assert (sel >= -1);
980
981   pc_probe = find_probe_by_pc (pc);
982   if (pc_probe.probe == NULL)
983     error (_("No probe at PC %s"), core_addr_to_string (pc));
984
985   n_args = get_probe_argument_count (pc_probe.probe, frame);
986
987   if (sel == -1)
988     {
989       value->kind = axs_rvalue;
990       value->type = builtin_type (expr->gdbarch)->builtin_int;
991       ax_const_l (expr, n_args);
992       return;
993     }
994
995   gdb_assert (sel >= 0);
996   if (sel >= n_args)
997     error (_("Invalid probe argument %d -- probe has %d arguments available"),
998            sel, n_args);
999
1000   pc_probe.probe->pops->compile_to_ax (pc_probe.probe, expr, value, sel);
1001 }
1002
1003 static const struct internalvar_funcs probe_funcs =
1004 {
1005   compute_probe_arg,
1006   compile_probe_arg,
1007   NULL
1008 };
1009
1010
1011 VEC (probe_ops_cp) *all_probe_ops;
1012
1013 void _initialize_probe (void);
1014
1015 void
1016 _initialize_probe (void)
1017 {
1018   VEC_safe_push (probe_ops_cp, all_probe_ops, &probe_ops_any);
1019
1020   create_internalvar_type_lazy ("_probe_argc", &probe_funcs,
1021                                 (void *) (uintptr_t) -1);
1022   create_internalvar_type_lazy ("_probe_arg0", &probe_funcs,
1023                                 (void *) (uintptr_t) 0);
1024   create_internalvar_type_lazy ("_probe_arg1", &probe_funcs,
1025                                 (void *) (uintptr_t) 1);
1026   create_internalvar_type_lazy ("_probe_arg2", &probe_funcs,
1027                                 (void *) (uintptr_t) 2);
1028   create_internalvar_type_lazy ("_probe_arg3", &probe_funcs,
1029                                 (void *) (uintptr_t) 3);
1030   create_internalvar_type_lazy ("_probe_arg4", &probe_funcs,
1031                                 (void *) (uintptr_t) 4);
1032   create_internalvar_type_lazy ("_probe_arg5", &probe_funcs,
1033                                 (void *) (uintptr_t) 5);
1034   create_internalvar_type_lazy ("_probe_arg6", &probe_funcs,
1035                                 (void *) (uintptr_t) 6);
1036   create_internalvar_type_lazy ("_probe_arg7", &probe_funcs,
1037                                 (void *) (uintptr_t) 7);
1038   create_internalvar_type_lazy ("_probe_arg8", &probe_funcs,
1039                                 (void *) (uintptr_t) 8);
1040   create_internalvar_type_lazy ("_probe_arg9", &probe_funcs,
1041                                 (void *) (uintptr_t) 9);
1042   create_internalvar_type_lazy ("_probe_arg10", &probe_funcs,
1043                                 (void *) (uintptr_t) 10);
1044   create_internalvar_type_lazy ("_probe_arg11", &probe_funcs,
1045                                 (void *) (uintptr_t) 11);
1046
1047   add_cmd ("all", class_info, info_probes_command,
1048            _("\
1049 Show information about all type of probes."),
1050            info_probes_cmdlist_get ());
1051
1052   add_cmd ("probes", class_breakpoint, enable_probes_command, _("\
1053 Enable probes.\n\
1054 Usage: enable probes [PROVIDER [NAME [OBJECT]]]\n\
1055 Each argument is a regular expression, used to select probes.\n\
1056 PROVIDER matches probe provider names.\n\
1057 NAME matches the probe names.\n\
1058 OBJECT matches the executable or shared library name.\n\
1059 If you do not specify any argument then the command will enable\n\
1060 all defined probes."),
1061            &enablelist);
1062
1063   add_cmd ("probes", class_breakpoint, disable_probes_command, _("\
1064 Disable probes.\n\
1065 Usage: disable probes [PROVIDER [NAME [OBJECT]]]\n\
1066 Each argument is a regular expression, used to select probes.\n\
1067 PROVIDER matches probe provider names.\n\
1068 NAME matches the probe names.\n\
1069 OBJECT matches the executable or shared library name.\n\
1070 If you do not specify any argument then the command will disable\n\
1071 all defined probes."),
1072            &disablelist);
1073
1074 }