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 <ctype.h>
  34
  35 typedef struct bound_probe bound_probe_s;
  36 DEF_VEC_O (bound_probe_s);
  37
  38 \f
  39
  40 /* See definition in probe.h.  */
  41
  42 struct symtabs_and_lines
  43 parse_probes (char **argptr, struct linespec_result *canonical)
  44 {
  45   char *arg_start, *arg_end, *arg;
  46   char *objfile_namestr = NULL, *provider = NULL, *name, *p;
  47   struct cleanup *cleanup;
  48   struct symtabs_and_lines result;
  49   struct objfile *objfile;
  50   struct program_space *pspace;
  51   const struct probe_ops *probe_ops;
  52   const char *cs;
  53
  54   result.sals = NULL;
  55   result.nelts = 0;
  56
  57   arg_start = *argptr;
  58
  59   cs = *argptr;
  60   probe_ops = probe_linespec_to_ops (&cs);
  61   if (probe_ops == NULL)
  62     error (_("'%s' is not a probe linespec"), arg_start);
  63
  64   arg = (char *) cs;
  65   arg = skip_spaces (arg);
  66   if (!*arg)
  67     error (_("argument to `%s' missing"), arg_start);
  68
  69   arg_end = skip_to_space (arg);
  70
  71   /* We make a copy here so we can write over parts with impunity.  */
  72   arg = savestring (arg, arg_end - arg);
  73   cleanup = make_cleanup (xfree, arg);
  74
  75   /* Extract each word from the argument, separated by ":"s.  */
  76   p = strchr (arg, ':');
  77   if (p == NULL)
  78     {
  79       /* This is `-p name'.  */
  80       name = arg;
  81     }
  82   else
  83     {
  84       char *hold = p + 1;
  85
  86       *p = '\0';
  87       p = strchr (hold, ':');
  88       if (p == NULL)
  89         {
  90           /* This is `-p provider:name'.  */
  91           provider = arg;
  92           name = hold;
  93         }
  94       else
  95         {
  96           /* This is `-p objfile:provider:name'.  */
  97           *p = '\0';
  98           objfile_namestr = arg;
  99           provider = hold;
 100           name = p + 1;
 101         }
 102     }
 103
 104   if (*name == '\0')
 105     error (_("no probe name specified"));
 106   if (provider && *provider == '\0')
 107     error (_("invalid provider name"));
 108   if (objfile_namestr && *objfile_namestr == '\0')
 109     error (_("invalid objfile name"));
 110
 111   ALL_PSPACES (pspace)
 112     ALL_PSPACE_OBJFILES (pspace, objfile)
 113       {
 114         VEC (probe_p) *probes;
 115         struct probe *probe;
 116         int ix;
 117
 118         if (!objfile->sf || !objfile->sf->sym_probe_fns)
 119           continue;
 120
 121         if (objfile_namestr
 122             && FILENAME_CMP (objfile_name (objfile), objfile_namestr) != 0
 123             && FILENAME_CMP (lbasename (objfile_name (objfile)),
 124                              objfile_namestr) != 0)
 125           continue;
 126
 127         probes = objfile->sf->sym_probe_fns->sym_get_probes (objfile);
 128
 129         for (ix = 0; VEC_iterate (probe_p, probes, ix, probe); ix++)
 130           {
 131             struct symtab_and_line *sal;
 132
 133             if (probe_ops != &probe_ops_any && probe->pops != probe_ops)
 134               continue;
 135
 136             if (provider && strcmp (probe->provider, provider) != 0)
 137               continue;
 138
 139             if (strcmp (probe->name, name) != 0)
 140               continue;
 141
 142             ++result.nelts;
 143             result.sals = xrealloc (result.sals,
 144                                     result.nelts
 145                                     * sizeof (struct symtab_and_line));
 146             sal = &result.sals[result.nelts - 1];
 147
 148             init_sal (sal);
 149
 150             sal->pc = get_probe_address (probe, objfile);
 151             sal->explicit_pc = 1;
 152             sal->section = find_pc_overlay (sal->pc);
 153             sal->pspace = pspace;
 154             sal->probe = probe;
 155             sal->objfile = objfile;
 156           }
 157       }
 158
 159   if (result.nelts == 0)
 160     {
 161       throw_error (NOT_FOUND_ERROR,
 162                    _("No probe matching objfile=`%s', provider=`%s', name=`%s'"),
 163                    objfile_namestr ? objfile_namestr : _("<any>"),
 164                    provider ? provider : _("<any>"),
 165                    name);
 166     }
 167
 168   if (canonical)
 169     {
 170       canonical->special_display = 1;
 171       canonical->pre_expanded = 1;
 172       canonical->addr_string = savestring (*argptr, arg_end - *argptr);
 173     }
 174
 175   *argptr = arg_end;
 176   do_cleanups (cleanup);
 177
 178   return result;
 179 }
 180
 181 /* See definition in probe.h.  */
 182
 183 VEC (probe_p) *
 184 find_probes_in_objfile (struct objfile *objfile, const char *provider,
 185                         const char *name)
 186 {
 187   VEC (probe_p) *probes, *result = NULL;
 188   int ix;
 189   struct probe *probe;
 190
 191   if (!objfile->sf || !objfile->sf->sym_probe_fns)
 192     return NULL;
 193
 194   probes = objfile->sf->sym_probe_fns->sym_get_probes (objfile);
 195   for (ix = 0; VEC_iterate (probe_p, probes, ix, probe); ix++)
 196     {
 197       if (strcmp (probe->provider, provider) != 0)
 198         continue;
 199
 200       if (strcmp (probe->name, name) != 0)
 201         continue;
 202
 203       VEC_safe_push (probe_p, result, probe);
 204     }
 205
 206   return result;
 207 }
 208
 209 /* See definition in probe.h.  */
 210
 211 struct bound_probe
 212 find_probe_by_pc (CORE_ADDR pc)
 213 {
 214   struct objfile *objfile;
 215   struct bound_probe result;
 216
 217   result.objfile = NULL;
 218   result.probe = NULL;
 219
 220   ALL_OBJFILES (objfile)
 221   {
 222     VEC (probe_p) *probes;
 223     int ix;
 224     struct probe *probe;
 225
 226     if (!objfile->sf || !objfile->sf->sym_probe_fns
 227         || objfile->sect_index_text == -1)
 228       continue;
 229
 230     /* If this proves too inefficient, we can replace with a hash.  */
 231     probes = objfile->sf->sym_probe_fns->sym_get_probes (objfile);
 232     for (ix = 0; VEC_iterate (probe_p, probes, ix, probe); ix++)
 233       if (get_probe_address (probe, objfile) == pc)
 234         {
 235           result.objfile = objfile;
 236           result.probe = probe;
 237           return result;
 238         }
 239   }
 240
 241   return result;
 242 }
 243
 244 \f
 245
 246 /* Make a vector of probes matching OBJNAME, PROVIDER, and PROBE_NAME.
 247    If POPS is not NULL, only probes of this certain probe_ops will match.
 248    Each argument is a regexp, or NULL, which matches anything.  */
 249
 250 static VEC (bound_probe_s) *
 251 collect_probes (char *objname, char *provider, char *probe_name,
 252                 const struct probe_ops *pops)
 253 {
 254   struct objfile *objfile;
 255   VEC (bound_probe_s) *result = NULL;
 256   struct cleanup *cleanup, *cleanup_temps;
 257   regex_t obj_pat, prov_pat, probe_pat;
 258
 259   cleanup = make_cleanup (VEC_cleanup (bound_probe_s), &result);
 260
 261   cleanup_temps = make_cleanup (null_cleanup, NULL);
 262   if (provider != NULL)
 263     compile_rx_or_error (&prov_pat, provider, _("Invalid provider regexp"));
 264   if (probe_name != NULL)
 265     compile_rx_or_error (&probe_pat, probe_name, _("Invalid probe regexp"));
 266   if (objname != NULL)
 267     compile_rx_or_error (&obj_pat, objname, _("Invalid object file regexp"));
 268
 269   ALL_OBJFILES (objfile)
 270     {
 271       VEC (probe_p) *probes;
 272       struct probe *probe;
 273       int ix;
 274
 275       if (! objfile->sf || ! objfile->sf->sym_probe_fns)
 276         continue;
 277
 278       if (objname)
 279         {
 280           if (regexec (&obj_pat, objfile_name (objfile), 0, NULL, 0) != 0)
 281             continue;
 282         }
 283
 284       probes = objfile->sf->sym_probe_fns->sym_get_probes (objfile);
 285
 286       for (ix = 0; VEC_iterate (probe_p, probes, ix, probe); ix++)
 287         {
 288           struct bound_probe bound;
 289
 290           if (pops != NULL && probe->pops != pops)
 291             continue;
 292
 293           if (provider
 294               && regexec (&prov_pat, probe->provider, 0, NULL, 0) != 0)
 295             continue;
 296
 297           if (probe_name
 298               && regexec (&probe_pat, probe->name, 0, NULL, 0) != 0)
 299             continue;
 300
 301           bound.objfile = objfile;
 302           bound.probe = probe;
 303           VEC_safe_push (bound_probe_s, result, &bound);
 304         }
 305     }
 306
 307   do_cleanups (cleanup_temps);
 308   discard_cleanups (cleanup);
 309   return result;
 310 }
 311
 312 /* A qsort comparison function for bound_probe_s objects.  */
 313
 314 static int
 315 compare_probes (const void *a, const void *b)
 316 {
 317   const struct bound_probe *pa = (const struct bound_probe *) a;
 318   const struct bound_probe *pb = (const struct bound_probe *) b;
 319   int v;
 320
 321   v = strcmp (pa->probe->provider, pb->probe->provider);
 322   if (v)
 323     return v;
 324
 325   v = strcmp (pa->probe->name, pb->probe->name);
 326   if (v)
 327     return v;
 328
 329   if (pa->probe->address < pb->probe->address)
 330     return -1;
 331   if (pa->probe->address > pb->probe->address)
 332     return 1;
 333
 334   return strcmp (objfile_name (pa->objfile), objfile_name (pb->objfile));
 335 }
 336
 337 /* Helper function that generate entries in the ui_out table being
 338    crafted by `info_probes_for_ops'.  */
 339
 340 static void
 341 gen_ui_out_table_header_info (VEC (bound_probe_s) *probes,
 342                               const struct probe_ops *p)
 343 {
 344   /* `headings' refers to the names of the columns when printing `info
 345      probes'.  */
 346   VEC (info_probe_column_s) *headings = NULL;
 347   struct cleanup *c;
 348   info_probe_column_s *column;
 349   size_t headings_size;
 350   int ix;
 351
 352   gdb_assert (p != NULL);
 353
 354   if (p->gen_info_probes_table_header == NULL
 355       && p->gen_info_probes_table_values == NULL)
 356     return;
 357
 358   gdb_assert (p->gen_info_probes_table_header != NULL
 359               && p->gen_info_probes_table_values != NULL);
 360
 361   c = make_cleanup (VEC_cleanup (info_probe_column_s), &headings);
 362   p->gen_info_probes_table_header (&headings);
 363
 364   headings_size = VEC_length (info_probe_column_s, headings);
 365
 366   for (ix = 0;
 367        VEC_iterate (info_probe_column_s, headings, ix, column);
 368        ++ix)
 369     {
 370       struct bound_probe *probe;
 371       int jx;
 372       size_t size_max = strlen (column->print_name);
 373
 374       for (jx = 0; VEC_iterate (bound_probe_s, probes, jx, probe); ++jx)
 375         {
 376           /* `probe_fields' refers to the values of each new field that this
 377              probe will display.  */
 378           VEC (const_char_ptr) *probe_fields = NULL;
 379           struct cleanup *c2;
 380           const char *val;
 381           int kx;
 382
 383           if (probe->probe->pops != p)
 384             continue;
 385
 386           c2 = make_cleanup (VEC_cleanup (const_char_ptr), &probe_fields);
 387           p->gen_info_probes_table_values (probe->probe, &probe_fields);
 388
 389           gdb_assert (VEC_length (const_char_ptr, probe_fields)
 390                       == headings_size);
 391
 392           for (kx = 0; VEC_iterate (const_char_ptr, probe_fields, kx, val);
 393                ++kx)
 394             {
 395               /* It is valid to have a NULL value here, which means that the
 396                  backend does not have something to write and this particular
 397                  field should be skipped.  */
 398               if (val == NULL)
 399                 continue;
 400
 401               size_max = max (strlen (val), size_max);
 402             }
 403           do_cleanups (c2);
 404         }
 405
 406       ui_out_table_header (current_uiout, size_max, ui_left,
 407                            column->field_name, column->print_name);
 408     }
 409
 410   do_cleanups (c);
 411 }
 412
 413 /* Helper function to print extra information about a probe and an objfile
 414    represented by PROBE.  */
 415
 416 static void
 417 print_ui_out_info (struct probe *probe)
 418 {
 419   int ix;
 420   int j = 0;
 421   /* `values' refers to the actual values of each new field in the output
 422      of `info probe'.  `headings' refers to the names of each new field.  */
 423   VEC (const_char_ptr) *values = NULL;
 424   VEC (info_probe_column_s) *headings = NULL;
 425   info_probe_column_s *column;
 426   struct cleanup *c;
 427
 428   gdb_assert (probe != NULL);
 429   gdb_assert (probe->pops != NULL);
 430
 431   if (probe->pops->gen_info_probes_table_header == NULL
 432       && probe->pops->gen_info_probes_table_values == NULL)
 433     return;
 434
 435   gdb_assert (probe->pops->gen_info_probes_table_header != NULL
 436               && probe->pops->gen_info_probes_table_values != NULL);
 437
 438   c = make_cleanup (VEC_cleanup (info_probe_column_s), &headings);
 439   make_cleanup (VEC_cleanup (const_char_ptr), &values);
 440
 441   probe->pops->gen_info_probes_table_header (&headings);
 442   probe->pops->gen_info_probes_table_values (probe, &values);
 443
 444   gdb_assert (VEC_length (info_probe_column_s, headings)
 445               == VEC_length (const_char_ptr, values));
 446
 447   for (ix = 0;
 448        VEC_iterate (info_probe_column_s, headings, ix, column);
 449        ++ix)
 450     {
 451       const char *val = VEC_index (const_char_ptr, values, j++);
 452
 453       if (val == NULL)
 454         ui_out_field_skip (current_uiout, column->field_name);
 455       else
 456         ui_out_field_string (current_uiout, column->field_name, val);
 457     }
 458
 459   do_cleanups (c);
 460 }
 461
 462 /* Helper function that returns the number of extra fields which POPS will
 463    need.  */
 464
 465 static int
 466 get_number_extra_fields (const struct probe_ops *pops)
 467 {
 468   VEC (info_probe_column_s) *headings = NULL;
 469   struct cleanup *c;
 470   int n;
 471
 472   if (pops->gen_info_probes_table_header == NULL)
 473     return 0;
 474
 475   c = make_cleanup (VEC_cleanup (info_probe_column_s), &headings);
 476   pops->gen_info_probes_table_header (&headings);
 477
 478   n = VEC_length (info_probe_column_s, headings);
 479
 480   do_cleanups (c);
 481
 482   return n;
 483 }
 484
 485 /* See comment in probe.h.  */
 486
 487 void
 488 info_probes_for_ops (const char *arg, int from_tty,
 489                      const struct probe_ops *pops)
 490 {
 491   char *provider, *probe_name = NULL, *objname = NULL;
 492   struct cleanup *cleanup = make_cleanup (null_cleanup, NULL);
 493   VEC (bound_probe_s) *probes;
 494   int i, any_found;
 495   int ui_out_extra_fields = 0;
 496   size_t size_addr;
 497   size_t size_name = strlen ("Name");
 498   size_t size_objname = strlen ("Object");
 499   size_t size_provider = strlen ("Provider");
 500   struct bound_probe *probe;
 501   struct gdbarch *gdbarch = get_current_arch ();
 502
 503   /* Do we have a `provider:probe:objfile' style of linespec?  */
 504   provider = extract_arg_const (&arg);
 505   if (provider)
 506     {
 507       make_cleanup (xfree, provider);
 508
 509       probe_name = extract_arg_const (&arg);
 510       if (probe_name)
 511         {
 512           make_cleanup (xfree, probe_name);
 513
 514           objname = extract_arg_const (&arg);
 515           if (objname)
 516             make_cleanup (xfree, objname);
 517         }
 518     }
 519
 520   if (pops == NULL)
 521     {
 522       const struct probe_ops *po;
 523       int ix;
 524
 525       /* If the probe_ops is NULL, it means the user has requested a "simple"
 526          `info probes', i.e., she wants to print all information about all
 527          probes.  For that, we have to identify how many extra fields we will
 528          need to add in the ui_out table.
 529
 530          To do that, we iterate over all probe_ops, querying each one about
 531          its extra fields, and incrementing `ui_out_extra_fields' to reflect
 532          that number.  */
 533
 534       for (ix = 0; VEC_iterate (probe_ops_cp, all_probe_ops, ix, po); ++ix)
 535         ui_out_extra_fields += get_number_extra_fields (po);
 536     }
 537   else
 538     ui_out_extra_fields = get_number_extra_fields (pops);
 539
 540   probes = collect_probes (objname, provider, probe_name, pops);
 541   make_cleanup (VEC_cleanup (probe_p), &probes);
 542   make_cleanup_ui_out_table_begin_end (current_uiout,
 543                                        4 + ui_out_extra_fields,
 544                                        VEC_length (bound_probe_s, probes),
 545                                        "StaticProbes");
 546
 547   if (!VEC_empty (bound_probe_s, probes))
 548     qsort (VEC_address (bound_probe_s, probes),
 549            VEC_length (bound_probe_s, probes),
 550            sizeof (bound_probe_s), compare_probes);
 551
 552   /* What's the size of an address in our architecture?  */
 553   size_addr = gdbarch_addr_bit (gdbarch) == 64 ? 18 : 10;
 554
 555   /* Determining the maximum size of each field (`provider', `name' and
 556      `objname').  */
 557   for (i = 0; VEC_iterate (bound_probe_s, probes, i, probe); ++i)
 558     {
 559       size_name = max (strlen (probe->probe->name), size_name);
 560       size_provider = max (strlen (probe->probe->provider), size_provider);
 561       size_objname = max (strlen (objfile_name (probe->objfile)), size_objname);
 562     }
 563
 564   ui_out_table_header (current_uiout, size_provider, ui_left, "provider",
 565                        _("Provider"));
 566   ui_out_table_header (current_uiout, size_name, ui_left, "name", _("Name"));
 567   ui_out_table_header (current_uiout, size_addr, ui_left, "addr", _("Where"));
 568
 569   if (pops == NULL)
 570     {
 571       const struct probe_ops *po;
 572       int ix;
 573
 574       /* We have to generate the table header for each new probe type that we
 575          will print.  */
 576       for (ix = 0; VEC_iterate (probe_ops_cp, all_probe_ops, ix, po); ++ix)
 577         gen_ui_out_table_header_info (probes, po);
 578     }
 579   else
 580     gen_ui_out_table_header_info (probes, pops);
 581
 582   ui_out_table_header (current_uiout, size_objname, ui_left, "object",
 583                        _("Object"));
 584   ui_out_table_body (current_uiout);
 585
 586   for (i = 0; VEC_iterate (bound_probe_s, probes, i, probe); ++i)
 587     {
 588       struct cleanup *inner;
 589
 590       inner = make_cleanup_ui_out_tuple_begin_end (current_uiout, "probe");
 591
 592       ui_out_field_string (current_uiout, "provider", probe->probe->provider);
 593       ui_out_field_string (current_uiout, "name", probe->probe->name);
 594       ui_out_field_core_addr (current_uiout, "addr",
 595                               probe->probe->arch,
 596                               get_probe_address (probe->probe, probe->objfile));
 597
 598       if (pops == NULL)
 599         {
 600           const struct probe_ops *po;
 601           int ix;
 602
 603           for (ix = 0; VEC_iterate (probe_ops_cp, all_probe_ops, ix, po);
 604                ++ix)
 605             if (probe->probe->pops == po)
 606               print_ui_out_info (probe->probe);
 607         }
 608       else
 609         print_ui_out_info (probe->probe);
 610
 611       ui_out_field_string (current_uiout, "object",
 612                            objfile_name (probe->objfile));
 613       ui_out_text (current_uiout, "\n");
 614
 615       do_cleanups (inner);
 616     }
 617
 618   any_found = !VEC_empty (bound_probe_s, probes);
 619   do_cleanups (cleanup);
 620
 621   if (!any_found)
 622     ui_out_message (current_uiout, 0, _("No probes matched.\n"));
 623 }
 624
 625 /* Implementation of the `info probes' command.  */
 626
 627 static void
 628 info_probes_command (char *arg, int from_tty)
 629 {
 630   info_probes_for_ops (arg, from_tty, NULL);
 631 }
 632
 633 /* See comments in probe.h.  */
 634
 635 CORE_ADDR
 636 get_probe_address (struct probe *probe, struct objfile *objfile)
 637 {
 638   return probe->pops->get_probe_address (probe, objfile);
 639 }
 640
 641 /* See comments in probe.h.  */
 642
 643 unsigned
 644 get_probe_argument_count (struct probe *probe, struct frame_info *frame)
 645 {
 646   return probe->pops->get_probe_argument_count (probe, frame);
 647 }
 648
 649 /* See comments in probe.h.  */
 650
 651 int
 652 can_evaluate_probe_arguments (struct probe *probe)
 653 {
 654   return probe->pops->can_evaluate_probe_arguments (probe);
 655 }
 656
 657 /* See comments in probe.h.  */
 658
 659 struct value *
 660 evaluate_probe_argument (struct probe *probe, unsigned n,
 661                          struct frame_info *frame)
 662 {
 663   return probe->pops->evaluate_probe_argument (probe, n, frame);
 664 }
 665
 666 /* See comments in probe.h.  */
 667
 668 struct value *
 669 probe_safe_evaluate_at_pc (struct frame_info *frame, unsigned n)
 670 {
 671   struct bound_probe probe;
 672   unsigned n_args;
 673
 674   probe = find_probe_by_pc (get_frame_pc (frame));
 675   if (!probe.probe)
 676     return NULL;
 677
 678   n_args = get_probe_argument_count (probe.probe, frame);
 679   if (n >= n_args)
 680     return NULL;
 681
 682   return evaluate_probe_argument (probe.probe, n, frame);
 683 }
 684
 685 /* See comment in probe.h.  */
 686
 687 const struct probe_ops *
 688 probe_linespec_to_ops (const char **linespecp)
 689 {
 690   int ix;
 691   const struct probe_ops *probe_ops;
 692
 693   for (ix = 0; VEC_iterate (probe_ops_cp, all_probe_ops, ix, probe_ops); ix++)
 694     if (probe_ops->is_linespec (linespecp))
 695       return probe_ops;
 696
 697   return NULL;
 698 }
 699
 700 /* See comment in probe.h.  */
 701
 702 int
 703 probe_is_linespec_by_keyword (const char **linespecp, const char *const *keywords)
 704 {
 705   const char *s = *linespecp;
 706   const char *const *csp;
 707
 708   for (csp = keywords; *csp; csp++)
 709     {
 710       const char *keyword = *csp;
 711       size_t len = strlen (keyword);
 712
 713       if (strncmp (s, keyword, len) == 0 && isspace (s[len]))
 714         {
 715           *linespecp += len + 1;
 716           return 1;
 717         }
 718     }
 719
 720   return 0;
 721 }
 722
 723 /* Implementation of `is_linespec' method for `struct probe_ops'.  */
 724
 725 static int
 726 probe_any_is_linespec (const char **linespecp)
 727 {
 728   static const char *const keywords[] = { "-p", "-probe", NULL };
 729
 730   return probe_is_linespec_by_keyword (linespecp, keywords);
 731 }
 732
 733 /* Dummy method used for `probe_ops_any'.  */
 734
 735 static void
 736 probe_any_get_probes (VEC (probe_p) **probesp, struct objfile *objfile)
 737 {
 738   /* No probes can be provided by this dummy backend.  */
 739 }
 740
 741 /* Operations associated with a generic probe.  */
 742
 743 const struct probe_ops probe_ops_any =
 744 {
 745   probe_any_is_linespec,
 746   probe_any_get_probes,
 747 };
 748
 749 /* See comments in probe.h.  */
 750
 751 struct cmd_list_element **
 752 info_probes_cmdlist_get (void)
 753 {
 754   static struct cmd_list_element *info_probes_cmdlist;
 755
 756   if (info_probes_cmdlist == NULL)
 757     add_prefix_cmd ("probes", class_info, info_probes_command,
 758                     _("\
 759 Show available static probes.\n\
 760 Usage: info probes [all|TYPE [ARGS]]\n\
 761 TYPE specifies the type of the probe, and can be one of the following:\n\
 762   - stap\n\
 763 If you specify TYPE, there may be additional arguments needed by the\n\
 764 subcommand.\n\
 765 If you do not specify any argument, or specify `all', then the command\n\
 766 will show information about all types of probes."),
 767                     &info_probes_cmdlist, "info probes ",
 768                     0/*allow-unknown*/, &infolist);
 769
 770   return &info_probes_cmdlist;
 771 }
 772
 773 VEC (probe_ops_cp) *all_probe_ops;
 774
 775 void _initialize_probe (void);
 776
 777 void
 778 _initialize_probe (void)
 779 {
 780   VEC_safe_push (probe_ops_cp, all_probe_ops, &probe_ops_any);
 781
 782   add_cmd ("all", class_info, info_probes_command,
 783            _("\
 784 Show information about all type of probes."),
 785            info_probes_cmdlist_get ());
 786 }