gdb/probe.c - gdb

Global variables defined

Data types defined

Functions defined

Source code

  1. /* Generic static probe support for GDB.

  3.    Copyright (C) 2012-2015 Free Software Foundation, Inc.

  5.    This file is part of GDB.

  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.

  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.

  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/>.  */

  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 "linespec.h"
  30. #include "gdb_regex.h"
  31. #include "frame.h"
  32. #include "arch-utils.h"
  33. #include <ctype.h>

  35. ‌typedef struct bound_probe bound_probe_s;
  36. ‌DEF_VEC_O (bound_probe_s);



  40. /* See definition in probe.h.  */

  42. struct symtabs_and_lines
  43. ‌parse_probes (char **argptr, struct linespec_result *canonical)
  44. {
  45.   char *arg_start, *arg_end, *arg;
  46.   char *objfile_namestr = NULL, *provider = NULL, *name, *p;
  47.   struct cleanup *cleanup;
  48.   struct symtabs_and_lines result;
  49.   struct objfile *objfile;
  50.   struct program_space *pspace;
  51.   const struct probe_ops *probe_ops;
  52.   const char *cs;

  54.   result.sals = NULL;
  55.   result.nelts = 0;

  57.   arg_start = *argptr;

  59.   cs = *argptr;
  60.   probe_ops = probe_linespec_to_ops (&cs);
  61.   if (probe_ops == NULL)
  62.     error (_("'%s' is not a probe linespec"), arg_start);

  64.   arg = (char *) cs;
  65.   arg = skip_spaces (arg);
  66.   if (!*arg)
  67.     error (_("argument to `%s' missing"), arg_start);

  69.   arg_end = skip_to_space (arg);

  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);

  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;

  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.     }

  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"));

  111.   ALL_PSPACES (pspace)
  112.     ALL_PSPACE_OBJFILES (pspace, objfile)
  113.       {
  114.         VEC (probe_p) *probes;
  115.         struct probe *probe;
  116.         int ix;

  118.         if (!objfile->sf || !objfile->sf->sym_probe_fns)
  119.           continue;

  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;

  127.         probes = objfile->sf->sym_probe_fns->sym_get_probes (objfile);

  129.         for (ix = 0; VEC_iterate (probe_p, probes, ix, probe); ix++)
  130.           {
  131.             struct symtab_and_line *sal;

  133.             if (probe_ops != &probe_ops_any && probe->pops != probe_ops)
  134.               continue;

  136.             if (provider && strcmp (probe->provider, provider) != 0)
  137.               continue;

  139.             if (strcmp (probe->name, name) != 0)
  140.               continue;

  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];

  148.             init_sal (sal);

  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.       }

  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.     }

  168.   if (canonical)
  169.     {
  170.       canonical->special_display = 1;
  171.       canonical->pre_expanded = 1;
  172.       canonical->addr_string = savestring (*argptr, arg_end - *argptr);
  173.     }

  175.   *argptr = arg_end;
  176.   do_cleanups (cleanup);

  178.   return result;
  179. }

  181. /* See definition in probe.h.  */

  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;

  191.   if (!objfile->sf || !objfile->sf->sym_probe_fns)
  192.     return NULL;

  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;

  200.       if (strcmp (probe->name, name) != 0)
  201.         continue;

  203.       VEC_safe_push (probe_p, result, probe);
  204.     }

  206.   return result;
  207. }

  209. /* See definition in probe.h.  */

  211. struct bound_probe
  212. ‌find_probe_by_pc (CORE_ADDR pc)
  213. {
  214.   struct objfile *objfile;
  215.   struct bound_probe result;

  217.   result.objfile = NULL;
  218.   result.probe = NULL;

  220.   ALL_OBJFILES (objfile)
  221.   {
  222.     VEC (probe_p) *probes;
  223.     int ix;
  224.     struct probe *probe;

  226.     if (!objfile->sf || !objfile->sf->sym_probe_fns
  227.         || objfile->sect_index_text == -1)
  228.       continue;

  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.   }

  241.   return result;
  242. }



  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.  */

  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;

  259.   cleanup = make_cleanup (VEC_cleanup (bound_probe_s), &result);

  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"));

  269.   ALL_OBJFILES (objfile)
  270.     {
  271.       VEC (probe_p) *probes;
  272.       struct probe *probe;
  273.       int ix;

  275.       if (! objfile->sf || ! objfile->sf->sym_probe_fns)
  276.         continue;

  278.       if (objname)
  279.         {
  280.           if (regexec (&obj_pat, objfile_name (objfile), 0, NULL, 0) != 0)
  281.             continue;
  282.         }

  284.       probes = objfile->sf->sym_probe_fns->sym_get_probes (objfile);

  286.       for (ix = 0; VEC_iterate (probe_p, probes, ix, probe); ix++)
  287.         {
  288.           struct bound_probe bound;

  290.           if (pops != NULL && probe->pops != pops)
  291.             continue;

  293.           if (provider
  294.               && regexec (&prov_pat, probe->provider, 0, NULL, 0) != 0)
  295.             continue;

  297.           if (probe_name
  298.               && regexec (&probe_pat, probe->name, 0, NULL, 0) != 0)
  299.             continue;

  301.           bound.objfile = objfile;
  302.           bound.probe = probe;
  303.           VEC_safe_push (bound_probe_s, result, &bound);
  304.         }
  305.     }

  307.   do_cleanups (cleanup_temps);
  308.   discard_cleanups (cleanup);
  309.   return result;
  310. }

  312. /* A qsort comparison function for bound_probe_s objects.  */

  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;

  321.   v = strcmp (pa->probe->provider, pb->probe->provider);
  322.   if (v)
  323.     return v;

  325.   v = strcmp (pa->probe->name, pb->probe->name);
  326.   if (v)
  327.     return v;

  329.   if (pa->probe->address < pb->probe->address)
  330.     return -1;
  331.   if (pa->probe->address > pb->probe->address)
  332.     return 1;

  334.   return strcmp (objfile_name (pa->objfile), objfile_name (pb->objfile));
  335. }

  337. /* Helper function that generate entries in the ui_out table being
  338.    crafted by `info_probes_for_ops'.  */

  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;

  352.   gdb_assert (p != NULL);

  354.   if (p->gen_info_probes_table_header == NULL
  355.       && p->gen_info_probes_table_values == NULL)
  356.     return;

  358.   gdb_assert (p->gen_info_probes_table_header != NULL
  359.               && p->gen_info_probes_table_values != NULL);

  361.   c = make_cleanup (VEC_cleanup (info_probe_column_s), &headings);
  362.   p->gen_info_probes_table_header (&headings);

  364.   headings_size = VEC_length (info_probe_column_s, headings);

  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);

  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;

  383.           if (probe->probe->pops != p)
  384.             continue;

  386.           c2 = make_cleanup (VEC_cleanup (const_char_ptr), &probe_fields);
  387.           p->gen_info_probes_table_values (probe->probe, &probe_fields);

  389.           gdb_assert (VEC_length (const_char_ptr, probe_fields)
  390.                       == headings_size);

  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;

  401.               size_max = max (strlen (val), size_max);
  402.             }
  403.           do_cleanups (c2);
  404.         }

  406.       ui_out_table_header (current_uiout, size_max, ui_left,
  407.                            column->field_name, column->print_name);
  408.     }

  410.   do_cleanups (c);
  411. }

  413. /* Helper function to print extra information about a probe and an objfile
  414.    represented by PROBE.  */

  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;

  428.   gdb_assert (probe != NULL);
  429.   gdb_assert (probe->pops != NULL);

  431.   if (probe->pops->gen_info_probes_table_header == NULL
  432.       && probe->pops->gen_info_probes_table_values == NULL)
  433.     return;

  435.   gdb_assert (probe->pops->gen_info_probes_table_header != NULL
  436.               && probe->pops->gen_info_probes_table_values != NULL);

  438.   c = make_cleanup (VEC_cleanup (info_probe_column_s), &headings);
  439.   make_cleanup (VEC_cleanup (const_char_ptr), &values);

  441.   probe->pops->gen_info_probes_table_header (&headings);
  442.   probe->pops->gen_info_probes_table_values (probe, &values);

  444.   gdb_assert (VEC_length (info_probe_column_s, headings)
  445.               == VEC_length (const_char_ptr, values));

  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++);

  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.     }

  459.   do_cleanups (c);
  460. }

  462. /* Helper function that returns the number of extra fields which POPS will
  463.    need.  */

  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;

  472.   if (pops->gen_info_probes_table_header == NULL)
  473.     return 0;

  475.   c = make_cleanup (VEC_cleanup (info_probe_column_s), &headings);
  476.   pops->gen_info_probes_table_header (&headings);

  478.   n = VEC_length (info_probe_column_s, headings);

  480.   do_cleanups (c);

  482.   return n;
  483. }

  485. /* See comment in probe.h.  */

  487. void
  488. ‌info_probes_for_ops (const char *arg, int from_tty,
  489.                      const struct probe_ops *pops)
  490. {
  491.   char *provider, *probe_name = NULL, *objname = NULL;
  492.   struct cleanup *cleanup = make_cleanup (null_cleanup, NULL);
  493.   VEC (bound_probe_s) *probes;
  494.   int i, any_found;
  495.   int ui_out_extra_fields = 0;
  496.   size_t size_addr;
  497.   size_t size_name = strlen ("Name");
  498.   size_t size_objname = strlen ("Object");
  499.   size_t size_provider = strlen ("Provider");
  500.   struct bound_probe *probe;
  501.   struct gdbarch *gdbarch = get_current_arch ();

  503.   /* Do we have a `provider:probe:objfile' style of linespec?  */
  504.   provider = extract_arg_const (&arg);
  505.   if (provider)
  506.     {
  507.       make_cleanup (xfree, provider);

  509.       probe_name = extract_arg_const (&arg);
  510.       if (probe_name)
  511.         {
  512.           make_cleanup (xfree, probe_name);

  514.           objname = extract_arg_const (&arg);
  515.           if (objname)
  516.             make_cleanup (xfree, objname);
  517.         }
  518.     }

  520.   if (pops == NULL)
  521.     {
  522.       const struct probe_ops *po;
  523.       int ix;

  525.       /* If the probe_ops is NULL, it means the user has requested a "simple"
  526.          `info probes', i.e., she wants to print all information about all
  527.          probes.  For that, we have to identify how many extra fields we will
  528.          need to add in the ui_out table.

  530.          To do that, we iterate over all probe_ops, querying each one about
  531.          its extra fields, and incrementing `ui_out_extra_fields' to reflect
  532.          that number.  */

  534.       for (ix = 0; VEC_iterate (probe_ops_cp, all_probe_ops, ix, po); ++ix)
  535.         ui_out_extra_fields += get_number_extra_fields (po);
  536.     }
  537.   else
  538.     ui_out_extra_fields = get_number_extra_fields (pops);

  540.   probes = collect_probes (objname, provider, probe_name, pops);
  541.   make_cleanup (VEC_cleanup (probe_p), &probes);
  542.   make_cleanup_ui_out_table_begin_end (current_uiout,
  543.                                        4 + ui_out_extra_fields,
  544.                                        VEC_length (bound_probe_s, probes),
  545.                                        "StaticProbes");

  547.   if (!VEC_empty (bound_probe_s, probes))
  548.     qsort (VEC_address (bound_probe_s, probes),
  549.            VEC_length (bound_probe_s, probes),
  550.            sizeof (bound_probe_s), compare_probes);

  552.   /* What's the size of an address in our architecture?  */
  553.   size_addr = gdbarch_addr_bit (gdbarch) == 64 ? 18 : 10;

  555.   /* Determining the maximum size of each field (`provider', `name' and
  556.      `objname').  */
  557.   for (i = 0; VEC_iterate (bound_probe_s, probes, i, probe); ++i)
  558.     {
  559.       size_name = max (strlen (probe->probe->name), size_name);
  560.       size_provider = max (strlen (probe->probe->provider), size_provider);
  561.       size_objname = max (strlen (objfile_name (probe->objfile)), size_objname);
  562.     }

  564.   ui_out_table_header (current_uiout, size_provider, ui_left, "provider",
  565.                        _("Provider"));
  566.   ui_out_table_header (current_uiout, size_name, ui_left, "name", _("Name"));
  567.   ui_out_table_header (current_uiout, size_addr, ui_left, "addr", _("Where"));

  569.   if (pops == NULL)
  570.     {
  571.       const struct probe_ops *po;
  572.       int ix;

  574.       /* We have to generate the table header for each new probe type that we
  575.          will print.  */
  576.       for (ix = 0; VEC_iterate (probe_ops_cp, all_probe_ops, ix, po); ++ix)
  577.         gen_ui_out_table_header_info (probes, po);
  578.     }
  579.   else
  580.     gen_ui_out_table_header_info (probes, pops);

  582.   ui_out_table_header (current_uiout, size_objname, ui_left, "object",
  583.                        _("Object"));
  584.   ui_out_table_body (current_uiout);

  586.   for (i = 0; VEC_iterate (bound_probe_s, probes, i, probe); ++i)
  587.     {
  588.       struct cleanup *inner;

  590.       inner = make_cleanup_ui_out_tuple_begin_end (current_uiout, "probe");

  592.       ui_out_field_string (current_uiout, "provider", probe->probe->provider);
  593.       ui_out_field_string (current_uiout, "name", probe->probe->name);
  594.       ui_out_field_core_addr (current_uiout, "addr",
  595.                               probe->probe->arch,
  596.                               get_probe_address (probe->probe, probe->objfile));

  598.       if (pops == NULL)
  599.         {
  600.           const struct probe_ops *po;
  601.           int ix;

  603.           for (ix = 0; VEC_iterate (probe_ops_cp, all_probe_ops, ix, po);
  604.                ++ix)
  605.             if (probe->probe->pops == po)
  606.               print_ui_out_info (probe->probe);
  607.         }
  608.       else
  609.         print_ui_out_info (probe->probe);

  611.       ui_out_field_string (current_uiout, "object",
  612.                            objfile_name (probe->objfile));
  613.       ui_out_text (current_uiout, "\n");

  615.       do_cleanups (inner);
  616.     }

  618.   any_found = !VEC_empty (bound_probe_s, probes);
  619.   do_cleanups (cleanup);

  621.   if (!any_found)
  622.     ui_out_message (current_uiout, 0, _("No probes matched.\n"));
  623. }

  625. /* Implementation of the `info probes' command.  */

  627. static void
  628. ‌info_probes_command (char *arg, int from_tty)
  629. {
  630.   info_probes_for_ops (arg, from_tty, NULL);
  631. }

  633. /* See comments in probe.h.  */

  635. CORE_ADDR
  636. ‌get_probe_address (struct probe *probe, struct objfile *objfile)
  637. {
  638.   return probe->pops->get_probe_address (probe, objfile);
  639. }

  641. /* See comments in probe.h.  */

  643. unsigned
  644. ‌get_probe_argument_count (struct probe *probe, struct frame_info *frame)
  645. {
  646.   return probe->pops->get_probe_argument_count (probe, frame);
  647. }

  649. /* See comments in probe.h.  */

  651. int
  652. ‌can_evaluate_probe_arguments (struct probe *probe)
  653. {
  654.   return probe->pops->can_evaluate_probe_arguments (probe);
  655. }

  657. /* See comments in probe.h.  */

  659. struct value *
  660. ‌evaluate_probe_argument (struct probe *probe, unsigned n,
  661.                          struct frame_info *frame)
  662. {
  663.   return probe->pops->evaluate_probe_argument (probe, n, frame);
  664. }

  666. /* See comments in probe.h.  */

  668. struct value *
  669. ‌probe_safe_evaluate_at_pc (struct frame_info *frame, unsigned n)
  670. {
  671.   struct bound_probe probe;
  672.   unsigned n_args;

  674.   probe = find_probe_by_pc (get_frame_pc (frame));
  675.   if (!probe.probe)
  676.     return NULL;

  678.   n_args = get_probe_argument_count (probe.probe, frame);
  679.   if (n >= n_args)
  680.     return NULL;

  682.   return evaluate_probe_argument (probe.probe, n, frame);
  683. }

  685. /* See comment in probe.h.  */

  687. const struct probe_ops *
  688. ‌probe_linespec_to_ops (const char **linespecp)
  689. {
  690.   int ix;
  691.   const struct probe_ops *probe_ops;

  693.   for (ix = 0; VEC_iterate (probe_ops_cp, all_probe_ops, ix, probe_ops); ix++)
  694.     if (probe_ops->is_linespec (linespecp))
  695.       return probe_ops;

  697.   return NULL;
  698. }

  700. /* See comment in probe.h.  */

  702. int
  703. ‌probe_is_linespec_by_keyword (const char **linespecp, const char *const *keywords)
  704. {
  705.   const char *s = *linespecp;
  706.   const char *const *csp;

  708.   for (csp = keywords; *csp; csp++)
  709.     {
  710.       const char *keyword = *csp;
  711.       size_t len = strlen (keyword);

  713.       if (strncmp (s, keyword, len) == 0 && isspace (s[len]))
  714.         {
  715.           *linespecp += len + 1;
  716.           return 1;
  717.         }
  718.     }

  720.   return 0;
  721. }

  723. /* Implementation of `is_linespec' method for `struct probe_ops'.  */

  725. static int
  726. ‌probe_any_is_linespec (const char **linespecp)
  727. {
  728.   static const char *const keywords[] = { "-p", "-probe", NULL };

  730.   return probe_is_linespec_by_keyword (linespecp, keywords);
  731. }

  733. /* Dummy method used for `probe_ops_any'.  */

  735. static void
  736. ‌probe_any_get_probes (VEC (probe_p) **probesp, struct objfile *objfile)
  737. {
  738.   /* No probes can be provided by this dummy backend.  */
  739. }

  741. /* Operations associated with a generic probe.  */

  743. ‌const struct probe_ops probe_ops_any =
  744. {
  745.   probe_any_is_linespec,
  746.   probe_any_get_probes,
  747. };

  749. /* See comments in probe.h.  */

  751. struct cmd_list_element **
  752. ‌info_probes_cmdlist_get (void)
  753. {
  754.   static struct cmd_list_element *info_probes_cmdlist;

  756.   if (info_probes_cmdlist == NULL)
  757.     add_prefix_cmd ("probes", class_info, info_probes_command,
  758.                     _("\
  759. Show available static probes.\n\
  760. Usage: info probes [all|TYPE [ARGS]]\n\
  761. TYPE specifies the type of the probe, and can be one of the following:\n\
  762.   - stap\n\
  763. If you specify TYPE, there may be additional arguments needed by the\n\
  764. subcommand.\n\
  765. If you do not specify any argument, or specify `all', then the command\n\
  766. will show information about all types of probes."),
  767.                     &info_probes_cmdlist, "info probes ",
  768.                     0/*allow-unknown*/, &infolist);

  770.   return &info_probes_cmdlist;
  771. }

  773. VEC (probe_ops_cp) *all_probe_ops;

  775. void _initialize_probe (void);

  777. void
  778. ‌_initialize_probe (void)
  779. {
  780.   VEC_safe_push (probe_ops_cp, all_probe_ops, &probe_ops_any);

  782.   add_cmd ("all", class_info, info_probes_command,
  783.            _("\
  784. Show information about all type of probes."),
  785.            info_probes_cmdlist_get ());
  786. }