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