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