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