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