gdb/probe.c

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