1 /* Generic static probe support for GDB.
3 Copyright (C) 2012-2019 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/>. */
23 #include "cli/cli-cmds.h"
24 #include "cli/cli-utils.h"
27 #include "progspace.h"
28 #include "filenames.h"
30 #include "gdb_regex.h"
32 #include "arch-utils.h"
39 #include "gdbsupport/gdb_optional.h"
41 /* Class that implements the static probe methods for "any" probe. */
43 class any_static_probe_ops : public static_probe_ops
47 bool is_linespec (const char **linespecp) const override;
50 void get_probes (std::vector<std::unique_ptr<probe>> *probesp,
51 struct objfile *objfile) const override;
54 const char *type_name () const override;
57 std::vector<struct info_probe_column> gen_info_probes_table_header
61 /* Static operations associated with a generic probe. */
63 const any_static_probe_ops any_static_probe_ops {};
65 /* A helper for parse_probes that decodes a probe specification in
66 SEARCH_PSPACE. It appends matching SALs to RESULT. */
69 parse_probes_in_pspace (const static_probe_ops *spops,
70 struct program_space *search_pspace,
71 const char *objfile_namestr,
74 std::vector<symtab_and_line> *result)
76 for (objfile *objfile : search_pspace->objfiles ())
78 if (!objfile->sf || !objfile->sf->sym_probe_fns)
82 && FILENAME_CMP (objfile_name (objfile), objfile_namestr) != 0
83 && FILENAME_CMP (lbasename (objfile_name (objfile)),
84 objfile_namestr) != 0)
87 const std::vector<std::unique_ptr<probe>> &probes
88 = objfile->sf->sym_probe_fns->sym_get_probes (objfile);
90 for (auto &p : probes)
92 if (spops != &any_static_probe_ops && p->get_static_ops () != spops)
95 if (provider != NULL && p->get_provider () != provider)
98 if (p->get_name () != name)
102 sal.pc = p->get_relocated_address (objfile);
104 sal.section = find_pc_overlay (sal.pc);
105 sal.pspace = search_pspace;
107 sal.objfile = objfile;
109 result->push_back (std::move (sal));
114 /* See definition in probe.h. */
116 std::vector<symtab_and_line>
117 parse_probes (const struct event_location *location,
118 struct program_space *search_pspace,
119 struct linespec_result *canonical)
122 char *objfile_namestr = NULL, *provider = NULL, *name, *p;
123 const char *arg_start, *cs;
125 gdb_assert (event_location_type (location) == PROBE_LOCATION);
126 arg_start = get_probe_location (location);
129 const static_probe_ops *spops = probe_linespec_to_static_ops (&cs);
131 error (_("'%s' is not a probe linespec"), arg_start);
134 arg = skip_spaces (arg);
136 error (_("argument to `%s' missing"), arg_start);
138 arg_end = skip_to_space (arg);
140 /* We make a copy here so we can write over parts with impunity. */
141 std::string copy (arg, arg_end - arg);
144 /* Extract each word from the argument, separated by ":"s. */
145 p = strchr (arg, ':');
148 /* This is `-p name'. */
156 p = strchr (hold, ':');
159 /* This is `-p provider:name'. */
165 /* This is `-p objfile:provider:name'. */
167 objfile_namestr = arg;
174 error (_("no probe name specified"));
175 if (provider && *provider == '\0')
176 error (_("invalid provider name"));
177 if (objfile_namestr && *objfile_namestr == '\0')
178 error (_("invalid objfile name"));
180 std::vector<symtab_and_line> result;
181 if (search_pspace != NULL)
183 parse_probes_in_pspace (spops, search_pspace, objfile_namestr,
184 provider, name, &result);
188 struct program_space *pspace;
191 parse_probes_in_pspace (spops, pspace, objfile_namestr,
192 provider, name, &result);
197 throw_error (NOT_FOUND_ERROR,
198 _("No probe matching objfile=`%s', provider=`%s', name=`%s'"),
199 objfile_namestr ? objfile_namestr : _("<any>"),
200 provider ? provider : _("<any>"),
206 std::string canon (arg_start, arg_end - arg_start);
207 canonical->special_display = 1;
208 canonical->pre_expanded = 1;
209 canonical->location = new_probe_location (canon.c_str ());
215 /* See definition in probe.h. */
218 find_probes_in_objfile (struct objfile *objfile, const char *provider,
221 std::vector<probe *> result;
223 if (!objfile->sf || !objfile->sf->sym_probe_fns)
226 const std::vector<std::unique_ptr<probe>> &probes
227 = objfile->sf->sym_probe_fns->sym_get_probes (objfile);
228 for (auto &p : probes)
230 if (p->get_provider () != provider)
233 if (p->get_name () != name)
236 result.push_back (p.get ());
242 /* See definition in probe.h. */
245 find_probe_by_pc (CORE_ADDR pc)
247 struct bound_probe result;
249 result.objfile = NULL;
252 for (objfile *objfile : current_program_space->objfiles ())
254 if (!objfile->sf || !objfile->sf->sym_probe_fns
255 || objfile->sect_index_text == -1)
258 /* If this proves too inefficient, we can replace with a hash. */
259 const std::vector<std::unique_ptr<probe>> &probes
260 = objfile->sf->sym_probe_fns->sym_get_probes (objfile);
261 for (auto &p : probes)
262 if (p->get_relocated_address (objfile) == pc)
264 result.objfile = objfile;
265 result.prob = p.get ();
275 /* Make a vector of probes matching OBJNAME, PROVIDER, and PROBE_NAME.
276 If SPOPS is not &any_static_probe_ops, only probes related to this
277 specific static probe ops will match. Each argument is a regexp,
278 or NULL, which matches anything. */
280 static std::vector<bound_probe>
281 collect_probes (const std::string &objname, const std::string &provider,
282 const std::string &probe_name, const static_probe_ops *spops)
284 std::vector<bound_probe> result;
285 gdb::optional<compiled_regex> obj_pat, prov_pat, probe_pat;
287 if (!provider.empty ())
288 prov_pat.emplace (provider.c_str (), REG_NOSUB,
289 _("Invalid provider regexp"));
290 if (!probe_name.empty ())
291 probe_pat.emplace (probe_name.c_str (), REG_NOSUB,
292 _("Invalid probe regexp"));
293 if (!objname.empty ())
294 obj_pat.emplace (objname.c_str (), REG_NOSUB,
295 _("Invalid object file regexp"));
297 for (objfile *objfile : current_program_space->objfiles ())
299 if (! objfile->sf || ! objfile->sf->sym_probe_fns)
304 if (obj_pat->exec (objfile_name (objfile), 0, NULL, 0) != 0)
308 const std::vector<std::unique_ptr<probe>> &probes
309 = objfile->sf->sym_probe_fns->sym_get_probes (objfile);
311 for (auto &p : probes)
313 if (spops != &any_static_probe_ops && p->get_static_ops () != spops)
317 && prov_pat->exec (p->get_provider ().c_str (), 0, NULL, 0) != 0)
321 && probe_pat->exec (p->get_name ().c_str (), 0, NULL, 0) != 0)
324 result.emplace_back (p.get (), objfile);
331 /* A qsort comparison function for bound_probe_s objects. */
334 compare_probes (const bound_probe &a, const bound_probe &b)
338 v = a.prob->get_provider ().compare (b.prob->get_provider ());
342 v = a.prob->get_name ().compare (b.prob->get_name ());
346 if (a.prob->get_address () != b.prob->get_address ())
347 return a.prob->get_address () < b.prob->get_address ();
349 return strcmp (objfile_name (a.objfile), objfile_name (b.objfile)) < 0;
352 /* Helper function that generate entries in the ui_out table being
353 crafted by `info_probes_for_ops'. */
356 gen_ui_out_table_header_info (const std::vector<bound_probe> &probes,
357 const static_probe_ops *spops)
359 /* `headings' refers to the names of the columns when printing `info
361 gdb_assert (spops != NULL);
363 std::vector<struct info_probe_column> headings
364 = spops->gen_info_probes_table_header ();
366 for (const info_probe_column &column : headings)
368 size_t size_max = strlen (column.print_name);
370 for (const bound_probe &probe : probes)
372 /* `probe_fields' refers to the values of each new field that this
373 probe will display. */
375 if (probe.prob->get_static_ops () != spops)
378 std::vector<const char *> probe_fields
379 = probe.prob->gen_info_probes_table_values ();
381 gdb_assert (probe_fields.size () == headings.size ());
383 for (const char *val : probe_fields)
385 /* It is valid to have a NULL value here, which means that the
386 backend does not have something to write and this particular
387 field should be skipped. */
391 size_max = std::max (strlen (val), size_max);
395 current_uiout->table_header (size_max, ui_left,
396 column.field_name, column.print_name);
400 /* Helper function to print not-applicable strings for all the extra
401 columns defined in a static_probe_ops. */
404 print_ui_out_not_applicables (const static_probe_ops *spops)
406 std::vector<struct info_probe_column> headings
407 = spops->gen_info_probes_table_header ();
409 for (const info_probe_column &column : headings)
410 current_uiout->field_string (column.field_name, _("n/a"));
413 /* Helper function to print extra information about a probe and an objfile
414 represented by PROBE. */
417 print_ui_out_info (probe *probe)
419 /* `values' refers to the actual values of each new field in the output
420 of `info probe'. `headings' refers to the names of each new field. */
421 gdb_assert (probe != NULL);
422 std::vector<struct info_probe_column> headings
423 = probe->get_static_ops ()->gen_info_probes_table_header ();
424 std::vector<const char *> values
425 = probe->gen_info_probes_table_values ();
427 gdb_assert (headings.size () == values.size ());
429 for (int ix = 0; ix < headings.size (); ++ix)
431 struct info_probe_column column = headings[ix];
432 const char *val = values[ix];
435 current_uiout->field_skip (column.field_name);
437 current_uiout->field_string (column.field_name, val);
441 /* Helper function that returns the number of extra fields which POPS will
445 get_number_extra_fields (const static_probe_ops *spops)
447 return spops->gen_info_probes_table_header ().size ();
450 /* Helper function that returns true if there is a probe in PROBES
451 featuring the given SPOPS. It returns false otherwise. */
454 exists_probe_with_spops (const std::vector<bound_probe> &probes,
455 const static_probe_ops *spops)
457 for (const bound_probe &probe : probes)
458 if (probe.prob->get_static_ops () == spops)
464 /* Helper function that parses a probe linespec of the form [PROVIDER
465 [PROBE [OBJNAME]]] from the provided string STR. */
468 parse_probe_linespec (const char *str, std::string *provider,
469 std::string *probe_name, std::string *objname)
471 *probe_name = *objname = "";
473 *provider = extract_arg (&str);
474 if (!provider->empty ())
476 *probe_name = extract_arg (&str);
477 if (!probe_name->empty ())
478 *objname = extract_arg (&str);
482 /* See comment in probe.h. */
485 info_probes_for_spops (const char *arg, int from_tty,
486 const static_probe_ops *spops)
488 std::string provider, probe_name, objname;
490 int ui_out_extra_fields = 0;
492 size_t size_name = strlen ("Name");
493 size_t size_objname = strlen ("Object");
494 size_t size_provider = strlen ("Provider");
495 size_t size_type = strlen ("Type");
496 struct gdbarch *gdbarch = get_current_arch ();
498 parse_probe_linespec (arg, &provider, &probe_name, &objname);
500 std::vector<bound_probe> probes
501 = collect_probes (objname, provider, probe_name, spops);
503 if (spops == &any_static_probe_ops)
505 /* If SPOPS is &any_static_probe_ops, it means the user has
506 requested a "simple" `info probes', i.e., she wants to print
507 all information about all probes. For that, we have to
508 identify how many extra fields we will need to add in the
511 To do that, we iterate over all static_probe_ops, querying
512 each one about its extra fields, and incrementing
513 `ui_out_extra_fields' to reflect that number. But note that
514 we ignore the static_probe_ops for which no probes are
515 defined with the given search criteria. */
517 for (const static_probe_ops *po : all_static_probe_ops)
518 if (exists_probe_with_spops (probes, po))
519 ui_out_extra_fields += get_number_extra_fields (po);
522 ui_out_extra_fields = get_number_extra_fields (spops);
525 ui_out_emit_table table_emitter (current_uiout,
526 5 + ui_out_extra_fields,
527 probes.size (), "StaticProbes");
529 std::sort (probes.begin (), probes.end (), compare_probes);
531 /* What's the size of an address in our architecture? */
532 size_addr = gdbarch_addr_bit (gdbarch) == 64 ? 18 : 10;
534 /* Determining the maximum size of each field (`type', `provider',
535 `name' and `objname'). */
536 for (const bound_probe &probe : probes)
538 const char *probe_type = probe.prob->get_static_ops ()->type_name ();
540 size_type = std::max (strlen (probe_type), size_type);
541 size_name = std::max (probe.prob->get_name ().size (), size_name);
542 size_provider = std::max (probe.prob->get_provider ().size (),
544 size_objname = std::max (strlen (objfile_name (probe.objfile)),
548 current_uiout->table_header (size_type, ui_left, "type", _("Type"));
549 current_uiout->table_header (size_provider, ui_left, "provider",
551 current_uiout->table_header (size_name, ui_left, "name", _("Name"));
552 current_uiout->table_header (size_addr, ui_left, "addr", _("Where"));
554 if (spops == &any_static_probe_ops)
556 /* We have to generate the table header for each new probe type
557 that we will print. Note that this excludes probe types not
558 having any defined probe with the search criteria. */
559 for (const static_probe_ops *po : all_static_probe_ops)
560 if (exists_probe_with_spops (probes, po))
561 gen_ui_out_table_header_info (probes, po);
564 gen_ui_out_table_header_info (probes, spops);
566 current_uiout->table_header (size_objname, ui_left, "object", _("Object"));
567 current_uiout->table_body ();
569 for (const bound_probe &probe : probes)
571 const char *probe_type = probe.prob->get_static_ops ()->type_name ();
573 ui_out_emit_tuple tuple_emitter (current_uiout, "probe");
575 current_uiout->field_string ("type", probe_type);
576 current_uiout->field_string ("provider",
577 probe.prob->get_provider ().c_str ());
578 current_uiout->field_string ("name", probe.prob->get_name ().c_str ());
579 current_uiout->field_core_addr ("addr", probe.prob->get_gdbarch (),
580 probe.prob->get_relocated_address
583 if (spops == &any_static_probe_ops)
585 for (const static_probe_ops *po : all_static_probe_ops)
587 if (probe.prob->get_static_ops () == po)
588 print_ui_out_info (probe.prob);
589 else if (exists_probe_with_spops (probes, po))
590 print_ui_out_not_applicables (po);
594 print_ui_out_info (probe.prob);
596 current_uiout->field_string ("object",
597 objfile_name (probe.objfile));
598 current_uiout->text ("\n");
601 any_found = !probes.empty ();
605 current_uiout->message (_("No probes matched.\n"));
608 /* Implementation of the `info probes' command. */
611 info_probes_command (const char *arg, int from_tty)
613 info_probes_for_spops (arg, from_tty, &any_static_probe_ops);
616 /* Implementation of the `enable probes' command. */
619 enable_probes_command (const char *arg, int from_tty)
621 std::string provider, probe_name, objname;
623 parse_probe_linespec ((const char *) arg, &provider, &probe_name, &objname);
625 std::vector<bound_probe> probes
626 = collect_probes (objname, provider, probe_name, &any_static_probe_ops);
629 current_uiout->message (_("No probes matched.\n"));
633 /* Enable the selected probes, provided their backends support the
634 notion of enabling a probe. */
635 for (const bound_probe &probe: probes)
637 if (probe.prob->get_static_ops ()->can_enable ())
639 probe.prob->enable ();
640 current_uiout->message (_("Probe %s:%s enabled.\n"),
641 probe.prob->get_provider ().c_str (),
642 probe.prob->get_name ().c_str ());
645 current_uiout->message (_("Probe %s:%s cannot be enabled.\n"),
646 probe.prob->get_provider ().c_str (),
647 probe.prob->get_name ().c_str ());
651 /* Implementation of the `disable probes' command. */
654 disable_probes_command (const char *arg, int from_tty)
656 std::string provider, probe_name, objname;
658 parse_probe_linespec ((const char *) arg, &provider, &probe_name, &objname);
660 std::vector<bound_probe> probes
661 = collect_probes (objname, provider, probe_name, &any_static_probe_ops);
664 current_uiout->message (_("No probes matched.\n"));
668 /* Disable the selected probes, provided their backends support the
669 notion of enabling a probe. */
670 for (const bound_probe &probe : probes)
672 if (probe.prob->get_static_ops ()->can_enable ())
674 probe.prob->disable ();
675 current_uiout->message (_("Probe %s:%s disabled.\n"),
676 probe.prob->get_provider ().c_str (),
677 probe.prob->get_name ().c_str ());
680 current_uiout->message (_("Probe %s:%s cannot be disabled.\n"),
681 probe.prob->get_provider ().c_str (),
682 probe.prob->get_name ().c_str ());
686 /* See comments in probe.h. */
689 probe_safe_evaluate_at_pc (struct frame_info *frame, unsigned n)
691 struct bound_probe probe;
694 probe = find_probe_by_pc (get_frame_pc (frame));
698 n_args = probe.prob->get_argument_count (get_frame_arch (frame));
702 return probe.prob->evaluate_argument (n, frame);
705 /* See comment in probe.h. */
707 const struct static_probe_ops *
708 probe_linespec_to_static_ops (const char **linespecp)
710 for (const static_probe_ops *ops : all_static_probe_ops)
711 if (ops->is_linespec (linespecp))
717 /* See comment in probe.h. */
720 probe_is_linespec_by_keyword (const char **linespecp, const char *const *keywords)
722 const char *s = *linespecp;
723 const char *const *csp;
725 for (csp = keywords; *csp; csp++)
727 const char *keyword = *csp;
728 size_t len = strlen (keyword);
730 if (strncmp (s, keyword, len) == 0 && isspace (s[len]))
732 *linespecp += len + 1;
740 /* Implementation of `is_linespec' method. */
743 any_static_probe_ops::is_linespec (const char **linespecp) const
745 static const char *const keywords[] = { "-p", "-probe", NULL };
747 return probe_is_linespec_by_keyword (linespecp, keywords);
750 /* Implementation of 'get_probes' method. */
753 any_static_probe_ops::get_probes (std::vector<std::unique_ptr<probe>> *probesp,
754 struct objfile *objfile) const
756 /* No probes can be provided by this dummy backend. */
759 /* Implementation of the 'type_name' method. */
762 any_static_probe_ops::type_name () const
767 /* Implementation of the 'gen_info_probes_table_header' method. */
769 std::vector<struct info_probe_column>
770 any_static_probe_ops::gen_info_probes_table_header () const
772 return std::vector<struct info_probe_column> ();
775 /* See comments in probe.h. */
777 struct cmd_list_element **
778 info_probes_cmdlist_get (void)
780 static struct cmd_list_element *info_probes_cmdlist;
782 if (info_probes_cmdlist == NULL)
783 add_prefix_cmd ("probes", class_info, info_probes_command,
785 Show available static probes.\n\
786 Usage: info probes [all|TYPE [ARGS]]\n\
787 TYPE specifies the type of the probe, and can be one of the following:\n\
789 If you specify TYPE, there may be additional arguments needed by the\n\
791 If you do not specify any argument, or specify `all', then the command\n\
792 will show information about all types of probes."),
793 &info_probes_cmdlist, "info probes ",
794 0/*allow-unknown*/, &infolist);
796 return &info_probes_cmdlist;
801 /* This is called to compute the value of one of the $_probe_arg*
802 convenience variables. */
804 static struct value *
805 compute_probe_arg (struct gdbarch *arch, struct internalvar *ivar,
808 struct frame_info *frame = get_selected_frame (_("No frame selected"));
809 CORE_ADDR pc = get_frame_pc (frame);
810 int sel = (int) (uintptr_t) data;
811 struct bound_probe pc_probe;
814 /* SEL == -1 means "_probe_argc". */
815 gdb_assert (sel >= -1);
817 pc_probe = find_probe_by_pc (pc);
818 if (pc_probe.prob == NULL)
819 error (_("No probe at PC %s"), core_addr_to_string (pc));
821 n_args = pc_probe.prob->get_argument_count (arch);
823 return value_from_longest (builtin_type (arch)->builtin_int, n_args);
826 error (_("Invalid probe argument %d -- probe has %u arguments available"),
829 return pc_probe.prob->evaluate_argument (sel, frame);
832 /* This is called to compile one of the $_probe_arg* convenience
833 variables into an agent expression. */
836 compile_probe_arg (struct internalvar *ivar, struct agent_expr *expr,
837 struct axs_value *value, void *data)
839 CORE_ADDR pc = expr->scope;
840 int sel = (int) (uintptr_t) data;
841 struct bound_probe pc_probe;
844 /* SEL == -1 means "_probe_argc". */
845 gdb_assert (sel >= -1);
847 pc_probe = find_probe_by_pc (pc);
848 if (pc_probe.prob == NULL)
849 error (_("No probe at PC %s"), core_addr_to_string (pc));
851 n_args = pc_probe.prob->get_argument_count (expr->gdbarch);
855 value->kind = axs_rvalue;
856 value->type = builtin_type (expr->gdbarch)->builtin_int;
857 ax_const_l (expr, n_args);
861 gdb_assert (sel >= 0);
863 error (_("Invalid probe argument %d -- probe has %d arguments available"),
866 pc_probe.prob->compile_to_ax (expr, value, sel);
869 static const struct internalvar_funcs probe_funcs =
877 std::vector<const static_probe_ops *> all_static_probe_ops;
880 _initialize_probe (void)
882 all_static_probe_ops.push_back (&any_static_probe_ops);
884 create_internalvar_type_lazy ("_probe_argc", &probe_funcs,
885 (void *) (uintptr_t) -1);
886 create_internalvar_type_lazy ("_probe_arg0", &probe_funcs,
887 (void *) (uintptr_t) 0);
888 create_internalvar_type_lazy ("_probe_arg1", &probe_funcs,
889 (void *) (uintptr_t) 1);
890 create_internalvar_type_lazy ("_probe_arg2", &probe_funcs,
891 (void *) (uintptr_t) 2);
892 create_internalvar_type_lazy ("_probe_arg3", &probe_funcs,
893 (void *) (uintptr_t) 3);
894 create_internalvar_type_lazy ("_probe_arg4", &probe_funcs,
895 (void *) (uintptr_t) 4);
896 create_internalvar_type_lazy ("_probe_arg5", &probe_funcs,
897 (void *) (uintptr_t) 5);
898 create_internalvar_type_lazy ("_probe_arg6", &probe_funcs,
899 (void *) (uintptr_t) 6);
900 create_internalvar_type_lazy ("_probe_arg7", &probe_funcs,
901 (void *) (uintptr_t) 7);
902 create_internalvar_type_lazy ("_probe_arg8", &probe_funcs,
903 (void *) (uintptr_t) 8);
904 create_internalvar_type_lazy ("_probe_arg9", &probe_funcs,
905 (void *) (uintptr_t) 9);
906 create_internalvar_type_lazy ("_probe_arg10", &probe_funcs,
907 (void *) (uintptr_t) 10);
908 create_internalvar_type_lazy ("_probe_arg11", &probe_funcs,
909 (void *) (uintptr_t) 11);
911 add_cmd ("all", class_info, info_probes_command,
913 Show information about all type of probes."),
914 info_probes_cmdlist_get ());
916 add_cmd ("probes", class_breakpoint, enable_probes_command, _("\
918 Usage: enable probes [PROVIDER [NAME [OBJECT]]]\n\
919 Each argument is a regular expression, used to select probes.\n\
920 PROVIDER matches probe provider names.\n\
921 NAME matches the probe names.\n\
922 OBJECT matches the executable or shared library name.\n\
923 If you do not specify any argument then the command will enable\n\
924 all defined probes."),
927 add_cmd ("probes", class_breakpoint, disable_probes_command, _("\
929 Usage: disable probes [PROVIDER [NAME [OBJECT]]]\n\
930 Each argument is a regular expression, used to select probes.\n\
931 PROVIDER matches probe provider names.\n\
932 NAME matches the probe names.\n\
933 OBJECT matches the executable or shared library name.\n\
934 If you do not specify any argument then the command will disable\n\
935 all defined probes."),