gdb/probe.c

   1 /* Generic static probe support for GDB.
   2
   3    Copyright (C) 2012-2014 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 "exceptions.h"
  30 #include "linespec.h"
  31 #include "gdb_regex.h"
  32 #include "frame.h"
  33 #include "arch-utils.h"
  34 #include <ctype.h>
  35
  36 typedef struct bound_probe bound_probe_s;
  37 DEF_VEC_O (bound_probe_s);
  38
  39 \f
  40
  41 /* See definition in probe.h.  */
  42
  43 struct symtabs_and_lines
  44 parse_probes (char **argptr, struct linespec_result *canonical)
  45 {
  46   char *arg_start, *arg_end, *arg;
  47   char *objfile_namestr = NULL, *provider = NULL, *name, *p;
  48   struct cleanup *cleanup;
  49   struct symtabs_and_lines result;
  50   struct objfile *objfile;
  51   struct program_space *pspace;
  52   const struct probe_ops *probe_ops;
  53   const char *cs;
  54
  55   result.sals = NULL;
  56   result.nelts = 0;
  57
  58   arg_start = *argptr;
  59
  60   cs = *argptr;
  61   probe_ops = probe_linespec_to_ops (&cs);
  62   if (probe_ops == NULL)
  63     error (_("'%s' is not a probe linespec"), arg_start);
  64
  65   arg = (char *) cs;
  66   arg = skip_spaces (arg);
  67   if (!*arg)
  68     error (_("argument to `%s' missing"), arg_start);
  69
  70   arg_end = skip_to_space (arg);
  71
  72   /* We make a copy here so we can write over parts with impunity.  */
  73   arg = savestring (arg, arg_end - arg);
  74   cleanup = make_cleanup (xfree, arg);
  75
  76   /* Extract each word from the argument, separated by ":"s.  */
  77   p = strchr (arg, ':');
  78   if (p == NULL)
  79     {
  80       /* This is `-p name'.  */
  81       name = arg;
  82     }
  83   else
  84     {
  85       char *hold = p + 1;
  86
  87       *p = '\0';
  88       p = strchr (hold, ':');
  89       if (p == NULL)
  90         {
  91           /* This is `-p provider:name'.  */
  92           provider = arg;
  93           name = hold;
  94         }
  95       else
  96         {
  97           /* This is `-p objfile:provider:name'.  */
  98           *p = '\0';
  99           objfile_namestr = arg;
 100           provider = hold;
 101           name = p + 1;
 102         }
 103     }
 104
 105   if (*name == '\0')
 106     error (_("no probe name specified"));
 107   if (provider && *provider == '\0')
 108     error (_("invalid provider name"));
 109   if (objfile_namestr && *objfile_namestr == '\0')
 110     error (_("invalid objfile name"));
 111
 112   ALL_PSPACES (pspace)
 113     ALL_PSPACE_OBJFILES (pspace, objfile)
 114       {
 115         VEC (probe_p) *probes;
 116         struct probe *probe;
 117         int ix;
 118
 119         if (!objfile->sf || !objfile->sf->sym_probe_fns)
 120           continue;
 121
 122         if (objfile_namestr
 123             && FILENAME_CMP (objfile_name (objfile), objfile_namestr) != 0
 124             && FILENAME_CMP (lbasename (objfile_name (objfile)),
 125                              objfile_namestr) != 0)
 126           continue;
 127
 128         probes = objfile->sf->sym_probe_fns->sym_get_probes (objfile);
 129
 130         for (ix = 0; VEC_iterate (probe_p, probes, ix, probe); ix++)
 131           {
 132             struct symtab_and_line *sal;
 133
 134             if (probe_ops != &probe_ops_any && probe->pops != probe_ops)
 135               continue;
 136
 137             if (provider && strcmp (probe->provider, provider) != 0)
 138               continue;
 139
 140             if (strcmp (probe->name, name) != 0)
 141               continue;
 142
 143             ++result.nelts;
 144             result.sals = xrealloc (result.sals,
 145                                     result.nelts
 146                                     * sizeof (struct symtab_and_line));
 147             sal = &result.sals[result.nelts - 1];
 148
 149             init_sal (sal);
 150
 151             sal->pc = get_probe_address (probe, objfile);
 152             sal->explicit_pc = 1;
 153             sal->section = find_pc_overlay (sal->pc);
 154             sal->pspace = pspace;
 155             sal->probe = probe;
 156             sal->objfile = objfile;
 157           }
 158       }
 159
 160   if (result.nelts == 0)
 161     {
 162       throw_error (NOT_FOUND_ERROR,
 163                    _("No probe matching objfile=`%s', provider=`%s', name=`%s'"),
 164                    objfile_namestr ? objfile_namestr : _("<any>"),
 165                    provider ? provider : _("<any>"),
 166                    name);
 167     }
 168
 169   if (canonical)
 170     {
 171       canonical->special_display = 1;
 172       canonical->pre_expanded = 1;
 173       canonical->addr_string = savestring (*argptr, arg_end - *argptr);
 174     }
 175
 176   *argptr = arg_end;
 177   do_cleanups (cleanup);
 178
 179   return result;
 180 }
 181
 182 /* See definition in probe.h.  */
 183
 184 VEC (probe_p) *
 185 find_probes_in_objfile (struct objfile *objfile, const char *provider,
 186                         const char *name)
 187 {
 188   VEC (probe_p) *probes, *result = NULL;
 189   int ix;
 190   struct probe *probe;
 191
 192   if (!objfile->sf || !objfile->sf->sym_probe_fns)
 193     return NULL;
 194
 195   probes = objfile->sf->sym_probe_fns->sym_get_probes (objfile);
 196   for (ix = 0; VEC_iterate (probe_p, probes, ix, probe); ix++)
 197     {
 198       if (strcmp (probe->provider, provider) != 0)
 199         continue;
 200
 201       if (strcmp (probe->name, name) != 0)
 202         continue;
 203
 204       VEC_safe_push (probe_p, result, probe);
 205     }
 206
 207   return result;
 208 }
 209
 210 /* See definition in probe.h.  */
 211
 212 struct bound_probe
 213 find_probe_by_pc (CORE_ADDR pc)
 214 {
 215   struct objfile *objfile;
 216   struct bound_probe result;
 217
 218   result.objfile = NULL;
 219   result.probe = NULL;
 220
 221   ALL_OBJFILES (objfile)
 222   {
 223     VEC (probe_p) *probes;
 224     int ix;
 225     struct probe *probe;
 226
 227     if (!objfile->sf || !objfile->sf->sym_probe_fns
 228         || objfile->sect_index_text == -1)
 229       continue;
 230
 231     /* If this proves too inefficient, we can replace with a hash.  */
 232     probes = objfile->sf->sym_probe_fns->sym_get_probes (objfile);
 233     for (ix = 0; VEC_iterate (probe_p, probes, ix, probe); ix++)
 234       if (get_probe_address (probe, objfile) == pc)
 235         {
 236           result.objfile = objfile;
 237           result.probe = probe;
 238           return result;
 239         }
 240   }
 241
 242   return result;
 243 }
 244
 245 \f
 246
 247 /* Make a vector of probes matching OBJNAME, PROVIDER, and PROBE_NAME.
 248    If POPS is not NULL, only probes of this certain probe_ops will match.
 249    Each argument is a regexp, or NULL, which matches anything.  */
 250
 251 static VEC (bound_probe_s) *
 252 collect_probes (char *objname, char *provider, char *probe_name,
 253                 const struct probe_ops *pops)
 254 {
 255   struct objfile *objfile;
 256   VEC (bound_probe_s) *result = NULL;
 257   struct cleanup *cleanup, *cleanup_temps;
 258   regex_t obj_pat, prov_pat, probe_pat;
 259
 260   cleanup = make_cleanup (VEC_cleanup (bound_probe_s), &result);
 261
 262   cleanup_temps = make_cleanup (null_cleanup, NULL);
 263   if (provider != NULL)
 264     compile_rx_or_error (&prov_pat, provider, _("Invalid provider regexp"));
 265   if (probe_name != NULL)
 266     compile_rx_or_error (&probe_pat, probe_name, _("Invalid probe regexp"));
 267   if (objname != NULL)
 268     compile_rx_or_error (&obj_pat, objname, _("Invalid object file regexp"));
 269
 270   ALL_OBJFILES (objfile)
 271     {
 272       VEC (probe_p) *probes;
 273       struct probe *probe;
 274       int ix;
 275
 276       if (! objfile->sf || ! objfile->sf->sym_probe_fns)
 277         continue;
 278
 279       if (objname)
 280         {
 281           if (regexec (&obj_pat, objfile_name (objfile), 0, NULL, 0) != 0)
 282             continue;
 283         }
 284
 285       probes = objfile->sf->sym_probe_fns->sym_get_probes (objfile);
 286
 287       for (ix = 0; VEC_iterate (probe_p, probes, ix, probe); ix++)
 288         {
 289           struct bound_probe bound;
 290
 291           if (pops != NULL && probe->pops != pops)
 292             continue;
 293
 294           if (provider
 295               && regexec (&prov_pat, probe->provider, 0, NULL, 0) != 0)
 296             continue;
 297
 298           if (probe_name
 299               && regexec (&probe_pat, probe->name, 0, NULL, 0) != 0)
 300             continue;
 301
 302           bound.objfile = objfile;
 303           bound.probe = probe;
 304           VEC_safe_push (bound_probe_s, result, &bound);
 305         }
 306     }
 307
 308   do_cleanups (cleanup_temps);
 309   discard_cleanups (cleanup);
 310   return result;
 311 }
 312
 313 /* A qsort comparison function for bound_probe_s objects.  */
 314
 315 static int
 316 compare_probes (const void *a, const void *b)
 317 {
 318   const struct bound_probe *pa = (const struct bound_probe *) a;
 319   const struct bound_probe *pb = (const struct bound_probe *) b;
 320   int v;
 321
 322   v = strcmp (pa->probe->provider, pb->probe->provider);
 323   if (v)
 324     return v;
 325
 326   v = strcmp (pa->probe->name, pb->probe->name);
 327   if (v)
 328     return v;
 329
 330   if (pa->probe->address < pb->probe->address)
 331     return -1;
 332   if (pa->probe->address > pb->probe->address)
 333     return 1;
 334
 335   return strcmp (objfile_name (pa->objfile), objfile_name (pb->objfile));
 336 }
 337
 338 /* Helper function that generate entries in the ui_out table being
 339    crafted by `info_probes_for_ops'.  */
 340
 341 static void
 342 gen_ui_out_table_header_info (VEC (bound_probe_s) *probes,
 343                               const struct probe_ops *p)
 344 {
 345   /* `headings' refers to the names of the columns when printing `info
 346      probes'.  */
 347   VEC (info_probe_column_s) *headings = NULL;
 348   struct cleanup *c;
 349   info_probe_column_s *column;
 350   size_t headings_size;
 351   int ix;
 352
 353   gdb_assert (p != NULL);
 354
 355   if (p->gen_info_probes_table_header == NULL
 356       && p->gen_info_probes_table_values == NULL)
 357     return;
 358
 359   gdb_assert (p->gen_info_probes_table_header != NULL
 360               && p->gen_info_probes_table_values != NULL);
 361
 362   c = make_cleanup (VEC_cleanup (info_probe_column_s), &headings);
 363   p->gen_info_probes_table_header (&headings);
 364
 365   headings_size = VEC_length (info_probe_column_s, headings);
 366
 367   for (ix = 0;
 368        VEC_iterate (info_probe_column_s, headings, ix, column);
 369        ++ix)
 370     {
 371       struct bound_probe *probe;
 372       int jx;
 373       size_t size_max = strlen (column->print_name);
 374
 375       for (jx = 0; VEC_iterate (bound_probe_s, probes, jx, probe); ++jx)
 376         {
 377           /* `probe_fields' refers to the values of each new field that this
 378              probe will display.  */
 379           VEC (const_char_ptr) *probe_fields = NULL;
 380           struct cleanup *c2;
 381           const char *val;
 382           int kx;
 383
 384           if (probe->probe->pops != p)
 385             continue;
 386
 387           c2 = make_cleanup (VEC_cleanup (const_char_ptr), &probe_fields);
 388           p->gen_info_probes_table_values (probe->probe, &probe_fields);
 389
 390           gdb_assert (VEC_length (const_char_ptr, probe_fields)
 391                       == headings_size);
 392
 393           for (kx = 0; VEC_iterate (const_char_ptr, probe_fields, kx, val);
 394                ++kx)
 395             {
 396               /* It is valid to have a NULL value here, which means that the
 397                  backend does not have something to write and this particular
 398                  field should be skipped.  */
 399               if (val == NULL)
 400                 continue;
 401
 402               size_max = max (strlen (val), size_max);
 403             }
 404           do_cleanups (c2);
 405         }
 406
 407       ui_out_table_header (current_uiout, size_max, ui_left,
 408                            column->field_name, column->print_name);
 409     }
 410
 411   do_cleanups (c);
 412 }
 413
 414 /* Helper function to print extra information about a probe and an objfile
 415    represented by PROBE.  */
 416
 417 static void
 418 print_ui_out_info (struct probe *probe)
 419 {
 420   int ix;
 421   int j = 0;
 422   /* `values' refers to the actual values of each new field in the output
 423      of `info probe'.  `headings' refers to the names of each new field.  */
 424   VEC (const_char_ptr) *values = NULL;
 425   VEC (info_probe_column_s) *headings = NULL;
 426   info_probe_column_s *column;
 427   struct cleanup *c;
 428
 429   gdb_assert (probe != NULL);
 430   gdb_assert (probe->pops != NULL);
 431
 432   if (probe->pops->gen_info_probes_table_header == NULL
 433       && probe->pops->gen_info_probes_table_values == NULL)
 434     return;
 435
 436   gdb_assert (probe->pops->gen_info_probes_table_header != NULL
 437               && probe->pops->gen_info_probes_table_values != NULL);
 438
 439   c = make_cleanup (VEC_cleanup (info_probe_column_s), &headings);
 440   make_cleanup (VEC_cleanup (const_char_ptr), &values);
 441
 442   probe->pops->gen_info_probes_table_header (&headings);
 443   probe->pops->gen_info_probes_table_values (probe, &values);
 444
 445   gdb_assert (VEC_length (info_probe_column_s, headings)
 446               == VEC_length (const_char_ptr, values));
 447
 448   for (ix = 0;
 449        VEC_iterate (info_probe_column_s, headings, ix, column);
 450        ++ix)
 451     {
 452       const char *val = VEC_index (const_char_ptr, values, j++);
 453
 454       if (val == NULL)
 455         ui_out_field_skip (current_uiout, column->field_name);
 456       else
 457         ui_out_field_string (current_uiout, column->field_name, val);
 458     }
 459
 460   do_cleanups (c);
 461 }
 462
 463 /* Helper function that returns the number of extra fields which POPS will
 464    need.  */
 465
 466 static int
 467 get_number_extra_fields (const struct probe_ops *pops)
 468 {
 469   VEC (info_probe_column_s) *headings = NULL;
 470   struct cleanup *c;
 471   int n;
 472
 473   if (pops->gen_info_probes_table_header == NULL)
 474     return 0;
 475
 476   c = make_cleanup (VEC_cleanup (info_probe_column_s), &headings);
 477   pops->gen_info_probes_table_header (&headings);
 478
 479   n = VEC_length (info_probe_column_s, headings);
 480
 481   do_cleanups (c);
 482
 483   return n;
 484 }
 485
 486 /* See comment in probe.h.  */
 487
 488 void
 489 info_probes_for_ops (char *arg, int from_tty, 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 (&arg);
 505   if (provider)
 506     {
 507       make_cleanup (xfree, provider);
 508
 509       probe_name = extract_arg (&arg);
 510       if (probe_name)
 511         {
 512           make_cleanup (xfree, probe_name);
 513
 514           objname = extract_arg (&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 }